module Buffet.Ir.Ir
  ( Buffet(..)
  , Dish(..)
  , DockerfilePart
  , Metadata(..)
  , Option(..)
  , TagKey(..)
  , TagValue(..)
  ) where

import qualified Buffet.Toolbox.TextTools as TextTools
import qualified Data.Aeson as Aeson
import qualified Data.Aeson.Types as Types
import qualified Data.Function as Function
import qualified Data.Map.Strict as Map
import qualified Data.Ord as Ord
import qualified Data.Text as T
import qualified Data.Yaml as Yaml
import qualified Language.Docker as Docker
import Prelude (Eq, FilePath, Maybe, Ord, Show, (.), fmap)

data Buffet =
  Buffet
    { Buffet -> Text
copyDummySourcePath :: T.Text
    , Buffet -> Map Option Dish
optionToDish :: Map.Map Option Dish
    }
  deriving (Buffet -> Buffet -> Bool
(Buffet -> Buffet -> Bool)
-> (Buffet -> Buffet -> Bool) -> Eq Buffet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Buffet -> Buffet -> Bool
$c/= :: Buffet -> Buffet -> Bool
== :: Buffet -> Buffet -> Bool
$c== :: Buffet -> Buffet -> Bool
Eq, Eq Buffet
Eq Buffet
-> (Buffet -> Buffet -> Ordering)
-> (Buffet -> Buffet -> Bool)
-> (Buffet -> Buffet -> Bool)
-> (Buffet -> Buffet -> Bool)
-> (Buffet -> Buffet -> Bool)
-> (Buffet -> Buffet -> Buffet)
-> (Buffet -> Buffet -> Buffet)
-> Ord Buffet
Buffet -> Buffet -> Bool
Buffet -> Buffet -> Ordering
Buffet -> Buffet -> Buffet
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
min :: Buffet -> Buffet -> Buffet
$cmin :: Buffet -> Buffet -> Buffet
max :: Buffet -> Buffet -> Buffet
$cmax :: Buffet -> Buffet -> Buffet
>= :: Buffet -> Buffet -> Bool
$c>= :: Buffet -> Buffet -> Bool
> :: Buffet -> Buffet -> Bool
$c> :: Buffet -> Buffet -> Bool
<= :: Buffet -> Buffet -> Bool
$c<= :: Buffet -> Buffet -> Bool
< :: Buffet -> Buffet -> Bool
$c< :: Buffet -> Buffet -> Bool
compare :: Buffet -> Buffet -> Ordering
$ccompare :: Buffet -> Buffet -> Ordering
$cp1Ord :: Eq Buffet
Ord, Int -> Buffet -> ShowS
[Buffet] -> ShowS
Buffet -> String
(Int -> Buffet -> ShowS)
-> (Buffet -> String) -> ([Buffet] -> ShowS) -> Show Buffet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Buffet] -> ShowS
$cshowList :: [Buffet] -> ShowS
show :: Buffet -> String
$cshow :: Buffet -> String
showsPrec :: Int -> Buffet -> ShowS
$cshowsPrec :: Int -> Buffet -> ShowS
Show)

newtype Option =
  Option
    { Option -> Text
option :: T.Text
    }
  deriving (Option -> Option -> Bool
(Option -> Option -> Bool)
-> (Option -> Option -> Bool) -> Eq Option
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Option -> Option -> Bool
$c/= :: Option -> Option -> Bool
== :: Option -> Option -> Bool
$c== :: Option -> Option -> Bool
Eq, Int -> Option -> ShowS
[Option] -> ShowS
Option -> String
(Int -> Option -> ShowS)
-> (Option -> String) -> ([Option] -> ShowS) -> Show Option
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Option] -> ShowS
$cshowList :: [Option] -> ShowS
show :: Option -> String
$cshow :: Option -> String
showsPrec :: Int -> Option -> ShowS
$cshowsPrec :: Int -> Option -> ShowS
Show)

instance Ord Option where
  compare :: Option -> Option -> Ordering
compare = (Text -> Text -> Ordering)
-> (Option -> Text) -> Option -> Option -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
Function.on Text -> Text -> Ordering
TextTools.lexicographicalCompare Option -> Text
option

instance Aeson.ToJSON Option where
  toJSON :: Option -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
Aeson.toJSON (Text -> Value) -> (Option -> Text) -> Option -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option -> Text
option

instance Aeson.ToJSONKey Option where
  toJSONKey :: ToJSONKeyFunction Option
toJSONKey = (Option -> Text) -> ToJSONKeyFunction Option
forall a. (a -> Text) -> ToJSONKeyFunction a
Types.toJSONKeyText Option -> Text
option

instance Yaml.FromJSON Option where
  parseJSON :: Value -> Parser Option
parseJSON = (Text -> Option) -> Parser Text -> Parser Option
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Option
Option (Parser Text -> Parser Option)
-> (Value -> Parser Text) -> Value -> Parser Option
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
Yaml.parseJSON

instance Types.FromJSONKey Option where
  fromJSONKey :: FromJSONKeyFunction Option
fromJSONKey = (Text -> Option) -> FromJSONKeyFunction Option
forall a. (Text -> a) -> FromJSONKeyFunction a
Aeson.FromJSONKeyText Text -> Option
Option

data Dish =
  Dish
    { Dish -> String
dockerfilePath :: FilePath
    , Dish -> Metadata
metadata :: Metadata
    , Dish -> DockerfilePart
beforeFirstBuildStage :: DockerfilePart
    , Dish -> [DockerfilePart]
localBuildStages :: [DockerfilePart]
    , Dish -> DockerfilePart
globalBuildStage :: DockerfilePart
    , Dish -> Maybe Text
healthCheck :: Maybe T.Text
    }
  deriving (Dish -> Dish -> Bool
(Dish -> Dish -> Bool) -> (Dish -> Dish -> Bool) -> Eq Dish
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dish -> Dish -> Bool
$c/= :: Dish -> Dish -> Bool
== :: Dish -> Dish -> Bool
$c== :: Dish -> Dish -> Bool
Eq, Eq Dish
Eq Dish
-> (Dish -> Dish -> Ordering)
-> (Dish -> Dish -> Bool)
-> (Dish -> Dish -> Bool)
-> (Dish -> Dish -> Bool)
-> (Dish -> Dish -> Bool)
-> (Dish -> Dish -> Dish)
-> (Dish -> Dish -> Dish)
-> Ord Dish
Dish -> Dish -> Bool
Dish -> Dish -> Ordering
Dish -> Dish -> Dish
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
min :: Dish -> Dish -> Dish
$cmin :: Dish -> Dish -> Dish
max :: Dish -> Dish -> Dish
$cmax :: Dish -> Dish -> Dish
>= :: Dish -> Dish -> Bool
$c>= :: Dish -> Dish -> Bool
> :: Dish -> Dish -> Bool
$c> :: Dish -> Dish -> Bool
<= :: Dish -> Dish -> Bool
$c<= :: Dish -> Dish -> Bool
< :: Dish -> Dish -> Bool
$c< :: Dish -> Dish -> Bool
compare :: Dish -> Dish -> Ordering
$ccompare :: Dish -> Dish -> Ordering
$cp1Ord :: Eq Dish
Ord, Int -> Dish -> ShowS
[Dish] -> ShowS
Dish -> String
(Int -> Dish -> ShowS)
-> (Dish -> String) -> ([Dish] -> ShowS) -> Show Dish
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dish] -> ShowS
$cshowList :: [Dish] -> ShowS
show :: Dish -> String
$cshow :: Dish -> String
showsPrec :: Int -> Dish -> ShowS
$cshowsPrec :: Int -> Dish -> ShowS
Show)

data Metadata =
  Metadata
    { Metadata -> Text
title :: T.Text
    , Metadata -> Text
url :: T.Text
    , Metadata -> Map TagKey [TagValue]
tags :: Map.Map TagKey [TagValue]
    }
  deriving (Metadata -> Metadata -> Bool
(Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool) -> Eq Metadata
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Metadata -> Metadata -> Bool
$c/= :: Metadata -> Metadata -> Bool
== :: Metadata -> Metadata -> Bool
$c== :: Metadata -> Metadata -> Bool
Eq, Eq Metadata
Eq Metadata
-> (Metadata -> Metadata -> Ordering)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Metadata)
-> (Metadata -> Metadata -> Metadata)
-> Ord Metadata
Metadata -> Metadata -> Bool
Metadata -> Metadata -> Ordering
Metadata -> Metadata -> Metadata
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
min :: Metadata -> Metadata -> Metadata
$cmin :: Metadata -> Metadata -> Metadata
max :: Metadata -> Metadata -> Metadata
$cmax :: Metadata -> Metadata -> Metadata
>= :: Metadata -> Metadata -> Bool
$c>= :: Metadata -> Metadata -> Bool
> :: Metadata -> Metadata -> Bool
$c> :: Metadata -> Metadata -> Bool
<= :: Metadata -> Metadata -> Bool
$c<= :: Metadata -> Metadata -> Bool
< :: Metadata -> Metadata -> Bool
$c< :: Metadata -> Metadata -> Bool
compare :: Metadata -> Metadata -> Ordering
$ccompare :: Metadata -> Metadata -> Ordering
$cp1Ord :: Eq Metadata
Ord, Int -> Metadata -> ShowS
[Metadata] -> ShowS
Metadata -> String
(Int -> Metadata -> ShowS)
-> (Metadata -> String) -> ([Metadata] -> ShowS) -> Show Metadata
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Metadata] -> ShowS
$cshowList :: [Metadata] -> ShowS
show :: Metadata -> String
$cshow :: Metadata -> String
showsPrec :: Int -> Metadata -> ShowS
$cshowsPrec :: Int -> Metadata -> ShowS
Show)

newtype TagKey =
  TagKey
    { TagKey -> Text
tagKey :: T.Text
    }
  deriving (TagKey -> TagKey -> Bool
(TagKey -> TagKey -> Bool)
-> (TagKey -> TagKey -> Bool) -> Eq TagKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TagKey -> TagKey -> Bool
$c/= :: TagKey -> TagKey -> Bool
== :: TagKey -> TagKey -> Bool
$c== :: TagKey -> TagKey -> Bool
Eq, Int -> TagKey -> ShowS
[TagKey] -> ShowS
TagKey -> String
(Int -> TagKey -> ShowS)
-> (TagKey -> String) -> ([TagKey] -> ShowS) -> Show TagKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TagKey] -> ShowS
$cshowList :: [TagKey] -> ShowS
show :: TagKey -> String
$cshow :: TagKey -> String
showsPrec :: Int -> TagKey -> ShowS
$cshowsPrec :: Int -> TagKey -> ShowS
Show)

instance Ord TagKey where
  compare :: TagKey -> TagKey -> Ordering
compare = (Text -> Text -> Ordering)
-> (TagKey -> Text) -> TagKey -> TagKey -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
Function.on Text -> Text -> Ordering
TextTools.lexicographicalCompare TagKey -> Text
tagKey

instance Aeson.ToJSON TagKey where
  toJSON :: TagKey -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
Aeson.toJSON (Text -> Value) -> (TagKey -> Text) -> TagKey -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagKey -> Text
tagKey

instance Aeson.ToJSONKey TagKey where
  toJSONKey :: ToJSONKeyFunction TagKey
toJSONKey = (TagKey -> Text) -> ToJSONKeyFunction TagKey
forall a. (a -> Text) -> ToJSONKeyFunction a
Types.toJSONKeyText TagKey -> Text
tagKey

newtype TagValue =
  TagValue
    { TagValue -> Text
tagValue :: T.Text
    }
  deriving (TagValue -> TagValue -> Bool
(TagValue -> TagValue -> Bool)
-> (TagValue -> TagValue -> Bool) -> Eq TagValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TagValue -> TagValue -> Bool
$c/= :: TagValue -> TagValue -> Bool
== :: TagValue -> TagValue -> Bool
$c== :: TagValue -> TagValue -> Bool
Eq, Int -> TagValue -> ShowS
[TagValue] -> ShowS
TagValue -> String
(Int -> TagValue -> ShowS)
-> (TagValue -> String) -> ([TagValue] -> ShowS) -> Show TagValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TagValue] -> ShowS
$cshowList :: [TagValue] -> ShowS
show :: TagValue -> String
$cshow :: TagValue -> String
showsPrec :: Int -> TagValue -> ShowS
$cshowsPrec :: Int -> TagValue -> ShowS
Show)

instance Ord TagValue where
  compare :: TagValue -> TagValue -> Ordering
compare = (Text -> Text -> Ordering)
-> (TagValue -> Text) -> TagValue -> TagValue -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
Function.on Text -> Text -> Ordering
TextTools.lexicographicalCompare TagValue -> Text
tagValue

instance Aeson.ToJSON TagValue where
  toJSON :: TagValue -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
Aeson.toJSON (Text -> Value) -> (TagValue -> Text) -> TagValue -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagValue -> Text
tagValue

instance Aeson.ToJSONKey TagValue where
  toJSONKey :: ToJSONKeyFunction TagValue
toJSONKey = (TagValue -> Text) -> ToJSONKeyFunction TagValue
forall a. (a -> Text) -> ToJSONKeyFunction a
Types.toJSONKeyText TagValue -> Text
tagValue

type DockerfilePart = [Docker.Instruction T.Text]