module Hix.Managed.Cabal.Mock.SourcePackage where

import qualified Data.Map.Strict as Map
import Distribution.Client.Types (PackageLocation (LocalTarballPackage), SourcePackageDb (..), UnresolvedSourcePackage)
import Distribution.PackageDescription (
  BuildInfo (targetBuildDepends),
  CondTree (..),
  Library (libBuildInfo),
  LibraryVisibility (LibraryVisibilityPublic),
  PackageDescription (..),
  emptyLibrary,
  emptyPackageDescription,
  )
import Distribution.Simple (Version)
import qualified Distribution.Solver.Types.PackageIndex as PackageIndex
import Distribution.Solver.Types.PackageIndex (PackageIndex)
import qualified Distribution.Solver.Types.SourcePackage as Cabal
import Distribution.Types.GenericPackageDescription (GenericPackageDescription (..), emptyGenericPackageDescription)
import Distribution.Types.Library (libVisibility)
import Exon (exon)

import Hix.Class.Map (nGet, nKeys, nMap, nTo1, nTransform, (!!))
import qualified Hix.Data.Dep as Dep
import Hix.Data.Dep (Dep)
import Hix.Data.Monad (M)
import qualified Hix.Data.PackageId as PackageId
import Hix.Data.PackageId (PackageId (PackageId))
import Hix.Data.PackageName (LocalPackage (LocalPackage), PackageName, localPackageName)
import Hix.Managed.Cabal.Data.SourcePackage (SourcePackage, SourcePackageId (..), SourcePackageVersions, SourcePackages)
import qualified Hix.Managed.Data.ManagedPackage as ManagedPackage
import Hix.Managed.Data.ManagedPackage (ManagedPackage)
import Hix.Managed.Data.Packages (Packages)
import Hix.Monad (noteClient)

allDeps :: [Dep] -> SourcePackage -> SourcePackage
allDeps :: [Dep] -> SourcePackage -> SourcePackage
allDeps [Dep]
deps =
  (SourcePackageId -> SourcePackageId)
-> SourcePackage -> SourcePackage
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap \ SourcePackageId
p -> SourcePackageId
p {deps = deps ++ p.deps}
  where

allDep :: Dep -> SourcePackage -> SourcePackage
allDep :: Dep -> SourcePackage -> SourcePackage
allDep = [Dep] -> SourcePackage -> SourcePackage
allDeps ([Dep] -> SourcePackage -> SourcePackage)
-> (Dep -> [Dep]) -> Dep -> SourcePackage -> SourcePackage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Dep -> [Dep]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure

sourcePackageVersions :: SourcePackages -> SourcePackageVersions
sourcePackageVersions :: SourcePackages -> SourcePackageVersions
sourcePackageVersions = (SourcePackage -> [Version])
-> SourcePackages -> SourcePackageVersions
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap ([Version] -> [Version]
forall a. Ord a => [a] -> [a]
sort ([Version] -> [Version])
-> (SourcePackage -> [Version]) -> SourcePackage -> [Version]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourcePackage -> [Version]
forall map k v sort. NMap map k v sort => map -> [k]
nKeys)

queryVersions :: SourcePackageVersions -> PackageName -> M [Version]
queryVersions :: SourcePackageVersions -> PackageName -> M [Version]
queryVersions SourcePackageVersions
packages PackageName
query = Text -> Maybe [Version] -> M [Version]
forall a. Text -> Maybe a -> M a
noteClient [exon|No such package in the source db: ##{query}|] (SourcePackageVersions
packages SourcePackageVersions -> PackageName -> Maybe [Version]
forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
map -> k -> l
!! PackageName
query)

queryPackages :: SourcePackages -> PackageName -> M [Version]
queryPackages :: SourcePackages -> PackageName -> M [Version]
queryPackages SourcePackages
packages =
  SourcePackageVersions -> PackageName -> M [Version]
queryVersions (SourcePackages -> SourcePackageVersions
sourcePackageVersions SourcePackages
packages)

queryVersionsLatest :: SourcePackageVersions -> PackageName -> M (Maybe Version)
queryVersionsLatest :: SourcePackageVersions -> PackageName -> M (Maybe Version)
queryVersionsLatest SourcePackageVersions
packages PackageName
query = [Version] -> Maybe Version
forall a. [a] -> Maybe a
last ([Version] -> Maybe Version) -> M [Version] -> M (Maybe Version)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SourcePackageVersions -> PackageName -> M [Version]
queryVersions SourcePackageVersions
packages PackageName
query

queryPackagesLatest :: SourcePackages -> PackageName -> M (Maybe Version)
queryPackagesLatest :: SourcePackages -> PackageName -> M (Maybe Version)
queryPackagesLatest SourcePackages
packages =
  SourcePackageVersions -> PackageName -> M (Maybe Version)
queryVersionsLatest SourcePackageVersions
versions
  where
    versions :: SourcePackageVersions
versions = SourcePackages -> SourcePackageVersions
sourcePackageVersions SourcePackages
packages

-- | This _must_ have the dependencies in both 'targetBuildDepends' and 'condTreeConstraints', otherwise they will be
-- ignored or deleted depending on what resolver params are used.
-- This is also evidenced by looking at a parsed Cabal file, see @CabalTest@.
mockSourcePackage :: PackageName -> Version -> SourcePackageId -> UnresolvedSourcePackage
mockSourcePackage :: PackageName
-> Version -> SourcePackageId -> UnresolvedSourcePackage
mockSourcePackage PackageName
name Version
version SourcePackageId {Maybe PackageDescription
description :: Maybe PackageDescription
description :: SourcePackageId -> Maybe PackageDescription
description, [Dep]
deps :: SourcePackageId -> [Dep]
deps :: [Dep]
deps} =
  Cabal.SourcePackage {
    srcpkgPackageId :: PackageId
srcpkgPackageId = PackageId
cabalId,
    srcpkgDescription :: GenericPackageDescription
srcpkgDescription = GenericPackageDescription
emptyGenericPackageDescription {
      packageDescription = (fromMaybe emptyPackageDescription description) {
        package = cabalId
      },
      condLibrary = Just library
    },
    srcpkgSource :: PackageLocation (Maybe String)
srcpkgSource = String -> PackageLocation (Maybe String)
forall local. String -> PackageLocation local
LocalTarballPackage String
"/invalid",
    srcpkgDescrOverride :: PackageDescriptionOverride
srcpkgDescrOverride = PackageDescriptionOverride
forall a. Maybe a
Nothing
  }
  where
    library :: CondTree ConfVar [Dependency] Library
library =
      CondTree ConfVar [Dependency] Library
forall a. Monoid a => a
mempty {
        condTreeData = emptyLibrary {
          libVisibility = LibraryVisibilityPublic,
          libBuildInfo = mempty {targetBuildDepends = cabalDeps}
        },
        condTreeConstraints = cabalDeps
      }
    cabalId :: PackageId
cabalId = PackageId -> PackageId
PackageId.toCabal PackageId {Version
PackageName
name :: PackageName
version :: Version
version :: Version
name :: PackageName
..}
    cabalDeps :: [Dependency]
cabalDeps = Dep -> Dependency
Dep.toCabal (Dep -> Dependency) -> [Dep] -> [Dependency]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Dep]
deps

mockSourcePackageDb :: SourcePackages -> SourcePackageDb
mockSourcePackageDb :: SourcePackages -> SourcePackageDb
mockSourcePackageDb SourcePackages
packages =
  SourcePackageDb {
    packageIndex :: PackageIndex UnresolvedSourcePackage
packageIndex = [UnresolvedSourcePackage] -> PackageIndex UnresolvedSourcePackage
forall pkg. Package pkg => [pkg] -> PackageIndex pkg
PackageIndex.fromList (SourcePackages
-> (PackageName
    -> Version -> SourcePackageId -> UnresolvedSourcePackage)
-> [UnresolvedSourcePackage]
forall map1 map2 k1 k2 v s1 s2 a.
(NMap map1 k1 map2 s1, NMap map2 k2 v s2) =>
map1 -> (k1 -> k2 -> v -> a) -> [a]
nTo1 SourcePackages
packages PackageName
-> Version -> SourcePackageId -> UnresolvedSourcePackage
mockSourcePackage),
    packagePreferences :: Map PackageName VersionRange
packagePreferences = []
  }

managedSourcePackageVersions :: Packages ManagedPackage -> SourcePackageVersions
managedSourcePackageVersions :: Packages ManagedPackage -> SourcePackageVersions
managedSourcePackageVersions =
  (LocalPackage -> ManagedPackage -> (PackageName, [Version]))
-> Packages ManagedPackage -> SourcePackageVersions
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 PackageName
name) ManagedPackage
package -> (PackageName
name, [ManagedPackage
package.version])

managedSourcePackage :: ManagedPackage -> UnresolvedSourcePackage
managedSourcePackage :: ManagedPackage -> UnresolvedSourcePackage
managedSourcePackage ManagedPackage
package =
  PackageName
-> Version -> SourcePackageId -> UnresolvedSourcePackage
mockSourcePackage (LocalPackage -> PackageName
localPackageName ManagedPackage
package.package) ManagedPackage
package.version SourcePackageId
pid
  where
    pid :: SourcePackageId
pid = SourcePackageId {deps :: [Dep]
deps = ManagedPackage -> [Dep]
ManagedPackage.deps ManagedPackage
package, description :: Maybe PackageDescription
description = Maybe PackageDescription
forall a. Maybe a
Nothing}

managedPackageIndex :: Packages ManagedPackage -> PackageIndex UnresolvedSourcePackage
managedPackageIndex :: Packages ManagedPackage -> PackageIndex UnresolvedSourcePackage
managedPackageIndex Packages ManagedPackage
packages =
  [UnresolvedSourcePackage] -> PackageIndex UnresolvedSourcePackage
forall pkg. Package pkg => [pkg] -> PackageIndex pkg
PackageIndex.fromList (ManagedPackage -> UnresolvedSourcePackage
managedSourcePackage (ManagedPackage -> UnresolvedSourcePackage)
-> [ManagedPackage] -> [UnresolvedSourcePackage]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map LocalPackage ManagedPackage -> [ManagedPackage]
forall k a. Map k a -> [a]
Map.elems (Packages ManagedPackage -> Map LocalPackage ManagedPackage
forall map k v sort. NMap map k v sort => map -> Map k v
nGet Packages ManagedPackage
packages))

dbWithManaged :: Packages ManagedPackage -> SourcePackageDb -> SourcePackageDb
dbWithManaged :: Packages ManagedPackage -> SourcePackageDb -> SourcePackageDb
dbWithManaged Packages ManagedPackage
packages SourcePackageDb {PackageIndex UnresolvedSourcePackage
packageIndex :: SourcePackageDb -> PackageIndex UnresolvedSourcePackage
packageIndex :: PackageIndex UnresolvedSourcePackage
packageIndex, Map PackageName VersionRange
packagePreferences :: SourcePackageDb -> Map PackageName VersionRange
packagePreferences :: Map PackageName VersionRange
packagePreferences} =
  SourcePackageDb {
    packageIndex :: PackageIndex UnresolvedSourcePackage
packageIndex = PackageIndex UnresolvedSourcePackage
-> PackageIndex UnresolvedSourcePackage
-> PackageIndex UnresolvedSourcePackage
forall pkg.
Package pkg =>
PackageIndex pkg -> PackageIndex pkg -> PackageIndex pkg
PackageIndex.merge PackageIndex UnresolvedSourcePackage
packageIndex (Packages ManagedPackage -> PackageIndex UnresolvedSourcePackage
managedPackageIndex Packages ManagedPackage
packages),
    Map PackageName VersionRange
packagePreferences :: Map PackageName VersionRange
packagePreferences :: Map PackageName VersionRange
packagePreferences
  }