{-|
Module : Main
Description : Parses command line and dispatches to correct backend
Copyright : (c) Rodrigo Setti, 2017
License : MIT
Maintainer : rodrigosetti@gmail.com
Stability : experimental
Portability : POSIX
-}
{-# LANGUAGE UnicodeSyntax #-}
module Main (main) where
import Data.List (intercalate)
import qualified Data.List.NonEmpty as NE
import Data.Maybe (catMaybes, fromMaybe)
import Data.Semigroup ((<>))
import qualified Data.Text.IO as TIO
import MasterPlan.Backend.Graph
import MasterPlan.Data
import qualified MasterPlan.Parser as P
import Options.Applicative
import System.Exit (die)
import System.IO (stdin)
-- |Type output from the command line parser
data Opts = Opts { inputPath :: Maybe FilePath
, outputPath :: Maybe FilePath
, rootKey :: ProjectKey -- ^ name of the root project
, projFilter :: ProjFilter -- ^ filter to consider
, renderParsingError :: Bool -- ^ will render the parsing error instead of printing
, parseStrict :: Bool -- ^ every project has to be defined
, renderOptions :: RenderOptions }
type ProjFilter = ProjectExpr → Bool
noFilter ∷ ProjFilter
noFilter = const True
readEnum ∷ [(String, a)] → ReadM a
readEnum mapping = maybeReader $ flip lookup mapping
-- |The command line parser
cmdParser ∷ Parser Opts
cmdParser = Opts <$> optional (strArgument ( help "plan file to read from (default from stdin)"
<> metavar "FILENAME" ))
<*> optional (strOption ( long "output"
<> short 'o'
<> help "output file name (.png, .tif, .bmp, .jpg and .pdf supported)"
<> metavar "FILENAME" ))
<*> strOption ( long "root"
<> short 'r'
<> help "name of the root project definition"
<> value "root"
<> showDefault
<> metavar "NAME")
<*> (filterParser <|> pure noFilter)
<*> switch ( long "render-parse-error"
<> help "instead of printing parsing errors, render as an image")
<*> switch ( long "strict"
<> help "strict parsing: every project has to be defined")
<*> renderOptionsParser
where
renderOptionsParser ∷ Parser RenderOptions
renderOptionsParser = RenderOptions <$> switch ( long "color"
<> short 'c'
<> help "color each project by progress")
<*> option auto ( long "width"
<> short 'w'
<> help "width of the output image"
<> value (-1)
<> metavar "NUMBER")
<*> option auto ( long "height"
<> help "height of the output image"
<> value (-1)
<> metavar "NUMBER")
<*> (invertProps <$> many (option property ( long "hide"
<> help "hide a particular property"
<> metavar (intercalate "|" $ map fst propertyNames))))
propertyNames = map (\p -> (show p, p)) [minBound :: ProjAttribute ..]
property = readEnum propertyNames
invertProps ∷ [ProjAttribute] → [ProjAttribute]
invertProps l = filter (`notElem` l) $ map snd propertyNames
filterParser ∷ Parser ProjFilter
filterParser = (mkProgressFilter . Progress) <$> option auto ( long "progress-below"
<> help "only display projects which progress is < N%"
<> metavar "N" )
where
mkProgressFilter n p = progress p * 100 < n
main ∷ IO ()
main = masterPlan =<< execParser opts
where
opts = info (cmdParser <**> helper)
( fullDesc
<> progDesc "See documentation on how to write project plan files"
<> header "master-plan - project management tool for hackers" )
filterProj ∷ ProjFilter -> ProjectExpr → Maybe ProjectExpr
filterProj f p@(Sum r ps) = filterHelper p f ps (Sum r)
filterProj f p@(Product r ps) = filterHelper p f ps (Product r)
filterProj f p@(Sequence r ps) = filterHelper p f ps (Sequence r)
filterProj f p = if f p then Just p else Nothing
filterHelper :: ProjectExpr
-> ProjFilter
-> NE.NonEmpty ProjectExpr
-> (NE.NonEmpty ProjectExpr -> ProjectExpr)
-> Maybe ProjectExpr
filterHelper p f ps c = if f p then c <$> filterProjs ps else Nothing
where
filterProjs ps' = NE.nonEmpty (catMaybes $ NE.toList $ filterProj f <$> ps')
masterPlan ∷ Opts → IO ()
masterPlan opts =
do contents <- maybe (TIO.hGetContents stdin) TIO.readFile $ inputPath opts
let outfile = fromMaybe (fromMaybe "output" (outputPath opts) ++ ".pdf") $ outputPath opts
case P.runParser (parseStrict opts) (fromMaybe "stdin" $ inputPath opts) contents (rootKey opts) of
Left e -> if renderParsingError opts
then renderText outfile (renderOptions opts) (lines e)
else die e
Right p ->
do let p' = fromMaybe defaultAtomic $ prioritize <$> filterProj (projFilter opts) p
render outfile (renderOptions opts) p'