module Hix.Managed.Data.ManagedPackage where

import Distribution.Pretty (Pretty (pretty))
import Text.PrettyPrint (hang, ($+$))

import Hix.Class.Map (nTo, nTransform)
import Hix.Data.Bounds (Ranges)
import qualified Hix.Data.Dep
import Hix.Data.Dep (Dep (Dep))
import qualified Hix.Data.PackageId
import Hix.Data.PackageId (PackageId (PackageId))
import Hix.Data.PackageName (LocalPackage (LocalPackage), localPackageName)
import Hix.Data.Version (Version)
import Hix.Managed.Data.Mutable (LocalRanges, MutableRanges, depName)

data ManagedPackage =
  ManagedPackage {
    ManagedPackage -> LocalPackage
package :: LocalPackage,
    ManagedPackage -> Version
version :: Version,
    ManagedPackage -> LocalRanges
local :: LocalRanges,
    ManagedPackage -> MutableRanges
mutable :: MutableRanges
  }
  deriving stock (ManagedPackage -> ManagedPackage -> Bool
(ManagedPackage -> ManagedPackage -> Bool)
-> (ManagedPackage -> ManagedPackage -> Bool) -> Eq ManagedPackage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ManagedPackage -> ManagedPackage -> Bool
== :: ManagedPackage -> ManagedPackage -> Bool
$c/= :: ManagedPackage -> ManagedPackage -> Bool
/= :: ManagedPackage -> ManagedPackage -> Bool
Eq, Int -> ManagedPackage -> ShowS
[ManagedPackage] -> ShowS
ManagedPackage -> String
(Int -> ManagedPackage -> ShowS)
-> (ManagedPackage -> String)
-> ([ManagedPackage] -> ShowS)
-> Show ManagedPackage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ManagedPackage -> ShowS
showsPrec :: Int -> ManagedPackage -> ShowS
$cshow :: ManagedPackage -> String
show :: ManagedPackage -> String
$cshowList :: [ManagedPackage] -> ShowS
showList :: [ManagedPackage] -> ShowS
Show, (forall x. ManagedPackage -> Rep ManagedPackage x)
-> (forall x. Rep ManagedPackage x -> ManagedPackage)
-> Generic ManagedPackage
forall x. Rep ManagedPackage x -> ManagedPackage
forall x. ManagedPackage -> Rep ManagedPackage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ManagedPackage -> Rep ManagedPackage x
from :: forall x. ManagedPackage -> Rep ManagedPackage x
$cto :: forall x. Rep ManagedPackage x -> ManagedPackage
to :: forall x. Rep ManagedPackage x -> ManagedPackage
Generic)

instance Pretty ManagedPackage where
  pretty :: ManagedPackage -> Doc
pretty ManagedPackage {Version
LocalPackage
LocalRanges
MutableRanges
package :: ManagedPackage -> LocalPackage
version :: ManagedPackage -> Version
local :: ManagedPackage -> LocalRanges
mutable :: ManagedPackage -> MutableRanges
package :: LocalPackage
version :: Version
local :: LocalRanges
mutable :: MutableRanges
..} =
    Doc -> Int -> Doc -> Doc
hang (LocalPackage -> Doc
forall a. Pretty a => a -> Doc
pretty LocalPackage
package) Int
2 (LocalRanges -> Doc
forall a. Pretty a => a -> Doc
pretty LocalRanges
local Doc -> Doc -> Doc
$+$ MutableRanges -> Doc
forall a. Pretty a => a -> Doc
pretty MutableRanges
mutable)

ranges :: ManagedPackage -> Ranges
ranges :: ManagedPackage -> Ranges
ranges ManagedPackage {LocalRanges
local :: ManagedPackage -> LocalRanges
local :: LocalRanges
local, MutableRanges
mutable :: ManagedPackage -> MutableRanges
mutable :: MutableRanges
mutable} =
  (LocalPackage -> VersionRange -> (PackageName, VersionRange))
-> LocalRanges -> Ranges
forall map1 k1 v1 sort1 map2 k2 v2 sort2.
(NMap map1 k1 v1 sort1, NMap map2 k2 v2 sort2) =>
(k1 -> v1 -> (k2, v2)) -> map1 -> map2
nTransform (\ LocalPackage
k VersionRange
v -> (LocalPackage -> PackageName
localPackageName LocalPackage
k, VersionRange
v)) LocalRanges
local Ranges -> Ranges -> Ranges
forall a. Semigroup a => a -> a -> a
<>
  (MutableDep -> VersionRange -> (PackageName, VersionRange))
-> MutableRanges -> Ranges
forall map1 k1 v1 sort1 map2 k2 v2 sort2.
(NMap map1 k1 v1 sort1, NMap map2 k2 v2 sort2) =>
(k1 -> v1 -> (k2, v2)) -> map1 -> map2
nTransform (\ MutableDep
k VersionRange
v -> (MutableDep -> PackageName
depName MutableDep
k, VersionRange
v)) MutableRanges
mutable

packageId :: ManagedPackage -> PackageId
packageId :: ManagedPackage -> PackageId
packageId ManagedPackage {package :: ManagedPackage -> LocalPackage
package = LocalPackage PackageName
name, Version
version :: ManagedPackage -> Version
version :: Version
version} =
  PackageId {Version
PackageName
name :: PackageName
version :: Version
version :: Version
name :: PackageName
..}

deps :: ManagedPackage -> [Dep]
deps :: ManagedPackage -> [Dep]
deps ManagedPackage
mp =
  Ranges -> (PackageName -> VersionRange -> Dep) -> [Dep]
forall map k v sort a.
NMap map k v sort =>
map -> (k -> v -> a) -> [a]
nTo (ManagedPackage -> Ranges
ranges ManagedPackage
mp) \ PackageName
package VersionRange
version -> Dep {VersionRange
PackageName
package :: PackageName
version :: VersionRange
version :: VersionRange
package :: PackageName
..}