{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE OverloadedStrings #-}

module Highlight.Highlight.Options
  ( ColorGrepFilenames(..)
  , colorGrepFilenamesParser
  , HasColorGrepFilenames(..)
  , Options(..)
  , defaultOptions
  , optionsParser
  , HasOptions(..)
  , module Highlight.Common.Options
  ) where

import Prelude ()
import Prelude.Compat

import Control.Lens (Lens', lens)
import Options.Applicative (Parser, flag, help, long, short)

import Highlight.Common.Options
       (CommonOptions, HasCommonOptions(commonOptionsLens),
        HasIgnoreCase(ignoreCaseLens), HasInputFilenames(inputFilenamesLens),
        HasRawRegex(rawRegexLens), HasRecursive(recursiveLens),
        IgnoreCase(DoNotIgnoreCase, IgnoreCase),
        InputFilename(InputFilename, unInputFilename), RawRegex(RawRegex),
        Recursive(Recursive), commonOptionsParser, defaultCommonOptions)

--------------------------
-- Color grep filenames --
--------------------------

-- | Whether or not to color filenames output by @grep@ when reading in from
-- stdin.
data ColorGrepFilenames = ColorGrepFilenames | DoNotColorGrepFileNames
  deriving (ColorGrepFilenames -> ColorGrepFilenames -> Bool
(ColorGrepFilenames -> ColorGrepFilenames -> Bool)
-> (ColorGrepFilenames -> ColorGrepFilenames -> Bool)
-> Eq ColorGrepFilenames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColorGrepFilenames -> ColorGrepFilenames -> Bool
$c/= :: ColorGrepFilenames -> ColorGrepFilenames -> Bool
== :: ColorGrepFilenames -> ColorGrepFilenames -> Bool
$c== :: ColorGrepFilenames -> ColorGrepFilenames -> Bool
Eq, ReadPrec [ColorGrepFilenames]
ReadPrec ColorGrepFilenames
Int -> ReadS ColorGrepFilenames
ReadS [ColorGrepFilenames]
(Int -> ReadS ColorGrepFilenames)
-> ReadS [ColorGrepFilenames]
-> ReadPrec ColorGrepFilenames
-> ReadPrec [ColorGrepFilenames]
-> Read ColorGrepFilenames
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ColorGrepFilenames]
$creadListPrec :: ReadPrec [ColorGrepFilenames]
readPrec :: ReadPrec ColorGrepFilenames
$creadPrec :: ReadPrec ColorGrepFilenames
readList :: ReadS [ColorGrepFilenames]
$creadList :: ReadS [ColorGrepFilenames]
readsPrec :: Int -> ReadS ColorGrepFilenames
$creadsPrec :: Int -> ReadS ColorGrepFilenames
Read, Int -> ColorGrepFilenames -> ShowS
[ColorGrepFilenames] -> ShowS
ColorGrepFilenames -> String
(Int -> ColorGrepFilenames -> ShowS)
-> (ColorGrepFilenames -> String)
-> ([ColorGrepFilenames] -> ShowS)
-> Show ColorGrepFilenames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColorGrepFilenames] -> ShowS
$cshowList :: [ColorGrepFilenames] -> ShowS
show :: ColorGrepFilenames -> String
$cshow :: ColorGrepFilenames -> String
showsPrec :: Int -> ColorGrepFilenames -> ShowS
$cshowsPrec :: Int -> ColorGrepFilenames -> ShowS
Show)

class HasColorGrepFilenames r where
  colorGrepFilenamesLens :: Lens' r ColorGrepFilenames

colorGrepFilenamesParser :: Parser ColorGrepFilenames
colorGrepFilenamesParser :: Parser ColorGrepFilenames
colorGrepFilenamesParser =
  let mods :: Mod FlagFields a
mods =
        String -> Mod FlagFields a
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"from-grep" Mod FlagFields a -> Mod FlagFields a -> Mod FlagFields a
forall a. Semigroup a => a -> a -> a
<>
        Char -> Mod FlagFields a
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'g' Mod FlagFields a -> Mod FlagFields a -> Mod FlagFields a
forall a. Semigroup a => a -> a -> a
<>
        String -> Mod FlagFields a
forall (f :: * -> *) a. String -> Mod f a
help String
"highlight output from grep"
  in ColorGrepFilenames
-> ColorGrepFilenames
-> Mod FlagFields ColorGrepFilenames
-> Parser ColorGrepFilenames
forall a. a -> a -> Mod FlagFields a -> Parser a
flag ColorGrepFilenames
DoNotColorGrepFileNames ColorGrepFilenames
ColorGrepFilenames Mod FlagFields ColorGrepFilenames
forall a. Mod FlagFields a
mods

-------------
-- Options --
-------------

data Options = Options
  { Options -> ColorGrepFilenames
optionsColorGrepFilenames :: ColorGrepFilenames
  , Options -> CommonOptions
optionsCommonOptions :: CommonOptions
  } deriving (Options -> Options -> Bool
(Options -> Options -> Bool)
-> (Options -> Options -> Bool) -> Eq Options
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Options -> Options -> Bool
$c/= :: Options -> Options -> Bool
== :: Options -> Options -> Bool
$c== :: Options -> Options -> Bool
Eq, ReadPrec [Options]
ReadPrec Options
Int -> ReadS Options
ReadS [Options]
(Int -> ReadS Options)
-> ReadS [Options]
-> ReadPrec Options
-> ReadPrec [Options]
-> Read Options
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Options]
$creadListPrec :: ReadPrec [Options]
readPrec :: ReadPrec Options
$creadPrec :: ReadPrec Options
readList :: ReadS [Options]
$creadList :: ReadS [Options]
readsPrec :: Int -> ReadS Options
$creadsPrec :: Int -> ReadS Options
Read, Int -> Options -> ShowS
[Options] -> ShowS
Options -> String
(Int -> Options -> ShowS)
-> (Options -> String) -> ([Options] -> ShowS) -> Show Options
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Options] -> ShowS
$cshowList :: [Options] -> ShowS
show :: Options -> String
$cshow :: Options -> String
showsPrec :: Int -> Options -> ShowS
$cshowsPrec :: Int -> Options -> ShowS
Show)

class HasOptions r where
  optionsLens :: Lens' r Options

instance HasOptions Options where
  optionsLens :: Lens' Options Options
  optionsLens :: (Options -> f Options) -> Options -> f Options
optionsLens = (Options -> f Options) -> Options -> f Options
forall a. a -> a
id

instance HasColorGrepFilenames Options where
  colorGrepFilenamesLens :: Lens' Options ColorGrepFilenames
  colorGrepFilenamesLens :: (ColorGrepFilenames -> f ColorGrepFilenames)
-> Options -> f Options
colorGrepFilenamesLens =
    (Options -> ColorGrepFilenames)
-> (Options -> ColorGrepFilenames -> Options)
-> Lens' Options ColorGrepFilenames
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      Options -> ColorGrepFilenames
optionsColorGrepFilenames
      (\Options
s ColorGrepFilenames
a -> Options
s {optionsColorGrepFilenames :: ColorGrepFilenames
optionsColorGrepFilenames = ColorGrepFilenames
a})

instance HasCommonOptions Options where
  commonOptionsLens :: Lens' Options CommonOptions
  commonOptionsLens :: (CommonOptions -> f CommonOptions) -> Options -> f Options
commonOptionsLens =
    (Options -> CommonOptions)
-> (Options -> CommonOptions -> Options)
-> Lens' Options CommonOptions
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      Options -> CommonOptions
optionsCommonOptions
      (\Options
s CommonOptions
a -> Options
s {optionsCommonOptions :: CommonOptions
optionsCommonOptions = CommonOptions
a})

instance HasIgnoreCase Options
instance HasRecursive Options
instance HasRawRegex Options
instance HasInputFilenames Options

optionsParser :: Parser Options
optionsParser :: Parser Options
optionsParser =
  ColorGrepFilenames -> CommonOptions -> Options
Options
    (ColorGrepFilenames -> CommonOptions -> Options)
-> Parser ColorGrepFilenames -> Parser (CommonOptions -> Options)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ColorGrepFilenames
colorGrepFilenamesParser
    Parser (CommonOptions -> Options)
-> Parser CommonOptions -> Parser Options
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CommonOptions
commonOptionsParser

defaultOptions :: Options
defaultOptions :: Options
defaultOptions = ColorGrepFilenames -> CommonOptions -> Options
Options ColorGrepFilenames
DoNotColorGrepFileNames CommonOptions
defaultCommonOptions