Merge with dir argument parsers

Author: cprecioso

waspc/cli/src/Wasp/Cli/Command/BuildStart/ArgumentsParser.hs

@@ -5,14 +5,15 @@ module Wasp.Cli.Command.BuildStart.ArgumentsParser
 where
 
 import qualified Options.Applicative as Opt
-import Wasp.Cli.Util.EnvVarArgument (EnvVarFileArgument, envVarFileReader, envVarReader)
+import Wasp.Cli.Util.EnvVarArgument (envVarReader)
+import Wasp.Cli.Util.PathArgument (FilePathArgument, filePathReader)
 import Wasp.Env (EnvVar)
 
 data BuildStartArgs = BuildStartArgs
   { clientEnvironmentVariables :: [EnvVar],
-    clientEnvironmentFiles :: [EnvVarFileArgument],
+    clientEnvironmentFiles :: [FilePathArgument],
     serverEnvironmentVariables :: [EnvVar],
-    serverEnvironmentFiles :: [EnvVarFileArgument]
+    serverEnvironmentFiles :: [FilePathArgument]
   }
 
 buildStartArgsParser :: Opt.Parser BuildStartArgs
@@ -41,9 +42,9 @@ buildStartArgsParser =
           <> Opt.metavar "NAME=VALUE"
           <> Opt.help ("Set an environment variable for the " <> targetName <> " (can be used multiple times)")
 
-    makeEnvironmentFileParser :: String -> String -> Opt.Parser EnvVarFileArgument
+    makeEnvironmentFileParser :: String -> String -> Opt.Parser FilePathArgument
     makeEnvironmentFileParser targetName longOptionName =
-      Opt.option envVarFileReader $
+      Opt.option filePathReader $
         Opt.long longOptionName
           <> Opt.metavar "FILE_PATH"
           <> Opt.help ("Load environment variables for the " <> targetName <> " from a file (can be used multiple times)")

waspc/cli/src/Wasp/Cli/Command/BuildStart/Config.hs

@@ -23,8 +23,9 @@ import qualified Wasp.AppSpec.Valid as ASV
 import Wasp.Cli.Command (Command, CommandError (CommandError))
 import Wasp.Cli.Command.BuildStart.ArgumentsParser (BuildStartArgs)
 import qualified Wasp.Cli.Command.BuildStart.ArgumentsParser as Args
-import Wasp.Cli.Util.EnvVarArgument (EnvVarFileArgument, readEnvVarFile)
-import Wasp.Env (EnvVar, nubEnvVars, overrideEnvVars)
+import Wasp.Cli.Util.PathArgument (FilePathArgument)
+import qualified Wasp.Cli.Util.PathArgument as PathArgument
+import Wasp.Env (EnvVar, nubEnvVars, overrideEnvVars, parseDotEnvFile)
 import Wasp.Generator.Common (ProjectRootDir)
 import Wasp.Generator.ServerGenerator.Common (defaultDevServerUrl)
 import qualified Wasp.Generator.ServerGenerator.Common as Server
@@ -108,8 +109,11 @@ overrideEnvVarsCommand forced existing =
             intercalate ", " duplicateNames
     Right combined -> return combined
 
-combineEnvVarsWithEnvFiles :: [EnvVar] -> [EnvVarFileArgument] -> IO [EnvVar]
+combineEnvVarsWithEnvFiles :: [EnvVar] -> [FilePathArgument] -> IO [EnvVar]
 combineEnvVarsWithEnvFiles pairs files = do
-  pairsFromFiles <- mapM readEnvVarFile files
+  pairsFromFiles <- mapM readEnvVarsFromFile files
   let allEnvVars = pairs <> concat pairsFromFiles
   return $ nubEnvVars allEnvVars
+
+readEnvVarsFromFile :: FilePathArgument -> IO [EnvVar]
+readEnvVarsFromFile pathArg = PathArgument.getFilePath pathArg >>= parseDotEnvFile

waspc/cli/src/Wasp/Cli/Util/EnvVarArgument.hs

@@ -1,19 +1,11 @@
 module Wasp.Cli.Util.EnvVarArgument
   ( envVarReader,
     envVarFromString,
-    EnvVarFileArgument,
-    getEnvVarFilePath,
-    envVarFileReader,
-    readEnvVarFile,
   )
 where
 
-import Control.Monad ((>=>))
-import Options.Applicative (ReadM, eitherReader, str)
-import StrongPath (Abs, File, Path')
-import StrongPath.FilePath (parseAbsFile)
-import System.Directory (makeAbsolute)
-import Wasp.Env (EnvVar, parseDotEnvFile)
+import Options.Applicative (ReadM, eitherReader)
+import Wasp.Env (EnvVar)
 
 envVarReader :: ReadM EnvVar
 envVarReader = eitherReader envVarFromString
@@ -28,20 +20,3 @@ envVarFromString var =
     _ -> failure
   where
     failure = Left $ "Environment variable must be in the format NAME=VALUE: " ++ var
-
-envVarFileReader :: ReadM EnvVarFileArgument
-envVarFileReader = EnvVarFileArgument <$> str
-
--- Paths passed as arguments to a CLI are conventionally either absolute paths,
--- or paths relative to the current working directory. We need IO to resolve
--- which kind of path it is, but we also don't want any unsafe transformations
--- in the meantime; so we make this type opaque until we have access to the IO
--- monad.
-newtype EnvVarFileArgument = EnvVarFileArgument FilePath
-  deriving (Show, Eq)
-
-getEnvVarFilePath :: EnvVarFileArgument -> IO (Path' Abs (File ()))
-getEnvVarFilePath (EnvVarFileArgument filePath) = makeAbsolute filePath >>= parseAbsFile
-
-readEnvVarFile :: EnvVarFileArgument -> IO [EnvVar]
-readEnvVarFile = getEnvVarFilePath >=> parseDotEnvFile

waspc/cli/src/Wasp/Cli/Util/PathArgument.hs

@@ -0,0 +1,38 @@
+module Wasp.Cli.Util.PathArgument
+  ( FilePathArgument,
+    DirPathArgument,
+    getFilePath,
+    getDirPath,
+    filePathReader,
+    dirPathReader,
+  )
+where
+
+import Options.Applicative (ReadM, str)
+import StrongPath (Abs, Dir', File', Path', parseAbsDir)
+import StrongPath.FilePath (parseAbsFile)
+import System.Directory (makeAbsolute)
+
+-- Paths passed as arguments to a CLI are conventionally either absolute paths,
+-- or paths relative to the current working directory. We need IO to resolve
+-- which kind of path it is, but we also don't want any unsafe transformations
+-- in the meantime; so we make these types opaque until we have access to the IO
+-- monad.
+
+newtype FilePathArgument = FilePathArgument FilePath
+  deriving (Show, Eq)
+
+newtype DirPathArgument = DirPathArgument FilePath
+  deriving (Show, Eq)
+
+filePathReader :: ReadM FilePathArgument
+filePathReader = FilePathArgument <$> str
+
+dirPathReader :: ReadM DirPathArgument
+dirPathReader = DirPathArgument <$> str
+
+getFilePath :: FilePathArgument -> IO (Path' Abs File')
+getFilePath (FilePathArgument filePath) = makeAbsolute filePath >>= parseAbsFile
+
+getDirPath :: DirPathArgument -> IO (Path' Abs Dir')
+getDirPath (DirPathArgument dirPath) = makeAbsolute dirPath >>= parseAbsDir

waspc/waspc.cabal

@@ -611,6 +611,7 @@ library cli-lib
     Wasp.Cli.Interactive
     Wasp.Cli.GithubRepo
     Wasp.Cli.Util.EnvVarArgument
+    Wasp.Cli.Util.PathArgument
     Wasp.Cli.Util.Parser
 
 executable wasp-cli