{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
module Distribution.Types.MungedPackageId
  ( MungedPackageId(..)
  , computeCompatPackageId
  ) where

import Distribution.Compat.Prelude
import Prelude ()

import Distribution.Parsec
import Distribution.Pretty
import Distribution.Types.LibraryName
import Distribution.Types.MungedPackageName
import Distribution.Types.PackageId
import Distribution.Version                 (Version, nullVersion)

import qualified Text.PrettyPrint as Disp

-- | A simple pair of a 'MungedPackageName' and 'Version'. 'MungedPackageName' is to
-- 'MungedPackageId' as 'PackageName' is to 'PackageId'. See 'MungedPackageName' for more
-- info.
data MungedPackageId
    = MungedPackageId {
        -- | The combined package and component name. see documentation for
        -- 'MungedPackageName'.
        MungedPackageId -> MungedPackageName
mungedName    :: MungedPackageName,
        -- | The version of this package / component, eg 1.2
        MungedPackageId -> Version
mungedVersion :: Version
     }
     deriving ((forall x. MungedPackageId -> Rep MungedPackageId x)
-> (forall x. Rep MungedPackageId x -> MungedPackageId)
-> Generic MungedPackageId
forall x. Rep MungedPackageId x -> MungedPackageId
forall x. MungedPackageId -> Rep MungedPackageId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MungedPackageId x -> MungedPackageId
$cfrom :: forall x. MungedPackageId -> Rep MungedPackageId x
Generic, ReadPrec [MungedPackageId]
ReadPrec MungedPackageId
Int -> ReadS MungedPackageId
ReadS [MungedPackageId]
(Int -> ReadS MungedPackageId)
-> ReadS [MungedPackageId]
-> ReadPrec MungedPackageId
-> ReadPrec [MungedPackageId]
-> Read MungedPackageId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MungedPackageId]
$creadListPrec :: ReadPrec [MungedPackageId]
readPrec :: ReadPrec MungedPackageId
$creadPrec :: ReadPrec MungedPackageId
readList :: ReadS [MungedPackageId]
$creadList :: ReadS [MungedPackageId]
readsPrec :: Int -> ReadS MungedPackageId
$creadsPrec :: Int -> ReadS MungedPackageId
External instance of the constraint type Read Version
External instance of the constraint type Read MungedPackageName
External instance of the constraint type Monad ReadPrec
External instance of the constraint type Monad ReadPrec
Instance of class: Read of the constraint type Read MungedPackageId
Read, Int -> MungedPackageId -> ShowS
[MungedPackageId] -> ShowS
MungedPackageId -> String
(Int -> MungedPackageId -> ShowS)
-> (MungedPackageId -> String)
-> ([MungedPackageId] -> ShowS)
-> Show MungedPackageId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MungedPackageId] -> ShowS
$cshowList :: [MungedPackageId] -> ShowS
show :: MungedPackageId -> String
$cshow :: MungedPackageId -> String
showsPrec :: Int -> MungedPackageId -> ShowS
$cshowsPrec :: Int -> MungedPackageId -> ShowS
External instance of the constraint type Show Version
External instance of the constraint type Show MungedPackageName
External instance of the constraint type Ord Int
Show, MungedPackageId -> MungedPackageId -> Bool
(MungedPackageId -> MungedPackageId -> Bool)
-> (MungedPackageId -> MungedPackageId -> Bool)
-> Eq MungedPackageId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MungedPackageId -> MungedPackageId -> Bool
$c/= :: MungedPackageId -> MungedPackageId -> Bool
== :: MungedPackageId -> MungedPackageId -> Bool
$c== :: MungedPackageId -> MungedPackageId -> Bool
External instance of the constraint type Eq Version
External instance of the constraint type Eq MungedPackageName
Eq, Eq MungedPackageId
Eq MungedPackageId
-> (MungedPackageId -> MungedPackageId -> Ordering)
-> (MungedPackageId -> MungedPackageId -> Bool)
-> (MungedPackageId -> MungedPackageId -> Bool)
-> (MungedPackageId -> MungedPackageId -> Bool)
-> (MungedPackageId -> MungedPackageId -> Bool)
-> (MungedPackageId -> MungedPackageId -> MungedPackageId)
-> (MungedPackageId -> MungedPackageId -> MungedPackageId)
-> Ord MungedPackageId
MungedPackageId -> MungedPackageId -> Bool
MungedPackageId -> MungedPackageId -> Ordering
MungedPackageId -> MungedPackageId -> MungedPackageId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MungedPackageId -> MungedPackageId -> MungedPackageId
$cmin :: MungedPackageId -> MungedPackageId -> MungedPackageId
max :: MungedPackageId -> MungedPackageId -> MungedPackageId
$cmax :: MungedPackageId -> MungedPackageId -> MungedPackageId
>= :: MungedPackageId -> MungedPackageId -> Bool
$c>= :: MungedPackageId -> MungedPackageId -> Bool
> :: MungedPackageId -> MungedPackageId -> Bool
$c> :: MungedPackageId -> MungedPackageId -> Bool
<= :: MungedPackageId -> MungedPackageId -> Bool
$c<= :: MungedPackageId -> MungedPackageId -> Bool
< :: MungedPackageId -> MungedPackageId -> Bool
$c< :: MungedPackageId -> MungedPackageId -> Bool
compare :: MungedPackageId -> MungedPackageId -> Ordering
$ccompare :: MungedPackageId -> MungedPackageId -> Ordering
External instance of the constraint type Ord Version
External instance of the constraint type Ord MungedPackageName
Instance of class: Eq of the constraint type Eq MungedPackageId
Instance of class: Ord of the constraint type Ord MungedPackageId
Instance of class: Eq of the constraint type Eq MungedPackageId
Ord, Typeable, Typeable MungedPackageId
DataType
Constr
Typeable MungedPackageId
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MungedPackageId)
-> (MungedPackageId -> Constr)
-> (MungedPackageId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MungedPackageId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MungedPackageId))
-> ((forall b. Data b => b -> b)
    -> MungedPackageId -> MungedPackageId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MungedPackageId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MungedPackageId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MungedPackageId -> m MungedPackageId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MungedPackageId -> m MungedPackageId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MungedPackageId -> m MungedPackageId)
-> Data MungedPackageId
MungedPackageId -> DataType
MungedPackageId -> Constr
(forall b. Data b => b -> b) -> MungedPackageId -> MungedPackageId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MungedPackageId
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MungedPackageId -> u
forall u. (forall d. Data d => d -> u) -> MungedPackageId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MungedPackageId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MungedPackageId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MungedPackageId)
$cMungedPackageId :: Constr
$tMungedPackageId :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
gmapMp :: (forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
gmapM :: (forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MungedPackageId -> m MungedPackageId
gmapQi :: Int -> (forall d. Data d => d -> u) -> MungedPackageId -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MungedPackageId -> u
gmapQ :: (forall d. Data d => d -> u) -> MungedPackageId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MungedPackageId -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r
gmapT :: (forall b. Data b => b -> b) -> MungedPackageId -> MungedPackageId
$cgmapT :: (forall b. Data b => b -> b) -> MungedPackageId -> MungedPackageId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MungedPackageId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MungedPackageId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MungedPackageId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MungedPackageId)
dataTypeOf :: MungedPackageId -> DataType
$cdataTypeOf :: MungedPackageId -> DataType
toConstr :: MungedPackageId -> Constr
$ctoConstr :: MungedPackageId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MungedPackageId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MungedPackageId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId
External instance of the constraint type Data MungedPackageName
External instance of the constraint type Data Version
Data)

instance Binary MungedPackageId
instance Structured MungedPackageId

-- |
--
-- >>> prettyShow $ MungedPackageId (MungedPackageName "servant" LMainLibName) (mkVersion [1,2,3])
-- "servant-1.2.3"
--
-- >>> prettyShow $ MungedPackageId (MungedPackageName "servant" (LSubLibName "lackey")) (mkVersion [0,1,2])
-- "z-servant-z-lackey-0.1.2"
--
instance Pretty MungedPackageId where
    pretty :: MungedPackageId -> Doc
pretty (MungedPackageId MungedPackageName
n Version
v)
        | Version
v Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
External instance of the constraint type Eq Version
== Version
nullVersion = MungedPackageName -> Doc
forall a. Pretty a => a -> Doc
External instance of the constraint type Pretty MungedPackageName
pretty MungedPackageName
n -- if no version, don't show version.
        | Bool
otherwise        = MungedPackageName -> Doc
forall a. Pretty a => a -> Doc
External instance of the constraint type Pretty MungedPackageName
pretty MungedPackageName
n Doc -> Doc -> Doc
<<>> Char -> Doc
Disp.char Char
'-' Doc -> Doc -> Doc
<<>> Version -> Doc
forall a. Pretty a => a -> Doc
External instance of the constraint type Pretty Version
pretty Version
v

-- |
--
-- >>> simpleParsec "foo-bar-0" :: Maybe MungedPackageId
-- Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion [0]})
--
-- >>> simpleParsec "foo-bar" :: Maybe MungedPackageId
-- Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") LMainLibName, mungedVersion = mkVersion []})
--
-- >>> simpleParsec "z-foo-bar-z-baz-0" :: Maybe MungedPackageId
-- Just (MungedPackageId {mungedName = MungedPackageName (PackageName "foo-bar") (LSubLibName (UnqualComponentName "baz")), mungedVersion = mkVersion [0]})
--
-- >>> simpleParsec "foo-bar-0-0" :: Maybe MungedPackageId
-- Nothing
--
-- >>> simpleParsec "foo-bar.0" :: Maybe MungedPackageId
-- Nothing
--
-- >>> simpleParsec "foo-bar.4-2" :: Maybe MungedPackageId
-- Nothing
--
instance Parsec MungedPackageId where
    parsec :: m MungedPackageId
parsec = do
        PackageIdentifier PackageName
pn Version
v <- m PackageIdentifier
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
Evidence bound by a type signature of the constraint type CabalParsing m
External instance of the constraint type Parsec PackageIdentifier
parsec
        MungedPackageId -> m MungedPackageId
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type forall (m :: * -> *). MonadPlus m => Monad m
External instance of the constraint type forall (m :: * -> *). CabalParsing m => MonadPlus m
Evidence bound by a type signature of the constraint type CabalParsing m
return (MungedPackageId -> m MungedPackageId)
-> MungedPackageId -> m MungedPackageId
forall a b. (a -> b) -> a -> b
$ MungedPackageName -> Version -> MungedPackageId
MungedPackageId (PackageName -> MungedPackageName
decodeCompatPackageName PackageName
pn) Version
v

instance NFData MungedPackageId where
    rnf :: MungedPackageId -> ()
rnf (MungedPackageId MungedPackageName
name Version
version) = MungedPackageName -> ()
forall a. NFData a => a -> ()
External instance of the constraint type NFData MungedPackageName
rnf MungedPackageName
name () -> () -> ()
`seq` Version -> ()
forall a. NFData a => a -> ()
External instance of the constraint type NFData Version
rnf Version
version

computeCompatPackageId :: PackageId -> LibraryName -> MungedPackageId
computeCompatPackageId :: PackageIdentifier -> LibraryName -> MungedPackageId
computeCompatPackageId (PackageIdentifier PackageName
pn Version
vr) LibraryName
ln =
    MungedPackageName -> Version -> MungedPackageId
MungedPackageId (PackageName -> LibraryName -> MungedPackageName
MungedPackageName PackageName
pn LibraryName
ln) Version
vr

-- $setup
-- >>> :seti -XOverloadedStrings
-- >>> import Distribution.Types.Version