module Twitch.Internal where
import Data.Map (Map)
import Control.Applicative
import Control.Monad
import Filesystem.Path
import Filesystem.Path.CurrentOS
import Prelude hiding (FilePath)
import Data.List
import Data.Text (Text)
import qualified Data.Text as T
import Control.Monad.Reader
import Control.Monad.State as State
import System.Directory
import System.FilePath.Glob
import qualified Twitch.Rule as Rule
import Twitch.Rule (Rule)
import Data.Monoid
import Data.Time.Clock
import Data.String
import Data.Default
import Control.Arrow
import Data.Either
import System.FSNotify (WatchManager)
newtype DepM a = DepM { unDepM :: State [Rule] a}
deriving ( Functor
, Applicative
, Monad
, MonadState [Rule]
)
type Dep = DepM ()
instance IsString Dep where
fromString = addRule . fromString
runDep :: Dep -> [Rule]
runDep = runDepWithState mempty
runDepWithState :: [Rule] -> Dep -> [Rule]
runDepWithState xs = flip execState xs . unDepM
addRule r = State.modify (r :)
modHeadRule :: Dep -> (Rule -> Rule) -> Dep
modHeadRule dep f = do
let res = runDep dep
case res of
x:xs -> put $ f x : xs
r -> put r
infixl 8 |+, |%, |-, |>, |#
(|+), (|%), (|-), (|>) :: Dep -> (FilePath -> IO a) -> Dep
x |+ f = modHeadRule x $ Rule.addF f
x |% f = modHeadRule x $ Rule.modifyF f
x |- f = modHeadRule x $ Rule.deleteF f
x |> f = x |+ f |% f
(|#) :: Dep -> Text -> Dep
r |# p = modHeadRule r $ Rule.nameF p
add, modify, delete, addModify :: (FilePath -> IO a) -> Dep -> Dep
add = flip (|+)
modify = flip (|%)
delete = flip (|-)
addModify = flip (|>)
name :: Text -> Dep -> Dep
name = flip (|#)