Add --cabal-path option

Allows usage with custom cabal path. Additionally, adds general
--cabal-options argument, for passing through arbitrary cabal options.

The latter subsumes the --jobs and --cabal-verbosity args, hence they
are removed. The previous behavior can be achieved with e.g.

  clc-stackage --cabal-options='--jobs=semaphore --verbose=1'

Author: tbidne

clc-stackage.cabal

@@ -43,7 +43,7 @@ library utils
     , bytestring       >=0.10.12.0 && <0.13
     , directory        ^>=1.3.5.0
     , file-io          ^>=0.1.0.0
-    , filepath         >=1.4.2.1   && <1.6
+    , filepath         >=1.4.100.0 && <1.6
     , pretty-terminal  ^>=0.1.0.0
     , text             >=1.2.3.2   && <2.2
     , time             >=1.9.3     && <1.15
@@ -130,9 +130,7 @@ executable clc-stackage
 
 library test-utils
   import:          common-lang
-  exposed-modules:
-    Test.Utils
-
+  exposed-modules: Test.Utils
   build-depends:
     , base
     , tasty         >=1.1.0.3  && <1.6
@@ -157,7 +155,7 @@ test-suite unit
     , runner
     , tasty
     , tasty-golden
-    , tasty-hunit   >=0.9      && <0.11
+    , tasty-hunit   >=0.9 && <0.11
     , test-utils
     , time
     , utils
@@ -177,9 +175,9 @@ test-suite functional
     , env-guard     ^>=0.2
     , filepath
     , runner
-    , test-utils
     , tasty
     , tasty-golden
+    , test-utils
     , text
     , time
     , utils

src/builder/CLC/Stackage/Builder/Env.hs

@@ -1,10 +1,6 @@
 -- | Provides the environment for building.
 module CLC.Stackage.Builder.Env
   ( BuildEnv (..),
-    CabalVerbosity (..),
-    cabalVerbosityToArg,
-    Jobs (..),
-    jobsToArg,
     Progress (..),
     WriteLogs (..),
   )
@@ -15,40 +11,6 @@ import CLC.Stackage.Utils.Logging qualified as Logging
 import Data.IORef (IORef)
 import Data.List.NonEmpty (NonEmpty)
 import Data.Set (Set)
-import Data.Word (Word8)
-
--- | Cabal's --verbose flag
-data CabalVerbosity
-  = -- | V0
-    CabalVerbosity0
-  | -- | V1
-    CabalVerbosity1
-  | -- | V2
-    CabalVerbosity2
-  | -- | V3
-    CabalVerbosity3
-  deriving stock (Eq, Show)
-
-cabalVerbosityToArg :: CabalVerbosity -> String
-cabalVerbosityToArg CabalVerbosity0 = "--verbose=0"
-cabalVerbosityToArg CabalVerbosity1 = "--verbose=1"
-cabalVerbosityToArg CabalVerbosity2 = "--verbose=2"
-cabalVerbosityToArg CabalVerbosity3 = "--verbose=3"
-
--- | Number of build jobs.
-data Jobs
-  = -- | Literal number of jobs.
-    JobsN Word8
-  | -- | String "$ncpus"
-    JobsNCpus
-  | -- | Job semaphore. Requires GHC 9.8 and Cabal 3.12
-    JobsSemaphore
-  deriving stock (Eq, Show)
-
-jobsToArg :: Jobs -> String
-jobsToArg (JobsN n) = "--jobs=" ++ show n
-jobsToArg JobsNCpus = "--jobs=$ncpus"
-jobsToArg JobsSemaphore = "--semaphore"
 
 data Progress = MkProgress
   { -- | Dependencies that built successfully.
@@ -74,6 +36,8 @@ data BuildEnv = MkBuildEnv
     batch :: Maybe Int,
     -- | Build arguments for cabal.
     buildArgs :: [String],
+    -- | Optional path to cabal executable.
+    cabalPath :: FilePath,
     -- | If true, colors logs.
     colorLogs :: Bool,
     -- | If true, the first group that fails to completely build stops

src/builder/CLC/Stackage/Builder/Process.hs

@@ -8,7 +8,8 @@ where
 import CLC.Stackage.Builder.Batch (PackageGroup (unPackageGroup))
 import CLC.Stackage.Builder.Env
   ( BuildEnv
-      ( colorLogs,
+      ( cabalPath,
+        colorLogs,
         groupFailFast,
         hLogger,
         progress,
@@ -45,15 +46,15 @@ buildProject env idx pkgs = do
   let buildNoLogs :: IO ExitCode
       buildNoLogs =
         withGeneratedDir $
-          (\(ec, _, _) -> ec) <$> P.readProcessWithExitCode "cabal" env.buildArgs ""
+          (\(ec, _, _) -> ec) <$> P.readProcessWithExitCode env.cabalPath env.buildArgs ""
 
       buildLogs :: Bool -> IO ExitCode
       buildLogs saveFailures = do
         (dirPath, stdoutPath, stderrPath) <- createCurrentLogsDir
 
         IO.withBinaryFileWriteMode stdoutPath $ \stdoutHandle ->
           IO.withBinaryFileWriteMode stderrPath $ \stderrHandle -> do
-            let createProc = P.proc "cabal" env.buildArgs
+            let createProc = P.proc env.cabalPath env.buildArgs
                 createProc' =
                   createProc
                     { P.std_out = P.UseHandle stdoutHandle,

src/runner/CLC/Stackage/Runner/Args.hs

@@ -6,15 +6,9 @@ module CLC.Stackage.Runner.Args
 where
 
 import CLC.Stackage.Builder.Env
-  ( CabalVerbosity
-      ( CabalVerbosity0,
-        CabalVerbosity1,
-        CabalVerbosity2,
-        CabalVerbosity3
-      ),
-    Jobs (JobsN, JobsNCpus, JobsSemaphore),
-    WriteLogs (WriteLogsCurrent, WriteLogsNone, WriteLogsSaveFailures),
+  ( WriteLogs (WriteLogsCurrent, WriteLogsNone, WriteLogsSaveFailures),
   )
+import Data.String qualified as Str
 import Options.Applicative
   ( Mod,
     Parser,
@@ -35,7 +29,8 @@ import Options.Applicative.Help.Chunk (Chunk (Chunk))
 import Options.Applicative.Help.Chunk qualified as Chunk
 import Options.Applicative.Help.Pretty qualified as Pretty
 import Options.Applicative.Types (ArgPolicy (Intersperse))
-import Text.Read qualified as TR
+import System.OsPath (OsPath)
+import System.OsPath qualified as OsP
 
 -- | Log coloring option.
 data ColorLogs
@@ -49,16 +44,16 @@ data Args = MkArgs
   { -- | If given, batches packages together so we build more than one.
     -- Defaults to batching everything together in the same group.
     batch :: Maybe Int,
-    -- | Cabal's --verbosity flag.
-    cabalVerbosity :: Maybe CabalVerbosity,
+    -- | Options to pass to cabal e.g. --semaphore.
+    cabalOpts :: [String],
+    -- | Optional path to cabal executable.
+    cabalPath :: Maybe OsPath,
     -- | Determines if we color the logs. If 'Nothing', attempts to detect
     -- if colors are supported.
     colorLogs :: ColorLogs,
     -- | If true, the first group that fails to completely build stops
     -- clc-stackage.
     groupFailFast :: Bool,
-    -- | Number of build jobs.
-    jobs :: Maybe Jobs,
     -- | Disables the cache, which otherwise saves the outcome of a run in a
     -- json file. The cache is used for resuming a run that was interrupted.
     noCache :: Bool,
@@ -119,10 +114,10 @@ parseCliArgs :: Parser Args
 parseCliArgs =
   ( do
       batch <- parseBatch
-      cabalVerbosity <- parseCabalVerbosity
+      cabalOpts <- parseCabalOpts
+      cabalPath <- parseCabalPath
       colorLogs <- parseColorLogs
       groupFailFast <- parseGroupFailFast
-      jobs <- parseJobs
       noCache <- parseNoCache
       noCleanup <- parseNoCleanup
       packageFailFast <- parsePackageFailFast
@@ -132,10 +127,10 @@ parseCliArgs =
       pure $
         MkArgs
           { batch,
-            cabalVerbosity,
+            cabalOpts,
+            cabalPath,
             colorLogs,
             groupFailFast,
-            jobs,
             noCache,
             noCleanup,
             packageFailFast,
@@ -164,27 +159,37 @@ parseBatch =
           ]
       )
 
-parseCabalVerbosity :: Parser (Maybe CabalVerbosity)
-parseCabalVerbosity =
+parseCabalOpts :: Parser [String]
+parseCabalOpts =
+  OA.option
+    readOpts
+    ( mconcat
+        [ OA.long "cabal-options",
+          OA.metavar "ARGS...",
+          OA.value [],
+          mkHelp "Quoted arguments to pass to cabal e.g. '--semaphore --verbose=1'"
+        ]
+    )
+  where
+    readOpts = Str.words <$> OA.str
+
+parseCabalPath :: Parser (Maybe OsPath)
+parseCabalPath =
   OA.optional $
     OA.option
-      readCabalVerbosity
+      readOsPath
       ( mconcat
-          [ OA.long "cabal-verbosity",
-            OA.metavar "(0 | 1 | 2 | 3)",
-            mkHelp
-              "Cabal's --verbose flag. Uses cabal's default if not given (1)."
+          [ OA.long "cabal-path",
+            OA.metavar "PATH",
+            mkHelp "Optional path to cabal executable."
           ]
       )
   where
-    readCabalVerbosity =
-      OA.str >>= \case
-        "0" -> pure CabalVerbosity0
-        "1" -> pure CabalVerbosity1
-        "2" -> pure CabalVerbosity2
-        "3" -> pure CabalVerbosity3
-        other ->
-          fail $ "Expected one of (0 | 1 | 2 | 3), received: " ++ other
+    readOsPath = do
+      fp <- OA.str
+      case OsP.encodeUtf fp of
+        Just osp -> pure osp
+        Nothing -> fail $ "Failed encoding to ospath: " ++ fp
 
 parseColorLogs :: Parser ColorLogs
 parseColorLogs =
@@ -220,44 +225,6 @@ parseGroupFailFast =
           "clc-stackage."
         ]
 
-parseJobs :: Parser (Maybe Jobs)
-parseJobs =
-  OA.optional $
-    OA.option
-      readJobs
-      ( mconcat
-          [ OA.short 'j',
-            OA.long "jobs",
-            OA.metavar "(NAT | $ncpus | semaphore)",
-            mkHelp $
-              mconcat
-                [ "Controls the number of build jobs i.e. the flag passed to ",
-                  "cabal's --jobs option. Can be a natural number in [1, 255] ",
-                  "or the literal string '$ncpus', meaning all cpus. The ",
-                  "literal 'semaphore' will instead use cabal's --semaphore ",
-                  "option. This requires GHC 9.8+ and Cabal 3.12+. No option ",
-                  "uses cabal's default i.e. $ncpus."
-                ]
-          ]
-      )
-  where
-    readJobs =
-      OA.str >>= \case
-        "$ncpus" -> pure JobsNCpus
-        "semaphore" -> pure JobsSemaphore
-        other -> case TR.readMaybe @Int other of
-          Just n ->
-            if n > 0 && n < 256
-              then pure $ JobsN $ fromIntegral n
-              else fail $ "Expected NAT in [1, 255], received: " ++ other
-          Nothing ->
-            fail $
-              mconcat
-                [ "Expected one of (NAT in [1, 255] | $ncpus | semaphore), ",
-                  "received: ",
-                  other
-                ]
-
 parseNoCache :: Parser Bool
 parseNoCache =
   OA.switch

src/runner/CLC/Stackage/Runner/Env.hs

@@ -1,3 +1,5 @@
+{-# LANGUAGE QuasiQuotes #-}
+
 module CLC.Stackage.Runner.Env
   ( RunnerEnv (..),
     setup,
@@ -40,6 +42,7 @@ import CLC.Stackage.Runner.Args
 import CLC.Stackage.Runner.Args qualified as Args
 import CLC.Stackage.Runner.Report (Results (MkResults))
 import CLC.Stackage.Runner.Report qualified as Report
+import CLC.Stackage.Utils.Exception qualified as Ex
 import CLC.Stackage.Utils.IO qualified as IO
 import CLC.Stackage.Utils.Logging qualified as Logging
 import CLC.Stackage.Utils.Paths qualified as Paths
@@ -49,15 +52,17 @@ import Data.Bool (Bool (False, True), not)
 import Data.Foldable (Foldable (foldl'))
 import Data.IORef (newIORef, readIORef)
 import Data.List.NonEmpty (NonEmpty ((:|)))
-import Data.Maybe (Maybe (Just, Nothing), fromMaybe, maybe)
+import Data.Maybe (Maybe (Just, Nothing), fromMaybe)
 import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.Text qualified as T
 import Data.Time (LocalTime)
 import System.Console.Pretty (supportsPretty)
 import System.Directory.OsPath qualified as Dir
 import System.Exit (ExitCode (ExitSuccess))
-import Prelude (IO, mconcat, pure, show, ($), (++), (.), (<$>), (<>))
+import System.OsPath (osp)
+import System.OsPath qualified as OsP
+import Prelude (IO, Monad ((>>=)), mconcat, pure, show, ($), (++), (.), (<$>), (<>))
 
 -- | Args used for building all packages.
 data RunnerEnv = MkRunnerEnv
@@ -90,18 +95,22 @@ setup hLogger modifyPackages = do
 
   -- Set up build args for cabal, filling in missing defaults
   let buildArgs =
-        ["build"]
-          ++ cabalVerboseArg
-          ++ jobsArg
-          ++ keepGoingArg
-
-      cabalVerboseArg = toArgs Builder.Env.cabalVerbosityToArg cliArgs.cabalVerbosity
-      jobsArg = toArgs Builder.Env.jobsToArg cliArgs.jobs
+        "build"
+          : keepGoingArg
+          ++ cliArgs.cabalOpts
 
       -- when packageFailFast is false, add keep-going so that we build as many
       -- packages in the group.
       keepGoingArg = ["--keep-going" | not cliArgs.packageFailFast]
 
+  let cabalPathRaw = fromMaybe [osp|cabal|] cliArgs.cabalPath
+  cabalPath <-
+    Dir.findExecutable cabalPathRaw >>= \case
+      -- TODO: It would be nice to avoid the decode here and keep everything
+      -- in OsPath, though that is blocked until process support OsPath.
+      Just p -> OsP.decodeUtf p
+      Nothing -> Ex.throwText "Cabal not found"
+
   successesRef <- newIORef Set.empty
   failuresRef <- newIORef Set.empty
 
@@ -158,6 +167,7 @@ setup hLogger modifyPackages = do
         MkBuildEnv
           { batch = cliArgs.batch,
             buildArgs,
+            cabalPath,
             colorLogs,
             groupFailFast = cliArgs.groupFailFast,
             hLogger,
@@ -187,9 +197,6 @@ setup hLogger modifyPackages = do
           version = p.version
         }
 
-    toArgs :: (a -> b) -> Maybe a -> [b]
-    toArgs f = maybe [] (\x -> [f x])
-
 -- | Prints summary and writes results to disk.
 teardown :: RunnerEnv -> IO ()
 teardown env = do