stack-to-nix: Add configurable output directory

Author: rvl

stack2nix/Main.hs

@@ -1,12 +1,7 @@
-{-# LANGUAGE RecordWildCards   #-}
 module Main where
 
-import Nix.Pretty (prettyNix)
-
-import Stack2nix
-import Stack2nix.CLI
-
---------------------------------------------------------------------------------
+import Stack2nix (doStack2nix)
+import Stack2nix.CLI (parseStack2nixArgs)
 
 main :: IO ()
-main = print . prettyNix =<< stackexpr =<< parseStack2nixArgs
+main = parseStack2nixArgs >>= doStack2nix

stack2nix/Stack2nix.hs

@@ -1,8 +1,9 @@
 {-# LANGUAGE LambdaCase, RecordWildCards, OverloadedStrings #-}
 
 module Stack2nix
-  ( stack2nix
+  ( doStack2nix
   , stackexpr
+  , stack2nix
   ) where
 
 import qualified Data.Text as T
@@ -11,9 +12,10 @@ import Data.String (fromString)
 import Control.Monad.Trans.Maybe
 import Control.Monad.IO.Class (liftIO)
 import Control.Monad (unless, forM)
+import Extra (unlessM)
 
 import System.FilePath ((<.>), (</>), takeDirectory, dropFileName)
-import System.Directory (createDirectoryIfMissing, doesDirectoryExist, getCurrentDirectory)
+import System.Directory (createDirectoryIfMissing, doesDirectoryExist, doesFileExist, getCurrentDirectory)
 import System.IO (IOMode(..), openFile, hClose)
 import Data.Yaml (decodeFileEither)
 
@@ -37,9 +39,18 @@ import Stack2nix.Project
 import Stack2nix.Stack (Stack(..), Dependency(..), Location(..))
 import Stack2nix.External.Resolve
 
+doStack2nix :: Args -> IO ()
+doStack2nix args = do
+  let pkgsNix = argOutputDir args </> "pkgs.nix"
+      defaultNix = argOutputDir args </> "default.nix"
+  pkgs <- stackexpr args
+  writeDoc pkgsNix (prettyNix pkgs)
+  unlessM (doesFileExist defaultNix) $ do
+    writeFile defaultNix defaultNixContents
+
 stackexpr :: Args -> IO NExpr
 stackexpr args =
-  do evalue <- decodeFileEither (stackFile args)
+  do evalue <- decodeFileEither (argStackYaml args)
      case evalue of
        Left e -> error (show e)
        Right value -> stack2nix args
@@ -103,19 +114,19 @@ packages2nix args (Stack _ _ pkgs) =
   do cwd <- getCurrentDirectory
      fmap (mkNonRecSet . concat) . forM pkgs $ \case
        (LocalPath folder) ->
-         do cabalFiles <- findCabalFiles (dropFileName (stackFile args) </> folder)
+         do cabalFiles <- findCabalFiles (dropFileName (argStackYaml args) </> folder)
             forM cabalFiles $ \cabalFile ->
               let pkg = cabalFilePkgName cabalFile
-                  nix = ".stack.nix" </> pkg <.> "nix"
-                  nixFile = outputPath args </> nix
+                  nix = pkg <.> "nix"
+                  nixFile = argOutputDir args </> nix
                   src = Just . C2N.Path $ relPath </> ".." </> folder
               in do createDirectoryIfMissing True (takeDirectory nixFile)
                     writeDoc nixFile =<<
                       prettyNix <$> cabal2nix src cabalFile
                     return $ fromString pkg $= mkPath False nix
        (DVCS (Git url rev) subdirs) ->
          fmap concat . forM subdirs $ \subdir ->
-         do cacheHits <- liftIO $ cacheHits cacheFile url rev subdir
+         do cacheHits <- liftIO $ cacheHits (argCacheFile args) url rev subdir
             case cacheHits of
               [] -> do
                 fetch (\dir -> cabalFromPath url rev subdir $ dir </> subdir)
@@ -126,7 +137,7 @@ packages2nix args (Stack _ _ pkgs) =
                 forM hits $ \( pkg, nix ) -> do
                   return $ fromString pkg $= mkPath False nix
        _ -> return []
-  where relPath = shortRelativePath (outputPath args) (dropFileName (stackFile args))
+  where relPath = shortRelativePath (argOutputDir args) (dropFileName (argStackYaml args))
         cabalFromPath
           :: String    -- URL
           -> String    -- Revision
@@ -140,16 +151,30 @@ packages2nix args (Stack _ _ pkgs) =
           return $ \sha256 ->
             forM cabalFiles $ \cabalFile -> do
             let pkg = cabalFilePkgName cabalFile
-                nix = ".stack.nix" </> pkg <.> "nix"
-                nixFile = outputPath args </> nix
+                nix = pkg <.> "nix"
+                nixFile = argOutputDir args </> nix
                 subdir' = if subdir == "." then Nothing
                           else Just subdir
                 src = Just $ C2N.Git url rev (Just sha256) subdir'
             createDirectoryIfMissing True (takeDirectory nixFile)
             writeDoc nixFile =<<
               prettyNix <$> cabal2nix src cabalFile
-            liftIO $ appendCache cacheFile url rev subdir sha256 pkg nix
+            liftIO $ appendCache (argCacheFile args) url rev subdir sha256 pkg nix
             return $ fromString pkg $= mkPath False nix
 
-cacheFile :: FilePath
-cacheFile = ".stack-to-nix.cache"
+defaultNixContents :: String
+defaultNixContents = unlines
+  [  "{ pkgs ? import <nixpkgs> {} }:"
+  , ""
+  , "let"
+  , "  haskell = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) { inherit pkgs; };"
+  , ""
+  , "  pkgSet = haskell.mkStackPkgSet {"
+  , "    stack-pkgs = import ./pkgs.nix;"
+  , "    pkg-def-overlays = [];"
+  , "    modules = [];"
+  , "  };"
+  , ""
+  , "in"
+  , "  pkgSet.config.hsPkgs"
+  ]

stack2nix/Stack2nix/CLI.hs

@@ -10,20 +10,21 @@ import Data.Semigroup ((<>))
 --------------------------------------------------------------------------------
 -- CLI Arguments
 data Args = Args
-  { outputPath :: FilePath
-  , stackFile  :: FilePath
+  { argOutputDir :: FilePath
+  , argStackYaml :: FilePath
+  , argCacheFile :: FilePath
   } deriving Show
 
 -- Argument Parser
 args :: Parser Args
 args = Args
-  <$> strOption ( long "output" <> short 'o' <> metavar "DIR" <> value "." <> help "Generate output in DIR" )
-  <*> argument str ( metavar "stack.yaml" )
-
+  <$> strOption ( long "output" <> short 'o' <> metavar "DIR" <> help "Generate output in DIR" )
+  <*> strOption ( long "stack-yaml" <> value "stack.yaml" <> showDefault <> metavar "FILE" <> help "Override project stack.yaml" )
+  <*> strOption ( long "cache" <> value ".stack-to-nix.cache" <> showDefault <> metavar "FILE" <> help "Dependency cache file" )
 
 parseStack2nixArgs :: IO Args
 parseStack2nixArgs = execParser opts
   where opts = info (args <**> helper)
           ( fullDesc
-         <> progDesc "Generate a nix expression from a stack.yaml file"
+         <> progDesc "Generate a Nix expression for a Haskell package using Stack"
          <> header "stack-to-nix - a stack to nix converter" )