Main.hs

{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE LambdaCase        #-}
{-# LANGUAGE NamedFieldPuns    #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE MultiWayIf #-}

module Main where

import           Control.Monad            (unless, when)
import           Control.Monad.Identity   (Identity)
import           Data.Aeson               (eitherDecode, encode)
import           Data.Aeson.Encode.Pretty (encodePretty)
import           Data.Aeson.KeyMap        (coercionToHashMap)
import qualified Data.ByteString.Lazy     as LB
import           Data.Maybe               (fromMaybe)
import qualified Data.Text.Encoding       as T
import qualified Data.Text.IO             as T
import           System.Exit              (ExitCode (..), exitWith)
import           System.IO                (hPutStrLn, stderr)
import           WithCli                  (Generic, HasArguments, withCli)

import           CheckDir                 (recursiveCheckDir, resultIsFatal, DirResult (dirresultGraph))
import           Control.Monad            (when)
import           LintConfig               (LintConfig (..), patchConfig)
import           Types                    (Level (..))
import           Util                     (printPretty)
import           WriteRepo                (writeAdjustedRepository)
import Text.Dot (showDot)

import qualified Version                  as V (version)

-- | the options this cli tool can take
data Options = Options
  { repository :: Maybe String
  -- ^ path to the repository containing maps to lint
  , entrypoint :: Maybe String
  -- ^ entrypoint in that repository
  , json       :: Bool
  -- ^ emit json if --json was given
  , lintlevel  :: Maybe Level
  -- ^ maximum lint level to print
  , pretty     :: Bool
  -- ^ pretty-print the json to make it human-readable
  , out        :: Maybe String
  -- ^ path to write the (possibly adjusted) maps to after linting
  , configFile :: Maybe FilePath
  -- ^ path to a config file. Currently required.
  , config     :: Maybe (LintConfig Maybe)
  -- ^ a "patch" for the configuration file
  , version    :: Bool
  , dot        :: Bool
  } deriving (Show, Generic, HasArguments)


main :: IO ()
main = withCli run

run :: Options -> IO ()
run options = do
  aesonWarning

  when (version options) $ do
    putStrLn V.version
    exitWith ExitSuccess

  let repo = fromMaybe "." (repository options)
  let entry = fromMaybe "main.json" (entrypoint options)
  let level = fromMaybe Suggestion (lintlevel options)