module Language.Docker.Parser.Pairs
  ( parseEnv,
    parseLabel,
  )
where

import qualified Data.Text as T
import Language.Docker.Parser.Prelude
import Language.Docker.Syntax


unquotedString :: (?esc :: Char) => (Char -> Bool) -> Parser Text
unquotedString :: (?esc::Char) => (Char -> Bool) -> Parser Text
unquotedString Char -> Bool
acceptCondition = do
  Text
str <- (?esc::Char) => [Char] -> Maybe (Char -> Bool) -> Parser Text
stringWithEscaped [Char
' ', Char
'\t'] (forall a. a -> Maybe a
Just (\Char
c -> Char -> Bool
acceptCondition Char
c Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'"' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\''))
  Text -> Parser Text
checkFaults Text
str
  where
    checkFaults :: Text -> Parser Text
checkFaults Text
str
      | Text -> Bool
T.null Text
str = forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"a non empty string"
      | Text -> Char
T.head Text
str forall a. Eq a => a -> a -> Bool
== Char
'\'' = forall a. DockerfileError -> Parser a
customError forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> DockerfileError
QuoteError [Char]
"single" (Text -> [Char]
T.unpack Text
str)
      | Text -> Char
T.head Text
str forall a. Eq a => a -> a -> Bool
== Char
'\"' = forall a. DockerfileError -> Parser a
customError forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> DockerfileError
QuoteError [Char]
"double" (Text -> [Char]
T.unpack Text
str)
      | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return Text
str

singleValue :: (?esc :: Char) => (Char -> Bool) -> Parser Text
singleValue :: (?esc::Char) => (Char -> Bool) -> Parser Text
singleValue Char -> Bool
acceptCondition = forall a. Monoid a => [a] -> a
mconcat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT DockerfileError Text Identity [Text]
variants
  where
    variants :: ParsecT DockerfileError Text Identity [Text]
variants =
      forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
          [ (?esc::Char) => Parser Text
doubleQuotedStringEscaped forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"a string inside double quotes",
            (?esc::Char) => Parser Text
singleQuotedStringEscaped forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"a string inside single quotes",
            (?esc::Char) => (Char -> Bool) -> Parser Text
unquotedString Char -> Bool
acceptCondition forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"a string with no quotes"
          ]

pair :: (?esc :: Char) => Parser (Text, Text)
pair :: (?esc::Char) => Parser (Text, Text)
pair = do
  Text
key <- (?esc::Char) => (Char -> Bool) -> Parser Text
singleValue (forall a. Eq a => a -> a -> Bool
/= Char
'=')
  Text
value <- Parser Text
withEqualSign forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Text
withoutEqualSign
  forall (m :: * -> *) a. Monad m => a -> m a
return (Text
key, Text
value)
  where
    withEqualSign :: Parser Text
withEqualSign = do
      forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'='
      (?esc::Char) => (Char -> Bool) -> Parser Text
singleValue (\Char
c -> Char
c forall a. Eq a => a -> a -> Bool
/= Char
' ' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\t')
    withoutEqualSign :: Parser Text
withoutEqualSign = do
      (?esc::Char) => ParsecT DockerfileError Text Identity ()
requiredWhitespace
      (?esc::Char) => [Char] -> Parser Text
untilEol [Char]
"value"

pairs :: (?esc :: Char) => Parser Pairs
pairs :: (?esc::Char) => Parser Pairs
pairs = ((?esc::Char) => Parser (Text, Text)
pair forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"a key value pair (key=value)") forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepEndBy1` (?esc::Char) => ParsecT DockerfileError Text Identity ()
requiredWhitespace

parseLabel :: (?esc :: Char) => Parser (Instruction Text)
parseLabel :: (?esc::Char) => Parser (Instruction Text)
parseLabel = do
  (?esc::Char) => Text -> ParsecT DockerfileError Text Identity ()
reserved Text
"LABEL"
  forall args. Pairs -> Instruction args
Label forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => Parser Pairs
pairs

parseEnv :: (?esc :: Char) => Parser (Instruction Text)
parseEnv :: (?esc::Char) => Parser (Instruction Text)
parseEnv = do
  (?esc::Char) => Text -> ParsecT DockerfileError Text Identity ()
reserved Text
"ENV"
  forall args. Pairs -> Instruction args
Env forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => Parser Pairs
pairs