{-|
Module      : Cabal2Ebuild
Copyright   : (C) 2005, Duncan Coutts
License     : GPL-2+
Maintainer  : haskell@gentoo.org

A program for generating a Gentoo ebuild from a .cabal file
-}
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU General Public License
-- as published by the Free Software Foundation; either version 2
-- of the License, or (at your option) any later version.

-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-- General Public License for more details.
--
module Cabal2Ebuild
        (cabal2ebuild
        ,convertDependencies
        ,convertDependency) where

import qualified Distribution.PackageDescription as Cabal
                                                ( PackageDescription(..), license)
import qualified Distribution.Package as Cabal  ( PackageIdentifier(..)
                                                , Dependency(..))
import qualified Distribution.Version as Cabal  ( VersionRange
                                                , cataVersionRange, normaliseVersionRange
                                                , majorUpperBound, mkVersion )
import Distribution.Version (VersionRangeF(..))
import Distribution.Pretty (prettyShow)

import qualified Distribution.Utils.ShortText as ST

import Data.Char          (isUpper)
import Data.Maybe

import Portage.Dependency
import qualified Portage.Cabal as Portage
import qualified Portage.PackageId as Portage
import qualified Portage.EBuild as Portage
import qualified Portage.EBuild.CabalFeature as Portage
import qualified Portage.Resolve as Portage
import qualified Portage.EBuild as E
import qualified Portage.Overlay as O
import Portage.Version

-- | Generate a 'Portage.EBuild' from a 'Portage.Category' and a 'Cabal.PackageDescription'.
cabal2ebuild :: Portage.Category -> Cabal.PackageDescription -> Portage.EBuild
cabal2ebuild :: Category -> PackageDescription -> EBuild
cabal2ebuild Category
cat PackageDescription
pkg = EBuild
Portage.ebuildTemplate {
    name :: String
E.name        = PackageName -> String
Portage.cabal_pn_to_PN PackageName
cabal_pn,
    category :: String
E.category    = Category -> String
forall a. Pretty a => a -> String
prettyShow Category
cat,
    hackage_name :: String
E.hackage_name= String
cabalPkgName,
    version :: String
E.version     = Version -> String
forall a. Pretty a => a -> String
prettyShow (PackageIdentifier -> Version
Cabal.pkgVersion (PackageDescription -> PackageIdentifier
Cabal.package PackageDescription
pkg)),
    description :: String
E.description = ShortText -> String
ST.fromShortText (ShortText -> String) -> ShortText -> String
forall a b. (a -> b) -> a -> b
$ if ShortText -> Bool
ST.null (PackageDescription -> ShortText
Cabal.synopsis PackageDescription
pkg)
                                          then PackageDescription -> ShortText
Cabal.description PackageDescription
pkg
                                          else PackageDescription -> ShortText
Cabal.synopsis PackageDescription
pkg,
    homepage :: String
E.homepage        = String
thisHomepage,
    license :: Either String String
E.license         = License -> Either String String
Portage.convertLicense (License -> Either String String)
-> License -> Either String String
forall a b. (a -> b) -> a -> b
$ PackageDescription -> License
Cabal.license PackageDescription
pkg,
    slot :: String
E.slot            = (EBuild -> String
E.slot EBuild
E.ebuildTemplate) String -> String -> String
forall a. [a] -> [a] -> [a]
++ (if Bool
hasLibs then String
"/${PV}" else String
""),
    my_pn :: Maybe String
E.my_pn           = if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Char -> Bool
isUpper String
cabalPkgName then String -> Maybe String
forall a. a -> Maybe a
Just String
cabalPkgName else Maybe String
forall a. Maybe a
Nothing,
    features :: [CabalFeature]
E.features        = EBuild -> [CabalFeature]
E.features EBuild
E.ebuildTemplate
                   [CabalFeature] -> [CabalFeature] -> [CabalFeature]
forall a. [a] -> [a] -> [a]
++ (if Bool
hasLibs then ([ CabalFeature
Portage.Lib
                                        , CabalFeature
Portage.Profile
                                        , CabalFeature
Portage.Haddock
                                        , CabalFeature
Portage.Hoogle
                                        ]
                                        [CabalFeature] -> [CabalFeature] -> [CabalFeature]
forall a. [a] -> [a] -> [a]
++ if String
cabalPkgName String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"hscolour"
                                                then []
                                                else [CabalFeature
Portage.HsColour])
                                  else [])
                   [CabalFeature] -> [CabalFeature] -> [CabalFeature]
forall a. [a] -> [a] -> [a]
++ (if Bool
hasTests then [CabalFeature
Portage.TestSuite]
                                   else [])
  } where
        cabal_pn :: PackageName
cabal_pn = PackageIdentifier -> PackageName
Cabal.pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
Cabal.package PackageDescription
pkg
        cabalPkgName :: String
cabalPkgName = PackageName -> String
forall a. Pretty a => a -> String
prettyShow PackageName
cabal_pn
        hasLibs :: Bool
hasLibs = Maybe Library -> Bool
forall a. Maybe a -> Bool
isJust (PackageDescription -> Maybe Library
Cabal.library PackageDescription
pkg)
        hasTests :: Bool
hasTests = (Bool -> Bool
not (Bool -> Bool) -> ([TestSuite] -> Bool) -> [TestSuite] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [TestSuite] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) (PackageDescription -> [TestSuite]
Cabal.testSuites PackageDescription
pkg)
        thisHomepage :: String
thisHomepage = if (ShortText -> Bool
ST.null (ShortText -> Bool) -> ShortText -> Bool
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
Cabal.homepage PackageDescription
pkg)
                         then EBuild -> String
E.homepage EBuild
E.ebuildTemplate
                         else ShortText -> String
ST.fromShortText (ShortText -> String) -> ShortText -> String
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
Cabal.homepage PackageDescription
pkg

-- | Map 'convertDependency' over ['Cabal.Dependency'].
convertDependencies :: O.Overlay -> Portage.Category -> [Cabal.Dependency] -> [Dependency]
convertDependencies :: Overlay -> Category -> [Dependency] -> [Dependency]
convertDependencies Overlay
overlay Category
category = (Dependency -> Dependency) -> [Dependency] -> [Dependency]
forall a b. (a -> b) -> [a] -> [b]
map (Overlay -> Category -> Dependency -> Dependency
convertDependency Overlay
overlay Category
category)

-- | Convert 'Cabal.Dependency' into 'Dependency'.
convertDependency :: O.Overlay -> Portage.Category -> Cabal.Dependency -> Dependency
convertDependency :: Overlay -> Category -> Dependency -> Dependency
convertDependency Overlay
overlay Category
category (Cabal.Dependency PackageName
pname VersionRange
versionRange NonEmptySet LibraryName
_lib)
  = VersionRange -> Dependency
convert VersionRange
versionRange
  where
    pn :: PackageName
pn = case Overlay -> PackageName -> Maybe PackageName
Portage.resolveFullPortageName Overlay
overlay PackageName
pname of
            Just PackageName
r  -> PackageName
r
            Maybe PackageName
Nothing -> Category -> PackageName -> PackageName
Portage.PackageName Category
category (PackageName -> PackageName
Portage.normalizeCabalPackageName PackageName
pname)
    mk_p :: DRange -> Dependency
    mk_p :: DRange -> Dependency
mk_p DRange
dr = Atom -> Dependency
DependAtom (PackageName -> DRange -> DAttr -> Atom
Atom PackageName
pn DRange
dr (SlotDepend -> [UseFlag] -> DAttr
DAttr SlotDepend
AnySlot []))
    p_v :: Version -> Version
p_v Version
v   = Version -> Version
fromCabalVersion Version
v

    convert :: Cabal.VersionRange -> Dependency
    convert :: VersionRange -> Dependency
convert = (VersionRangeF Dependency -> Dependency)
-> VersionRange -> Dependency
forall a. (VersionRangeF a -> a) -> VersionRange -> a
Cabal.cataVersionRange VersionRangeF Dependency -> Dependency
alg (VersionRange -> Dependency)
-> (VersionRange -> VersionRange) -> VersionRange -> Dependency
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionRange -> VersionRange
Cabal.normaliseVersionRange
              where
                alg :: VersionRangeF Dependency -> Dependency
alg (ThisVersionF Version
v)                = DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ Version -> DRange
DExact (Version -> DRange) -> Version -> DRange
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v
                alg (LaterVersionF Version
v)               = DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange (Version -> LBound
StrictLB (Version -> LBound) -> Version -> LBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v) UBound
InfinityB
                alg (EarlierVersionF Version
v)             = DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange LBound
ZeroB (UBound -> DRange) -> UBound -> DRange
forall a b. (a -> b) -> a -> b
$ Version -> UBound
StrictUB (Version -> UBound) -> Version -> UBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v
                alg (OrLaterVersionF Version
v)             = if Version
v Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
== [Int] -> Version
Cabal.mkVersion [Int
0] -- any version
                                                      then DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange LBound
ZeroB UBound
InfinityB
                                                      else DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange (Version -> LBound
NonstrictLB (Version -> LBound) -> Version -> LBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v)
                                                           UBound
InfinityB
                alg (OrEarlierVersionF Version
v)           = DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange LBound
ZeroB (UBound -> DRange) -> UBound -> DRange
forall a b. (a -> b) -> a -> b
$ Version -> UBound
NonstrictUB (Version -> UBound) -> Version -> UBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v
                alg (MajorBoundVersionF Version
v)          = DRange -> Dependency
mk_p (DRange -> Dependency) -> DRange -> Dependency
forall a b. (a -> b) -> a -> b
$ LBound -> UBound -> DRange
DRange (Version -> LBound
NonstrictLB (Version -> LBound) -> Version -> LBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v Version
v)
                                                      (UBound -> DRange) -> UBound -> DRange
forall a b. (a -> b) -> a -> b
$ Version -> UBound
StrictUB (Version -> UBound) -> Version -> UBound
forall a b. (a -> b) -> a -> b
$ Version -> Version
p_v (Version -> Version) -> Version -> Version
forall a b. (a -> b) -> a -> b
$ Version -> Version
Cabal.majorUpperBound Version
v
                alg (UnionVersionRangesF Dependency
v1 Dependency
v2)     = [Dependency] -> Dependency
DependAnyOf [Dependency
v1, Dependency
v2]
                alg (IntersectVersionRangesF Dependency
v1 Dependency
v2) = [Dependency] -> Dependency
DependAllOf [Dependency
v1, Dependency
v2]