module Hix.Managed.ManagedPackageProto where

import Hix.Class.Map (nFromList, nKeysSet, nMap)
import qualified Hix.Managed.Data.ManagedPackage
import Hix.Managed.Data.ManagedPackage (ManagedPackage (ManagedPackage))
import qualified Hix.Managed.Data.ManagedPackageProto
import Hix.Managed.Data.ManagedPackageProto (ManagedPackageProto (ManagedPackageProto))
import Hix.Managed.Data.Mutable (classifyPackageDep)
import Hix.Managed.Data.Packages (Packages)

validate ::
  Packages ManagedPackageProto ->
  Packages ManagedPackage
validate :: Packages ManagedPackageProto -> Packages ManagedPackage
validate Packages ManagedPackageProto
proto =
  (ManagedPackageProto -> ManagedPackage)
-> Packages ManagedPackageProto -> Packages ManagedPackage
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ManagedPackageProto -> ManagedPackage
package Packages ManagedPackageProto
proto
  where
    package :: ManagedPackageProto -> ManagedPackage
package ManagedPackageProto {[Dep]
Version
LocalPackage
name :: LocalPackage
version :: Version
deps :: [Dep]
deps :: ManagedPackageProto -> [Dep]
version :: ManagedPackageProto -> Version
name :: ManagedPackageProto -> LocalPackage
..} =
      ManagedPackage {
        package :: LocalPackage
package = LocalPackage
name,
        Version
version :: Version
version :: Version
version,
        local :: LocalRanges
local = [(LocalPackage, VersionRange)] -> LocalRanges
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList [(LocalPackage, VersionRange)]
localDeps,
        mutable :: MutableRanges
mutable = [(MutableDep, VersionRange)] -> MutableRanges
forall map k v sort. NMap map k v sort => [(k, v)] -> map
nFromList [(MutableDep, VersionRange)]
mutableDeps
      }
      where
        ([(LocalPackage, VersionRange)]
localDeps, [(MutableDep, VersionRange)]
mutableDeps) = [Either (LocalPackage, VersionRange) (MutableDep, VersionRange)]
-> ([(LocalPackage, VersionRange)], [(MutableDep, VersionRange)])
forall a b. [Either a b] -> ([a], [b])
partitionEithers (Set LocalPackage
-> Dep
-> Either (LocalPackage, VersionRange) (MutableDep, VersionRange)
classifyPackageDep Set LocalPackage
locals (Dep
 -> Either (LocalPackage, VersionRange) (MutableDep, VersionRange))
-> [Dep]
-> [Either (LocalPackage, VersionRange) (MutableDep, VersionRange)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Dep]
deps)

    locals :: Set LocalPackage
locals = Packages ManagedPackageProto -> Set LocalPackage
forall map k v sort. NMap map k v sort => map -> Set k
nKeysSet Packages ManagedPackageProto
proto