{-# OPTIONS_GHC -Wno-orphans #-}

{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE QuasiQuotes           #-}
{-# LANGUAGE TemplateHaskell       #-}
{-# LANGUAGE TypeFamilies          #-}

{-|
Module      : GHCup.Types.JSON
Description : GHCup JSON types/instances
Copyright   : (c) Julian Ospald, 2020
License     : LGPL-3.0
Maintainer  : hasufell@hasufell.de
Stability   : experimental
Portability : portable
-}
module GHCup.Types.JSON where

import           GHCup.Types
import           GHCup.Types.JSON.Utils
import           GHCup.Utils.MegaParsec

import           Control.Applicative            ( (<|>) )
import           Data.Aeson              hiding (Key)
import           Data.Aeson.TH
import           Data.Aeson.Types        hiding (Key)
import           Data.List.NonEmpty             ( NonEmpty(..) )
import           Data.Text.Encoding            as E
import           Data.Versions
import           Data.Void
import           URI.ByteString
import           Text.Casing

import qualified Data.List.NonEmpty            as NE
import qualified Data.Text                     as T
import qualified Data.Text.Encoding.Error      as E
import qualified Text.Megaparsec               as MP
import qualified Text.Megaparsec.Char          as MPC


deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Architecture
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GPGSetting

instance ToJSON Tag where
  toJSON :: Tag -> Value
toJSON Tag
Latest             = Text -> Value
String Text
"Latest"
  toJSON Tag
Recommended        = Text -> Value
String Text
"Recommended"
  toJSON Tag
Prerelease         = Text -> Value
String Text
"Prerelease"
  toJSON Tag
Old                = Text -> Value
String Text
"old"
  toJSON (Base       PVP
pvp'') = Text -> Value
String (Text
"base-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> PVP -> Text
prettyPVP PVP
pvp'')
  toJSON (UnknownTag String
x    ) = Text -> Value
String (String -> Text
T.pack String
x)

instance FromJSON Tag where
  parseJSON :: Value -> Parser Tag
parseJSON = String -> (Text -> Parser Tag) -> Value -> Parser Tag
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Tag" ((Text -> Parser Tag) -> Value -> Parser Tag)
-> (Text -> Parser Tag) -> Value -> Parser Tag
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> String
T.unpack Text
t of
    String
"Latest"                             -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure Tag
Latest
    String
"Recommended"                        -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure Tag
Recommended
    String
"Prerelease"                         -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure Tag
Prerelease
    String
"old"                                -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure Tag
Old
    (Char
'b' : Char
'a' : Char
's' : Char
'e' : Char
'-' : String
ver') -> case Text -> Either ParsingError PVP
pvp (String -> Text
T.pack String
ver') of
      Right PVP
x -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Tag -> Parser Tag) -> Tag -> Parser Tag
forall a b. (a -> b) -> a -> b
$ PVP -> Tag
Base PVP
x
      Left  ParsingError
e -> String -> Parser Tag
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Tag)
-> (ParsingError -> String) -> ParsingError -> Parser Tag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParsingError -> String
forall a. Show a => a -> String
show (ParsingError -> Parser Tag) -> ParsingError -> Parser Tag
forall a b. (a -> b) -> a -> b
$ ParsingError
e
    String
x -> Tag -> Parser Tag
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Tag
UnknownTag String
x)

instance ToJSON URI where
  toJSON :: URI -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (URI -> Text) -> URI -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OnDecodeError -> ByteString -> Text
E.decodeUtf8With OnDecodeError
E.lenientDecode (ByteString -> Text) -> (URI -> ByteString) -> URI -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URI -> ByteString
forall a. URIRef a -> ByteString
serializeURIRef'

instance FromJSON URLSource where
  parseJSON :: Value -> Parser URLSource
parseJSON Value
v =
        Value -> Parser URLSource
parseGHCupURL Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
parseOwnSourceLegacy Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
parseOwnSourceNew1 Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
parseOwnSourceNew2 Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
parseOwnSpec Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
legacyParseAddSource Value
v
    Parser URLSource -> Parser URLSource -> Parser URLSource
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser URLSource
newParseAddSource Value
v
   where
    parseOwnSourceLegacy :: Value -> Parser URLSource
parseOwnSourceLegacy = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      URI
r :: URI <- Object
o Object -> Key -> Parser URI
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OwnSource"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Either GHCupInfo URI] -> URLSource
OwnSource [URI -> Either GHCupInfo URI
forall a b. b -> Either a b
Right URI
r])
    parseOwnSourceNew1 :: Value -> Parser URLSource
parseOwnSourceNew1 = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      [URI]
r :: [URI] <- Object
o Object -> Key -> Parser [URI]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OwnSource"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Either GHCupInfo URI] -> URLSource
OwnSource ((URI -> Either GHCupInfo URI) -> [URI] -> [Either GHCupInfo URI]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap URI -> Either GHCupInfo URI
forall a b. b -> Either a b
Right [URI]
r))
    parseOwnSourceNew2 :: Value -> Parser URLSource
parseOwnSourceNew2 = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      [Either GHCupInfo URI]
r :: [Either GHCupInfo URI] <- Object
o Object -> Key -> Parser [Either GHCupInfo URI]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OwnSource"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Either GHCupInfo URI] -> URLSource
OwnSource [Either GHCupInfo URI]
r)
    parseOwnSpec :: Value -> Parser URLSource
parseOwnSpec = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      GHCupInfo
r :: GHCupInfo <- Object
o Object -> Key -> Parser GHCupInfo
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"OwnSpec"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GHCupInfo -> URLSource
OwnSpec GHCupInfo
r)
    parseGHCupURL :: Value -> Parser URLSource
parseGHCupURL = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      [Value]
_ :: [Value] <- Object
o Object -> Key -> Parser [Value]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"GHCupURL"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure URLSource
GHCupURL
    legacyParseAddSource :: Value -> Parser URLSource
legacyParseAddSource = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      Either GHCupInfo URI
r :: Either GHCupInfo URI <- Object
o Object -> Key -> Parser (Either GHCupInfo URI)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"AddSource"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Either GHCupInfo URI] -> URLSource
AddSource [Either GHCupInfo URI
r])
    newParseAddSource :: Value -> Parser URLSource
newParseAddSource = String -> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"URLSource" ((Object -> Parser URLSource) -> Value -> Parser URLSource)
-> (Object -> Parser URLSource) -> Value -> Parser URLSource
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      [Either GHCupInfo URI]
r :: [Either GHCupInfo URI] <- Object
o Object -> Key -> Parser [Either GHCupInfo URI]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"AddSource"
      URLSource -> Parser URLSource
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Either GHCupInfo URI] -> URLSource
AddSource [Either GHCupInfo URI]
r)

instance FromJSON URI where
  parseJSON :: Value -> Parser URI
parseJSON = String -> (Text -> Parser URI) -> Value -> Parser URI
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"URL" ((Text -> Parser URI) -> Value -> Parser URI)
-> (Text -> Parser URI) -> Value -> Parser URI
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    case URIParserOptions -> ByteString -> Either URIParseError URI
parseURI URIParserOptions
strictURIParserOptions (Text -> ByteString
encodeUtf8 Text
t) of
      Right URI
x -> URI -> Parser URI
forall (f :: * -> *) a. Applicative f => a -> f a
pure URI
x
      Left  URIParseError
e -> String -> Parser URI
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser URI)
-> (URIParseError -> String) -> URIParseError -> Parser URI
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URIParseError -> String
forall a. Show a => a -> String
show (URIParseError -> Parser URI) -> URIParseError -> Parser URI
forall a b. (a -> b) -> a -> b
$ URIParseError
e

instance ToJSON Versioning where
  toJSON :: Versioning -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (Versioning -> Text) -> Versioning -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Versioning -> Text
prettyV

instance FromJSON Versioning where
  parseJSON :: Value -> Parser Versioning
parseJSON = String -> (Text -> Parser Versioning) -> Value -> Parser Versioning
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Versioning" ((Text -> Parser Versioning) -> Value -> Parser Versioning)
-> (Text -> Parser Versioning) -> Value -> Parser Versioning
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Either ParsingError Versioning
versioning Text
t of
    Right Versioning
x -> Versioning -> Parser Versioning
forall (f :: * -> *) a. Applicative f => a -> f a
pure Versioning
x
    Left  ParsingError
e -> String -> Parser Versioning
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Versioning) -> String -> Parser Versioning
forall a b. (a -> b) -> a -> b
$ String
"Failure in Version (FromJSON)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSONKey Versioning where
  toJSONKey :: ToJSONKeyFunction Versioning
toJSONKey = (Versioning -> Text) -> ToJSONKeyFunction Versioning
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Versioning -> Text) -> ToJSONKeyFunction Versioning)
-> (Versioning -> Text) -> ToJSONKeyFunction Versioning
forall a b. (a -> b) -> a -> b
$ \Versioning
x -> Versioning -> Text
prettyV Versioning
x

instance FromJSONKey Versioning where
  fromJSONKey :: FromJSONKeyFunction Versioning
fromJSONKey = (Text -> Parser Versioning) -> FromJSONKeyFunction Versioning
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser Versioning) -> FromJSONKeyFunction Versioning)
-> (Text -> Parser Versioning) -> FromJSONKeyFunction Versioning
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Either ParsingError Versioning
versioning Text
t of
    Right Versioning
x -> Versioning -> Parser Versioning
forall (f :: * -> *) a. Applicative f => a -> f a
pure Versioning
x
    Left  ParsingError
e -> String -> Parser Versioning
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Versioning) -> String -> Parser Versioning
forall a b. (a -> b) -> a -> b
$ String
"Failure in Versioning (FromJSONKey)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSONKey (Maybe Versioning) where
  toJSONKey :: ToJSONKeyFunction (Maybe Versioning)
toJSONKey = (Maybe Versioning -> Text) -> ToJSONKeyFunction (Maybe Versioning)
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Maybe Versioning -> Text)
 -> ToJSONKeyFunction (Maybe Versioning))
-> (Maybe Versioning -> Text)
-> ToJSONKeyFunction (Maybe Versioning)
forall a b. (a -> b) -> a -> b
$ \case
    Just Versioning
x  -> Versioning -> Text
prettyV Versioning
x
    Maybe Versioning
Nothing -> String -> Text
T.pack String
"unknown_versioning"

instance FromJSONKey (Maybe Versioning) where
  fromJSONKey :: FromJSONKeyFunction (Maybe Versioning)
fromJSONKey = (Text -> Parser (Maybe Versioning))
-> FromJSONKeyFunction (Maybe Versioning)
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser (Maybe Versioning))
 -> FromJSONKeyFunction (Maybe Versioning))
-> (Text -> Parser (Maybe Versioning))
-> FromJSONKeyFunction (Maybe Versioning)
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    if Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Text
T.pack String
"unknown_versioning" then Maybe Versioning -> Parser (Maybe Versioning)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Versioning
forall a. Maybe a
Nothing else Text -> Parser (Maybe Versioning)
forall (f :: * -> *). MonadFail f => Text -> f (Maybe Versioning)
just Text
t
   where
    just :: Text -> f (Maybe Versioning)
just Text
t = case Text -> Either ParsingError Versioning
versioning Text
t of
      Right Versioning
x -> Maybe Versioning -> f (Maybe Versioning)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Versioning -> f (Maybe Versioning))
-> Maybe Versioning -> f (Maybe Versioning)
forall a b. (a -> b) -> a -> b
$ Versioning -> Maybe Versioning
forall a. a -> Maybe a
Just Versioning
x
      Left  ParsingError
e -> String -> f (Maybe Versioning)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> f (Maybe Versioning)) -> String -> f (Maybe Versioning)
forall a b. (a -> b) -> a -> b
$ String
"Failure in (Maybe Versioning) (FromJSONKey)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSONKey Platform where
  toJSONKey :: ToJSONKeyFunction Platform
toJSONKey = (Platform -> Text) -> ToJSONKeyFunction Platform
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Platform -> Text) -> ToJSONKeyFunction Platform)
-> (Platform -> Text) -> ToJSONKeyFunction Platform
forall a b. (a -> b) -> a -> b
$ \case
    Platform
Darwin  -> String -> Text
T.pack String
"Darwin"
    Platform
FreeBSD -> String -> Text
T.pack String
"FreeBSD"
    Linux LinuxDistro
d -> String -> Text
T.pack (String
"Linux_" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> LinuxDistro -> String
forall a. Show a => a -> String
show LinuxDistro
d)
    Platform
Windows -> String -> Text
T.pack String
"Windows"

instance FromJSONKey Platform where
  fromJSONKey :: FromJSONKeyFunction Platform
fromJSONKey = (Text -> Parser Platform) -> FromJSONKeyFunction Platform
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser Platform) -> FromJSONKeyFunction Platform)
-> (Text -> Parser Platform) -> FromJSONKeyFunction Platform
forall a b. (a -> b) -> a -> b
$ \Text
t -> if
    | String -> Text
T.pack String
"Darwin" Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
t -> Platform -> Parser Platform
forall (f :: * -> *) a. Applicative f => a -> f a
pure Platform
Darwin
    | String -> Text
T.pack String
"FreeBSD" Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
t -> Platform -> Parser Platform
forall (f :: * -> *) a. Applicative f => a -> f a
pure Platform
FreeBSD
    | String -> Text
T.pack String
"Windows" Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
t -> Platform -> Parser Platform
forall (f :: * -> *) a. Applicative f => a -> f a
pure Platform
Windows
    | String -> Text
T.pack String
"Linux_" Text -> Text -> Bool
`T.isPrefixOf` Text
t -> case
        Text -> Text -> Maybe Text
T.stripPrefix (String -> Text
T.pack String
"Linux_") Text
t
      of
        Just Text
dstr ->
          case
              (ByteString -> Maybe LinuxDistro
forall a. FromJSON a => ByteString -> Maybe a
decodeStrict (Text -> ByteString
E.encodeUtf8 (String -> Text
T.pack String
"\"" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
dstr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack String
"\"")) :: Maybe
                  LinuxDistro
              )
            of
              Just LinuxDistro
d -> Platform -> Parser Platform
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Platform -> Parser Platform) -> Platform -> Parser Platform
forall a b. (a -> b) -> a -> b
$ LinuxDistro -> Platform
Linux LinuxDistro
d
              Maybe LinuxDistro
Nothing ->
                String -> Parser Platform
forall (m :: * -> *) a. MonadFail m => String -> m a
fail
                  (String -> Parser Platform) -> String -> Parser Platform
forall a b. (a -> b) -> a -> b
$  String
"Unexpected failure in decoding LinuxDistro: "
                  String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Text -> String
forall a. Show a => a -> String
show Text
dstr
        Maybe Text
Nothing -> String -> Parser Platform
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Unexpected failure in Platform stripPrefix"
    | Bool
otherwise -> String -> Parser Platform
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Failure in Platform (FromJSONKey)"

instance ToJSONKey Architecture where
  toJSONKey :: ToJSONKeyFunction Architecture
toJSONKey = JSONKeyOptions -> ToJSONKeyFunction Architecture
forall a.
(Generic a, GToJSONKey (Rep a)) =>
JSONKeyOptions -> ToJSONKeyFunction a
genericToJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance FromJSONKey Architecture where
  fromJSONKey :: FromJSONKeyFunction Architecture
fromJSONKey = JSONKeyOptions -> FromJSONKeyFunction Architecture
forall a.
(Generic a, GFromJSONKey (Rep a)) =>
JSONKeyOptions -> FromJSONKeyFunction a
genericFromJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance ToJSONKey (Maybe Version) where
  toJSONKey :: ToJSONKeyFunction (Maybe Version)
toJSONKey = (Maybe Version -> Text) -> ToJSONKeyFunction (Maybe Version)
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Maybe Version -> Text) -> ToJSONKeyFunction (Maybe Version))
-> (Maybe Version -> Text) -> ToJSONKeyFunction (Maybe Version)
forall a b. (a -> b) -> a -> b
$ \case
    Just Version
x  -> Version -> Text
prettyVer Version
x
    Maybe Version
Nothing -> String -> Text
T.pack String
"unknown_version"

instance FromJSONKey (Maybe Version) where
  fromJSONKey :: FromJSONKeyFunction (Maybe Version)
fromJSONKey = (Text -> Parser (Maybe Version))
-> FromJSONKeyFunction (Maybe Version)
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser (Maybe Version))
 -> FromJSONKeyFunction (Maybe Version))
-> (Text -> Parser (Maybe Version))
-> FromJSONKeyFunction (Maybe Version)
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    if Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Text
T.pack String
"unknown_version" then Maybe Version -> Parser (Maybe Version)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Version
forall a. Maybe a
Nothing else Text -> Parser (Maybe Version)
forall (f :: * -> *). MonadFail f => Text -> f (Maybe Version)
just Text
t
   where
    just :: Text -> f (Maybe Version)
just Text
t = case Text -> Either ParsingError Version
version Text
t of
      Right Version
x -> Maybe Version -> f (Maybe Version)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Version -> f (Maybe Version))
-> Maybe Version -> f (Maybe Version)
forall a b. (a -> b) -> a -> b
$ Version -> Maybe Version
forall a. a -> Maybe a
Just Version
x
      Left  ParsingError
e -> String -> f (Maybe Version)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> f (Maybe Version)) -> String -> f (Maybe Version)
forall a b. (a -> b) -> a -> b
$ String
"Failure in (Maybe Version) (FromJSONKey)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSON Version where
  toJSON :: Version -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (Version -> Text) -> Version -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> Text
prettyVer

instance FromJSON Version where
  parseJSON :: Value -> Parser Version
parseJSON = String -> (Text -> Parser Version) -> Value -> Parser Version
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Version" ((Text -> Parser Version) -> Value -> Parser Version)
-> (Text -> Parser Version) -> Value -> Parser Version
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Either ParsingError Version
version Text
t of
    Right Version
x -> Version -> Parser Version
forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
x
    Left  ParsingError
e -> String -> Parser Version
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Version) -> String -> Parser Version
forall a b. (a -> b) -> a -> b
$ String
"Failure in Version (FromJSON)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSONKey Version where
  toJSONKey :: ToJSONKeyFunction Version
toJSONKey = (Version -> Text) -> ToJSONKeyFunction Version
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Version -> Text) -> ToJSONKeyFunction Version)
-> (Version -> Text) -> ToJSONKeyFunction Version
forall a b. (a -> b) -> a -> b
$ \Version
x -> Version -> Text
prettyVer Version
x

instance FromJSONKey Version where
  fromJSONKey :: FromJSONKeyFunction Version
fromJSONKey = (Text -> Parser Version) -> FromJSONKeyFunction Version
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser Version) -> FromJSONKeyFunction Version)
-> (Text -> Parser Version) -> FromJSONKeyFunction Version
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Either ParsingError Version
version Text
t of
    Right Version
x -> Version -> Parser Version
forall (f :: * -> *) a. Applicative f => a -> f a
pure Version
x
    Left  ParsingError
e -> String -> Parser Version
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Version) -> String -> Parser Version
forall a b. (a -> b) -> a -> b
$ String
"Failure in Version (FromJSONKey)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSON PVP where
  toJSON :: PVP -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (PVP -> Text) -> PVP -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PVP -> Text
prettyPVP

instance FromJSON PVP where
  parseJSON :: Value -> Parser PVP
parseJSON = String -> (Text -> Parser PVP) -> Value -> Parser PVP
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"PVP" ((Text -> Parser PVP) -> Value -> Parser PVP)
-> (Text -> Parser PVP) -> Value -> Parser PVP
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Either ParsingError PVP
pvp Text
t of
    Right PVP
x -> PVP -> Parser PVP
forall (f :: * -> *) a. Applicative f => a -> f a
pure PVP
x
    Left  ParsingError
e -> String -> Parser PVP
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser PVP) -> String -> Parser PVP
forall a b. (a -> b) -> a -> b
$ String
"Failure in PVP (FromJSON)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall a. Show a => a -> String
show ParsingError
e

instance ToJSONKey Tool where
  toJSONKey :: ToJSONKeyFunction Tool
toJSONKey = JSONKeyOptions -> ToJSONKeyFunction Tool
forall a.
(Generic a, GToJSONKey (Rep a)) =>
JSONKeyOptions -> ToJSONKeyFunction a
genericToJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance FromJSONKey Tool where
  fromJSONKey :: FromJSONKeyFunction Tool
fromJSONKey = JSONKeyOptions -> FromJSONKeyFunction Tool
forall a.
(Generic a, GFromJSONKey (Rep a)) =>
JSONKeyOptions -> FromJSONKeyFunction a
genericFromJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance ToJSONKey GlobalTool where
  toJSONKey :: ToJSONKeyFunction GlobalTool
toJSONKey = JSONKeyOptions -> ToJSONKeyFunction GlobalTool
forall a.
(Generic a, GToJSONKey (Rep a)) =>
JSONKeyOptions -> ToJSONKeyFunction a
genericToJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance FromJSONKey GlobalTool where
  fromJSONKey :: FromJSONKeyFunction GlobalTool
fromJSONKey = JSONKeyOptions -> FromJSONKeyFunction GlobalTool
forall a.
(Generic a, GFromJSONKey (Rep a)) =>
JSONKeyOptions -> FromJSONKeyFunction a
genericFromJSONKey JSONKeyOptions
defaultJSONKeyOptions

instance ToJSON TarDir where
  toJSON :: TarDir -> Value
toJSON (RealDir  String
p) = String -> Value
forall a. ToJSON a => a -> Value
toJSON String
p
  toJSON (RegexDir String
r) = [Pair] -> Value
object [Key
"RegexDir" Key -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String
r]

instance FromJSON TarDir where
  parseJSON :: Value -> Parser TarDir
parseJSON Value
v = Value -> Parser TarDir
realDir Value
v Parser TarDir -> Parser TarDir -> Parser TarDir
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser TarDir
regexDir Value
v
   where
    realDir :: Value -> Parser TarDir
realDir = String -> (Text -> Parser TarDir) -> Value -> Parser TarDir
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"TarDir" ((Text -> Parser TarDir) -> Value -> Parser TarDir)
-> (Text -> Parser TarDir) -> Value -> Parser TarDir
forall a b. (a -> b) -> a -> b
$ \Text
t -> do
      String
fp <- Value -> Parser String
forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
String Text
t)
      TarDir -> Parser TarDir
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> TarDir
RealDir String
fp)
    regexDir :: Value -> Parser TarDir
regexDir = String -> (Object -> Parser TarDir) -> Value -> Parser TarDir
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TarDir" ((Object -> Parser TarDir) -> Value -> Parser TarDir)
-> (Object -> Parser TarDir) -> Value -> Parser TarDir
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      String
r <- Object
o Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"RegexDir"
      TarDir -> Parser TarDir
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TarDir -> Parser TarDir) -> TarDir -> Parser TarDir
forall a b. (a -> b) -> a -> b
$ String -> TarDir
RegexDir String
r


instance ToJSON VersionCmp where
  toJSON :: VersionCmp -> Value
toJSON = Text -> Value
String (Text -> Value) -> (VersionCmp -> Text) -> VersionCmp -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionCmp -> Text
versionCmpToText

instance FromJSON VersionCmp where
  parseJSON :: Value -> Parser VersionCmp
parseJSON = String -> (Text -> Parser VersionCmp) -> Value -> Parser VersionCmp
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"VersionCmp" ((Text -> Parser VersionCmp) -> Value -> Parser VersionCmp)
-> (Text -> Parser VersionCmp) -> Value -> Parser VersionCmp
forall a b. (a -> b) -> a -> b
$ \Text
t -> do
    case Parsec Void Text VersionCmp
-> String -> Text -> Either ParsingError VersionCmp
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
MP.parse Parsec Void Text VersionCmp
versionCmpP String
"" Text
t of
      Right VersionCmp
r -> VersionCmp -> Parser VersionCmp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VersionCmp
r
      Left  ParsingError
e -> String -> Parser VersionCmp
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (ParsingError -> String
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
MP.errorBundlePretty ParsingError
e)

versionCmpToText :: VersionCmp -> T.Text
versionCmpToText :: VersionCmp -> Text
versionCmpToText (VR_gt   Versioning
ver') = Text
"> " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Versioning -> Text
prettyV Versioning
ver'
versionCmpToText (VR_gteq Versioning
ver') = Text
">= " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Versioning -> Text
prettyV Versioning
ver'
versionCmpToText (VR_lt   Versioning
ver') = Text
"< " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Versioning -> Text
prettyV Versioning
ver'
versionCmpToText (VR_lteq Versioning
ver') = Text
"<= " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Versioning -> Text
prettyV Versioning
ver'
versionCmpToText (VR_eq   Versioning
ver') = Text
"== " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Versioning -> Text
prettyV Versioning
ver'

versionCmpP :: MP.Parsec Void T.Text VersionCmp
versionCmpP :: Parsec Void Text VersionCmp
versionCmpP =
  (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Versioning -> VersionCmp
VR_gt (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
">" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)
    Parsec Void Text VersionCmp
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          Versioning -> VersionCmp
VR_gteq
          (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
">=" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)
    Parsec Void Text VersionCmp
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          Versioning -> VersionCmp
VR_lt
          (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"<" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)
    Parsec Void Text VersionCmp
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          Versioning -> VersionCmp
VR_lteq
          (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"<=" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)
    Parsec Void Text VersionCmp
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          Versioning -> VersionCmp
VR_eq
          (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"==" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)
    Parsec Void Text VersionCmp
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Versioning -> VersionCmp)
-> ParsecT Void Text Identity Versioning
-> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          Versioning -> VersionCmp
VR_eq
          (ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Versioning
 -> ParsecT Void Text Identity Versioning)
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall a b. (a -> b) -> a -> b
$ ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity Versioning
versioningEnd)

instance ToJSON VersionRange where
  toJSON :: VersionRange -> Value
toJSON = Text -> Value
String (Text -> Value) -> (VersionRange -> Text) -> VersionRange -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionRange -> Text
verRangeToText

verRangeToText :: VersionRange -> T.Text
verRangeToText :: VersionRange -> Text
verRangeToText  (SimpleRange NonEmpty VersionCmp
cmps) =
  let inner :: Text
inner = (Text -> Text -> Text) -> [Text] -> Text
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 (\Text
x Text
y -> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" && " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
y)
                     (VersionCmp -> Text
versionCmpToText (VersionCmp -> Text) -> [VersionCmp] -> [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty VersionCmp -> [VersionCmp]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty VersionCmp
cmps)
  in  Text
"( " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
inner Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" )"
verRangeToText (OrRange NonEmpty VersionCmp
cmps VersionRange
range) =
  let left :: Text
left  = VersionRange -> Text
verRangeToText (NonEmpty VersionCmp -> VersionRange
SimpleRange NonEmpty VersionCmp
cmps)
      right :: Text
right = VersionRange -> Text
verRangeToText VersionRange
range
  in  Text
left Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" || " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
right

instance FromJSON VersionRange where
  parseJSON :: Value -> Parser VersionRange
parseJSON = String
-> (Text -> Parser VersionRange) -> Value -> Parser VersionRange
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"VersionRange" ((Text -> Parser VersionRange) -> Value -> Parser VersionRange)
-> (Text -> Parser VersionRange) -> Value -> Parser VersionRange
forall a b. (a -> b) -> a -> b
$ \Text
t -> do
    case Parsec Void Text VersionRange
-> String -> Text -> Either ParsingError VersionRange
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
MP.parse Parsec Void Text VersionRange
versionRangeP String
"" Text
t of
      Right VersionRange
r -> VersionRange -> Parser VersionRange
forall (f :: * -> *) a. Applicative f => a -> f a
pure VersionRange
r
      Left  ParsingError
e -> String -> Parser VersionRange
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (ParsingError -> String
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
MP.errorBundlePretty ParsingError
e)

versionRangeP :: MP.Parsec Void T.Text VersionRange
versionRangeP :: Parsec Void Text VersionRange
versionRangeP = Parsec Void Text VersionRange
go Parsec Void Text VersionRange
-> ParsecT Void Text Identity () -> Parsec Void Text VersionRange
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
MP.eof
 where
  go :: Parsec Void Text VersionRange
go =
    Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try Parsec Void Text VersionRange
orParse
      Parsec Void Text VersionRange
-> Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try ((NonEmpty VersionCmp -> VersionRange)
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
-> Parsec Void Text VersionRange
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty VersionCmp -> VersionRange
SimpleRange ParsecT Void Text Identity (NonEmpty VersionCmp)
andParse)
      Parsec Void Text VersionRange
-> Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (VersionCmp -> VersionRange)
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionRange
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NonEmpty VersionCmp -> VersionRange
SimpleRange (NonEmpty VersionCmp -> VersionRange)
-> (VersionCmp -> NonEmpty VersionCmp)
-> VersionCmp
-> VersionRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionCmp -> NonEmpty VersionCmp
forall (f :: * -> *) a. Applicative f => a -> f a
pure) Parsec Void Text VersionCmp
versionCmpP

  orParse :: MP.Parsec Void T.Text VersionRange
  orParse :: Parsec Void Text VersionRange
orParse =
    (\NonEmpty VersionCmp
a VersionRange
o -> NonEmpty VersionCmp -> VersionRange -> VersionRange
OrRange NonEmpty VersionCmp
a VersionRange
o)
      (NonEmpty VersionCmp -> VersionRange -> VersionRange)
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity (VersionRange -> VersionRange)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try ParsecT Void Text Identity (NonEmpty VersionCmp)
andParse ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (VersionCmp -> NonEmpty VersionCmp)
-> Parsec Void Text VersionCmp
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap VersionCmp -> NonEmpty VersionCmp
forall (f :: * -> *) a. Applicative f => a -> f a
pure Parsec Void Text VersionCmp
versionCmpP)
      ParsecT Void Text Identity (VersionRange -> VersionRange)
-> Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"||" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> Parsec Void Text VersionRange -> Parsec Void Text VersionRange
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text VersionRange
go)

  andParse :: MP.Parsec Void T.Text (NonEmpty VersionCmp)
  andParse :: ParsecT Void Text Identity (NonEmpty VersionCmp)
andParse =
    (VersionCmp -> [VersionCmp] -> NonEmpty VersionCmp)
-> Parsec Void Text VersionCmp
-> ParsecT Void Text Identity ([VersionCmp] -> NonEmpty VersionCmp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\VersionCmp
h [VersionCmp]
t -> VersionCmp
h VersionCmp -> [VersionCmp] -> NonEmpty VersionCmp
forall a. a -> [a] -> NonEmpty a
:| [VersionCmp]
t)
         (ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"(" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text VersionCmp
versionCmpP)
      ParsecT Void Text Identity ([VersionCmp] -> NonEmpty VersionCmp)
-> ParsecT Void Text Identity [VersionCmp]
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT Void Text Identity [VersionCmp]
-> ParsecT Void Text Identity [VersionCmp]
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (Parsec Void Text VersionCmp
-> ParsecT Void Text Identity [VersionCmp]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
MP.many (ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"&&" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity () -> ParsecT Void Text Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space ParsecT Void Text Identity ()
-> Parsec Void Text VersionCmp -> Parsec Void Text VersionCmp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec Void Text VersionCmp
versionCmpP))
      ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity ()
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space
      ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
")"
      ParsecT Void Text Identity (NonEmpty VersionCmp)
-> ParsecT Void Text Identity ()
-> ParsecT Void Text Identity (NonEmpty VersionCmp)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space

versioningEnd :: MP.Parsec Void T.Text Versioning
versioningEnd :: ParsecT Void Text Identity Versioning
versioningEnd =
  ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
MP.try (ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Versioning
verP (Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
" " ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
")" ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
-> ParsecT Void Text Identity Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Tokens Text -> ParsecT Void Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
MP.chunk Tokens Text
"&&") ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity ()
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Void Text Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
MPC.space)
    ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
-> ParsecT Void Text Identity Versioning
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Void Text Identity Versioning
versioning'

instance ToJSONKey (Maybe VersionRange) where
  toJSONKey :: ToJSONKeyFunction (Maybe VersionRange)
toJSONKey = (Maybe VersionRange -> Text)
-> ToJSONKeyFunction (Maybe VersionRange)
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText ((Maybe VersionRange -> Text)
 -> ToJSONKeyFunction (Maybe VersionRange))
-> (Maybe VersionRange -> Text)
-> ToJSONKeyFunction (Maybe VersionRange)
forall a b. (a -> b) -> a -> b
$ \case
    Just VersionRange
x -> VersionRange -> Text
verRangeToText VersionRange
x
    Maybe VersionRange
Nothing -> Text
"unknown_versioning"

instance FromJSONKey (Maybe VersionRange)  where
  fromJSONKey :: FromJSONKeyFunction (Maybe VersionRange)
fromJSONKey = (Text -> Parser (Maybe VersionRange))
-> FromJSONKeyFunction (Maybe VersionRange)
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser ((Text -> Parser (Maybe VersionRange))
 -> FromJSONKeyFunction (Maybe VersionRange))
-> (Text -> Parser (Maybe VersionRange))
-> FromJSONKeyFunction (Maybe VersionRange)
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    if Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Text
T.pack String
"unknown_versioning" then Maybe VersionRange -> Parser (Maybe VersionRange)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe VersionRange
forall a. Maybe a
Nothing else Text -> Parser (Maybe VersionRange)
forall (f :: * -> *). MonadFail f => Text -> f (Maybe VersionRange)
just Text
t
   where
    just :: Text -> f (Maybe VersionRange)
just Text
t = case Parsec Void Text VersionRange
-> String -> Text -> Either ParsingError VersionRange
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
MP.parse Parsec Void Text VersionRange
versionRangeP String
"" Text
t of
      Right VersionRange
x -> Maybe VersionRange -> f (Maybe VersionRange)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe VersionRange -> f (Maybe VersionRange))
-> Maybe VersionRange -> f (Maybe VersionRange)
forall a b. (a -> b) -> a -> b
$ VersionRange -> Maybe VersionRange
forall a. a -> Maybe a
Just VersionRange
x
      Left  ParsingError
e -> String -> f (Maybe VersionRange)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> f (Maybe VersionRange))
-> String -> f (Maybe VersionRange)
forall a b. (a -> b) -> a -> b
$ String
"Failure in (Maybe VersionRange) (FromJSONKey)" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParsingError -> String
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
MP.errorBundlePretty ParsingError
e



deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
deriveToJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Key
deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings

deriveToJSON defaultOptions { fieldLabelModifier = kebab } ''Settings
deriveToJSON defaultOptions { fieldLabelModifier = drop 2 . kebab } ''KeyBindings -- move under key-bindings key