update 'Main's

Author: barakber

language-powerquery/app/Main.hs

@@ -1,6 +1,105 @@
+{-# LANGUAGE PackageImports #-}
 module Main where
 
-import qualified Language.PowerQuery.Main as PQ
+import                                     Prelude hiding (lex)
+import           "base"                    Data.Semigroup ((<>))
+import           "base"                    System.IO (stdin)
+import qualified "bytestring"              Data.ByteString.Lazy.Char8 as B (ByteString, readFile, putStrLn, hGetContents, unpack)
+import           "aeson"                   Data.Aeson (encode)
+import           "optparse-applicative"    Options.Applicative
+import           "language-powerquery-ast" Language.PowerQuery.AST
+import           "language-powerquery"     Language.PowerQuery
+
+
+data Lex
+    = Lex
+    { _lex_path :: !(Maybe FilePath)
+    }
+
+data Parse
+    = Parse
+    { _parse_path :: !(Maybe FilePath)
+    , _parse_json :: !Bool
+    }
+
+data PPrint
+    = PPrint
+    { _print_path :: !(Maybe FilePath)
+    }
+
+data Command
+    = C1 Lex
+    | C2 Parse
+    | C3 PPrint
+
+lexParser :: Parser Command
+lexParser = C1 <$> (Lex
+    <$> optional (strOption
+      ( long "path"
+     <> short 'p'
+     <> metavar "PATH"
+     <> help "Lex PowerQuery Text"
+      ))
+    )
+
+parseParser :: Parser Command
+parseParser = C2 <$> (Parse
+    <$> optional (strOption
+      ( long "path"
+     <> short 'p'
+     <> metavar "PATH"
+     <> help "Parse PowerQuery Text"
+      ))
+    <*> switch
+      ( long "json"
+     <> short 'j'
+     <> help "print AST as JSON"
+      )
+    )
+
+combined :: Parser Command
+combined = subparser
+         ( command "lex" (info lexParser (progDesc "Lex PowerQuery Text"))
+        <> command "parse" (info parseParser (progDesc "Parse PowerQuery Text"))
+         )
+
+fromRight (Right x)  = x
+fromRight (Left err) = error err
+
+
+readPathOrStdin :: Maybe FilePath -> IO B.ByteString
+readPathOrStdin Nothing     = B.hGetContents stdin
+readPathOrStdin (Just path) = B.readFile path
+
+
+lex :: Lex -> IO ()
+lex (Lex mPath) = do
+    bs <- readPathOrStdin mPath
+    let tokens = lexer
+               . B.unpack
+               $ bs
+    print tokens
+    return ()
+
+
+parse :: Parse -> IO ()
+parse (Parse mPath shouldJSON) = do
+    bs <- readPathOrStdin mPath
+    let ast = parseDocument
+            . fromRight
+            . lexer
+            . B.unpack
+            $ bs
+    if shouldJSON
+    then B.putStrLn . encode $ ast
+    else print               $ ast
+    return ()
+
 
 main :: IO ()
-main = PQ.main
+main = do
+    options <- execParser (info (combined <**> helper) (fullDesc <> progDesc "PowerQuery Lexer/Parser/Pretty Printer"))
+    case options of
+        C1 config -> lex config
+        C2 config -> parse config
+        C3 config -> undefined

language-powerquery/language-powerquery.cabal

@@ -53,6 +53,8 @@ executable language-powerquery
   -- other-modules:
   -- other-extensions:
   build-depends:       base
+                     , bytestring
+                     , aeson
                      , optparse-applicative
                      , language-powerquery-ast
                      , language-powerquery

pbix/app/Main.hs

@@ -2,8 +2,9 @@
 module Main where
 
 import           "base"                    Data.Semigroup ((<>))
+import           "base"                    System.IO (stdin)
 import           "lens"                    Control.Lens
-import qualified "bytestring"              Data.ByteString.Lazy.Char8 as B (readFile, putStrLn)
+import qualified "bytestring"              Data.ByteString.Lazy.Char8 as B (ByteString, readFile, hGetContents, putStrLn)
 import           "aeson"                   Data.Aeson (encode)
 import           "optparse-applicative"    Options.Applicative
 import           "pbix"                    Codec.Pbix.Types
@@ -12,12 +13,12 @@ import           "language-powerquery-ast" Language.PowerQuery.AST
 
 data ListFormulas
     = ListFormulas
-    { _listFormula_path :: !FilePath
+    { _listFormula_path :: !(Maybe FilePath)
     }
 
 data PrintFormula
     = PrintFormula
-    { _printFormula_path    :: !FilePath
+    { _printFormula_path    :: !(Maybe FilePath)
     , _printFormula_formula :: !String
     , _printFormula_parse   :: !Bool
     , _printFormaul_json    :: !Bool
@@ -29,22 +30,22 @@ data Command
 
 listFormulasParser :: Parser Command
 listFormulasParser = C1 <$> (ListFormulas
-    <$> strOption
+    <$> optional (strOption
       ( long "path"
      <> short 'p'
      <> metavar "PATH"
      <> help ".pbix file path"
       )
-    )
+    ))
 
 printFormulaParser :: Parser Command
 printFormulaParser = C2 <$> (PrintFormula
-    <$> strOption
+    <$> optional (strOption
       ( long "path"
      <> short 'p'
      <> metavar "PATH"
      <> help ".pbix file path"
-      )
+      ))
     <*> strOption
       ( long "formula"
      <> short 'f'
@@ -70,14 +71,18 @@ combined = subparser
         <> command "print" (info printFormulaParser (progDesc "Print a formula in a .pbix"))
          )
 
+readPathOrStdin :: Maybe FilePath -> IO B.ByteString
+readPathOrStdin Nothing     = B.hGetContents stdin
+readPathOrStdin (Just path) = B.readFile path
+
 listFormulas :: ListFormulas -> IO ()
-listFormulas (ListFormulas path) = do
-    bs <- B.readFile path
+listFormulas (ListFormulas mPath) = do
+    bs <- readPathOrStdin mPath
     print $ bs ^. pbix . dataMashup . formulas
 
 printFormula :: PrintFormula -> IO ()
-printFormula (PrintFormula path name shouldParse shouldJSON) = do
-    bs <- B.readFile path
+printFormula (PrintFormula mPath name shouldParse shouldJSON) = do
+    bs <- readPathOrStdin mPath
     let script = bs ^. pbix . dataMashup . formula name
     if shouldParse
     then if shouldJSON