{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ApplicativeDo #-}

module Cabal2nix
  ( main, cabal2nix, cabal2nix', cabal2nixWithDB, parseArgs
  , Options(..)
  )
  where

import Control.Exception ( bracket )
import Control.Lens
import Control.Monad
import Data.Maybe ( fromMaybe, isJust )
import qualified Data.Set as Set
import Data.String
import Data.Time
import Distribution.Compiler
import Distribution.Nixpkgs.Color (colorStderrLn, warningColor)
import Distribution.Nixpkgs.Fetch
import Distribution.Nixpkgs.Haskell
import Distribution.Nixpkgs.Haskell.FromCabal
import Distribution.Nixpkgs.Haskell.FromCabal.Flags
import Distribution.Nixpkgs.Haskell.Platform
import qualified Distribution.Nixpkgs.Haskell.FromCabal.PostProcess as PP (pkg)
import qualified Distribution.Nixpkgs.Haskell.Hackage as DB
import Distribution.Nixpkgs.Haskell.OrphanInstances ( )
import Distribution.Nixpkgs.Haskell.PackageSourceSpec
import Distribution.Nixpkgs.Meta
import Distribution.Package ( packageId )
import Distribution.PackageDescription ( mkFlagName, mkFlagAssignment, FlagAssignment )
import Distribution.Parsec as P
import Distribution.Simple.Utils ( lowercase )
import Distribution.System
import Language.Nix
import Options.Applicative
import Paths_cabal2nix ( version )
import System.Environment ( getArgs )
import System.IO ( hFlush, stdout, stderr )
import qualified Text.PrettyPrint.ANSI.Leijen as P2
import Text.PrettyPrint.HughesPJClass ( Doc, Pretty(..), text, vcat, hcat, semi, render, prettyShow )

{-# ANN module ("HLint: ignore Use Just" :: String) #-}

data Options = Options
  { Options -> Maybe [Char]
optSha256 :: Maybe String
  , Options -> [[Char]]
optMaintainer :: [String]
--, optPlatform :: [String]       -- TODO: fix command line handling of platforms
  , Options -> Bool
optHaddock :: Bool
  , Options -> HpackUse
optHpack :: HpackUse
  , Options -> Bool
optDoCheck :: Bool
  , Options -> Bool
optJailbreak :: Bool
  , Options -> Bool
optDoBenchmark :: Bool
  , Options -> Maybe [Char]
optRevision :: Maybe String
  , Options -> Bool
optHyperlinkSource :: Bool
  , Options -> Bool
optEnableLibraryProfiling :: Bool
  , Options -> Bool
optEnableExecutableProfiling :: Bool
  , Options -> Maybe Bool
optEnableProfiling :: Maybe Bool
  , Options -> [[Char]]
optExtraArgs :: [String]
  , Options -> Maybe [Char]
optHackageDb :: Maybe FilePath
  , Options -> Bool
optNixShellOutput :: Bool
  , Options -> [[Char]]
optFlags :: [String]
  , Options -> CompilerId
optCompiler :: CompilerId
  , Options -> Platform
optSystem :: Platform
  , Options -> Maybe [Char]
optSubpath :: Maybe FilePath
  , Options -> Maybe UTCTime
optHackageSnapshot :: Maybe UTCTime
  , Options -> NixpkgsResolver
optNixpkgsIdentifier :: NixpkgsResolver
  , Options -> [Char]
optUrl :: String
  , Options -> FetchSubmodules
optFetchSubmodules :: FetchSubmodules
  }

options :: Parser Options
options :: Parser Options
options = do
  Maybe [Char]
optSha256
    <- Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"sha256" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"HASH" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"sha256 hash of source tarball")
  [[Char]]
optMaintainer
    <- Parser [Char] -> Parser [[Char]]
forall a. Parser a -> Parser [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"maintainer" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"MAINTAINER" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"maintainer of this package (may be specified multiple times)")
-- optPlatform <- many (strOption $ long "platform" <> metavar "PLATFORM" <> help "supported build platforms (may be specified multiple times)")
  Bool
optHaddock
    <- Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag Bool
True Bool
False ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"no-haddock" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"don't run Haddock when building this package")
  HpackUse
optHpack
    <-
      (
        HpackUse -> Mod FlagFields HpackUse -> Parser HpackUse
forall a. a -> Mod FlagFields a -> Parser a
flag' HpackUse
ForceHpack ([Char] -> Mod FlagFields HpackUse
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"hpack" Mod FlagFields HpackUse
-> Mod FlagFields HpackUse -> Mod FlagFields HpackUse
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields HpackUse
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"run hpack before configuring this package (only non-hackage packages)")
        Parser HpackUse -> Parser HpackUse -> Parser HpackUse
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
        HpackUse -> Mod FlagFields HpackUse -> Parser HpackUse
forall a. a -> Mod FlagFields a -> Parser a
flag' HpackUse
NoHpack ([Char] -> Mod FlagFields HpackUse
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"no-hpack" Mod FlagFields HpackUse
-> Mod FlagFields HpackUse -> Mod FlagFields HpackUse
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields HpackUse
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"disable hpack run and use only cabal disregarding package.yaml existence")
        Parser HpackUse -> Parser HpackUse -> Parser HpackUse
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
        HpackUse -> Parser HpackUse
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HpackUse
PackageYamlHpack
      )
  Bool
optDoCheck
    <- Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag Bool
True Bool
False ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"no-check" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"don't run regression test suites of this package")
  Bool
optJailbreak
    <- Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"jailbreak" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"disregard version restrictions on build inputs")
  Bool
optDoBenchmark
    <- Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"benchmark" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"enable benchmarks for this package")
  Maybe [Char]
optRevision
    <- Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"revision" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"revision to use when fetching from VCS")
  Bool
optHyperlinkSource
    <- Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag Bool
True Bool
False ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"no-hyperlink-source" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"don't generate pretty-printed source code for the documentation")
  Bool
optEnableLibraryProfiling
    <- Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"enable-library-profiling" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"enable library profiling in the generated build")
  Bool
optEnableExecutableProfiling
    <- Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"enable-executable-profiling" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"enable executable profiling in the generated build")
  Maybe Bool
optEnableProfiling
    <- Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"enable-profiling" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"enable both library and executable profiling in the generated build"))
  [[Char]]
optExtraArgs
    <- Parser [Char] -> Parser [[Char]]
forall a. Parser a -> Parser [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"extra-arguments" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"extra parameters required for the function body")
  Maybe [Char]
optHackageDb
    <- Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"hackage-db" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"PATH" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"path to the local hackage db in tar format")
  Bool
optNixShellOutput
    <- Mod FlagFields Bool -> Parser Bool
switch ([Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"shell" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"generate output suitable for nix-shell")
  [[Char]]
optFlags
    <- Parser [Char] -> Parser [[Char]]
forall a. Parser a -> Parser [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ Char -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'f' Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"flag" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Cabal flag (may be specified multiple times)")
  CompilerId
optCompiler
    <- ReadM CompilerId
-> Mod OptionFields CompilerId -> Parser CompilerId
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM CompilerId
forall a. Parsec a => ReadM a
parseCabal ([Char] -> Mod OptionFields CompilerId
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"compiler" Mod OptionFields CompilerId
-> Mod OptionFields CompilerId -> Mod OptionFields CompilerId
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields CompilerId
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"compiler to use when evaluating the Cabal file" Mod OptionFields CompilerId
-> Mod OptionFields CompilerId -> Mod OptionFields CompilerId
forall a. Semigroup a => a -> a -> a
<> CompilerId -> Mod OptionFields CompilerId
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value CompilerId
buildCompilerId Mod OptionFields CompilerId
-> Mod OptionFields CompilerId -> Mod OptionFields CompilerId
forall a. Semigroup a => a -> a -> a
<> (CompilerId -> [Char]) -> Mod OptionFields CompilerId
forall a (f :: * -> *). (a -> [Char]) -> Mod f a
showDefaultWith CompilerId -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow)
  Platform
optSystem
    <- ReadM Platform -> Mod OptionFields Platform -> Parser Platform
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (([Char] -> Maybe Platform) -> ReadM Platform
forall a. ([Char] -> Maybe a) -> ReadM a
maybeReader [Char] -> Maybe Platform
parsePlatformLenient) ([Char] -> Mod OptionFields Platform
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"system" Mod OptionFields Platform
-> Mod OptionFields Platform -> Mod OptionFields Platform
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Platform
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"host system (in either short Nix format or full LLVM style) to use when evaluating the Cabal file" Mod OptionFields Platform
-> Mod OptionFields Platform -> Mod OptionFields Platform
forall a. Semigroup a => a -> a -> a
<> Platform -> Mod OptionFields Platform
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value Platform
buildPlatform Mod OptionFields Platform
-> Mod OptionFields Platform -> Mod OptionFields Platform
forall a. Semigroup a => a -> a -> a
<> (Platform -> [Char]) -> Mod OptionFields Platform
forall a (f :: * -> *). (a -> [Char]) -> Mod f a
showDefaultWith Platform -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow)
  Maybe [Char]
optSubpath
    <- Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields [Char] -> Parser [Char])
-> Mod OptionFields [Char] -> Parser [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"subpath" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"PATH" Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Path to Cabal file's directory relative to the URI (default is root directory)")
  Maybe UTCTime
optHackageSnapshot
    <- Parser UTCTime -> Parser (Maybe UTCTime)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ReadM UTCTime -> Mod OptionFields UTCTime -> Parser UTCTime
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM UTCTime
utcTimeReader ([Char] -> Mod OptionFields UTCTime
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"hackage-snapshot" Mod OptionFields UTCTime
-> Mod OptionFields UTCTime -> Mod OptionFields UTCTime
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields UTCTime
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"hackage snapshot time, ISO format"))
  NixpkgsResolver
optNixpkgsIdentifier
    <- NixpkgsResolver -> Parser NixpkgsResolver
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (\Identifier
i -> Binding -> Maybe Binding
forall a. a -> Maybe a
Just (Tagged (Identifier, Path) (Identity (Identifier, Path))
-> Tagged Binding (Identity Binding)
Iso' Binding (Identifier, Path)
binding (Tagged (Identifier, Path) (Identity (Identifier, Path))
 -> Tagged Binding (Identity Binding))
-> (Identifier, Path) -> Binding
forall t b. AReview t b -> b -> t
# (Identifier
i, Tagged [Identifier] (Identity [Identifier])
-> Tagged Path (Identity Path)
Iso' Path [Identifier]
path (Tagged [Identifier] (Identity [Identifier])
 -> Tagged Path (Identity Path))
-> [Identifier] -> Path
forall t b. AReview t b -> b -> t
# [Tagged [Char] (Identity [Char])
-> Tagged Identifier (Identity Identifier)
Iso' Identifier [Char]
ident (Tagged [Char] (Identity [Char])
 -> Tagged Identifier (Identity Identifier))
-> [Char] -> Identifier
forall t b. AReview t b -> b -> t
# [Char]
"pkgs", Identifier
i])))
  [Char]
optUrl
    <- Mod ArgumentFields [Char] -> Parser [Char]
forall s. IsString s => Mod ArgumentFields s -> Parser s
strArgument ([Char] -> Mod ArgumentFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"URI")
  FetchSubmodules
optFetchSubmodules
    <- FetchSubmodules
-> FetchSubmodules
-> Mod FlagFields FetchSubmodules
-> Parser FetchSubmodules
forall a. a -> a -> Mod FlagFields a -> Parser a
flag FetchSubmodules
FetchSubmodules FetchSubmodules
DontFetchSubmodules  ([Char] -> Mod FlagFields FetchSubmodules
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"dont-fetch-submodules" Mod FlagFields FetchSubmodules
-> Mod FlagFields FetchSubmodules -> Mod FlagFields FetchSubmodules
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields FetchSubmodules
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"do not fetch git submodules from git sources")
  pure Options{Bool
[Char]
[[Char]]
Maybe Bool
Maybe [Char]
Maybe UTCTime
CompilerId
Platform
FetchSubmodules
HpackUse
NixpkgsResolver
optSha256 :: Maybe [Char]
optMaintainer :: [[Char]]
optHaddock :: Bool
optHpack :: HpackUse
optDoCheck :: Bool
optJailbreak :: Bool
optDoBenchmark :: Bool
optRevision :: Maybe [Char]
optHyperlinkSource :: Bool
optEnableLibraryProfiling :: Bool
optEnableExecutableProfiling :: Bool
optEnableProfiling :: Maybe Bool
optExtraArgs :: [[Char]]
optHackageDb :: Maybe [Char]
optNixShellOutput :: Bool
optFlags :: [[Char]]
optCompiler :: CompilerId
optSystem :: Platform
optSubpath :: Maybe [Char]
optHackageSnapshot :: Maybe UTCTime
optNixpkgsIdentifier :: NixpkgsResolver
optUrl :: [Char]
optFetchSubmodules :: FetchSubmodules
optSha256 :: Maybe [Char]
optMaintainer :: [[Char]]
optHaddock :: Bool
optHpack :: HpackUse
optDoCheck :: Bool
optJailbreak :: Bool
optDoBenchmark :: Bool
optRevision :: Maybe [Char]
optHyperlinkSource :: Bool
optEnableLibraryProfiling :: Bool
optEnableExecutableProfiling :: Bool
optEnableProfiling :: Maybe Bool
optExtraArgs :: [[Char]]
optHackageDb :: Maybe [Char]
optNixShellOutput :: Bool
optFlags :: [[Char]]
optCompiler :: CompilerId
optSystem :: Platform
optSubpath :: Maybe [Char]
optHackageSnapshot :: Maybe UTCTime
optNixpkgsIdentifier :: NixpkgsResolver
optUrl :: [Char]
optFetchSubmodules :: FetchSubmodules
..}

-- | A parser for the date. Hackage updates happen maybe once or twice a month.
-- Example: parseTime defaultTimeLocale "%FT%T%QZ" "2017-11-20T12:18:35Z" :: Maybe UTCTime
utcTimeReader :: ReadM UTCTime
utcTimeReader :: ReadM UTCTime
utcTimeReader = ([Char] -> Either [Char] UTCTime) -> ReadM UTCTime
forall a. ([Char] -> Either [Char] a) -> ReadM a
eitherReader (([Char] -> Either [Char] UTCTime) -> ReadM UTCTime)
-> ([Char] -> Either [Char] UTCTime) -> ReadM UTCTime
forall a b. (a -> b) -> a -> b
$ \[Char]
arg ->
    case Bool -> TimeLocale -> [Char] -> [Char] -> Maybe UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> [Char] -> [Char] -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale [Char]
"%FT%T%QZ" [Char]
arg of
        Maybe UTCTime
Nothing      -> [Char] -> Either [Char] UTCTime
forall a b. a -> Either a b
Left ([Char] -> Either [Char] UTCTime)
-> [Char] -> Either [Char] UTCTime
forall a b. (a -> b) -> a -> b
$ [Char]
"Cannot parse date, ISO format used ('2017-11-20T12:18:35Z'): " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
arg
        Just UTCTime
utcTime -> UTCTime -> Either [Char] UTCTime
forall a b. b -> Either a b
Right UTCTime
utcTime

parseCabal :: Parsec a => ReadM a
parseCabal :: forall a. Parsec a => ReadM a
parseCabal = ([Char] -> Either [Char] a) -> ReadM a
forall a. ([Char] -> Either [Char] a) -> ReadM a
eitherReader [Char] -> Either [Char] a
forall a. Parsec a => [Char] -> Either [Char] a
eitherParsec

pinfo :: ParserInfo Options
pinfo :: ParserInfo Options
pinfo = Parser Options -> InfoMod Options -> ParserInfo Options
forall a. Parser a -> InfoMod a -> ParserInfo a
info
        (   Parser ((Options -> Options) -> Options -> Options)
forall a. Parser (a -> a)
helper
        Parser ((Options -> Options) -> Options -> Options)
-> Parser (Options -> Options) -> Parser (Options -> Options)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char]
-> Mod OptionFields (Options -> Options)
-> Parser (Options -> Options)
forall a. [Char] -> Mod OptionFields (a -> a) -> Parser (a -> a)
infoOption ([Char]
"cabal2nix " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Version -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow Version
version) ([Char] -> Mod OptionFields (Options -> Options)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"version" Mod OptionFields (Options -> Options)
-> Mod OptionFields (Options -> Options)
-> Mod OptionFields (Options -> Options)
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields (Options -> Options)
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Show version number")
        Parser (Options -> Options) -> Parser Options -> Parser Options
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Options
options
        )
        (  InfoMod Options
forall a. InfoMod a
fullDesc
        InfoMod Options -> InfoMod Options -> InfoMod Options
forall a. Semigroup a => a -> a -> a
<> [Char] -> InfoMod Options
forall a. [Char] -> InfoMod a
header [Char]
"cabal2nix converts Cabal files into build instructions for Nix."
        InfoMod Options -> InfoMod Options -> InfoMod Options
forall a. Semigroup a => a -> a -> a
<> Maybe Doc -> InfoMod Options
forall a. Maybe Doc -> InfoMod a
progDescDoc (Doc -> Maybe Doc
forall a. a -> Maybe a
Just ([Doc] -> Doc
P2.vcat
                     [ [Char] -> Doc
P2.text [Char]
""
                     , [Char] -> Doc
P2.text [Char]
"Recognized URI schemes:"
                     , [Char] -> Doc
P2.text [Char]
""
                     , [Char] -> Doc
P2.text [Char]
"  cabal://pkgname-pkgversion     download the specified package from Hackage"
                     , [Char] -> Doc
P2.text [Char]
"  cabal://pkgname                download latest version of this package from Hackage"
                     , [Char] -> Doc
P2.text [Char]
"  file:///local/path             load the Cabal file from the local disk"
                     , [Char] -> Doc
P2.text [Char]
"  /local/path                    abbreviated version of file URI"
                     , [Char] -> Doc
P2.text [Char]
"  <git/svn/bzr/hg URL>           download the source from the specified repository"
                     , [Char] -> Doc
P2.text [Char]
""
                     , [Doc] -> Doc
P2.fillSep (([Char] -> Doc) -> [[Char]] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Doc
P2.text ([Char] -> [[Char]]
words (  [Char]
"If the URI refers to a cabal file, information for building the package "
                                                      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"will be retrieved from that file, but hackage will be used as a source "
                                                      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"for the derivation. Otherwise, the supplied URI will be used to as the "
                                                      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"source for the derivation and the information is taken from the cabal file "
                                                      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"at the root of the downloaded source."
                                                      )))
                     ]))
        )

main :: IO ()
main :: IO ()
main = IO () -> (() -> IO ()) -> (() -> IO ()) -> IO ()
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (\() -> Handle -> IO ()
hFlush Handle
stdout IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Handle -> IO ()
hFlush Handle
stderr) ((() -> IO ()) -> IO ()) -> (() -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \() ->
  [[Char]] -> IO ()
cabal2nix ([[Char]] -> IO ()) -> IO [[Char]] -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO [[Char]]
getArgs

hpackOverrides :: Derivation -> Derivation
hpackOverrides :: Derivation -> Derivation
hpackOverrides = ASetter Derivation Derivation [Char] [Char]
-> ([Char] -> [Char]) -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter Derivation Derivation [Char] [Char]
Lens' Derivation [Char]
phaseOverrides ([Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"prePatch = \"hpack\";")
               (Derivation -> Derivation)
-> (Derivation -> Derivation) -> Derivation -> Derivation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
set ((BuildInfo -> Identity BuildInfo)
-> Derivation -> Identity Derivation
Lens' Derivation BuildInfo
libraryDepends ((BuildInfo -> Identity BuildInfo)
 -> Derivation -> Identity Derivation)
-> ((Bool -> Identity Bool) -> BuildInfo -> Identity BuildInfo)
-> ASetter Derivation Derivation Bool Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Binding -> Identity (Set Binding))
-> BuildInfo -> Identity BuildInfo
Lens' BuildInfo (Set Binding)
tool ((Set Binding -> Identity (Set Binding))
 -> BuildInfo -> Identity BuildInfo)
-> ((Bool -> Identity Bool)
    -> Set Binding -> Identity (Set Binding))
-> (Bool -> Identity Bool)
-> BuildInfo
-> Identity BuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Index (Set Binding) -> Lens' (Set Binding) Bool
forall m. Contains m => Index m -> Lens' m Bool
contains (Identifier -> Binding
PP.pkg Identifier
"hpack")) Bool
True

cabal2nix' :: Options -> IO (Either Doc Derivation)
cabal2nix' :: Options -> IO (Either Doc Derivation)
cabal2nix' opts :: Options
opts@Options{Bool
[Char]
[[Char]]
Maybe Bool
Maybe [Char]
Maybe UTCTime
CompilerId
Platform
FetchSubmodules
HpackUse
NixpkgsResolver
optSha256 :: Options -> Maybe [Char]
optMaintainer :: Options -> [[Char]]
optHaddock :: Options -> Bool
optHpack :: Options -> HpackUse
optDoCheck :: Options -> Bool
optJailbreak :: Options -> Bool
optDoBenchmark :: Options -> Bool
optRevision :: Options -> Maybe [Char]
optHyperlinkSource :: Options -> Bool
optEnableLibraryProfiling :: Options -> Bool
optEnableExecutableProfiling :: Options -> Bool
optEnableProfiling :: Options -> Maybe Bool
optExtraArgs :: Options -> [[Char]]
optHackageDb :: Options -> Maybe [Char]
optNixShellOutput :: Options -> Bool
optFlags :: Options -> [[Char]]
optCompiler :: Options -> CompilerId
optSystem :: Options -> Platform
optSubpath :: Options -> Maybe [Char]
optHackageSnapshot :: Options -> Maybe UTCTime
optNixpkgsIdentifier :: Options -> NixpkgsResolver
optUrl :: Options -> [Char]
optFetchSubmodules :: Options -> FetchSubmodules
optSha256 :: Maybe [Char]
optMaintainer :: [[Char]]
optHaddock :: Bool
optHpack :: HpackUse
optDoCheck :: Bool
optJailbreak :: Bool
optDoBenchmark :: Bool
optRevision :: Maybe [Char]
optHyperlinkSource :: Bool
optEnableLibraryProfiling :: Bool
optEnableExecutableProfiling :: Bool
optEnableProfiling :: Maybe Bool
optExtraArgs :: [[Char]]
optHackageDb :: Maybe [Char]
optNixShellOutput :: Bool
optFlags :: [[Char]]
optCompiler :: CompilerId
optSystem :: Platform
optSubpath :: Maybe [Char]
optHackageSnapshot :: Maybe UTCTime
optNixpkgsIdentifier :: NixpkgsResolver
optUrl :: [Char]
optFetchSubmodules :: FetchSubmodules
..} = do
  Package
pkg <- HpackUse
-> FetchSubmodules
-> Maybe [Char]
-> Maybe UTCTime
-> Source
-> IO Package
getPackage HpackUse
optHpack FetchSubmodules
optFetchSubmodules Maybe [Char]
optHackageDb Maybe UTCTime
optHackageSnapshot (Source -> IO Package) -> Source -> IO Package
forall a b. (a -> b) -> a -> b
$
         Source {
           sourceUrl :: [Char]
sourceUrl = [Char]
optUrl,
           sourceRevision :: [Char]
sourceRevision = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
"" Maybe [Char]
optRevision,
           sourceHash :: Hash
sourceHash = case Maybe [Char]
optSha256 of
             Maybe [Char]
Nothing -> Hash
UnknownHash
             Just [Char]
hash -> [Char] -> Hash
Guess [Char]
hash,
           sourceCabalDir :: [Char]
sourceCabalDir = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
"" Maybe [Char]
optSubpath
         }
  Options -> Package -> IO (Either Doc Derivation)
processPackage Options
opts Package
pkg

cabal2nixWithDB :: DB.HackageDB -> Options -> IO (Either Doc Derivation)
cabal2nixWithDB :: HackageDB -> Options -> IO (Either Doc Derivation)
cabal2nixWithDB HackageDB
db opts :: Options
opts@Options{Bool
[Char]
[[Char]]
Maybe Bool
Maybe [Char]
Maybe UTCTime
CompilerId
Platform
FetchSubmodules
HpackUse
NixpkgsResolver
optSha256 :: Options -> Maybe [Char]
optMaintainer :: Options -> [[Char]]
optHaddock :: Options -> Bool
optHpack :: Options -> HpackUse
optDoCheck :: Options -> Bool
optJailbreak :: Options -> Bool
optDoBenchmark :: Options -> Bool
optRevision :: Options -> Maybe [Char]
optHyperlinkSource :: Options -> Bool
optEnableLibraryProfiling :: Options -> Bool
optEnableExecutableProfiling :: Options -> Bool
optEnableProfiling :: Options -> Maybe Bool
optExtraArgs :: Options -> [[Char]]
optHackageDb :: Options -> Maybe [Char]
optNixShellOutput :: Options -> Bool
optFlags :: Options -> [[Char]]
optCompiler :: Options -> CompilerId
optSystem :: Options -> Platform
optSubpath :: Options -> Maybe [Char]
optHackageSnapshot :: Options -> Maybe UTCTime
optNixpkgsIdentifier :: Options -> NixpkgsResolver
optUrl :: Options -> [Char]
optFetchSubmodules :: Options -> FetchSubmodules
optSha256 :: Maybe [Char]
optMaintainer :: [[Char]]
optHaddock :: Bool
optHpack :: HpackUse
optDoCheck :: Bool
optJailbreak :: Bool
optDoBenchmark :: Bool
optRevision :: Maybe [Char]
optHyperlinkSource :: Bool
optEnableLibraryProfiling :: Bool
optEnableExecutableProfiling :: Bool
optEnableProfiling :: Maybe Bool
optExtraArgs :: [[Char]]
optHackageDb :: Maybe [Char]
optNixShellOutput :: Bool
optFlags :: [[Char]]
optCompiler :: CompilerId
optSystem :: Platform
optSubpath :: Maybe [Char]
optHackageSnapshot :: Maybe UTCTime
optNixpkgsIdentifier :: NixpkgsResolver
optUrl :: [Char]
optFetchSubmodules :: FetchSubmodules
..} = do
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe [Char] -> Bool
forall a. Maybe a -> Bool
isJust Maybe [Char]
optHackageDb) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ [SGR] -> [Char] -> IO ()
forall (m :: * -> *). MonadIO m => [SGR] -> [Char] -> m ()
colorStderrLn [SGR]
warningColor [Char]
"WARN: HackageDB provided directly; ignoring --hackage-db"
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe UTCTime -> Bool
forall a. Maybe a -> Bool
isJust Maybe UTCTime
optHackageSnapshot) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ [SGR] -> [Char] -> IO ()
forall (m :: * -> *). MonadIO m => [SGR] -> [Char] -> m ()
colorStderrLn [SGR]
warningColor [Char]
"WARN: HackageDB provided directly; ignoring --hackage-snapshot"
  Package
pkg <- HpackUse -> FetchSubmodules -> IO HackageDB -> Source -> IO Package
getPackage' HpackUse
optHpack FetchSubmodules
optFetchSubmodules (HackageDB -> IO HackageDB
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return HackageDB
db) (Source -> IO Package) -> Source -> IO Package
forall a b. (a -> b) -> a -> b
$
         Source {
           sourceUrl :: [Char]
sourceUrl = [Char]
optUrl,
           sourceRevision :: [Char]
sourceRevision = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
"" Maybe [Char]
optRevision,
           sourceHash :: Hash
sourceHash = case Maybe [Char]
optSha256 of
             Maybe [Char]
Nothing -> Hash
UnknownHash
             Just [Char]
hash -> [Char] -> Hash
Guess [Char]
hash,
           sourceCabalDir :: [Char]
sourceCabalDir = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
"" Maybe [Char]
optSubpath
         }
  Options -> Package -> IO (Either Doc Derivation)
processPackage Options
opts Package
pkg

processPackage :: Options -> Package -> IO (Either Doc Derivation)
processPackage :: Options -> Package -> IO (Either Doc Derivation)
processPackage Options{Bool
[Char]
[[Char]]
Maybe Bool
Maybe [Char]
Maybe UTCTime
CompilerId
Platform
FetchSubmodules
HpackUse
NixpkgsResolver
optSha256 :: Options -> Maybe [Char]
optMaintainer :: Options -> [[Char]]
optHaddock :: Options -> Bool
optHpack :: Options -> HpackUse
optDoCheck :: Options -> Bool
optJailbreak :: Options -> Bool
optDoBenchmark :: Options -> Bool
optRevision :: Options -> Maybe [Char]
optHyperlinkSource :: Options -> Bool
optEnableLibraryProfiling :: Options -> Bool
optEnableExecutableProfiling :: Options -> Bool
optEnableProfiling :: Options -> Maybe Bool
optExtraArgs :: Options -> [[Char]]
optHackageDb :: Options -> Maybe [Char]
optNixShellOutput :: Options -> Bool
optFlags :: Options -> [[Char]]
optCompiler :: Options -> CompilerId
optSystem :: Options -> Platform
optSubpath :: Options -> Maybe [Char]
optHackageSnapshot :: Options -> Maybe UTCTime
optNixpkgsIdentifier :: Options -> NixpkgsResolver
optUrl :: Options -> [Char]
optFetchSubmodules :: Options -> FetchSubmodules
optSha256 :: Maybe [Char]
optMaintainer :: [[Char]]
optHaddock :: Bool
optHpack :: HpackUse
optDoCheck :: Bool
optJailbreak :: Bool
optDoBenchmark :: Bool
optRevision :: Maybe [Char]
optHyperlinkSource :: Bool
optEnableLibraryProfiling :: Bool
optEnableExecutableProfiling :: Bool
optEnableProfiling :: Maybe Bool
optExtraArgs :: [[Char]]
optHackageDb :: Maybe [Char]
optNixShellOutput :: Bool
optFlags :: [[Char]]
optCompiler :: CompilerId
optSystem :: Platform
optSubpath :: Maybe [Char]
optHackageSnapshot :: Maybe UTCTime
optNixpkgsIdentifier :: NixpkgsResolver
optUrl :: [Char]
optFetchSubmodules :: FetchSubmodules
..} Package
pkg = do
  let
      withHpackOverrides :: Derivation -> Derivation
      withHpackOverrides :: Derivation -> Derivation
withHpackOverrides = if Package -> Bool
pkgRanHpack Package
pkg then Derivation -> Derivation
hpackOverrides else Derivation -> Derivation
forall a. a -> a
id

      flags :: FlagAssignment
      flags :: FlagAssignment
flags = PackageIdentifier -> FlagAssignment
configureCabalFlags (GenericPackageDescription -> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId (Package -> GenericPackageDescription
pkgCabal Package
pkg)) FlagAssignment -> FlagAssignment -> FlagAssignment
forall a. Monoid a => a -> a -> a
`mappend` [[Char]] -> FlagAssignment
readFlagList [[Char]]
optFlags

      deriv :: Derivation
      deriv :: Derivation
deriv = Derivation -> Derivation
withHpackOverrides (Derivation -> Derivation) -> Derivation -> Derivation
forall a b. (a -> b) -> a -> b
$ HaskellResolver
-> NixpkgsResolver
-> Platform
-> CompilerInfo
-> FlagAssignment
-> [Constraint]
-> GenericPackageDescription
-> Derivation
fromGenericPackageDescription (Bool -> HaskellResolver
forall a b. a -> b -> a
const Bool
True)
                                            NixpkgsResolver
optNixpkgsIdentifier
                                            Platform
optSystem
                                            (CompilerId -> AbiTag -> CompilerInfo
unknownCompilerInfo CompilerId
optCompiler AbiTag
NoAbiTag)
                                            FlagAssignment
flags
                                            []
                                            (Package -> GenericPackageDescription
pkgCabal Package
pkg)
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& (DerivationSource -> Identity DerivationSource)
-> Derivation -> Identity Derivation
Lens' Derivation DerivationSource
src ((DerivationSource -> Identity DerivationSource)
 -> Derivation -> Identity Derivation)
-> DerivationSource -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Package -> DerivationSource
pkgSource Package
pkg
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation [Char] [Char]
Lens' Derivation [Char]
subpath ASetter Derivation Derivation [Char] [Char]
-> [Char] -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
"." Maybe [Char]
optSubpath
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
runHaddock ASetter Derivation Derivation Bool Bool
-> (Bool -> Bool) -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (Bool
optHaddock Bool -> Bool -> Bool
&&)
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
jailbreak ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
optJailbreak
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
hyperlinkSource ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
optHyperlinkSource
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
enableLibraryProfiling ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
optEnableProfiling Bool -> Bool -> Bool
|| Bool
optEnableLibraryProfiling)
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
enableExecutableProfiling ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
optEnableProfiling Bool -> Bool -> Bool
|| Bool
optEnableExecutableProfiling)
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& (Meta -> Identity Meta) -> Derivation -> Identity Derivation
Lens' Derivation Meta
metaSection((Meta -> Identity Meta) -> Derivation -> Identity Derivation)
-> ((Set Identifier -> Identity (Set Identifier))
    -> Meta -> Identity Meta)
-> (Set Identifier -> Identity (Set Identifier))
-> Derivation
-> Identity Derivation
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Set Identifier -> Identity (Set Identifier))
-> Meta -> Identity Meta
Lens' Meta (Set Identifier)
maintainers ((Set Identifier -> Identity (Set Identifier))
 -> Derivation -> Identity Derivation)
-> Set Identifier -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList (([Char] -> Identifier) -> [[Char]] -> [Identifier]
forall a b. (a -> b) -> [a] -> [b]
map ((Tagged [Char] (Identity [Char])
 -> Tagged Identifier (Identity Identifier))
-> [Char] -> Identifier
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review Tagged [Char] (Identity [Char])
-> Tagged Identifier (Identity Identifier)
Iso' Identifier [Char]
ident) [[Char]]
optMaintainer)
--            & metaSection.platforms .~ Set.fromList optPlatform
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
doCheck ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t. ASetter s t Bool Bool -> Bool -> s -> t
&&~ Bool
optDoCheck
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& ASetter Derivation Derivation Bool Bool
Lens' Derivation Bool
doBenchmark ASetter Derivation Derivation Bool Bool
-> Bool -> Derivation -> Derivation
forall s t. ASetter s t Bool Bool -> Bool -> s -> t
||~ Bool
optDoBenchmark
              Derivation -> (Derivation -> Derivation) -> Derivation
forall a b. a -> (a -> b) -> b
& (Set Binding -> Identity (Set Binding))
-> Derivation -> Identity Derivation
Lens' Derivation (Set Binding)
extraFunctionArgs ((Set Binding -> Identity (Set Binding))
 -> Derivation -> Identity Derivation)
-> (Set Binding -> Set Binding) -> Derivation -> Derivation
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Set Binding -> Set Binding -> Set Binding
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([Binding] -> Set Binding
forall a. Ord a => [a] -> Set a
Set.fromList (Binding
"inherit lib"Binding -> [Binding] -> [Binding]
forall a. a -> [a] -> [a]
:([Char] -> Binding) -> [[Char]] -> [Binding]
forall a b. (a -> b) -> [a] -> [b]
map ([Char] -> Binding
forall a. IsString a => [Char] -> a
fromString ([Char] -> Binding) -> ([Char] -> [Char]) -> [Char] -> Binding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"inherit " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++)) [[Char]]
optExtraArgs))

      shell :: Doc
      shell :: Doc
shell = [Doc] -> Doc
vcat
              [ [Char] -> Doc
text [Char]
"{ nixpkgs ? import <nixpkgs> {}, compiler ? \"default\", doBenchmark ? false }:"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"let"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"  inherit (nixpkgs) pkgs;"
              , [Char] -> Doc
text [Char]
""
              , [Doc] -> Doc
hcat [ [Char] -> Doc
text [Char]
"  f = ", Derivation -> Doc
forall a. Pretty a => a -> Doc
pPrint Derivation
deriv, Doc
semi ]
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"  haskellPackages = if compiler == \"default\""
              , [Char] -> Doc
text [Char]
"                       then pkgs.haskellPackages"
              , [Char] -> Doc
text [Char]
"                       else pkgs.haskell.packages.${compiler};"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"  variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id;"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"  drv = variant (haskellPackages.callPackage f {});"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"in"
              , [Char] -> Doc
text [Char]
""
              , [Char] -> Doc
text [Char]
"  if pkgs.lib.inNixShell then drv.env else drv"
              ]
  Either Doc Derivation -> IO (Either Doc Derivation)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either Doc Derivation -> IO (Either Doc Derivation))
-> Either Doc Derivation -> IO (Either Doc Derivation)
forall a b. (a -> b) -> a -> b
$ if Bool
optNixShellOutput then Doc -> Either Doc Derivation
forall a b. a -> Either a b
Left Doc
shell else Derivation -> Either Doc Derivation
forall a b. b -> Either a b
Right Derivation
deriv

cabal2nix :: [String] -> IO ()
cabal2nix :: [[Char]] -> IO ()
cabal2nix = [[Char]] -> IO Options
parseArgs ([[Char]] -> IO Options) -> (Options -> IO ()) -> [[Char]] -> IO ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Options -> IO (Either Doc Derivation)
cabal2nix' (Options -> IO (Either Doc Derivation))
-> (Either Doc Derivation -> IO ()) -> Options -> IO ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [Char] -> IO ()
putStrLn ([Char] -> IO ())
-> (Either Doc Derivation -> [Char])
-> Either Doc Derivation
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Doc -> [Char])
-> (Derivation -> [Char]) -> Either Doc Derivation -> [Char]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Doc -> [Char]
render Derivation -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow

parseArgs :: [String] -> IO Options
parseArgs :: [[Char]] -> IO Options
parseArgs = ParserResult Options -> IO Options
forall a. ParserResult a -> IO a
handleParseResult (ParserResult Options -> IO Options)
-> ([[Char]] -> ParserResult Options) -> [[Char]] -> IO Options
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParserPrefs
-> ParserInfo Options -> [[Char]] -> ParserResult Options
forall a. ParserPrefs -> ParserInfo a -> [[Char]] -> ParserResult a
execParserPure ParserPrefs
defaultPrefs ParserInfo Options
pinfo

-- Utils

readFlagList :: [String] -> FlagAssignment
readFlagList :: [[Char]] -> FlagAssignment
readFlagList = [(FlagName, Bool)] -> FlagAssignment
mkFlagAssignment ([(FlagName, Bool)] -> FlagAssignment)
-> ([[Char]] -> [(FlagName, Bool)]) -> [[Char]] -> FlagAssignment
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> (FlagName, Bool)) -> [[Char]] -> [(FlagName, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> (FlagName, Bool)
tagWithValue
  where tagWithValue :: [Char] -> (FlagName, Bool)
tagWithValue (Char
'-':[Char]
fname) = ([Char] -> FlagName
mkFlagName ([Char] -> [Char]
lowercase [Char]
fname), Bool
False)
        tagWithValue [Char]
fname       = ([Char] -> FlagName
mkFlagName ([Char] -> [Char]
lowercase [Char]
fname), Bool
True)