{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedLists       #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeOperators         #-}
module Gist
    ( API
    , GistAPI
    , getGists
    , createNewGist
    , getGist
    , updateGist
    , Owner(..)
    , GistId(..)
    , Gist(..)
    , GistFile(..)
    , NewGist(..)
    , NewGistFile(..)
    ) where

import Auth.Types (Token, TokenProvider (Github))
import Data.Aeson (FromJSON, GFromJSON, ToJSON, Value, Zero, genericParseJSON, object, parseJSON, toJSON, withObject,
                   (.!=), (.:), (.:?), (.=))
import Data.Aeson.Casing (aesonPrefix, snakeCase)
import Data.Aeson.Key qualified as Key
import Data.Aeson.Types (Parser)
import Data.Bifunctor (Bifunctor (first), bimap)
import Data.Map (Map)
import Data.Proxy (Proxy (Proxy))
import Data.Text (Text)
import Data.Text qualified as T
import GHC.Generics (Generic, Rep)
import Servant.API (Capture, FromHttpApiData (parseQueryParam), Get, Header, JSON, Post, ReqBody,
                    ToHttpApiData (toQueryParam), (:<|>), (:>))
import Servant.Client (ClientM, client)
import Servant.Extra qualified
import Text.Read (readEither)

type API = Header "Authorization" (Token 'Github) :> "gists" :> GistAPI

type GistAPI
     = Get '[ JSON] [Gist]
       :<|> ReqBody '[ JSON] NewGist :> Post '[ JSON] Gist
       :<|> Capture "GistId" GistId :> Get '[ JSON] Gist
       :<|> Capture "GistId" GistId :> ReqBody '[ JSON] NewGist :> Post '[ JSON] Gist

apiClient ::
       Maybe (Token 'Github)
    -> ClientM [Gist]
       :<|> (NewGist -> ClientM Gist)
       :<|> (GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist)
apiClient :: Maybe (Token 'Github)
-> ClientM [Gist]
   :<|> ((NewGist -> ClientM Gist)
         :<|> ((GistId -> ClientM Gist)
               :<|> (GistId -> NewGist -> ClientM Gist)))
apiClient = Proxy API -> Client ClientM API
forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
client (Proxy API
forall k (t :: k). Proxy t
Proxy @API)

getGists :: Maybe (Token 'Github) -> ClientM [Gist]
getGists :: Maybe (Token 'Github) -> ClientM [Gist]
getGists = (ClientM [Gist]
 :<|> ((NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist))))
-> ClientM [Gist]
forall a b. (a :<|> b) -> a
Servant.Extra.left ((ClientM [Gist]
  :<|> ((NewGist -> ClientM Gist)
        :<|> ((GistId -> ClientM Gist)
              :<|> (GistId -> NewGist -> ClientM Gist))))
 -> ClientM [Gist])
-> (Maybe (Token 'Github)
    -> ClientM [Gist]
       :<|> ((NewGist -> ClientM Gist)
             :<|> ((GistId -> ClientM Gist)
                   :<|> (GistId -> NewGist -> ClientM Gist))))
-> Maybe (Token 'Github)
-> ClientM [Gist]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Token 'Github)
-> ClientM [Gist]
   :<|> ((NewGist -> ClientM Gist)
         :<|> ((GistId -> ClientM Gist)
               :<|> (GistId -> NewGist -> ClientM Gist)))
apiClient

createNewGist :: Maybe (Token 'Github) -> NewGist -> ClientM Gist
createNewGist :: Maybe (Token 'Github) -> NewGist -> ClientM Gist
createNewGist = ((NewGist -> ClientM Gist)
 :<|> ((GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist)))
-> NewGist -> ClientM Gist
forall a b. (a :<|> b) -> a
Servant.Extra.left (((NewGist -> ClientM Gist)
  :<|> ((GistId -> ClientM Gist)
        :<|> (GistId -> NewGist -> ClientM Gist)))
 -> NewGist -> ClientM Gist)
-> (Maybe (Token 'Github)
    -> (NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist)))
-> Maybe (Token 'Github)
-> NewGist
-> ClientM Gist
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientM [Gist]
 :<|> ((NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist))))
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall a b. (a :<|> b) -> b
Servant.Extra.right ((ClientM [Gist]
  :<|> ((NewGist -> ClientM Gist)
        :<|> ((GistId -> ClientM Gist)
              :<|> (GistId -> NewGist -> ClientM Gist))))
 -> (NewGist -> ClientM Gist)
    :<|> ((GistId -> ClientM Gist)
          :<|> (GistId -> NewGist -> ClientM Gist)))
-> (Maybe (Token 'Github)
    -> ClientM [Gist]
       :<|> ((NewGist -> ClientM Gist)
             :<|> ((GistId -> ClientM Gist)
                   :<|> (GistId -> NewGist -> ClientM Gist))))
-> Maybe (Token 'Github)
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Token 'Github)
-> ClientM [Gist]
   :<|> ((NewGist -> ClientM Gist)
         :<|> ((GistId -> ClientM Gist)
               :<|> (GistId -> NewGist -> ClientM Gist)))
apiClient

getGist :: Maybe (Token 'Github) -> GistId -> ClientM Gist
getGist :: Maybe (Token 'Github) -> GistId -> ClientM Gist
getGist =
    ((GistId -> ClientM Gist) :<|> (GistId -> NewGist -> ClientM Gist))
-> GistId -> ClientM Gist
forall a b. (a :<|> b) -> a
Servant.Extra.left (((GistId -> ClientM Gist)
  :<|> (GistId -> NewGist -> ClientM Gist))
 -> GistId -> ClientM Gist)
-> (Maybe (Token 'Github)
    -> (GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist))
-> Maybe (Token 'Github)
-> GistId
-> ClientM Gist
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((NewGist -> ClientM Gist)
 :<|> ((GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist)))
-> (GistId -> ClientM Gist)
   :<|> (GistId -> NewGist -> ClientM Gist)
forall a b. (a :<|> b) -> b
Servant.Extra.right (((NewGist -> ClientM Gist)
  :<|> ((GistId -> ClientM Gist)
        :<|> (GistId -> NewGist -> ClientM Gist)))
 -> (GistId -> ClientM Gist)
    :<|> (GistId -> NewGist -> ClientM Gist))
-> (Maybe (Token 'Github)
    -> (NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist)))
-> Maybe (Token 'Github)
-> (GistId -> ClientM Gist)
   :<|> (GistId -> NewGist -> ClientM Gist)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientM [Gist]
 :<|> ((NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist))))
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall a b. (a :<|> b) -> b
Servant.Extra.right ((ClientM [Gist]
  :<|> ((NewGist -> ClientM Gist)
        :<|> ((GistId -> ClientM Gist)
              :<|> (GistId -> NewGist -> ClientM Gist))))
 -> (NewGist -> ClientM Gist)
    :<|> ((GistId -> ClientM Gist)
          :<|> (GistId -> NewGist -> ClientM Gist)))
-> (Maybe (Token 'Github)
    -> ClientM [Gist]
       :<|> ((NewGist -> ClientM Gist)
             :<|> ((GistId -> ClientM Gist)
                   :<|> (GistId -> NewGist -> ClientM Gist))))
-> Maybe (Token 'Github)
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Token 'Github)
-> ClientM [Gist]
   :<|> ((NewGist -> ClientM Gist)
         :<|> ((GistId -> ClientM Gist)
               :<|> (GistId -> NewGist -> ClientM Gist)))
apiClient

updateGist :: Maybe (Token 'Github) -> GistId -> NewGist -> ClientM Gist
updateGist :: Maybe (Token 'Github) -> GistId -> NewGist -> ClientM Gist
updateGist =
    ((GistId -> ClientM Gist) :<|> (GistId -> NewGist -> ClientM Gist))
-> GistId -> NewGist -> ClientM Gist
forall a b. (a :<|> b) -> b
Servant.Extra.right (((GistId -> ClientM Gist)
  :<|> (GistId -> NewGist -> ClientM Gist))
 -> GistId -> NewGist -> ClientM Gist)
-> (Maybe (Token 'Github)
    -> (GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist))
-> Maybe (Token 'Github)
-> GistId
-> NewGist
-> ClientM Gist
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((NewGist -> ClientM Gist)
 :<|> ((GistId -> ClientM Gist)
       :<|> (GistId -> NewGist -> ClientM Gist)))
-> (GistId -> ClientM Gist)
   :<|> (GistId -> NewGist -> ClientM Gist)
forall a b. (a :<|> b) -> b
Servant.Extra.right (((NewGist -> ClientM Gist)
  :<|> ((GistId -> ClientM Gist)
        :<|> (GistId -> NewGist -> ClientM Gist)))
 -> (GistId -> ClientM Gist)
    :<|> (GistId -> NewGist -> ClientM Gist))
-> (Maybe (Token 'Github)
    -> (NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist)))
-> Maybe (Token 'Github)
-> (GistId -> ClientM Gist)
   :<|> (GistId -> NewGist -> ClientM Gist)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientM [Gist]
 :<|> ((NewGist -> ClientM Gist)
       :<|> ((GistId -> ClientM Gist)
             :<|> (GistId -> NewGist -> ClientM Gist))))
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall a b. (a :<|> b) -> b
Servant.Extra.right ((ClientM [Gist]
  :<|> ((NewGist -> ClientM Gist)
        :<|> ((GistId -> ClientM Gist)
              :<|> (GistId -> NewGist -> ClientM Gist))))
 -> (NewGist -> ClientM Gist)
    :<|> ((GistId -> ClientM Gist)
          :<|> (GistId -> NewGist -> ClientM Gist)))
-> (Maybe (Token 'Github)
    -> ClientM [Gist]
       :<|> ((NewGist -> ClientM Gist)
             :<|> ((GistId -> ClientM Gist)
                   :<|> (GistId -> NewGist -> ClientM Gist))))
-> Maybe (Token 'Github)
-> (NewGist -> ClientM Gist)
   :<|> ((GistId -> ClientM Gist)
         :<|> (GistId -> NewGist -> ClientM Gist))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Token 'Github)
-> ClientM [Gist]
   :<|> ((NewGist -> ClientM Gist)
         :<|> ((GistId -> ClientM Gist)
               :<|> (GistId -> NewGist -> ClientM Gist)))
apiClient

------------------------------------------------------------
data Owner =
    Owner
        { Owner -> Text
_ownerLogin   :: !Text
        , Owner -> Text
_ownerHtmlUrl :: !Text
        }
    deriving (Int -> Owner -> ShowS
[Owner] -> ShowS
Owner -> String
(Int -> Owner -> ShowS)
-> (Owner -> String) -> ([Owner] -> ShowS) -> Show Owner
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Owner] -> ShowS
$cshowList :: [Owner] -> ShowS
show :: Owner -> String
$cshow :: Owner -> String
showsPrec :: Int -> Owner -> ShowS
$cshowsPrec :: Int -> Owner -> ShowS
Show, Owner -> Owner -> Bool
(Owner -> Owner -> Bool) -> (Owner -> Owner -> Bool) -> Eq Owner
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Owner -> Owner -> Bool
$c/= :: Owner -> Owner -> Bool
== :: Owner -> Owner -> Bool
$c== :: Owner -> Owner -> Bool
Eq, (forall x. Owner -> Rep Owner x)
-> (forall x. Rep Owner x -> Owner) -> Generic Owner
forall x. Rep Owner x -> Owner
forall x. Owner -> Rep Owner x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Owner x -> Owner
$cfrom :: forall x. Owner -> Rep Owner x
Generic, [Owner] -> Encoding
[Owner] -> Value
Owner -> Encoding
Owner -> Value
(Owner -> Value)
-> (Owner -> Encoding)
-> ([Owner] -> Value)
-> ([Owner] -> Encoding)
-> ToJSON Owner
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Owner] -> Encoding
$ctoEncodingList :: [Owner] -> Encoding
toJSONList :: [Owner] -> Value
$ctoJSONList :: [Owner] -> Value
toEncoding :: Owner -> Encoding
$ctoEncoding :: Owner -> Encoding
toJSON :: Owner -> Value
$ctoJSON :: Owner -> Value
ToJSON)

instance FromJSON Owner where
    parseJSON :: Value -> Parser Owner
parseJSON = Value -> Parser Owner
forall a. (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a
githubParseJSON

data NewGist =
    NewGist
        { NewGist -> Text
_newGistDescription :: !Text
        , NewGist -> Bool
_newGistPublic      :: !Bool
        , NewGist -> [NewGistFile]
_newGistFiles       :: ![NewGistFile]
        }
    deriving (Int -> NewGist -> ShowS
[NewGist] -> ShowS
NewGist -> String
(Int -> NewGist -> ShowS)
-> (NewGist -> String) -> ([NewGist] -> ShowS) -> Show NewGist
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewGist] -> ShowS
$cshowList :: [NewGist] -> ShowS
show :: NewGist -> String
$cshow :: NewGist -> String
showsPrec :: Int -> NewGist -> ShowS
$cshowsPrec :: Int -> NewGist -> ShowS
Show, NewGist -> NewGist -> Bool
(NewGist -> NewGist -> Bool)
-> (NewGist -> NewGist -> Bool) -> Eq NewGist
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewGist -> NewGist -> Bool
$c/= :: NewGist -> NewGist -> Bool
== :: NewGist -> NewGist -> Bool
$c== :: NewGist -> NewGist -> Bool
Eq, (forall x. NewGist -> Rep NewGist x)
-> (forall x. Rep NewGist x -> NewGist) -> Generic NewGist
forall x. Rep NewGist x -> NewGist
forall x. NewGist -> Rep NewGist x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewGist x -> NewGist
$cfrom :: forall x. NewGist -> Rep NewGist x
Generic, Value -> Parser [NewGist]
Value -> Parser NewGist
(Value -> Parser NewGist)
-> (Value -> Parser [NewGist]) -> FromJSON NewGist
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NewGist]
$cparseJSONList :: Value -> Parser [NewGist]
parseJSON :: Value -> Parser NewGist
$cparseJSON :: Value -> Parser NewGist
FromJSON)

instance ToJSON NewGist where
    toJSON :: NewGist -> Value
toJSON NewGist {Bool
[NewGistFile]
Text
_newGistFiles :: [NewGistFile]
_newGistPublic :: Bool
_newGistDescription :: Text
_newGistFiles :: NewGist -> [NewGistFile]
_newGistPublic :: NewGist -> Bool
_newGistDescription :: NewGist -> Text
..} =
        [Pair] -> Value
object
            [ Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
_newGistDescription
            , Key
"public" Key -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
_newGistPublic
            , Key
"files" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object ((Text -> Key) -> (Text, Value) -> Pair
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Text -> Key
Key.fromText ((Text, Value) -> Pair)
-> (NewGistFile -> (Text, Value)) -> NewGistFile -> Pair
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NewGistFile -> (Text, Value)
toPair (NewGistFile -> Pair) -> [NewGistFile] -> [Pair]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NewGistFile]
_newGistFiles)
            ]
      where
        toPair :: NewGistFile -> (Text, Value)
toPair NewGistFile {Text
_newGistFileContent :: NewGistFile -> Text
_newGistFilename :: NewGistFile -> Text
_newGistFileContent :: Text
_newGistFilename :: Text
..} =
            (Text
_newGistFilename, [Pair] -> Value
object [Key
"content" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
_newGistFileContent])

data NewGistFile =
    NewGistFile
        { NewGistFile -> Text
_newGistFilename    :: !Text
        , NewGistFile -> Text
_newGistFileContent :: !Text
        }
    deriving (Int -> NewGistFile -> ShowS
[NewGistFile] -> ShowS
NewGistFile -> String
(Int -> NewGistFile -> ShowS)
-> (NewGistFile -> String)
-> ([NewGistFile] -> ShowS)
-> Show NewGistFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewGistFile] -> ShowS
$cshowList :: [NewGistFile] -> ShowS
show :: NewGistFile -> String
$cshow :: NewGistFile -> String
showsPrec :: Int -> NewGistFile -> ShowS
$cshowsPrec :: Int -> NewGistFile -> ShowS
Show, NewGistFile -> NewGistFile -> Bool
(NewGistFile -> NewGistFile -> Bool)
-> (NewGistFile -> NewGistFile -> Bool) -> Eq NewGistFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewGistFile -> NewGistFile -> Bool
$c/= :: NewGistFile -> NewGistFile -> Bool
== :: NewGistFile -> NewGistFile -> Bool
$c== :: NewGistFile -> NewGistFile -> Bool
Eq, (forall x. NewGistFile -> Rep NewGistFile x)
-> (forall x. Rep NewGistFile x -> NewGistFile)
-> Generic NewGistFile
forall x. Rep NewGistFile x -> NewGistFile
forall x. NewGistFile -> Rep NewGistFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewGistFile x -> NewGistFile
$cfrom :: forall x. NewGistFile -> Rep NewGistFile x
Generic, Value -> Parser [NewGistFile]
Value -> Parser NewGistFile
(Value -> Parser NewGistFile)
-> (Value -> Parser [NewGistFile]) -> FromJSON NewGistFile
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NewGistFile]
$cparseJSONList :: Value -> Parser [NewGistFile]
parseJSON :: Value -> Parser NewGistFile
$cparseJSON :: Value -> Parser NewGistFile
FromJSON)

newtype GistId =
    GistId Text
    deriving (Int -> GistId -> ShowS
[GistId] -> ShowS
GistId -> String
(Int -> GistId -> ShowS)
-> (GistId -> String) -> ([GistId] -> ShowS) -> Show GistId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GistId] -> ShowS
$cshowList :: [GistId] -> ShowS
show :: GistId -> String
$cshow :: GistId -> String
showsPrec :: Int -> GistId -> ShowS
$cshowsPrec :: Int -> GistId -> ShowS
Show, GistId -> GistId -> Bool
(GistId -> GistId -> Bool)
-> (GistId -> GistId -> Bool) -> Eq GistId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GistId -> GistId -> Bool
$c/= :: GistId -> GistId -> Bool
== :: GistId -> GistId -> Bool
$c== :: GistId -> GistId -> Bool
Eq, Eq GistId
Eq GistId
-> (GistId -> GistId -> Ordering)
-> (GistId -> GistId -> Bool)
-> (GistId -> GistId -> Bool)
-> (GistId -> GistId -> Bool)
-> (GistId -> GistId -> Bool)
-> (GistId -> GistId -> GistId)
-> (GistId -> GistId -> GistId)
-> Ord GistId
GistId -> GistId -> Bool
GistId -> GistId -> Ordering
GistId -> GistId -> GistId
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 :: GistId -> GistId -> GistId
$cmin :: GistId -> GistId -> GistId
max :: GistId -> GistId -> GistId
$cmax :: GistId -> GistId -> GistId
>= :: GistId -> GistId -> Bool
$c>= :: GistId -> GistId -> Bool
> :: GistId -> GistId -> Bool
$c> :: GistId -> GistId -> Bool
<= :: GistId -> GistId -> Bool
$c<= :: GistId -> GistId -> Bool
< :: GistId -> GistId -> Bool
$c< :: GistId -> GistId -> Bool
compare :: GistId -> GistId -> Ordering
$ccompare :: GistId -> GistId -> Ordering
$cp1Ord :: Eq GistId
Ord, (forall x. GistId -> Rep GistId x)
-> (forall x. Rep GistId x -> GistId) -> Generic GistId
forall x. Rep GistId x -> GistId
forall x. GistId -> Rep GistId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GistId x -> GistId
$cfrom :: forall x. GistId -> Rep GistId x
Generic, Value -> Parser [GistId]
Value -> Parser GistId
(Value -> Parser GistId)
-> (Value -> Parser [GistId]) -> FromJSON GistId
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [GistId]
$cparseJSONList :: Value -> Parser [GistId]
parseJSON :: Value -> Parser GistId
$cparseJSON :: Value -> Parser GistId
FromJSON, [GistId] -> Encoding
[GistId] -> Value
GistId -> Encoding
GistId -> Value
(GistId -> Value)
-> (GistId -> Encoding)
-> ([GistId] -> Value)
-> ([GistId] -> Encoding)
-> ToJSON GistId
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [GistId] -> Encoding
$ctoEncodingList :: [GistId] -> Encoding
toJSONList :: [GistId] -> Value
$ctoJSONList :: [GistId] -> Value
toEncoding :: GistId -> Encoding
$ctoEncoding :: GistId -> Encoding
toJSON :: GistId -> Value
$ctoJSON :: GistId -> Value
ToJSON)

instance ToHttpApiData GistId where
    toQueryParam :: GistId -> Text
toQueryParam (GistId Text
gistId) = Text
gistId

instance FromHttpApiData GistId where
    parseQueryParam :: Text -> Either Text GistId
parseQueryParam = (String -> Text)
-> (Text -> GistId) -> Either String Text -> Either Text GistId
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap String -> Text
T.pack Text -> GistId
GistId (Either String Text -> Either Text GistId)
-> (Text -> Either String Text) -> Text -> Either Text GistId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either String Text
forall a. Read a => String -> Either String a
readEither (String -> Either String Text)
-> (Text -> String) -> Text -> Either String Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack

data Gist =
    Gist
        { Gist -> GistId
_gistId          :: !GistId
        , Gist -> Text
_gistGitPushUrl  :: !Text
        , Gist -> Text
_gistHtmlUrl     :: !Text
        , Gist -> Owner
_gistOwner       :: !Owner
        , Gist -> Map String GistFile
_gistFiles       :: !(Map String GistFile)
        , Gist -> Bool
_gistTruncated   :: !Bool
        , Gist -> String
_gistCreatedAt   :: !String
        , Gist -> String
_gistUpdatedAt   :: !String
        , Gist -> String
_gistDescription :: !String
        }
    deriving (Int -> Gist -> ShowS
[Gist] -> ShowS
Gist -> String
(Int -> Gist -> ShowS)
-> (Gist -> String) -> ([Gist] -> ShowS) -> Show Gist
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gist] -> ShowS
$cshowList :: [Gist] -> ShowS
show :: Gist -> String
$cshow :: Gist -> String
showsPrec :: Int -> Gist -> ShowS
$cshowsPrec :: Int -> Gist -> ShowS
Show, Gist -> Gist -> Bool
(Gist -> Gist -> Bool) -> (Gist -> Gist -> Bool) -> Eq Gist
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gist -> Gist -> Bool
$c/= :: Gist -> Gist -> Bool
== :: Gist -> Gist -> Bool
$c== :: Gist -> Gist -> Bool
Eq, (forall x. Gist -> Rep Gist x)
-> (forall x. Rep Gist x -> Gist) -> Generic Gist
forall x. Rep Gist x -> Gist
forall x. Gist -> Rep Gist x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Gist x -> Gist
$cfrom :: forall x. Gist -> Rep Gist x
Generic, [Gist] -> Encoding
[Gist] -> Value
Gist -> Encoding
Gist -> Value
(Gist -> Value)
-> (Gist -> Encoding)
-> ([Gist] -> Value)
-> ([Gist] -> Encoding)
-> ToJSON Gist
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Gist] -> Encoding
$ctoEncodingList :: [Gist] -> Encoding
toJSONList :: [Gist] -> Value
$ctoJSONList :: [Gist] -> Value
toEncoding :: Gist -> Encoding
$ctoEncoding :: Gist -> Encoding
toJSON :: Gist -> Value
$ctoJSON :: Gist -> Value
ToJSON)

instance FromJSON Gist where
    parseJSON :: Value -> Parser Gist
parseJSON =
        String -> (Object -> Parser Gist) -> Value -> Parser Gist
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"gist" ((Object -> Parser Gist) -> Value -> Parser Gist)
-> (Object -> Parser Gist) -> Value -> Parser Gist
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
            GistId
_gistId <- Object
o Object -> Key -> Parser GistId
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            Text
_gistGitPushUrl <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"git_push_url"
            Text
_gistHtmlUrl <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"
            Owner
_gistOwner <- Object
o Object -> Key -> Parser Owner
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner"
            Map String GistFile
_gistFiles <- Object
o Object -> Key -> Parser (Map String GistFile)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"files"
            Bool
_gistTruncated <- Object
o Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"truncated"
            String
_gistCreatedAt <- Object
o Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
            String
_gistUpdatedAt <- Object
o Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
            -- playground gists will always have a description but to avoid breaking with non-playground gists we change null to empty string
            String
_gistDescription <- Object
o Object -> Key -> Parser (Maybe String)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description" Parser (Maybe String) -> String -> Parser String
forall a. Parser (Maybe a) -> a -> Parser a
.!= String
""
            Gist -> Parser Gist
forall (f :: * -> *) a. Applicative f => a -> f a
pure Gist :: GistId
-> Text
-> Text
-> Owner
-> Map String GistFile
-> Bool
-> String
-> String
-> String
-> Gist
Gist {Bool
String
Map String GistFile
Text
GistId
Owner
_gistDescription :: String
_gistUpdatedAt :: String
_gistCreatedAt :: String
_gistTruncated :: Bool
_gistFiles :: Map String GistFile
_gistOwner :: Owner
_gistHtmlUrl :: Text
_gistGitPushUrl :: Text
_gistId :: GistId
_gistDescription :: String
_gistUpdatedAt :: String
_gistCreatedAt :: String
_gistTruncated :: Bool
_gistFiles :: Map String GistFile
_gistOwner :: Owner
_gistHtmlUrl :: Text
_gistGitPushUrl :: Text
_gistId :: GistId
..}

data GistFile =
    GistFile
        { GistFile -> Text
_gistFileFilename  :: !Text
        , GistFile -> Maybe Text
_gistFileLanguage  :: !(Maybe Text)
        , GistFile -> Text
_gistFileType      :: !Text
        , GistFile -> Maybe Bool
_gistFileTruncated :: !(Maybe Bool)
        , GistFile -> Maybe Text
_gistFileContent   :: !(Maybe Text)
        }
    deriving (Int -> GistFile -> ShowS
[GistFile] -> ShowS
GistFile -> String
(Int -> GistFile -> ShowS)
-> (GistFile -> String) -> ([GistFile] -> ShowS) -> Show GistFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GistFile] -> ShowS
$cshowList :: [GistFile] -> ShowS
show :: GistFile -> String
$cshow :: GistFile -> String
showsPrec :: Int -> GistFile -> ShowS
$cshowsPrec :: Int -> GistFile -> ShowS
Show, GistFile -> GistFile -> Bool
(GistFile -> GistFile -> Bool)
-> (GistFile -> GistFile -> Bool) -> Eq GistFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GistFile -> GistFile -> Bool
$c/= :: GistFile -> GistFile -> Bool
== :: GistFile -> GistFile -> Bool
$c== :: GistFile -> GistFile -> Bool
Eq, (forall x. GistFile -> Rep GistFile x)
-> (forall x. Rep GistFile x -> GistFile) -> Generic GistFile
forall x. Rep GistFile x -> GistFile
forall x. GistFile -> Rep GistFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GistFile x -> GistFile
$cfrom :: forall x. GistFile -> Rep GistFile x
Generic, [GistFile] -> Encoding
[GistFile] -> Value
GistFile -> Encoding
GistFile -> Value
(GistFile -> Value)
-> (GistFile -> Encoding)
-> ([GistFile] -> Value)
-> ([GistFile] -> Encoding)
-> ToJSON GistFile
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [GistFile] -> Encoding
$ctoEncodingList :: [GistFile] -> Encoding
toJSONList :: [GistFile] -> Value
$ctoJSONList :: [GistFile] -> Value
toEncoding :: GistFile -> Encoding
$ctoEncoding :: GistFile -> Encoding
toJSON :: GistFile -> Value
$ctoJSON :: GistFile -> Value
ToJSON)

instance FromJSON GistFile where
    parseJSON :: Value -> Parser GistFile
parseJSON =
        String -> (Object -> Parser GistFile) -> Value -> Parser GistFile
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"gistfile" ((Object -> Parser GistFile) -> Value -> Parser GistFile)
-> (Object -> Parser GistFile) -> Value -> Parser GistFile
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
            Text
_gistFileFilename <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"filename"
            Maybe Text
_gistFileLanguage <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"language"
            Text
_gistFileType <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
            Maybe Bool
_gistFileTruncated <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"truncated"
            Maybe Text
_gistFileContent <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"content"
            GistFile -> Parser GistFile
forall (f :: * -> *) a. Applicative f => a -> f a
pure GistFile :: Text -> Maybe Text -> Text -> Maybe Bool -> Maybe Text -> GistFile
GistFile {Maybe Bool
Maybe Text
Text
_gistFileContent :: Maybe Text
_gistFileTruncated :: Maybe Bool
_gistFileType :: Text
_gistFileLanguage :: Maybe Text
_gistFileFilename :: Text
_gistFileContent :: Maybe Text
_gistFileTruncated :: Maybe Bool
_gistFileType :: Text
_gistFileLanguage :: Maybe Text
_gistFileFilename :: Text
..}

------------------------------------------------------------
githubParseJSON :: (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a
githubParseJSON :: Value -> Parser a
githubParseJSON = Options -> Value -> Parser a
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON (Options -> Value -> Parser a) -> Options -> Value -> Parser a
forall a b. (a -> b) -> a -> b
$ ShowS -> Options
aesonPrefix ShowS
snakeCase