f6e1b43 · typeable/cabal2nix

git.iko.soy/typeable/cabal2nix

Support all VCS that have a nix-prefetch script

We now use the various nix-prefetch-* scripts to fetch the source. This makes it easy to add new sources, and also makes the code simpler. A side effect is that we now generate a `fetchurl` source for hackage packages, using the `hackage` mirror. This depends on NixOS/nixpkgs#3038 and NixOS/nixpkgs#3039

commitf6e1b432ef7f7c2f23e560aca112db610012377e authorBenno Fünfstück <benno.fuenfstueck@gmail.com> dateSat 21 Jun 2014, 21:10 (12 years ago) parent3e1a648

5 files changed+261−138

compare with master

unifiedsplit

cabal2nix.cabal+4−2 src/Cabal2Nix/Package.hs+96−109 src/Distribution/NixOS/Derivation/Cabal.hs+21−16 src/Distribution/NixOS/Fetch.hs+126 src/cabal2nix.hs+14−11

cabal2nix.cabal+4−2

@@ -49,7 +49,7 @@ Executable cabal2nix

4949 main-is: cabal2nix.hs

5050 hs-source-dirs: src

5151 Build-Depends: base >= 3 && < 5, regex-posix, pretty, Cabal >= 1.16,

52− filepath, directory, process, HTTP, hackage-db, uri

52+ filepath, directory, process, hackage-db, transformers

5353 Extensions: PatternGuards, RecordWildCards, CPP

5454 Ghc-Options: -Wall

5555 other-modules: Cabal2Nix.CorePackages

@@ -60,6 +60,7 @@ Executable cabal2nix

6060 Cabal2Nix.Name

6161 Cabal2Nix.Normalize

6262 Cabal2Nix.PostProcess

63+ Distribution.NixOS.Fetch

6364 Distribution.NixOS.Derivation.Cabal

6465 Distribution.NixOS.Derivation.License

6566 Distribution.NixOS.Derivation.Meta

@@ -69,7 +70,7 @@ Executable hackage4nix

6970 main-is: hackage4nix.hs

7071 hs-source-dirs: src

7172 Build-Depends: base >= 3 && < 5, regex-posix, pretty, Cabal >= 1.16,

72− mtl, containers, directory, filepath, hackage-db

73+ mtl, containers, directory, filepath, hackage-db, transformers, process

7374 Extensions: PatternGuards, RecordWildCards, CPP

7475 Ghc-Options: -Wall

7576 other-modules: Cabal2Nix.CorePackages

@@ -79,6 +80,7 @@ Executable hackage4nix

7980 Cabal2Nix.Name

8081 Cabal2Nix.Normalize

8182 Cabal2Nix.PostProcess

83+ Distribution.NixOS.Fetch

8284 Distribution.NixOS.Derivation.Cabal

8385 Distribution.NixOS.Derivation.License

8486 Distribution.NixOS.Derivation.Meta

src/Cabal2Nix/Package.hs+96−109

@@ -1,20 +1,18 @@

11module Cabal2Nix.Package where

3−import Control.Exception ( handle, SomeException(..))

43import Control.Monad

5−import Data.Functor ( (<$>) )

6−import Data.List ( isSuffixOf )

7−import Data.Maybe ( fromMaybe, fromJust )

4+import Control.Monad.IO.Class

5+import Control.Monad.Trans.Maybe

6+import Data.Functor ( (<$>), (<$) )

7+import Data.List ( isSuffixOf, isPrefixOf )

8+import Data.Maybe ( listToMaybe )

89import Distribution.NixOS.Derivation.Cabal

10+import Distribution.NixOS.Fetch

911import Distribution.Text ( simpleParse )

10−import Network.Browser ( browse, request, setCheckForProxy, setDebugLog, setOutHandler )

11−import Network.HTTP ( getRequest, rspBody )

1212import System.Directory ( doesDirectoryExist, doesFileExist, createDirectoryIfMissing, getHomeDirectory, getDirectoryContents )

1313import System.Exit ( exitFailure )

14−import System.FilePath ( dropFileName, (</>), (<.>) )

15−import System.IO ( hPutStrLn, stderr)

16−import System.Process ( readProcess )

17−import Text.URI

14+import System.FilePath ( (</>), (<.>) )

15+import System.IO ( hPutStrLn, stderr, hPutStr )

1816

1917import qualified Distribution.Hackage.DB as DB

2018import qualified Distribution.Package as Cabal

@@ -26,102 +24,91 @@ data Package = Package

2624 , cabal :: Cabal.GenericPackageDescription

2725 }

2826

29−readPackage :: Maybe String -> URI -> IO Package

30−readPackage optHash uri = case uriScheme uri of

31− Nothing -> local

32− Just "file" -> local

33− Just "cabal" -> cabalPackage optHash $ fromMaybe "" (uriRegName uri) ++ uriPath uri

34− Just scheme -> hPutStrLn stderr ("*** unsupported URI scheme: " ++ scheme) >> exitFailure

35− where local = localPackage optHash $ fromMaybe "" (uriRegName uri) ++ uriPath uri

36−

37−localPackage :: Maybe String -> FilePath -> IO Package

38−localPackage optHash path = do

39− isDir <- doesDirectoryExist path

40− cabalFile <- if isDir

41− then do

42− cabals <- filter (".cabal" `isSuffixOf`) <$> getDirectoryContents path

43− case cabals of

44− [] -> hPutStrLn stderr "*** No cabal file found in given directory" >> exitFailure

45− (f:_) -> return $ path </> f

46− else return path

47− pkgDesc <- readFile cabalFile >>= readPackageDescription

48− if isDir

49− then return $ Package (Directory path) pkgDesc

50− else do

51− hash <- getHash optHash pkgDesc

52− return $ Package (Hackage hash) pkgDesc

53−

54−cabalPackage :: Maybe String -> String -> IO Package

55−cabalPackage optHash packageName = do

56− pkgDesc <- case versionBranch $ Cabal.pkgVersion $ pid packageName of

57− [] -> do

58− packageDescription <- DB.lookup packageName `fmap` DB.readHackage

59− case packageDescription of

60− Just d -> return $ snd $ last $ DB.toList d

61− Nothing -> error "No such package"

62− _ -> fetchUrl (hackagePath (pid packageName) Cabal) >>= readPackageDescription

63− hash <- getHash optHash pkgDesc

64− return $ Package (Hackage hash) pkgDesc

65−

66− where pid p = fromJust $ simpleParse p

67−

68−fetchUrl :: String -> IO String

69−fetchUrl url = do

70− (_,rsp) <- browse $ do

71− setCheckForProxy True

72− setDebugLog Nothing

73− setOutHandler (\_ -> return ())

74− request (getRequest url)

75− return (rspBody rsp)

76−

77−readPackageDescription :: String -> IO Cabal.GenericPackageDescription

78−readPackageDescription source = case Cabal.parsePackageDescription source of

79− Cabal.ParseOk _ a -> return a

80− Cabal.ParseFailed err -> do

81− hPutStrLn stderr ("*** cannot parse cabal file: " ++ show err)

82− exitFailure

83−

84−getHash :: Maybe String -> Cabal.GenericPackageDescription -> IO String

85−getHash optHash pkgDesc = maybe (hashPackage $ Cabal.package $ Cabal.packageDescription pkgDesc) return optHash

86−

87−data Ext = TarGz | Cabal deriving Eq

88−

89−showExt :: Ext -> String

90−showExt TarGz = ".tar.gz"

91−showExt Cabal = ".cabal"

92−

93−hackagePath :: Cabal.PackageIdentifier -> Ext -> String

94−hackagePath (Cabal.PackageIdentifier (Cabal.PackageName name) version') ext =

95− "http://hackage.haskell.org/packages/archive/" ++

96− name ++ "/" ++ version ++ "/" ++ name ++

97− (if ext == TarGz then '-' : version else "") ++

98− showExt ext

99− where

100− version = showVersion version'

101−

102−hashPackage :: Cabal.PackageIdentifier -> IO String

103−hashPackage pkg = do

104− cachePath <- hashCachePath pkg

105− exists <- doesFileExist cachePath

106− hash' <- if exists

107− then readFile cachePath

108− else getHackageHash

109− let hash = reverse (dropWhile (=='\n') (reverse hash'))

110− unless exists $ do

111− createDirectoryIfMissing True (dropFileName cachePath)

112− writeFile cachePath hash

113− return hash

114− where getHackageHash = do

115− let command = "exec nix-prefetch-url 2>/dev/tty " ++ hackagePath pkg TarGz

116− handle handlePrefetchError (readProcess "bash" ["-c", command] "")

117− handlePrefetchError (SomeException _) =

118− error $ "\nError: Cannot compute hash. (Not a hackage project?)\n" ++

119− "Specify hash explicitly via --sha256 and add appropriate \"src\" attribute " ++

120− "to resulting nix expression."

121−

122−hashCachePath :: Cabal.PackageIdentifier -> IO FilePath

123−hashCachePath (Cabal.PackageIdentifier (Cabal.PackageName name) version') = do

124− home <- getHomeDirectory

125− return $ home ++ "/.cache/cabal2nix" </> name ++ "-" ++ version <.> "sha256"

126− where

127− version = showVersion version'

27+getPackage :: Source -> IO Package

28+getPackage source = do

29+ (derivSource, pkgDesc) <- fetchOrFromDB source

30+ flip Package pkgDesc <$> maybe (sourceFromHackage (sourceHash source) $ showPackageIdentifier pkgDesc) return derivSource

31+

32+

33+fetchOrFromDB :: Source -> IO (Maybe DerivationSource, Cabal.GenericPackageDescription)

34+fetchOrFromDB src

35+ | "cabal://" `isPrefixOf` sourceUrl src = fmap ((,) Nothing) . fromDB . drop (length "cabal://") $ sourceUrl src

36+ | otherwise = do

37+ r <- fetch cabalFromPath src

38+ case r of

39+ Nothing -> hPutStrLn stderr "*** failed to fetch source. Does the URL exist?" >> exitFailure

40+ Just (derivSource, (externalSource, pkgDesc)) ->

41+ return (derivSource <$ guard externalSource, pkgDesc)

42+

43+fromDB :: String -> IO Cabal.GenericPackageDescription

44+fromDB pkg = do

45+ pkgDesc <- (lookupVersion <=< DB.lookup name) <$> DB.readHackage

46+ case pkgDesc of

47+ Just r -> return r

48+ Nothing -> hPutStrLn stderr "*** no such package in the cabal database (did you run cabal update?). " >> exitFailure

49+ where

50+ Just pkgId = simpleParse pkg

51+ Cabal.PackageName name = Cabal.pkgName pkgId

52+ version = Cabal.pkgVersion pkgId

53+

54+ lookupVersion :: DB.Map DB.Version Cabal.GenericPackageDescription -> Maybe Cabal.GenericPackageDescription

55+ lookupVersion

56+ | null (versionBranch version) = fmap snd . listToMaybe . reverse . DB.toAscList

57+ | otherwise = DB.lookup version

58+

59+

60+readFileMay :: String -> IO (Maybe String)

61+readFileMay file = do

62+ e <- doesFileExist file

63+ if e

64+ then Just <$> readFile file

65+ else return Nothing

66+

67+hashCachePath :: String -> IO String

68+hashCachePath pid = do

69+ home <- getHomeDirectory

70+ let cacheDir = home </> ".cache/cabal2nix"

71+ createDirectoryIfMissing True cacheDir

72+ return $ cacheDir </> pid <.> "sha256"

73+

74+sourceFromHackage :: Maybe String -> String -> IO DerivationSource

75+sourceFromHackage optHash pkgId = do

76+ cacheFile <- hashCachePath pkgId

77+ hash <- maybe (readFileMay cacheFile) (return . Just) optHash

78+ res <- runMaybeT $ fst <$> fetchWith (False, "url") (Source ("mirror://hackage/" ++ pkgId ++ ".tar.gz") "" hash)

79+ case res of

80+ Just r -> writeFile cacheFile (derivHash r) >> return r

81+ Nothing -> do

82+ hPutStr stderr $ unlines

83+ [ "*** cannot compute hash. (Not a hackage project?)"

84+ , " Specify hash explicitly via --sha256 and add appropriate \"src\" attribute"

85+ , " to resulting nix expression."

86+ ]

87+ exitFailure

88+

89+showPackageIdentifier :: Cabal.GenericPackageDescription -> String

90+showPackageIdentifier pkgDesc = name ++ "-" ++ showVersion version where

91+ pkgId = Cabal.package . Cabal.packageDescription $ pkgDesc

92+ Cabal.PackageName name = Cabal.packageName pkgId

93+ version = Cabal.packageVersion pkgId

94+

95+cabalFromPath :: FilePath -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

96+cabalFromPath path = do

97+ d <- liftIO $ doesDirectoryExist path

98+ (,) d <$> if d

99+ then cabalFromDirectory path

100+ else cabalFromFile path

101+

102+cabalFromDirectory :: FilePath -> MaybeT IO Cabal.GenericPackageDescription

103+cabalFromDirectory dir = do

104+ cabals <- liftIO $ getDirectoryContents dir >>= filterM doesFileExist . map (dir </>) . filter (".cabal" `isSuffixOf`)

105+ case cabals of

106+ [cabalFile] -> cabalFromFile cabalFile

107+ _ -> liftIO $ hPutStrLn stderr "*** found zero or more than one cabal file. Exiting." >> exitFailure

108+

109+cabalFromFile :: FilePath -> MaybeT IO Cabal.GenericPackageDescription

110+cabalFromFile file = do

111+ content <- liftIO $ readFile file

112+ case Cabal.parsePackageDescription content of

113+ Cabal.ParseFailed _ -> mzero

114+ Cabal.ParseOk _ a -> return a

src/Distribution/NixOS/Derivation/Cabal.hs+21−16

@@ -21,6 +21,7 @@ module Distribution.NixOS.Derivation.Cabal

2121 where

2222

2323import Distribution.NixOS.Derivation.Meta

24+import Distribution.NixOS.Fetch

2425import Distribution.NixOS.PrettyPrinting

2526import Distribution.Package

2627import Distribution.Text

@@ -34,8 +35,6 @@ import Data.Char

3435import Data.Function

3536import Text.Regex.Posix hiding ( empty )

3637

37−data DerivationSource = Hackage String | Directory String | FetchUrl String String deriving (Eq, Show, Ord)

38−

3938-- | A represtation of Nix expressions for building Haskell packages.

4039-- The data type correspond closely to the definition of

4140-- 'PackageDescription' from Cabal.

@@ -79,8 +78,8 @@ renderDerivation deriv = funargs (map text ("cabal" : inputs)) $$ vcat

7978 , nest 2 $ vcat $

8079 [ attr "pname" $ string (pname deriv)

8180 , attr "version" $ doubleQuotes (disp (version deriv))

82− ] ++ sourceAttrs (src deriv) ++

83− [ boolattr "isLibrary" (not (isLibrary deriv) || isExecutable deriv) (isLibrary deriv)

81+ , sourceAttr (src deriv)

82+ , boolattr "isLibrary" (not (isLibrary deriv) || isExecutable deriv) (isLibrary deriv)

8483 , boolattr "isExecutable" (not (isLibrary deriv) || isExecutable deriv) (isExecutable deriv)

8584 , listattr "buildDepends" (buildDepends deriv)

8685 , listattr "testDepends" (testDepends deriv)

@@ -101,20 +100,24 @@ renderDerivation deriv = funargs (map text ("cabal" : inputs)) $$ vcat

101100 where

102101 inputs = nub $ sortBy (compare `on` map toLower) $ filter (/="cabal") $ filter (not . isPrefixOf "self.") $

103102 buildDepends deriv ++ testDepends deriv ++ buildTools deriv ++ extraLibs deriv ++ pkgConfDeps deriv ++ extraFunctionArgs deriv

104− ++ ["fetchurl" | FetchUrl _ _ <- [src deriv]]

103+ ++ ["fetch" ++ derivKind (src deriv) | derivKind (src deriv) /= ""]

105104 renderedFlags = [ text "-f" <> (if enable then empty else char '-') <> text f | (FlagName f, enable) <- cabalFlags deriv ]

106105 ++ map text (configureFlags deriv)

107− sourceAttrs (Hackage hash) = [attr "sha256" $ string hash]

108− sourceAttrs (Directory dir) = [attr "src" $ text dir]

109− sourceAttrs (FetchUrl url hash) = return $ attr "src" $ text "fetchurl" <+> lbrace $$ nest 2 (vcat

110− [ attr "url" $ string url

111− , attr "sha256" $ string hash

112− ])

106+ sourceAttr (DerivationSource{..})

107+ | derivKind /= "" = vcat

108+ [ text "src" <+> equals <+> text ("fetch" ++ derivKind) <+> lbrace

109+ , nest 2 $ vcat

110+ [ attr "url" $ string derivUrl

111+ , attr "sha256" $ string derivHash

112+ , if derivRevision /= "" then attr "rev" (string derivRevision) else empty

113+ ]

114+ , rbrace <> semi

115+ ]

116+ | otherwise = attr "src" $ text derivUrl

113117

114118-- | A very incomplete parser that extracts 'pname', 'version',

115119-- 'sha256', 'platforms', 'hydraPlatforms', 'maintainers', 'doCheck',

116120-- 'jailbreak', and 'runHaddock' from the given Nix expression.

117−

118121parseDerivation :: String -> Maybe Derivation

119122parseDerivation buf

120123 | buf =~ "cabal.mkDerivation"

@@ -123,7 +126,8 @@ parseDerivation buf

123126 , Just vers <- simpleParse vers'

124127 , sha <- buf `regsubmatch` "sha256 *= *\"([^\"]+)\""

125128 , sr <- buf `regsubmatch` "src *= *([^;]+);"

126− , url <- buf `regsubmatch` "url *= *([^;]+);"

129+ , url <- buf `regsubmatch` "url *= *\"?([^;\"]+)\"? *;"

130+ , rev <- buf `regsubmatch` "rev *= *\"([^\"]+)\""

127131 , hplats <- buf `regsubmatch` "hydraPlatforms *= *([^;]+);"

128132 , plats <- buf `regsubmatch` "platforms *= *([^;]+);"

129133 , maint <- buf `regsubmatch` "maintainers *= *\\[([^\"]+)]"

@@ -134,9 +138,10 @@ parseDerivation buf

134138 { pname = name

135139 , version = vers

136140 , src = case (sr,url) of

137− ([] , _ ) -> Hackage $ head sha

138− (_ , url':_ ) -> FetchUrl url' $ head sha

139− (sr':_, [] ) -> Directory sr'

141+ ([] , _ ) -> DerivationSource "url" ("mirror://hackage/" ++ name ++ "-" ++ vers' ++ ".tar.gz") "" $ head sha

142+ (sr':_, [] ) -> DerivationSource "" sr' "" ""

143+ (sr':_, url':_ ) -> DerivationSource (drop (length "fetch") . head . words $ sr')

144+ url' (head $ rev ++ [""]) $ head sha

140145

141146 , isLibrary = False

142147 , isExecutable = False

src/Distribution/NixOS/Fetch.hsnew file+126

@@ -0,0 +1,126 @@

1+{-# LANGUAGE OverloadedStrings #-}

2+{-# LANGUAGE RecordWildCards #-}

3+{-# LANGUAGE ScopedTypeVariables #-}

4+module Distribution.NixOS.Fetch

5+ ( Source(..)

6+ , DerivationSource(..), fromDerivationSource

7+ , fetch

8+ , fetchWith

9+ ) where

10+

11+import Control.Applicative

12+import Control.Monad

13+import Control.Monad.IO.Class

14+import Control.Monad.Trans.Maybe

15+import Data.Maybe

16+import System.Directory

17+import System.Environment

18+import System.Exit

19+import System.IO

20+import System.Process

21+

22+-- | A source is a location from which we can fetch, such as a HTTP URL, a GIT URL, ....

23+data Source = Source

24+ { sourceUrl :: String -- ^ URL to fetch from.

25+ , sourceRevision :: String -- ^ Revision to use. For protocols where this doesn't make sense (such as HTTP), this

26+ -- should be the empty string.

27+ , sourceHash :: Maybe String -- ^ The expected hash of the source, if available.

28+ } deriving (Show, Eq, Ord)

29+

30+-- | A source for a derivation. It always needs a hash and also has a protocol attached to it (url, git, svn, ...).

31+-- A @DerivationSource@ also always has it's revision fully resolved (not relative revisions like @master@, @HEAD@, etc).

32+data DerivationSource = DerivationSource

33+ { derivKind :: String -- ^ The kind of the source. The name of the build-support fetch derivation should be fetch<kind>.

34+ , derivUrl :: String -- ^ URL to fetch from.

35+ , derivRevision :: String -- ^ Revision to use. Leave empty if the fetcher doesn't support revisions.

36+ , derivHash :: String -- ^ The hash of the source.

37+ } deriving (Show, Eq, Ord)

38+

39+fromDerivationSource :: DerivationSource -> Source

40+fromDerivationSource DerivationSource{..} = Source derivUrl derivRevision $ Just derivHash

41+

42+-- | Fetch a source, trying any of the various nix-prefetch-* scripts.

43+fetch :: forall a. (String -> MaybeT IO a) -- ^ This function is passed the output path name as an argument.

44+ -- It should return 'Nothing' if the file doesn't match the expected format.

45+ -- This is required, because we cannot always check if a download succeeded otherwise.

46+ -> Source -- ^ The source to fetch from.

47+ -> IO (Maybe (DerivationSource, a)) -- ^ The derivation source and the result of the processing function. Returns Nothing if the download failed.

48+fetch f = runMaybeT . fetchers where

49+ fetchers :: Source -> MaybeT IO (DerivationSource, a)

50+ fetchers source = msum . (fetchLocal source :) $ map (\fetcher -> fetchWith fetcher source >>= process)

51+ [ (False, "url")

52+ , (True, "git")

53+ , (True, "hg")

54+ , (True, "svn")

55+ , (True, "bzr")

56+ ]

57+

58+ fetchLocal :: Source -> MaybeT IO (DerivationSource, a)

59+ fetchLocal src = do

60+ let path = stripPrefix "file://" $ sourceUrl src

61+ existsFile <- liftIO $ doesFileExist path

62+ existsDir <- liftIO $ doesDirectoryExist path

63+ guard $ existsDir || existsFile

64+ process (DerivationSource "" path "" "", path)

65+

66+ process :: (DerivationSource, FilePath) -> MaybeT IO (DerivationSource, a)

67+ process (derivSource, file) = (,) derivSource <$> f file

68+

69+-- | Like 'fetch', but allows to specify which script to use.

70+fetchWith :: (Bool, String) -> Source -> MaybeT IO (DerivationSource, FilePath)

71+fetchWith (supportsRev, kind) source = do

72+ liftIO $ hPutStrLn stderr $ "* trying fetcher: " ++ kind

73+

74+ unless ((sourceRevision source /= "") || isNothing (sourceHash source) || not supportsRev) $

75+ liftIO (hPutStrLn stderr "** need a revision for VCS when the hash is given. skipping.") >> mzero

76+

77+ MaybeT $ liftIO $ do

78+ envs <- getEnvironment

79+ (Nothing, Just stdoutH, _, processH) <- createProcess (proc script args)

80+ { env = Just $ ("PRINT_PATH", "1") : envs

81+ , std_in = Inherit

82+ , std_err = CreatePipe

83+ , std_out = CreatePipe

84+ }

85+

86+ exitCode <- waitForProcess processH

87+ case exitCode of

88+ ExitSuccess -> fmap Just . processOutputSwitch . lines =<< hGetContents stdoutH

89+ ExitFailure _ -> return Nothing

90+

91+ where

92+

93+ script :: String

94+ script = "nix-prefetch-" ++ kind

95+

96+ args :: [String]

97+ args = sourceUrl source : [ sourceRevision source | supportsRev ] ++ maybeToList (sourceHash source)

98+

99+ processOutputWithRev :: [String] -> IO (DerivationSource, FilePath)

100+ processOutputWithRev [rev,hash,path] = return (DerivationSource kind (sourceUrl source) (extractRevision rev) hash, path)

101+ processOutputWithRev out = unexpectedOutput out

102+

103+ extractRevision :: String -> String

104+ extractRevision = unwords . drop 3 . words -- drop the "<vcs> revision is" prefix

105+

106+ processOutput :: [String] -> IO (DerivationSource, FilePath)

107+ processOutput [hash,path] = return (DerivationSource kind (sourceUrl source) (sourceRevision source) hash, path)

108+ processOutput out = unexpectedOutput out

109+

110+ unexpectedOutput :: [String] -> IO a

111+ unexpectedOutput out = do

112+ hPutStrLn stderr $ "*** unexpected output from " ++ "nix-prefetch-" ++ kind ++ " script: "

113+ hPutStr stderr $ unlines out

114+ exitFailure

115+

116+ processOutputSwitch :: [String] -> IO (DerivationSource, FilePath)

117+ processOutputSwitch

118+ | supportsRev && isNothing (sourceHash source) = processOutputWithRev

119+ | otherwise = processOutput

120+

121+stripPrefix :: Eq a => [a] -> [a] -> [a]

122+stripPrefix prefix as

123+ | prefix' == prefix = stripped

124+ | otherwise = as

125+ where

126+ (prefix', stripped) = splitAt (length prefix) as

src/cabal2nix.hs+14−11

@@ -4,6 +4,7 @@ import Cabal2Nix.Generate ( cabal2nix )

44import Cabal2Nix.Normalize ( normalize )

55import Cabal2Nix.Package

66import Distribution.NixOS.Derivation.Cabal

7+import Distribution.NixOS.Fetch

89import Control.Exception ( bracket )

910import Control.Monad ( when )

@@ -12,7 +13,6 @@ import System.Console.GetOpt ( OptDescr(..), ArgDescr(..), ArgOrder(..), usageIn

1213import System.Environment ( getArgs )

1314import System.Exit ( exitFailure, exitSuccess )

1415import System.IO ( hPutStrLn, hFlush, stdout, stderr )

15−import Text.URI ( parseURI )

1616

1717data Configuration = Configuration

1818 { optPrintHelp :: Bool

@@ -23,6 +23,7 @@ data Configuration = Configuration

2323 , optHaddock :: Bool

2424 , optDoCheck :: Bool

2525 , optJailbreak :: Bool

26+ , optRevision :: String

2627 }

2728 deriving (Show)

2829

@@ -36,6 +37,7 @@ defaultConfiguration = Configuration

3637 , optHaddock = True

3738 , optDoCheck = True

3839 , optJailbreak = False

40+ , optRevision = ""

3941 }

4042

4143options :: [OptDescr (Configuration -> Configuration)]

@@ -47,6 +49,7 @@ options =

4749 , Option "" ["no-haddock"] (NoArg (\o -> o { optHaddock = False })) "don't run Haddock when building this package"

4850 , Option "" ["no-check"] (NoArg (\o -> o { optDoCheck = False })) "don't run regression test suites of this package"

4951 , Option "" ["jailbreak"] (NoArg (\o -> o { optJailbreak = True })) "don't honor version restrictions on build inputs"

52+ , Option "" ["rev"] (ReqArg (\x o -> o { optRevision = x }) "REVISION") "revision, only used when fetching from VCS"

5053 ]

5154

5255usage :: String

@@ -54,13 +57,16 @@ usage = usageInfo "Usage: cabal2nix [options] URI" options ++ unlines

5457 [ ""

5558 , "Recognized URI schemes:"

5659 , ""

57− , " cabal://pkgname-pkgversion download the specified package from Hackage"

58− , " cabal://pkgname download latest version of the specified package from Hackage"

59− , " file:///local/path load the Cabal file from the local disk"

60− , " /local/path abbreviated version of file URI"

60+ , " cabal://pkgname-pkgversion download the specified package from Hackage"

61+ , " cabal://pkgname download latest version of the specified package from Hackage"

62+ , " file:///local/path load the Cabal file from the local disk"

63+ , " /local/path abbreviated version of file URI"

64+ , " <git/svn/bzr/hg URL> download the source from the specified repository"

6165 , ""

62− , "If URI is a local path and is not a file, then it will be used as the source of the package. Otherwise, the source"

63− , "will be downloaded from hackage."

66+ , "If the URI refers to a cabal file, information for building the package will be retrieved from that file, but "

67+ , "hackage will be used as a source for the derivation."

68+ , "Otherwise, the supplied URI will be used to as the source for the derivation and the information is taken"

69+ , "from the cabal file at the root of the downloaded source."

6470 ]

6571

6672cmdlineError :: String -> IO a

@@ -77,10 +83,7 @@ main = bracket (return ()) (\() -> hFlush stdout >> hFlush stderr) $ \() -> do

7783 when (optPrintHelp cfg) (putStr usage >> exitSuccess)

7884 when (length args /= 1) (cmdlineError "*** exactly one url-to-cabal-file must be specified\n")

7985

80− uri <- case parseURI (head args) of

81− Nothing -> hPutStrLn stderr "*** invalid uri" >> exitFailure

82− Just uri' -> return uri'

83− pkg <- readPackage (optSha256 cfg) uri

86+ pkg <- getPackage $ Source (head args) (optRevision cfg) (optSha256 cfg)

8487

8588 let deriv = (cabal2nix $ cabal pkg) { src = source pkg, runHaddock = optHaddock cfg, jailbreak = optJailbreak cfg }

8689 deriv' = deriv { metaSection = (metaSection deriv)