module Language.Docker.Parser.Instruction
  ( parseArg,
    parseComment,
    parseEntryPoint,
    parseEscapePragma,
    parseInstruction,
    parseMaintainer,
    parseOnbuild,
    parsePragma,
    parseShell,
    parseStopSignal,
    parseSyntaxPragma,
    parseUser,
    parseVolume,
    parseWorkdir,
  )
where

import Language.Docker.Parser.Arguments (arguments)
import Language.Docker.Parser.Cmd (parseCmd)
import Language.Docker.Parser.Copy (parseAdd, parseCopy)
import Language.Docker.Parser.Expose (parseExpose)
import Language.Docker.Parser.From (parseFrom)
import Language.Docker.Parser.Healthcheck (parseHealthcheck)
import Language.Docker.Parser.Pairs (parseEnv, parseLabel)
import Language.Docker.Parser.Prelude
import Language.Docker.Parser.Run (parseRun)
import Language.Docker.Syntax

parseShell :: (?esc :: Char) => Parser (Instruction Text)
parseShell :: (?esc::Char) => Parser (Instruction Text)
parseShell = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"SHELL"
  forall args. Arguments args -> Instruction args
Shell forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => Parser (Arguments Text)
arguments

parseStopSignal :: (?esc :: Char) => Parser (Instruction Text)
parseStopSignal :: (?esc::Char) => Parser (Instruction Text)
parseStopSignal = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"STOPSIGNAL"
  Text
args <- (?esc::Char) => String -> Parser Text
untilEol String
"the stop signal"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Instruction args
Stopsignal Text
args

parseArg :: (?esc :: Char) => Parser (Instruction Text)
parseArg :: (?esc::Char) => Parser (Instruction Text)
parseArg = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"ARG"
  (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall {args}.
ParsecT DockerfileError Text Identity (Instruction args)
nameWithDefault forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"the arg name")
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall {args}.
ParsecT DockerfileError Text Identity (Instruction args)
nameWithoutDefault forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"the arg name")
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall args. Text -> Maybe Text -> Instruction args
Arg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => String -> Parser Text
untilEol String
"the argument name" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing
  where
    nameWithoutDefault :: ParsecT DockerfileError Text Identity (Instruction args)
nameWithoutDefault = do
      Text
name <- (?esc::Char) => String -> (Char -> Bool) -> Parser Text
someUnless String
"the argument name" (forall a. Eq a => a -> a -> Bool
== Char
'=')
      forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ (?esc::Char) => String -> Parser Text
untilEol String
"the rest"
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Maybe Text -> Instruction args
Arg Text
name forall a. Maybe a
Nothing
    nameWithDefault :: ParsecT DockerfileError Text Identity (Instruction args)
nameWithDefault = do
      Text
name <- (?esc::Char) => String -> (Char -> Bool) -> Parser Text
someUnless String
"the argument name" (forall a. Eq a => a -> a -> Bool
== Char
'=')
      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
'='
      Text
df <- (?esc::Char) => String -> Parser Text
untilEol String
"the argument value"
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Maybe Text -> Instruction args
Arg Text
name (forall a. a -> Maybe a
Just Text
df)

parseUser :: (?esc :: Char) => Parser (Instruction Text)
parseUser :: (?esc::Char) => Parser (Instruction Text)
parseUser = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"USER"
  Text
username <- (?esc::Char) => String -> Parser Text
untilEol String
"the user"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Instruction args
User Text
username

parseWorkdir :: (?esc :: Char) => Parser (Instruction Text)
parseWorkdir :: (?esc::Char) => Parser (Instruction Text)
parseWorkdir = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"WORKDIR"
  Text
directory <- (?esc::Char) => String -> Parser Text
untilEol String
"the workdir path"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Instruction args
Workdir Text
directory

parseVolume :: (?esc :: Char) => Parser (Instruction Text)
parseVolume :: (?esc::Char) => Parser (Instruction Text)
parseVolume = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"VOLUME"
  Text
directory <- (?esc::Char) => String -> Parser Text
untilEol String
"the volume path"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Instruction args
Volume Text
directory

parseMaintainer :: (?esc :: Char) => Parser (Instruction Text)
parseMaintainer :: (?esc::Char) => Parser (Instruction Text)
parseMaintainer = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"MAINTAINER"
  Text
name <- (?esc::Char) => String -> Parser Text
untilEol String
"the maintainer name"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. Text -> Instruction args
Maintainer Text
name

parseEntryPoint :: (?esc :: Char) => Parser (Instruction Text)
parseEntryPoint :: (?esc::Char) => Parser (Instruction Text)
parseEntryPoint = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"ENTRYPOINT"
  forall args. Arguments args -> Instruction args
Entrypoint forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => Parser (Arguments Text)
arguments

parseOnbuild :: (?esc :: Char) => Parser (Instruction Text)
parseOnbuild :: (?esc::Char) => Parser (Instruction Text)
parseOnbuild = do
  (?esc::Char) => Text -> Parser ()
reserved Text
"ONBUILD"
  forall args. Instruction args -> Instruction args
OnBuild forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (?esc::Char) => Parser (Instruction Text)
parseInstruction

parsePragma :: (?esc :: Char) => Parser (Instruction Text)
parsePragma :: (?esc::Char) => Parser (Instruction Text)
parsePragma = do
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Parser a
lexeme' (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'#')
  forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
    [ Parser (Instruction Text)
parseEscapePragma forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"an escape",
      (?esc::Char) => Parser (Instruction Text)
parseSyntaxPragma forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"a syntax"
    ]

parseEscapePragma :: Parser (Instruction Text)
parseEscapePragma :: Parser (Instruction Text)
parseEscapePragma = do
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Parser a
lexeme' (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"escape")
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Parser a
lexeme' (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"=")
  forall args. PragmaDirective -> Instruction args
Pragma forall b c a. (b -> c) -> (a -> b) -> a -> c
. EscapeChar -> PragmaDirective
Escape forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> EscapeChar
EscapeChar forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
charLiteral

parseSyntaxPragma :: (?esc :: Char) => Parser (Instruction Text)
parseSyntaxPragma :: (?esc::Char) => Parser (Instruction Text)
parseSyntaxPragma = do
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Parser a
lexeme' (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"syntax")
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Parser a
lexeme' (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"=")
  Text
img <- (?esc::Char) => String -> Parser Text
untilEol String
"the syntax"
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall args. PragmaDirective -> Instruction args
Pragma
      ( SyntaxImage -> PragmaDirective
Syntax
          ( Image -> SyntaxImage
SyntaxImage
              ( Image
                  { $sel:registryName:Image :: Maybe Registry
registryName = forall a. Maybe a
Nothing,
                    $sel:imageName:Image :: Text
imageName = Text
img
                  }
              )
          )
      )

parseComment :: (?esc :: Char) => Parser (Instruction Text)
parseComment :: (?esc::Char) => Parser (Instruction Text)
parseComment = (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (?esc::Char) => Parser (Instruction Text)
parsePragma forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"a pragma") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall args. Text -> Instruction args
Comment forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
comment

parseInstruction :: (?esc :: Char) => Parser (Instruction Text)
parseInstruction :: (?esc::Char) => Parser (Instruction Text)
parseInstruction =
  forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
    [ (?esc::Char) => Parser (Instruction Text)
parseOnbuild,
      (?esc::Char) => Parser (Instruction Text)
parseFrom,
      (?esc::Char) => Parser (Instruction Text)
parseCopy,
      (?esc::Char) => Parser (Instruction Text)
parseRun,
      (?esc::Char) => Parser (Instruction Text)
parseWorkdir,
      (?esc::Char) => Parser (Instruction Text)
parseEntryPoint,
      (?esc::Char) => Parser (Instruction Text)
parseVolume,
      (?esc::Char) => Parser (Instruction Text)
parseExpose,
      (?esc::Char) => Parser (Instruction Text)
parseEnv,
      (?esc::Char) => Parser (Instruction Text)
parseArg,
      (?esc::Char) => Parser (Instruction Text)
parseUser,
      (?esc::Char) => Parser (Instruction Text)
parseLabel,
      (?esc::Char) => Parser (Instruction Text)
parseStopSignal,
      (?esc::Char) => Parser (Instruction Text)
parseCmd,
      (?esc::Char) => Parser (Instruction Text)
parseShell,
      (?esc::Char) => Parser (Instruction Text)
parseMaintainer,
      (?esc::Char) => Parser (Instruction Text)
parseAdd,
      (?esc::Char) => Parser (Instruction Text)
parseComment,
      (?esc::Char) => Parser (Instruction Text)
parseHealthcheck
    ]