Options.hs

module Horizon.Gen.Nix.Cabal2Nix.Options
 ( haskellPackageToCabal2NixOptions
 , mkDefaultCabal2NixOptions
 , applyGitSourceToCabal2NixOptions
 , applyHackageSourceToCabal2NixOptions
 , applyModifiersToCabal2NixOptions
  ) where

import           Cabal2nix                                      (Options (Options),
                                                                 optCompiler,
                                                                 optDoBenchmark,
                                                                 optDoCheck,
                                                                 optEnableExecutableProfiling,
                                                                 optEnableLibraryProfiling,
                                                                 optEnableProfiling,
                                                                 optExtraArgs,
                                                                 optFetchSubmodules,
                                                                 optFlags,
                                                                 optHackageDb,
                                                                 optHackageSnapshot,
                                                                 optHaddock,
                                                                 optHpack,
                                                                 optHyperlinkSource,
                                                                 optJailbreak,
                                                                 optMaintainer,
                                                                 optNixShellOutput,
                                                                 optNixpkgsIdentifier,
                                                                 optRevision,
                                                                 optSha256,
                                                                 optSubpath,
                                                                 optSystem,
                                                                 optUrl)
import           Control.Lens                                   ((#))
import qualified Data.Text                                      as T
import           Distribution.Compiler                          (buildCompilerId)
import           Distribution.Nixpkgs.Fetch                     (FetchSubmodules (FetchSubmodules))
import           Distribution.Nixpkgs.Haskell.PackageSourceSpec (HpackUse (NoHpack))
import           Distribution.System                            (buildPlatform)
import           Horizon.Spec                                   (GitSource (MkGitSource),
                                                                 HackageSource (MkHackageSource),
                                                                 HaskellPackage (MkHaskellPackage),
                                                                 HaskellSource (FromGit, FromHackage, FromLocal, FromTarball),
                                                                 LocalSource (MkLocalSource),
                                                                 Modifiers,
                                                                 Name (MkName),
                                                                 Repo (MkRepo),
                                                                 Subdir (MkSubdir),
                                                                 TarballSource (MkTarballSource),
                                                                 Url (MkUrl),
                                                                 Version (MkVersion),
                                                                 doCheck,
                                                                 doJailbreak,
                                                                 enableProfiling,
                                                                 fromRevision,
                                                                 fromSubdir)
import           Language.Nix.Binding                           (binding)
import           Language.Nix.Identifier                        (ident)
import           Language.Nix.Path                              (path)
import           Path                                           (toFilePath)

mkDefaultCabal2NixOptions :: Options
mkDefaultCabal2NixOptions = Options
  { optSha256 = Nothing
  , optMaintainer = []
  , optHpack = NoHpack
  , optDoCheck = False
  , optJailbreak = False
  , optDoBenchmark = False
  , optRevision = Nothing
  , optHyperlinkSource = False
  , optEnableLibraryProfiling = False
  , optEnableExecutableProfiling = False
  , optEnableProfiling = Nothing
  , optExtraArgs = []
  , optHackageDb = Nothing
  , optNixShellOutput = False
  , optFlags = []
  , optCompiler = buildCompilerId
  , optSystem = buildPlatform
  , optSubpath = Nothing
  , optHackageSnapshot = Nothing
  , optNixpkgsIdentifier = \i -> Just (binding # (i, path # [ident # "pkgs", i]))
  , optUrl = mempty
  , optHaddock = False
  , optFetchSubmodules = FetchSubmodules
  }

haskellPackageToCabal2NixOptions :: HaskellPackage -> Options
haskellPackageToCabal2NixOptions (MkHaskellPackage x ms _) =
  applyModifiersToCabal2NixOptions ms $ (
    case x of
      FromHackage z -> applyHackageSourceToCabal2NixOptions z
      FromGit z     -> applyGitSourceToCabal2NixOptions z
      FromLocal z   -> applyLocalSourceToCabal2NixOptions z
      FromTarball z -> applyTarballSourceToCabal2NixOptions z
    ) mkDefaultCabal2NixOptions

applyGitSourceToCabal2NixOptions
  :: GitSource
  -> Options
  -> Options
applyGitSourceToCabal2NixOptions
  (MkGitSource (MkRepo (MkUrl u)) r s) opts = opts
  { optRevision = Just $ (T.unpack . fromRevision) r
  , optSubpath = fmap (toFilePath . fromSubdir) s
  , optUrl = T.unpack u
  }

applyHackageSourceToCabal2NixOptions ::  HackageSource -> Options -> Options
applyHackageSourceToCabal2NixOptions (MkHackageSource (MkName n) (MkVersion v)) opts = opts
  { optUrl = "cabal://" <> T.unpack n <> "-" <> T.unpack v }

applyLocalSourceToCabal2NixOptions :: LocalSource -> Options -> Options
applyLocalSourceToCabal2NixOptions (MkLocalSource (MkSubdir d)) opts = opts { optUrl = "file://" <> toFilePath d }

applyTarballSourceToCabal2NixOptions :: TarballSource -> Options -> Options
applyTarballSourceToCabal2NixOptions (MkTarballSource (MkUrl u)) opts = opts { optUrl = T.unpack u }

applyModifiersToCabal2NixOptions :: Modifiers -> Options -> Options
applyModifiersToCabal2NixOptions ms opts = opts
  { optDoCheck = doCheck ms
  , optJailbreak = doJailbreak ms
  , optEnableProfiling = Just $ enableProfiling ms
  , optEnableLibraryProfiling = enableProfiling ms
  , optEnableExecutableProfiling = enableProfiling ms
  }