Improve CLI and add file running and formatting (fix axellang#47)

Author: jgrosso

.hindent.yaml

@@ -17,6 +17,7 @@ extensions:
   - KindSignatures
   - LambdaCase
   - MultiParamTypeClasses
+  - MultiWayIf
   - OverloadedStrings
   - PolyKinds
   - RankNTypes

.hlint.yaml

@@ -28,6 +28,7 @@
   - -XKindSignatures
   - -XLambdaCase
   - -XMultiParamTypeClasses
+  - -XMultiWayIf
   - -XNoImplicitPrelude
   - -XOverloadedStrings
   - -XPolyKinds

app/Main.axel

@@ -1,55 +1,39 @@
 (module Main)
-(importq Prelude
-         GHCPrelude
-         all)
-(importq Axel.Parse.AST
-         AST
-         all)
-(import Axel.Eff.App
-        (AppEffs runApp))
-(import Axel.Eff.Console
-        (putStrLn))
-(import Axel.Eff.Ghci
-        (withGhci))
-(import Axel.Haskell.File
-        (convertFileInPlace transpileFileInPlace))
-(import Axel.Haskell.Project
-        (buildProject runProject))
-(import Axel.Haskell.Stack
-        (axelStackageVersion))
-(importq Axel.Parse.AST
-         AST
-         all)
-(import Axel.Parse.Args
-        ((Command Convert
-                  File
-                  Project
-                  Version) commandParser))
+(importq Prelude GHCPrelude all)
+(importq Axel.Parse.AST AST all)
+(import Axel.Eff.App (AppEffs runApp))
+(import Axel.Eff.Console (putStrLn))
+(import Axel.Eff.Ghci (withGhci))
+(import Axel.Haskell.File (convertFileInPlace formatFileInPlace transpileFileInPlace))
+(import Axel.Haskell.Project (buildProject runProject))
+(import Axel.Haskell.Stack (axelStackageVersion))
+(importq Axel.Parse.AST AST all)
+(import Axel.Parse.Args ((Command FileCommand ProjectCommand Version) (FileCommand ConvertFile RunFile FormatFile) (ProjectCommand RunProject) commandParserInfo))
 (import Control.Monad (void))
 (importq Data.Map Map (empty))
-(import Options.Applicative
-        (<**> execParser
-              helper
-              info
-              progDesc))
+(import Options.Applicative (execParser))
 (importq Polysemy Sem all)
-(importq Polysemy.State
-         Sem
-         all)
+(importq Polysemy.State Sem all)
 (raw "import Prelude hiding (putStrLn)")
 
-(def app
-     ((-> Command) (Sem.Sem AppEffs Unit))
-     (((Convert filePath)) (void (convertFileInPlace filePath)))
-     (((File filePath)) (void (Sem.evalState Map.empty
-                                             (withGhci (transpileFileInPlace filePath)))))
-     (((Project)) (>> buildProject runProject))
-     (((Version)) (putStrLn (<> "Axel version "
-                                axelStackageVersion))))
+(def
+ app
+ ((-> Command) (Sem.Sem AppEffs Unit))
+ (((FileCommand fileCommand))
+  (case fileCommand
+        ((ConvertFile filePath) (void (convertFileInPlace filePath)))
+        ((FormatFile filePath) (formatFileInPlace filePath))
+        ((RunFile filePath)
+          (void (Sem.evalState Map.empty (withGhci (transpileFileInPlace filePath)))))))
+ (((ProjectCommand projectCommand))
+  (case projectCommand
+        (RunProject (>> buildProject runProject))))
+ (((Version)) (putStrLn (<> "Axel version " axelStackageVersion))))
 
-(def main
-     (IO Unit)
-     (() (>>= (execParser (info (<**> commandParser helper)
-                                (progDesc "The command to run.")))
-              (\ (modeCommand)
-                 (runApp (app modeCommand))))))
+(def
+ main
+ (IO Unit)
+ (()
+  (>>=
+   (execParser commandParserInfo)
+   (\ (modeCommand) (runApp (app modeCommand))))))

app/Main.hs

@@ -1,24 +1,25 @@
 module Main where
 import qualified Prelude as GHCPrelude
 import qualified Axel.Parse.AST as AST
+import qualified Prelude as GHCPrelude
+import qualified Axel.Parse.AST as AST
 import Axel.Eff.App(AppEffs,runApp)
 import Axel.Eff.Console(putStrLn)
 import Axel.Eff.Ghci(withGhci)
-import Axel.Haskell.File(convertFileInPlace,transpileFileInPlace)
+import Axel.Haskell.File(convertFileInPlace,formatFileInPlace,transpileFileInPlace)
 import Axel.Haskell.Project(buildProject,runProject)
 import Axel.Haskell.Stack(axelStackageVersion)
 import qualified Axel.Parse.AST as AST
-import Axel.Parse.Args(Command(Convert,File,Project,Version),commandParser)
+import Axel.Parse.Args(Command(FileCommand,ProjectCommand,Version),FileCommand(ConvertFile,RunFile,FormatFile),ProjectCommand(RunProject),commandParserInfo)
 import Control.Monad(void)
 import qualified Data.Map as Map(empty)
-import Options.Applicative((<**>),execParser,helper,info,progDesc)
+import Options.Applicative(execParser)
 import qualified Polysemy as Sem
 import qualified Polysemy.State as Sem
 import Prelude hiding (putStrLn)
-app (Convert filePath) = (void (convertFileInPlace filePath))
-app (File filePath) = (void (Sem.evalState Map.empty (withGhci (transpileFileInPlace filePath))))
-app (Project ) = ((>>) buildProject runProject)
+app (FileCommand fileCommand) = (case fileCommand of {(ConvertFile filePath) -> (void (convertFileInPlace filePath));(FormatFile filePath) -> (formatFileInPlace filePath);(RunFile filePath) -> (void (Sem.evalState Map.empty (withGhci (transpileFileInPlace filePath))))})
+app (ProjectCommand projectCommand) = (case projectCommand of {RunProject -> ((>>) buildProject runProject)})
 app (Version ) = (putStrLn ((<>) "Axel version " axelStackageVersion))
 app :: (((->) Command) (Sem.Sem AppEffs ()))
-main  = ((>>=) (execParser (info ((<**>) commandParser helper) (progDesc "The command to run."))) (\modeCommand -> (runApp (app modeCommand))))
+main  = ((>>=) (execParser commandParserInfo) (\modeCommand -> (runApp (app modeCommand))))
 main :: (IO ())

axel.cabal

@@ -4,7 +4,7 @@ cabal-version: 1.12
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 3bd176f732bbb770b9959ea979b99b32f8723c2df6b2bfdaf208f8662379add4
+-- hash: 1a081e352686653c22acf2b4fe2222d390f6f14d7be24466e714125b3d4420f1
 
 name:           axel
 version:        0.0.11
@@ -98,7 +98,7 @@ library
       Paths_axel
   hs-source-dirs:
       src
-  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
+  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses MultiWayIf NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
   ghc-options: -Weverything -Wno-all-missed-specialisations -Wno-implicit-prelude -Wno-missed-specialisations -Wno-missing-import-lists -Wno-missing-export-lists -Wno-missing-local-signatures -Wno-monomorphism-restriction -Wno-safe -Wno-unsafe -optP-Wno-nonportable-include-path -fplugin=Polysemy.Plugin -O2 -flate-specialise -fspecialise-aggressively
   build-tool-depends:
       hpack:hpack
@@ -152,7 +152,7 @@ executable axel
       Paths_axel
   hs-source-dirs:
       app
-  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
+  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses MultiWayIf NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
   ghc-options: -Weverything -Wno-all-missed-specialisations -Wno-implicit-prelude -Wno-missed-specialisations -Wno-missing-import-lists -Wno-missing-export-lists -Wno-missing-local-signatures -Wno-monomorphism-restriction -Wno-safe -Wno-unsafe -optP-Wno-nonportable-include-path -fplugin=Polysemy.Plugin -O2 -flate-specialise -fspecialise-aggressively -threaded -rtsopts -with-rtsopts=-N
   build-tool-depends:
       hpack:hpack
@@ -230,7 +230,7 @@ test-suite axel-test
       Paths_axel
   hs-source-dirs:
       test
-  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
+  default-extensions: BangPatterns ConstraintKinds DataKinds DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses MultiWayIf NoImplicitPrelude OverloadedStrings PolyKinds RankNTypes StandaloneDeriving TupleSections TypeApplications TypeOperators
   ghc-options: -Weverything -Wno-all-missed-specialisations -Wno-implicit-prelude -Wno-missed-specialisations -Wno-missing-import-lists -Wno-missing-export-lists -Wno-missing-local-signatures -Wno-monomorphism-restriction -Wno-safe -Wno-unsafe -optP-Wno-nonportable-include-path -fplugin=Polysemy.Plugin -O2 -flate-specialise -fspecialise-aggressively -threaded -rtsopts -with-rtsopts=-N
   build-tool-depends:
       hpack:hpack

package.yaml

@@ -92,6 +92,7 @@ default-extensions:
   - KindSignatures
   - LambdaCase
   - MultiParamTypeClasses
+  - MultiWayIf
   - NoImplicitPrelude
   - OverloadedStrings
   - PolyKinds # Required by `Polysemy.makeSem`

src/Axel/Haskell/File.hs

@@ -24,8 +24,9 @@ import qualified Axel.Eff.Restartable as Effs (Restartable)
 import Axel.Haskell.Convert (convertFile)
 import Axel.Macros (handleFunctionApplication, processProgram)
 import Axel.Normalize (normalizeStatement, withExprCtxt)
-import Axel.Parse (parseSource)
+import Axel.Parse (parseMultiple, parseSource)
 import Axel.Parse.AST (Expression(Symbol))
+import Axel.Pretty (prettifyProgram)
 import qualified Axel.Sourcemap as SM
   ( Expression
   , Output
@@ -146,3 +147,13 @@ transpileFileInPlace path = do
   let newPath = replaceExtension path "hs"
   unless alreadyCompiled $ transpileFile path newPath
   pure newPath
+
+formatFileInPlace ::
+     (Sem.Members '[ Effs.Console, Effs.FileSystem, Sem.Error Error] effs)
+  => FilePath
+  -> Sem.Sem effs ()
+formatFileInPlace path = do
+  contents <- FS.readFile path
+  program <- parseMultiple (Just path) contents
+  let prettifiedContents = prettifyProgram program
+  FS.writeFile path prettifiedContents

src/Axel/Haskell/Project.hs

@@ -20,7 +20,11 @@ import qualified Axel.Eff.Log as Effs (Log)
 import qualified Axel.Eff.Process as Effs (Process)
 import Axel.Eff.Resource (getResourcePath, newProjectTemplate)
 import qualified Axel.Eff.Resource as Effs (Resource)
-import Axel.Haskell.File (readModuleInfo, transpileFileInPlace)
+import Axel.Haskell.File
+  ( formatFileInPlace
+  , readModuleInfo
+  , transpileFileInPlace
+  )
 import Axel.Haskell.Stack
   ( addStackDependency
   , axelStackageId
@@ -30,8 +34,10 @@ import Axel.Haskell.Stack
   )
 import Axel.Sourcemap (ModuleInfo)
 import Axel.Utils.FilePath ((<.>), (</>))
+import Axel.Utils.Monad (concatMapM)
 
 import Control.Lens (op)
+import Control.Monad (void)
 
 import qualified Data.Text as T
 
@@ -63,20 +69,21 @@ newProject projectName = do
     , FilePath "test" </> FilePath "Spec"
     ]
 
+getProjectAxelFiles ::
+     (Sem.Member Effs.FileSystem effs) => Sem.Sem effs [FilePath]
+getProjectAxelFiles = do
+  files <-
+    concatMapM
+      getDirectoryContentsRec
+      [FilePath "app", FilePath "src", FilePath "test"]
+  pure $ filter (\filePath -> ".axel" `T.isSuffixOf` op FilePath filePath) files
+
 transpileProject ::
      (Sem.Members '[ Effs.Console, Sem.Error Error, Effs.FileSystem, Effs.Ghci, Effs.Log, Effs.Process, Effs.Resource] effs)
   => Sem.Sem effs ModuleInfo
 transpileProject =
   Ghci.withGhci $ do
-    files <-
-      concat <$>
-      mapM
-        getDirectoryContentsRec
-        [FilePath "app", FilePath "src", FilePath "test"]
-    let axelFiles =
-          filter
-            (\filePath -> ".axel" `T.isSuffixOf` op FilePath filePath)
-            files
+    axelFiles <- getProjectAxelFiles
     initialModuleInfo <- readModuleInfo axelFiles
     (moduleInfo, _) <-
       Sem.runState initialModuleInfo $ mapM transpileFileInPlace axelFiles
@@ -94,3 +101,8 @@ runProject ::
      (Sem.Members '[ Effs.Console, Sem.Error Error, Effs.FileSystem, Effs.Process] effs)
   => Sem.Sem effs ()
 runProject = getCurrentDirectory >>= runStackProject
+
+formatProject ::
+     (Sem.Members '[ Effs.Console, Effs.FileSystem, Sem.Error Error] effs)
+  => Sem.Sem effs ()
+formatProject = getProjectAxelFiles >>= void . traverse formatFileInPlace

src/Axel/Parse.hs

@@ -59,7 +59,7 @@ parseReadMacro prefix wrapper = do
   ann SExpression (pure [Symbol Nothing (T.unpack wrapper), expr])
 
 eol :: Parser ()
-eol = P.try (void P.newline) <|> P.eof
+eol = P.try (void P.eol) <|> P.eof
 
 ignored :: Parser ()
 ignored = P.skipMany $ P.try comment <|> void P.spaceChar
@@ -171,8 +171,8 @@ parseMultiple maybeFilePath input =
   P.parse program (T.unpack $ op FilePath filePath) input
   where
     filePath = fromMaybe (FilePath "") maybeFilePath
-    program = P.some (ignored *> expression <* ignored) <* eol
-    throwErr = Sem.throw . ParseError filePath . showText
+    program = P.some (ignored *> expression <* ignored) <* P.eof
+    throwErr = Sem.throw . ParseError filePath . T.pack . P.errorBundlePretty
     expandQuasiquotes =
       map $
       bottomUpFmapSplicing

src/Axel/Parse/Args.axel

@@ -2,32 +2,73 @@
 
 (import Axel.Prelude all)
 
-(importq Data.Text T all)
+(import Control.Applicative (<**>))
+
+(import Data.Foldable (asum))
 (import Data.Semigroup (<>))
+(importq Data.Text T all)
+
+(import Options.Applicative (Parser ParserInfo argument command fullDesc helper hsubparser info metavar progDesc str))
+
+(data FileCommand
+      (ConvertFile FilePath)
+      (RunFile FilePath)
+      (FormatFile FilePath))
 
-(import Options.Applicative (Parser argument command info metavar progDesc str subparser))
+(data ProjectCommand
+      (RunProject))
 
 (data Command
-  (Convert FilePath)
-  (File FilePath)
-  (Project)
-  (Version))
-
-(def commandParser (Parser Command)
-  (() (subparser {projectCommand <> {fileCommand <> {convertCommand <> versionCommand}}})
-   (= convertCommand ()
-     (command "convert"
-              (info {{Convert . {FilePath . T.pack}} <$> (argument str (metavar "FILE"))}
-                    (progDesc "(EXPERIMENTAL) Convert a Haskell file to Axel"))))
-   (= fileCommand ()
-     (command "file"
-               (info {{File . {FilePath . T.pack}} <$> (argument str (metavar "FILE"))}
-                     (progDesc "Build and run a single file"))))
-   (= projectCommand ()
-     (command "project"
-               (info (pure Project)
-                     (progDesc "Build and run the project"))))
-   (= versionCommand ()
-     (command "version"
-               (info (pure Version)
-                     (progDesc "Display the version of the Axel compiler"))))))
+      (FileCommand FileCommand)
+      (ProjectCommand ProjectCommand)
+      (Version))
+
+(def experimental {String -> String}
+     (() (<> "(EXPERIMENTAL) ")))
+
+(def fileCommandParser (Parser FileCommand)
+     (() (hsubparser (mconcat [convertFileCommand formatFileCommand runFileCommand]))
+      (= convertFileCommand ()
+         (command "convert"
+                  (filePathParser ConvertFile
+                                  (experimental "Convert a Haskell file to Axel"))))
+      (= runFileCommand ()
+         (command "run"
+                  (filePathParser RunFile
+                                  "Transpile and run an Axel file")))
+      (= formatFileCommand ()
+         (command "format"
+                  (filePathParser FormatFile
+                                  "Format an Axel file")))
+      (= filePathParser (ctor desc)
+         (info {{ctor . {FilePath . T.pack}} <$> (argument str (metavar "FILE"))}
+               (progDesc desc)))))
+
+(def projectCommandParser (Parser ProjectCommand)
+     (() (hsubparser (mconcat [runProjectCommand]))
+      (= runProjectCommand ()
+         (command "run"
+                  (info (pure RunProject)
+                        (progDesc "Build and run the project"))))))
+
+(def commandParserInfo (ParserInfo Command)
+     (() (let ((subparsers (asum [fileCommand projectCommand versionCommand])))
+           (info {subparsers <**> helper} fullDesc))
+      (= fileCommand ()
+         (hsubparser {(command "file"
+                               (info {FileCommand <$> fileCommandParser}
+                                     (progDesc "Run file-specific commands")))
+                     <>
+                     (metavar "file")}))
+      (= projectCommand ()
+         (hsubparser {(command "project"
+                               (info {ProjectCommand <$> projectCommandParser}
+                                     (progDesc "Run project-wide commands")))
+                     <>
+                     (metavar "project")}))
+      (= versionCommand ()
+         (hsubparser {(command "version"
+                               (info (pure Version)
+                                     (progDesc "Display the version of the Axel compiler")))
+                     <>
+                     (metavar "version")}))))