{-# LANGUAGE TupleSections #-}
module Ecluse.Core.Registry.Cargo.Target (
CargoTarget,
parseTarget,
) where
import Data.Char (isAlphaNum, isAsciiLower, isAsciiUpper, isDigit)
import Data.Text qualified as T
import Ecluse.Core.Registry (ParseError (..))
import Ecluse.Core.Security.Limits (Limits (maxNestingDepth))
data CargoTarget = NamedTarget Text | ConfiguredTarget Cfg
deriving stock (CargoTarget -> CargoTarget -> Bool
(CargoTarget -> CargoTarget -> Bool)
-> (CargoTarget -> CargoTarget -> Bool) -> Eq CargoTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CargoTarget -> CargoTarget -> Bool
== :: CargoTarget -> CargoTarget -> Bool
$c/= :: CargoTarget -> CargoTarget -> Bool
/= :: CargoTarget -> CargoTarget -> Bool
Eq, Eq CargoTarget
Eq CargoTarget =>
(CargoTarget -> CargoTarget -> Ordering)
-> (CargoTarget -> CargoTarget -> Bool)
-> (CargoTarget -> CargoTarget -> Bool)
-> (CargoTarget -> CargoTarget -> Bool)
-> (CargoTarget -> CargoTarget -> Bool)
-> (CargoTarget -> CargoTarget -> CargoTarget)
-> (CargoTarget -> CargoTarget -> CargoTarget)
-> Ord CargoTarget
CargoTarget -> CargoTarget -> Bool
CargoTarget -> CargoTarget -> Ordering
CargoTarget -> CargoTarget -> CargoTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CargoTarget -> CargoTarget -> Ordering
compare :: CargoTarget -> CargoTarget -> Ordering
$c< :: CargoTarget -> CargoTarget -> Bool
< :: CargoTarget -> CargoTarget -> Bool
$c<= :: CargoTarget -> CargoTarget -> Bool
<= :: CargoTarget -> CargoTarget -> Bool
$c> :: CargoTarget -> CargoTarget -> Bool
> :: CargoTarget -> CargoTarget -> Bool
$c>= :: CargoTarget -> CargoTarget -> Bool
>= :: CargoTarget -> CargoTarget -> Bool
$cmax :: CargoTarget -> CargoTarget -> CargoTarget
max :: CargoTarget -> CargoTarget -> CargoTarget
$cmin :: CargoTarget -> CargoTarget -> CargoTarget
min :: CargoTarget -> CargoTarget -> CargoTarget
Ord, Int -> CargoTarget -> ShowS
[CargoTarget] -> ShowS
CargoTarget -> String
(Int -> CargoTarget -> ShowS)
-> (CargoTarget -> String)
-> ([CargoTarget] -> ShowS)
-> Show CargoTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CargoTarget -> ShowS
showsPrec :: Int -> CargoTarget -> ShowS
$cshow :: CargoTarget -> String
show :: CargoTarget -> String
$cshowList :: [CargoTarget] -> ShowS
showList :: [CargoTarget] -> ShowS
Show)
data Cfg = NamedCfg Text | KeyCfg Text Text | AllCfg [Cfg] | AnyCfg [Cfg] | NotCfg Cfg
deriving stock (Cfg -> Cfg -> Bool
(Cfg -> Cfg -> Bool) -> (Cfg -> Cfg -> Bool) -> Eq Cfg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Cfg -> Cfg -> Bool
== :: Cfg -> Cfg -> Bool
$c/= :: Cfg -> Cfg -> Bool
/= :: Cfg -> Cfg -> Bool
Eq, Eq Cfg
Eq Cfg =>
(Cfg -> Cfg -> Ordering)
-> (Cfg -> Cfg -> Bool)
-> (Cfg -> Cfg -> Bool)
-> (Cfg -> Cfg -> Bool)
-> (Cfg -> Cfg -> Bool)
-> (Cfg -> Cfg -> Cfg)
-> (Cfg -> Cfg -> Cfg)
-> Ord Cfg
Cfg -> Cfg -> Bool
Cfg -> Cfg -> Ordering
Cfg -> Cfg -> Cfg
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Cfg -> Cfg -> Ordering
compare :: Cfg -> Cfg -> Ordering
$c< :: Cfg -> Cfg -> Bool
< :: Cfg -> Cfg -> Bool
$c<= :: Cfg -> Cfg -> Bool
<= :: Cfg -> Cfg -> Bool
$c> :: Cfg -> Cfg -> Bool
> :: Cfg -> Cfg -> Bool
$c>= :: Cfg -> Cfg -> Bool
>= :: Cfg -> Cfg -> Bool
$cmax :: Cfg -> Cfg -> Cfg
max :: Cfg -> Cfg -> Cfg
$cmin :: Cfg -> Cfg -> Cfg
min :: Cfg -> Cfg -> Cfg
Ord, Int -> Cfg -> ShowS
[Cfg] -> ShowS
Cfg -> String
(Int -> Cfg -> ShowS)
-> (Cfg -> String) -> ([Cfg] -> ShowS) -> Show Cfg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Cfg -> ShowS
showsPrec :: Int -> Cfg -> ShowS
$cshow :: Cfg -> String
show :: Cfg -> String
$cshowList :: [Cfg] -> ShowS
showList :: [Cfg] -> ShowS
Show)
parseTarget :: Limits -> Text -> Either ParseError CargoTarget
parseTarget :: Limits -> Text -> Either ParseError CargoTarget
parseTarget Limits
limits Text
target = case Text -> Text -> Maybe Text
T.stripPrefix Text
"cfg(" Text
target Maybe Text -> (Text -> Maybe Text) -> Maybe Text
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Text -> Maybe Text
T.stripSuffix Text
")" of
Maybe Text
Nothing -> do
Bool -> Either ParseError () -> Either ParseError ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ((Char -> Bool) -> Text -> Bool
T.all (\Char
char -> Char -> Bool
isAlphaNum Char
char Bool -> Bool -> Bool
|| Char
char Char -> String -> Bool
forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` [Char
'_', Char
'-', Char
'.']) Text
target) Either ParseError ()
forall a. Either ParseError a
malformed
CargoTarget -> Either ParseError CargoTarget
forall a. a -> Either ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> CargoTarget
NamedTarget Text
target)
Just Text
input -> do
(expression, rest) <- Int -> Text -> Either ParseError (Cfg, Text)
parseExpr Int
1 Text
input
unless (T.null (spaces rest)) malformed
pure (ConfiguredTarget expression)
where
parseExpr :: Int -> Text -> Either ParseError (Cfg, Text)
parseExpr Int
depth Text
input = do
Bool -> Either ParseError () -> Either ParseError ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Limits -> Int
maxNestingDepth Limits
limits Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 Bool -> Bool -> Bool
|| Int
depth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Limits -> Int
maxNestingDepth Limits
limits) (ParseError -> Either ParseError ()
forall a b. a -> Either a b
Left (Text -> ParseError
ParseError Text
"Cargo target nesting exceeds its bound"))
(name, raw, rest) <- Text -> Either ParseError (Text, Bool, Text)
identifier Text
input
case (raw, name) of
(Bool
False, Text
"all") -> ([Cfg] -> Cfg) -> Int -> Text -> Either ParseError (Cfg, Text)
parseList [Cfg] -> Cfg
AllCfg Int
depth (Text -> Either ParseError (Cfg, Text))
-> Either ParseError Text -> Either ParseError (Cfg, Text)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Char -> Text -> Either ParseError Text
symbol Char
'(' Text
rest
(Bool
False, Text
"any") -> ([Cfg] -> Cfg) -> Int -> Text -> Either ParseError (Cfg, Text)
parseList [Cfg] -> Cfg
AnyCfg Int
depth (Text -> Either ParseError (Cfg, Text))
-> Either ParseError Text -> Either ParseError (Cfg, Text)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Char -> Text -> Either ParseError Text
symbol Char
'(' Text
rest
(Bool
False, Text
"not") -> do
start <- Char -> Text -> Either ParseError Text
symbol Char
'(' Text
rest
(expression, after) <- parseExpr (depth + 1) start
end <- symbol ')' after
pure (NotCfg expression, end)
(Bool, Text)
_ -> case Text -> Maybe (Char, Text)
T.uncons (Text -> Text
spaces Text
rest) of
Just (Char
'=', Text
after) -> do
start <- Char -> Text -> Either ParseError Text
symbol Char
'"' Text
after
let (value, close) = T.breakOn "\"" start
end <- symbol '"' close
pure (KeyCfg name value, end)
Maybe (Char, Text)
_ -> (Cfg, Text) -> Either ParseError (Cfg, Text)
forall a. a -> Either ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Cfg
NamedCfg Text
name, Text
rest)
parseList :: ([Cfg] -> Cfg) -> Int -> Text -> Either ParseError (Cfg, Text)
parseList [Cfg] -> Cfg
constructor Int
depth = [Cfg] -> Text -> Either ParseError (Cfg, Text)
loop []
where
loop :: [Cfg] -> Text -> Either ParseError (Cfg, Text)
loop [Cfg]
held Text
input = case Text -> Maybe (Char, Text)
T.uncons (Text -> Text
spaces Text
input) of
Just (Char
')', Text
rest) -> (Cfg, Text) -> Either ParseError (Cfg, Text)
forall a. a -> Either ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Cfg] -> Cfg
constructor ([Cfg] -> [Cfg]
forall a. [a] -> [a]
reverse [Cfg]
held), Text
rest)
Maybe (Char, Text)
_ -> do
(expression, rest) <- Int -> Text -> Either ParseError (Cfg, Text)
parseExpr (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Text
input
case T.uncons (spaces rest) of
Just (Char
',', Text
after) -> [Cfg] -> Text -> Either ParseError (Cfg, Text)
loop (Cfg
expression Cfg -> [Cfg] -> [Cfg]
forall a. a -> [a] -> [a]
: [Cfg]
held) Text
after
Just (Char
')', Text
after) -> (Cfg, Text) -> Either ParseError (Cfg, Text)
forall a. a -> Either ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Cfg] -> Cfg
constructor ([Cfg] -> [Cfg]
forall a. [a] -> [a]
reverse (Cfg
expression Cfg -> [Cfg] -> [Cfg]
forall a. a -> [a] -> [a]
: [Cfg]
held)), Text
after)
Maybe (Char, Text)
_ -> Either ParseError (Cfg, Text)
forall a. Either ParseError a
malformed
identifier :: Text -> Either ParseError (Text, Bool, Text)
identifier :: Text -> Either ParseError (Text, Bool, Text)
identifier Text
input = do
let start :: Text
start = Text -> Text
spaces Text
input
(Bool
raw, Text
content) = (Bool, Text)
-> (Text -> (Bool, Text)) -> Maybe Text -> (Bool, Text)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool
False, Text
start) (Bool
True,) (Text -> Text -> Maybe Text
T.stripPrefix Text
"r#" Text
start)
(Text
name, Text
rest) = (Char -> Bool) -> Text -> (Text, Text)
T.span (\Char
char -> Char -> Bool
identStart Char
char Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
char) Text
content
case Text -> Maybe (Char, Text)
T.uncons Text
name of
Just (Char
char, Text
_) | Char -> Bool
identStart Char
char -> (Text, Bool, Text) -> Either ParseError (Text, Bool, Text)
forall a. a -> Either ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
name, Bool
raw, Text
rest)
Maybe (Char, Text)
_ -> Either ParseError (Text, Bool, Text)
forall a. Either ParseError a
malformed
identStart :: Char -> Bool
identStart :: Char -> Bool
identStart Char
char = Char
char Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char -> Bool
isAsciiLower Char
char Bool -> Bool -> Bool
|| Char -> Bool
isAsciiUpper Char
char
spaces :: Text -> Text
spaces :: Text -> Text
spaces = (Char -> Bool) -> Text -> Text
T.dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ')
symbol :: Char -> Text -> Either ParseError Text
symbol :: Char -> Text -> Either ParseError Text
symbol Char
expected Text
input = case Text -> Maybe (Char, Text)
T.uncons (Text -> Text
spaces Text
input) of
Just (Char
actual, Text
rest) | Char
actual Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
expected -> Text -> Either ParseError Text
forall a b. b -> Either a b
Right Text
rest
Maybe (Char, Text)
_ -> Either ParseError Text
forall a. Either ParseError a
malformed
malformed :: Either ParseError a
malformed :: forall a. Either ParseError a
malformed = ParseError -> Either ParseError a
forall a b. a -> Either a b
Left (Text -> ParseError
ParseError Text
"Cargo target declaration is malformed")