module GitHub.Data.GitData where

import GitHub.Data.Definitions
import GitHub.Data.Name        (Name)
import GitHub.Data.URL         (URL)
import GitHub.Internal.Prelude
import Prelude ()

import qualified Data.Vector as V

-- | The options for querying commits.
data CommitQueryOption
    = CommitQuerySha !Text
    | CommitQueryPath !Text
    | CommitQueryAuthor !Text
    | CommitQuerySince !UTCTime
    | CommitQueryUntil !UTCTime
  deriving (Int -> CommitQueryOption -> ShowS
[CommitQueryOption] -> ShowS
CommitQueryOption -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommitQueryOption] -> ShowS
$cshowList :: [CommitQueryOption] -> ShowS
show :: CommitQueryOption -> String
$cshow :: CommitQueryOption -> String
showsPrec :: Int -> CommitQueryOption -> ShowS
$cshowsPrec :: Int -> CommitQueryOption -> ShowS
Show, CommitQueryOption -> CommitQueryOption -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommitQueryOption -> CommitQueryOption -> Bool
$c/= :: CommitQueryOption -> CommitQueryOption -> Bool
== :: CommitQueryOption -> CommitQueryOption -> Bool
$c== :: CommitQueryOption -> CommitQueryOption -> Bool
Eq, Eq CommitQueryOption
CommitQueryOption -> CommitQueryOption -> Bool
CommitQueryOption -> CommitQueryOption -> Ordering
CommitQueryOption -> CommitQueryOption -> CommitQueryOption
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 :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
$cmin :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
max :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
$cmax :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
>= :: CommitQueryOption -> CommitQueryOption -> Bool
$c>= :: CommitQueryOption -> CommitQueryOption -> Bool
> :: CommitQueryOption -> CommitQueryOption -> Bool
$c> :: CommitQueryOption -> CommitQueryOption -> Bool
<= :: CommitQueryOption -> CommitQueryOption -> Bool
$c<= :: CommitQueryOption -> CommitQueryOption -> Bool
< :: CommitQueryOption -> CommitQueryOption -> Bool
$c< :: CommitQueryOption -> CommitQueryOption -> Bool
compare :: CommitQueryOption -> CommitQueryOption -> Ordering
$ccompare :: CommitQueryOption -> CommitQueryOption -> Ordering
Ord, forall x. Rep CommitQueryOption x -> CommitQueryOption
forall x. CommitQueryOption -> Rep CommitQueryOption x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommitQueryOption x -> CommitQueryOption
$cfrom :: forall x. CommitQueryOption -> Rep CommitQueryOption x
Generic, Typeable, Typeable CommitQueryOption
CommitQueryOption -> DataType
CommitQueryOption -> Constr
(forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
gmapT :: (forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
$cgmapT :: (forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
dataTypeOf :: CommitQueryOption -> DataType
$cdataTypeOf :: CommitQueryOption -> DataType
toConstr :: CommitQueryOption -> Constr
$ctoConstr :: CommitQueryOption -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
Data)

data Stats = Stats
    { Stats -> Int
statsAdditions :: !Int
    , Stats -> Int
statsTotal     :: !Int
    , Stats -> Int
statsDeletions :: !Int
    }
  deriving (Int -> Stats -> ShowS
[Stats] -> ShowS
Stats -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stats] -> ShowS
$cshowList :: [Stats] -> ShowS
show :: Stats -> String
$cshow :: Stats -> String
showsPrec :: Int -> Stats -> ShowS
$cshowsPrec :: Int -> Stats -> ShowS
Show, Typeable Stats
Stats -> DataType
Stats -> Constr
(forall b. Data b => b -> b) -> Stats -> Stats
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
forall u. (forall d. Data d => d -> u) -> Stats -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Stats -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stats -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
gmapT :: (forall b. Data b => b -> b) -> Stats -> Stats
$cgmapT :: (forall b. Data b => b -> b) -> Stats -> Stats
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
dataTypeOf :: Stats -> DataType
$cdataTypeOf :: Stats -> DataType
toConstr :: Stats -> Constr
$ctoConstr :: Stats -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
Data, Typeable, Stats -> Stats -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stats -> Stats -> Bool
$c/= :: Stats -> Stats -> Bool
== :: Stats -> Stats -> Bool
$c== :: Stats -> Stats -> Bool
Eq, Eq Stats
Stats -> Stats -> Bool
Stats -> Stats -> Ordering
Stats -> Stats -> Stats
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 :: Stats -> Stats -> Stats
$cmin :: Stats -> Stats -> Stats
max :: Stats -> Stats -> Stats
$cmax :: Stats -> Stats -> Stats
>= :: Stats -> Stats -> Bool
$c>= :: Stats -> Stats -> Bool
> :: Stats -> Stats -> Bool
$c> :: Stats -> Stats -> Bool
<= :: Stats -> Stats -> Bool
$c<= :: Stats -> Stats -> Bool
< :: Stats -> Stats -> Bool
$c< :: Stats -> Stats -> Bool
compare :: Stats -> Stats -> Ordering
$ccompare :: Stats -> Stats -> Ordering
Ord, forall x. Rep Stats x -> Stats
forall x. Stats -> Rep Stats x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Stats x -> Stats
$cfrom :: forall x. Stats -> Rep Stats x
Generic)

instance NFData Stats where rnf :: Stats -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Stats

data Commit = Commit
    { Commit -> Name Commit
commitSha       :: !(Name Commit)
    , Commit -> Vector Tree
commitParents   :: !(Vector Tree)
    , Commit -> URL
commitUrl       :: !URL
    , Commit -> GitCommit
commitGitCommit :: !GitCommit
    , Commit -> Maybe SimpleUser
commitCommitter :: !(Maybe SimpleUser)
    , Commit -> Maybe SimpleUser
commitAuthor    :: !(Maybe SimpleUser)
    , Commit -> Vector File
commitFiles     :: !(Vector File)
    , Commit -> Maybe Stats
commitStats     :: !(Maybe Stats)
    }
  deriving (Int -> Commit -> ShowS
[Commit] -> ShowS
Commit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Commit] -> ShowS
$cshowList :: [Commit] -> ShowS
show :: Commit -> String
$cshow :: Commit -> String
showsPrec :: Int -> Commit -> ShowS
$cshowsPrec :: Int -> Commit -> ShowS
Show, Typeable Commit
Commit -> DataType
Commit -> Constr
(forall b. Data b => b -> b) -> Commit -> Commit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
forall u. (forall d. Data d => d -> u) -> Commit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Commit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Commit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
gmapT :: (forall b. Data b => b -> b) -> Commit -> Commit
$cgmapT :: (forall b. Data b => b -> b) -> Commit -> Commit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
dataTypeOf :: Commit -> DataType
$cdataTypeOf :: Commit -> DataType
toConstr :: Commit -> Constr
$ctoConstr :: Commit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
Data, Typeable, Commit -> Commit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Commit -> Commit -> Bool
$c/= :: Commit -> Commit -> Bool
== :: Commit -> Commit -> Bool
$c== :: Commit -> Commit -> Bool
Eq, Eq Commit
Commit -> Commit -> Bool
Commit -> Commit -> Ordering
Commit -> Commit -> Commit
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 :: Commit -> Commit -> Commit
$cmin :: Commit -> Commit -> Commit
max :: Commit -> Commit -> Commit
$cmax :: Commit -> Commit -> Commit
>= :: Commit -> Commit -> Bool
$c>= :: Commit -> Commit -> Bool
> :: Commit -> Commit -> Bool
$c> :: Commit -> Commit -> Bool
<= :: Commit -> Commit -> Bool
$c<= :: Commit -> Commit -> Bool
< :: Commit -> Commit -> Bool
$c< :: Commit -> Commit -> Bool
compare :: Commit -> Commit -> Ordering
$ccompare :: Commit -> Commit -> Ordering
Ord, forall x. Rep Commit x -> Commit
forall x. Commit -> Rep Commit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Commit x -> Commit
$cfrom :: forall x. Commit -> Rep Commit x
Generic)

instance NFData Commit where rnf :: Commit -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Commit

data Tree = Tree
    { Tree -> Name Tree
treeSha      :: !(Name Tree)
    , Tree -> URL
treeUrl      :: !URL
    , Tree -> Vector GitTree
treeGitTrees :: !(Vector GitTree)
    }
  deriving (Int -> Tree -> ShowS
[Tree] -> ShowS
Tree -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tree] -> ShowS
$cshowList :: [Tree] -> ShowS
show :: Tree -> String
$cshow :: Tree -> String
showsPrec :: Int -> Tree -> ShowS
$cshowsPrec :: Int -> Tree -> ShowS
Show, Typeable Tree
Tree -> DataType
Tree -> Constr
(forall b. Data b => b -> b) -> Tree -> Tree
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
forall u. (forall d. Data d => d -> u) -> Tree -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tree -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tree -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
gmapT :: (forall b. Data b => b -> b) -> Tree -> Tree
$cgmapT :: (forall b. Data b => b -> b) -> Tree -> Tree
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
dataTypeOf :: Tree -> DataType
$cdataTypeOf :: Tree -> DataType
toConstr :: Tree -> Constr
$ctoConstr :: Tree -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
Data, Typeable, Tree -> Tree -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tree -> Tree -> Bool
$c/= :: Tree -> Tree -> Bool
== :: Tree -> Tree -> Bool
$c== :: Tree -> Tree -> Bool
Eq, Eq Tree
Tree -> Tree -> Bool
Tree -> Tree -> Ordering
Tree -> Tree -> Tree
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 :: Tree -> Tree -> Tree
$cmin :: Tree -> Tree -> Tree
max :: Tree -> Tree -> Tree
$cmax :: Tree -> Tree -> Tree
>= :: Tree -> Tree -> Bool
$c>= :: Tree -> Tree -> Bool
> :: Tree -> Tree -> Bool
$c> :: Tree -> Tree -> Bool
<= :: Tree -> Tree -> Bool
$c<= :: Tree -> Tree -> Bool
< :: Tree -> Tree -> Bool
$c< :: Tree -> Tree -> Bool
compare :: Tree -> Tree -> Ordering
$ccompare :: Tree -> Tree -> Ordering
Ord, forall x. Rep Tree x -> Tree
forall x. Tree -> Rep Tree x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tree x -> Tree
$cfrom :: forall x. Tree -> Rep Tree x
Generic)

instance NFData Tree where rnf :: Tree -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Tree

data GitTree = GitTree
    { GitTree -> Text
gitTreeType :: !Text
    , GitTree -> Name GitTree
gitTreeSha  :: !(Name GitTree)
    -- Can be empty for submodule
    , GitTree -> Maybe URL
gitTreeUrl  :: !(Maybe URL)
    , GitTree -> Maybe Int
gitTreeSize :: !(Maybe Int)
    , GitTree -> Text
gitTreePath :: !Text
    , GitTree -> Text
gitTreeMode :: !Text
    }
  deriving (Int -> GitTree -> ShowS
[GitTree] -> ShowS
GitTree -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitTree] -> ShowS
$cshowList :: [GitTree] -> ShowS
show :: GitTree -> String
$cshow :: GitTree -> String
showsPrec :: Int -> GitTree -> ShowS
$cshowsPrec :: Int -> GitTree -> ShowS
Show, Typeable GitTree
GitTree -> DataType
GitTree -> Constr
(forall b. Data b => b -> b) -> GitTree -> GitTree
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
gmapT :: (forall b. Data b => b -> b) -> GitTree -> GitTree
$cgmapT :: (forall b. Data b => b -> b) -> GitTree -> GitTree
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
dataTypeOf :: GitTree -> DataType
$cdataTypeOf :: GitTree -> DataType
toConstr :: GitTree -> Constr
$ctoConstr :: GitTree -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
Data, Typeable, GitTree -> GitTree -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitTree -> GitTree -> Bool
$c/= :: GitTree -> GitTree -> Bool
== :: GitTree -> GitTree -> Bool
$c== :: GitTree -> GitTree -> Bool
Eq, Eq GitTree
GitTree -> GitTree -> Bool
GitTree -> GitTree -> Ordering
GitTree -> GitTree -> GitTree
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 :: GitTree -> GitTree -> GitTree
$cmin :: GitTree -> GitTree -> GitTree
max :: GitTree -> GitTree -> GitTree
$cmax :: GitTree -> GitTree -> GitTree
>= :: GitTree -> GitTree -> Bool
$c>= :: GitTree -> GitTree -> Bool
> :: GitTree -> GitTree -> Bool
$c> :: GitTree -> GitTree -> Bool
<= :: GitTree -> GitTree -> Bool
$c<= :: GitTree -> GitTree -> Bool
< :: GitTree -> GitTree -> Bool
$c< :: GitTree -> GitTree -> Bool
compare :: GitTree -> GitTree -> Ordering
$ccompare :: GitTree -> GitTree -> Ordering
Ord, forall x. Rep GitTree x -> GitTree
forall x. GitTree -> Rep GitTree x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitTree x -> GitTree
$cfrom :: forall x. GitTree -> Rep GitTree x
Generic)

instance NFData GitTree where rnf :: GitTree -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitTree

data GitCommit = GitCommit
    { GitCommit -> Text
gitCommitMessage   :: !Text
    , GitCommit -> URL
gitCommitUrl       :: !URL
    , GitCommit -> GitUser
gitCommitCommitter :: !GitUser
    , GitCommit -> GitUser
gitCommitAuthor    :: !GitUser
    , GitCommit -> Tree
gitCommitTree      :: !Tree
    , GitCommit -> Maybe (Name GitCommit)
gitCommitSha       :: !(Maybe (Name GitCommit))
    , GitCommit -> Vector Tree
gitCommitParents   :: !(Vector Tree)
    }
  deriving (Int -> GitCommit -> ShowS
[GitCommit] -> ShowS
GitCommit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitCommit] -> ShowS
$cshowList :: [GitCommit] -> ShowS
show :: GitCommit -> String
$cshow :: GitCommit -> String
showsPrec :: Int -> GitCommit -> ShowS
$cshowsPrec :: Int -> GitCommit -> ShowS
Show, Typeable GitCommit
GitCommit -> DataType
GitCommit -> Constr
(forall b. Data b => b -> b) -> GitCommit -> GitCommit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
gmapT :: (forall b. Data b => b -> b) -> GitCommit -> GitCommit
$cgmapT :: (forall b. Data b => b -> b) -> GitCommit -> GitCommit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
dataTypeOf :: GitCommit -> DataType
$cdataTypeOf :: GitCommit -> DataType
toConstr :: GitCommit -> Constr
$ctoConstr :: GitCommit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
Data, Typeable, GitCommit -> GitCommit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitCommit -> GitCommit -> Bool
$c/= :: GitCommit -> GitCommit -> Bool
== :: GitCommit -> GitCommit -> Bool
$c== :: GitCommit -> GitCommit -> Bool
Eq, Eq GitCommit
GitCommit -> GitCommit -> Bool
GitCommit -> GitCommit -> Ordering
GitCommit -> GitCommit -> GitCommit
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 :: GitCommit -> GitCommit -> GitCommit
$cmin :: GitCommit -> GitCommit -> GitCommit
max :: GitCommit -> GitCommit -> GitCommit
$cmax :: GitCommit -> GitCommit -> GitCommit
>= :: GitCommit -> GitCommit -> Bool
$c>= :: GitCommit -> GitCommit -> Bool
> :: GitCommit -> GitCommit -> Bool
$c> :: GitCommit -> GitCommit -> Bool
<= :: GitCommit -> GitCommit -> Bool
$c<= :: GitCommit -> GitCommit -> Bool
< :: GitCommit -> GitCommit -> Bool
$c< :: GitCommit -> GitCommit -> Bool
compare :: GitCommit -> GitCommit -> Ordering
$ccompare :: GitCommit -> GitCommit -> Ordering
Ord, forall x. Rep GitCommit x -> GitCommit
forall x. GitCommit -> Rep GitCommit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitCommit x -> GitCommit
$cfrom :: forall x. GitCommit -> Rep GitCommit x
Generic)

instance NFData GitCommit where rnf :: GitCommit -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitCommit

data Blob = Blob
    { Blob -> URL
blobUrl      :: !URL
    , Blob -> Text
blobEncoding :: !Text
    , Blob -> Text
blobContent  :: !Text
    , Blob -> Name Blob
blobSha      :: !(Name Blob)
    , Blob -> Int
blobSize     :: !Int
    }
  deriving (Int -> Blob -> ShowS
[Blob] -> ShowS
Blob -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Blob] -> ShowS
$cshowList :: [Blob] -> ShowS
show :: Blob -> String
$cshow :: Blob -> String
showsPrec :: Int -> Blob -> ShowS
$cshowsPrec :: Int -> Blob -> ShowS
Show, Typeable Blob
Blob -> DataType
Blob -> Constr
(forall b. Data b => b -> b) -> Blob -> Blob
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
forall u. (forall d. Data d => d -> u) -> Blob -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Blob -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Blob -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
gmapT :: (forall b. Data b => b -> b) -> Blob -> Blob
$cgmapT :: (forall b. Data b => b -> b) -> Blob -> Blob
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
dataTypeOf :: Blob -> DataType
$cdataTypeOf :: Blob -> DataType
toConstr :: Blob -> Constr
$ctoConstr :: Blob -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
Data, Typeable, Blob -> Blob -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Blob -> Blob -> Bool
$c/= :: Blob -> Blob -> Bool
== :: Blob -> Blob -> Bool
$c== :: Blob -> Blob -> Bool
Eq, Eq Blob
Blob -> Blob -> Bool
Blob -> Blob -> Ordering
Blob -> Blob -> Blob
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 :: Blob -> Blob -> Blob
$cmin :: Blob -> Blob -> Blob
max :: Blob -> Blob -> Blob
$cmax :: Blob -> Blob -> Blob
>= :: Blob -> Blob -> Bool
$c>= :: Blob -> Blob -> Bool
> :: Blob -> Blob -> Bool
$c> :: Blob -> Blob -> Bool
<= :: Blob -> Blob -> Bool
$c<= :: Blob -> Blob -> Bool
< :: Blob -> Blob -> Bool
$c< :: Blob -> Blob -> Bool
compare :: Blob -> Blob -> Ordering
$ccompare :: Blob -> Blob -> Ordering
Ord, forall x. Rep Blob x -> Blob
forall x. Blob -> Rep Blob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Blob x -> Blob
$cfrom :: forall x. Blob -> Rep Blob x
Generic)

instance NFData Blob where rnf :: Blob -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Blob

data Tag = Tag
    { Tag -> Text
tagName       :: !Text
    , Tag -> URL
tagZipballUrl :: !URL
    , Tag -> URL
tagTarballUrl :: !URL
    , Tag -> BranchCommit
tagCommit     :: !BranchCommit
    }
  deriving (Int -> Tag -> ShowS
[Tag] -> ShowS
Tag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tag] -> ShowS
$cshowList :: [Tag] -> ShowS
show :: Tag -> String
$cshow :: Tag -> String
showsPrec :: Int -> Tag -> ShowS
$cshowsPrec :: Int -> Tag -> ShowS
Show, Typeable Tag
Tag -> DataType
Tag -> Constr
(forall b. Data b => b -> b) -> Tag -> Tag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
forall u. (forall d. Data d => d -> u) -> Tag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tag -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
gmapT :: (forall b. Data b => b -> b) -> Tag -> Tag
$cgmapT :: (forall b. Data b => b -> b) -> Tag -> Tag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
dataTypeOf :: Tag -> DataType
$cdataTypeOf :: Tag -> DataType
toConstr :: Tag -> Constr
$ctoConstr :: Tag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
Data, Typeable, Tag -> Tag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tag -> Tag -> Bool
$c/= :: Tag -> Tag -> Bool
== :: Tag -> Tag -> Bool
$c== :: Tag -> Tag -> Bool
Eq, Eq Tag
Tag -> Tag -> Bool
Tag -> Tag -> Ordering
Tag -> Tag -> Tag
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 :: Tag -> Tag -> Tag
$cmin :: Tag -> Tag -> Tag
max :: Tag -> Tag -> Tag
$cmax :: Tag -> Tag -> Tag
>= :: Tag -> Tag -> Bool
$c>= :: Tag -> Tag -> Bool
> :: Tag -> Tag -> Bool
$c> :: Tag -> Tag -> Bool
<= :: Tag -> Tag -> Bool
$c<= :: Tag -> Tag -> Bool
< :: Tag -> Tag -> Bool
$c< :: Tag -> Tag -> Bool
compare :: Tag -> Tag -> Ordering
$ccompare :: Tag -> Tag -> Ordering
Ord, forall x. Rep Tag x -> Tag
forall x. Tag -> Rep Tag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tag x -> Tag
$cfrom :: forall x. Tag -> Rep Tag x
Generic)

instance NFData Tag where rnf :: Tag -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Tag

data Branch = Branch
    { Branch -> Text
branchName   :: !Text
    , Branch -> BranchCommit
branchCommit :: !BranchCommit
    }
  deriving (Int -> Branch -> ShowS
[Branch] -> ShowS
Branch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Branch] -> ShowS
$cshowList :: [Branch] -> ShowS
show :: Branch -> String
$cshow :: Branch -> String
showsPrec :: Int -> Branch -> ShowS
$cshowsPrec :: Int -> Branch -> ShowS
Show, Typeable Branch
Branch -> DataType
Branch -> Constr
(forall b. Data b => b -> b) -> Branch -> Branch
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
forall u. (forall d. Data d => d -> u) -> Branch -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Branch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Branch -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
gmapT :: (forall b. Data b => b -> b) -> Branch -> Branch
$cgmapT :: (forall b. Data b => b -> b) -> Branch -> Branch
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
dataTypeOf :: Branch -> DataType
$cdataTypeOf :: Branch -> DataType
toConstr :: Branch -> Constr
$ctoConstr :: Branch -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
Data, Typeable, Branch -> Branch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Branch -> Branch -> Bool
$c/= :: Branch -> Branch -> Bool
== :: Branch -> Branch -> Bool
$c== :: Branch -> Branch -> Bool
Eq, Eq Branch
Branch -> Branch -> Bool
Branch -> Branch -> Ordering
Branch -> Branch -> Branch
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 :: Branch -> Branch -> Branch
$cmin :: Branch -> Branch -> Branch
max :: Branch -> Branch -> Branch
$cmax :: Branch -> Branch -> Branch
>= :: Branch -> Branch -> Bool
$c>= :: Branch -> Branch -> Bool
> :: Branch -> Branch -> Bool
$c> :: Branch -> Branch -> Bool
<= :: Branch -> Branch -> Bool
$c<= :: Branch -> Branch -> Bool
< :: Branch -> Branch -> Bool
$c< :: Branch -> Branch -> Bool
compare :: Branch -> Branch -> Ordering
$ccompare :: Branch -> Branch -> Ordering
Ord, forall x. Rep Branch x -> Branch
forall x. Branch -> Rep Branch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Branch x -> Branch
$cfrom :: forall x. Branch -> Rep Branch x
Generic)

instance NFData Branch where rnf :: Branch -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf

data BranchCommit = BranchCommit
    { BranchCommit -> Text
branchCommitSha :: !Text
    , BranchCommit -> URL
branchCommitUrl :: !URL
    }
  deriving (Int -> BranchCommit -> ShowS
[BranchCommit] -> ShowS
BranchCommit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BranchCommit] -> ShowS
$cshowList :: [BranchCommit] -> ShowS
show :: BranchCommit -> String
$cshow :: BranchCommit -> String
showsPrec :: Int -> BranchCommit -> ShowS
$cshowsPrec :: Int -> BranchCommit -> ShowS
Show, Typeable BranchCommit
BranchCommit -> DataType
BranchCommit -> Constr
(forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
gmapT :: (forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
$cgmapT :: (forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
dataTypeOf :: BranchCommit -> DataType
$cdataTypeOf :: BranchCommit -> DataType
toConstr :: BranchCommit -> Constr
$ctoConstr :: BranchCommit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
Data, Typeable, BranchCommit -> BranchCommit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BranchCommit -> BranchCommit -> Bool
$c/= :: BranchCommit -> BranchCommit -> Bool
== :: BranchCommit -> BranchCommit -> Bool
$c== :: BranchCommit -> BranchCommit -> Bool
Eq, Eq BranchCommit
BranchCommit -> BranchCommit -> Bool
BranchCommit -> BranchCommit -> Ordering
BranchCommit -> BranchCommit -> BranchCommit
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 :: BranchCommit -> BranchCommit -> BranchCommit
$cmin :: BranchCommit -> BranchCommit -> BranchCommit
max :: BranchCommit -> BranchCommit -> BranchCommit
$cmax :: BranchCommit -> BranchCommit -> BranchCommit
>= :: BranchCommit -> BranchCommit -> Bool
$c>= :: BranchCommit -> BranchCommit -> Bool
> :: BranchCommit -> BranchCommit -> Bool
$c> :: BranchCommit -> BranchCommit -> Bool
<= :: BranchCommit -> BranchCommit -> Bool
$c<= :: BranchCommit -> BranchCommit -> Bool
< :: BranchCommit -> BranchCommit -> Bool
$c< :: BranchCommit -> BranchCommit -> Bool
compare :: BranchCommit -> BranchCommit -> Ordering
$ccompare :: BranchCommit -> BranchCommit -> Ordering
Ord, forall x. Rep BranchCommit x -> BranchCommit
forall x. BranchCommit -> Rep BranchCommit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BranchCommit x -> BranchCommit
$cfrom :: forall x. BranchCommit -> Rep BranchCommit x
Generic)

instance NFData BranchCommit where rnf :: BranchCommit -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary BranchCommit

data Diff = Diff
    { Diff -> Text
diffStatus       :: !Text
    , Diff -> Int
diffBehindBy     :: !Int
    , Diff -> URL
diffPatchUrl     :: !URL
    , Diff -> URL
diffUrl          :: !URL
    , Diff -> Commit
diffBaseCommit   :: !Commit
    , Diff -> Vector Commit
diffCommits      :: !(Vector Commit)
    , Diff -> Int
diffTotalCommits :: !Int
    , Diff -> URL
diffHtmlUrl      :: !URL
    , Diff -> Vector File
diffFiles        :: !(Vector File)
    , Diff -> Int
diffAheadBy      :: !Int
    , Diff -> URL
diffDiffUrl      :: !URL
    , Diff -> URL
diffPermalinkUrl :: !URL
    }
  deriving (Int -> Diff -> ShowS
[Diff] -> ShowS
Diff -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Diff] -> ShowS
$cshowList :: [Diff] -> ShowS
show :: Diff -> String
$cshow :: Diff -> String
showsPrec :: Int -> Diff -> ShowS
$cshowsPrec :: Int -> Diff -> ShowS
Show, Typeable Diff
Diff -> DataType
Diff -> Constr
(forall b. Data b => b -> b) -> Diff -> Diff
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
forall u. (forall d. Data d => d -> u) -> Diff -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Diff -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Diff -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
gmapT :: (forall b. Data b => b -> b) -> Diff -> Diff
$cgmapT :: (forall b. Data b => b -> b) -> Diff -> Diff
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
dataTypeOf :: Diff -> DataType
$cdataTypeOf :: Diff -> DataType
toConstr :: Diff -> Constr
$ctoConstr :: Diff -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
Data, Typeable, Diff -> Diff -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Diff -> Diff -> Bool
$c/= :: Diff -> Diff -> Bool
== :: Diff -> Diff -> Bool
$c== :: Diff -> Diff -> Bool
Eq, Eq Diff
Diff -> Diff -> Bool
Diff -> Diff -> Ordering
Diff -> Diff -> Diff
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 :: Diff -> Diff -> Diff
$cmin :: Diff -> Diff -> Diff
max :: Diff -> Diff -> Diff
$cmax :: Diff -> Diff -> Diff
>= :: Diff -> Diff -> Bool
$c>= :: Diff -> Diff -> Bool
> :: Diff -> Diff -> Bool
$c> :: Diff -> Diff -> Bool
<= :: Diff -> Diff -> Bool
$c<= :: Diff -> Diff -> Bool
< :: Diff -> Diff -> Bool
$c< :: Diff -> Diff -> Bool
compare :: Diff -> Diff -> Ordering
$ccompare :: Diff -> Diff -> Ordering
Ord, forall x. Rep Diff x -> Diff
forall x. Diff -> Rep Diff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Diff x -> Diff
$cfrom :: forall x. Diff -> Rep Diff x
Generic)

instance NFData Diff where rnf :: Diff -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Diff

data NewGitReference = NewGitReference
    { NewGitReference -> Text
newGitReferenceRef :: !Text
    , NewGitReference -> Text
newGitReferenceSha :: !Text
    }
  deriving (Int -> NewGitReference -> ShowS
[NewGitReference] -> ShowS
NewGitReference -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewGitReference] -> ShowS
$cshowList :: [NewGitReference] -> ShowS
show :: NewGitReference -> String
$cshow :: NewGitReference -> String
showsPrec :: Int -> NewGitReference -> ShowS
$cshowsPrec :: Int -> NewGitReference -> ShowS
Show, Typeable NewGitReference
NewGitReference -> DataType
NewGitReference -> Constr
(forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
gmapT :: (forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
$cgmapT :: (forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
dataTypeOf :: NewGitReference -> DataType
$cdataTypeOf :: NewGitReference -> DataType
toConstr :: NewGitReference -> Constr
$ctoConstr :: NewGitReference -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
Data, Typeable, NewGitReference -> NewGitReference -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewGitReference -> NewGitReference -> Bool
$c/= :: NewGitReference -> NewGitReference -> Bool
== :: NewGitReference -> NewGitReference -> Bool
$c== :: NewGitReference -> NewGitReference -> Bool
Eq, Eq NewGitReference
NewGitReference -> NewGitReference -> Bool
NewGitReference -> NewGitReference -> Ordering
NewGitReference -> NewGitReference -> NewGitReference
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 :: NewGitReference -> NewGitReference -> NewGitReference
$cmin :: NewGitReference -> NewGitReference -> NewGitReference
max :: NewGitReference -> NewGitReference -> NewGitReference
$cmax :: NewGitReference -> NewGitReference -> NewGitReference
>= :: NewGitReference -> NewGitReference -> Bool
$c>= :: NewGitReference -> NewGitReference -> Bool
> :: NewGitReference -> NewGitReference -> Bool
$c> :: NewGitReference -> NewGitReference -> Bool
<= :: NewGitReference -> NewGitReference -> Bool
$c<= :: NewGitReference -> NewGitReference -> Bool
< :: NewGitReference -> NewGitReference -> Bool
$c< :: NewGitReference -> NewGitReference -> Bool
compare :: NewGitReference -> NewGitReference -> Ordering
$ccompare :: NewGitReference -> NewGitReference -> Ordering
Ord, forall x. Rep NewGitReference x -> NewGitReference
forall x. NewGitReference -> Rep NewGitReference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewGitReference x -> NewGitReference
$cfrom :: forall x. NewGitReference -> Rep NewGitReference x
Generic)

instance NFData NewGitReference where rnf :: NewGitReference -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary NewGitReference

data GitReference = GitReference
    { GitReference -> GitObject
gitReferenceObject :: !GitObject
    , GitReference -> URL
gitReferenceUrl    :: !URL
    , GitReference -> Name GitReference
gitReferenceRef    :: !(Name GitReference)
    }
  deriving (Int -> GitReference -> ShowS
[GitReference] -> ShowS
GitReference -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitReference] -> ShowS
$cshowList :: [GitReference] -> ShowS
show :: GitReference -> String
$cshow :: GitReference -> String
showsPrec :: Int -> GitReference -> ShowS
$cshowsPrec :: Int -> GitReference -> ShowS
Show, Typeable GitReference
GitReference -> DataType
GitReference -> Constr
(forall b. Data b => b -> b) -> GitReference -> GitReference
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
gmapT :: (forall b. Data b => b -> b) -> GitReference -> GitReference
$cgmapT :: (forall b. Data b => b -> b) -> GitReference -> GitReference
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
dataTypeOf :: GitReference -> DataType
$cdataTypeOf :: GitReference -> DataType
toConstr :: GitReference -> Constr
$ctoConstr :: GitReference -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
Data, Typeable, GitReference -> GitReference -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitReference -> GitReference -> Bool
$c/= :: GitReference -> GitReference -> Bool
== :: GitReference -> GitReference -> Bool
$c== :: GitReference -> GitReference -> Bool
Eq, Eq GitReference
GitReference -> GitReference -> Bool
GitReference -> GitReference -> Ordering
GitReference -> GitReference -> GitReference
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 :: GitReference -> GitReference -> GitReference
$cmin :: GitReference -> GitReference -> GitReference
max :: GitReference -> GitReference -> GitReference
$cmax :: GitReference -> GitReference -> GitReference
>= :: GitReference -> GitReference -> Bool
$c>= :: GitReference -> GitReference -> Bool
> :: GitReference -> GitReference -> Bool
$c> :: GitReference -> GitReference -> Bool
<= :: GitReference -> GitReference -> Bool
$c<= :: GitReference -> GitReference -> Bool
< :: GitReference -> GitReference -> Bool
$c< :: GitReference -> GitReference -> Bool
compare :: GitReference -> GitReference -> Ordering
$ccompare :: GitReference -> GitReference -> Ordering
Ord, forall x. Rep GitReference x -> GitReference
forall x. GitReference -> Rep GitReference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitReference x -> GitReference
$cfrom :: forall x. GitReference -> Rep GitReference x
Generic)

instance NFData GitReference where rnf :: GitReference -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitReference

data GitObject = GitObject
    { GitObject -> Text
gitObjectType :: !Text
    , GitObject -> Text
gitObjectSha  :: !Text
    , GitObject -> URL
gitObjectUrl  :: !URL
    }
  deriving (Int -> GitObject -> ShowS
[GitObject] -> ShowS
GitObject -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitObject] -> ShowS
$cshowList :: [GitObject] -> ShowS
show :: GitObject -> String
$cshow :: GitObject -> String
showsPrec :: Int -> GitObject -> ShowS
$cshowsPrec :: Int -> GitObject -> ShowS
Show, Typeable GitObject
GitObject -> DataType
GitObject -> Constr
(forall b. Data b => b -> b) -> GitObject -> GitObject
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
gmapT :: (forall b. Data b => b -> b) -> GitObject -> GitObject
$cgmapT :: (forall b. Data b => b -> b) -> GitObject -> GitObject
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
dataTypeOf :: GitObject -> DataType
$cdataTypeOf :: GitObject -> DataType
toConstr :: GitObject -> Constr
$ctoConstr :: GitObject -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
Data, Typeable, GitObject -> GitObject -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitObject -> GitObject -> Bool
$c/= :: GitObject -> GitObject -> Bool
== :: GitObject -> GitObject -> Bool
$c== :: GitObject -> GitObject -> Bool
Eq, Eq GitObject
GitObject -> GitObject -> Bool
GitObject -> GitObject -> Ordering
GitObject -> GitObject -> GitObject
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 :: GitObject -> GitObject -> GitObject
$cmin :: GitObject -> GitObject -> GitObject
max :: GitObject -> GitObject -> GitObject
$cmax :: GitObject -> GitObject -> GitObject
>= :: GitObject -> GitObject -> Bool
$c>= :: GitObject -> GitObject -> Bool
> :: GitObject -> GitObject -> Bool
$c> :: GitObject -> GitObject -> Bool
<= :: GitObject -> GitObject -> Bool
$c<= :: GitObject -> GitObject -> Bool
< :: GitObject -> GitObject -> Bool
$c< :: GitObject -> GitObject -> Bool
compare :: GitObject -> GitObject -> Ordering
$ccompare :: GitObject -> GitObject -> Ordering
Ord, forall x. Rep GitObject x -> GitObject
forall x. GitObject -> Rep GitObject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitObject x -> GitObject
$cfrom :: forall x. GitObject -> Rep GitObject x
Generic)

instance NFData GitObject where rnf :: GitObject -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitObject

data GitUser = GitUser
    { GitUser -> Text
gitUserName  :: !Text
    , GitUser -> Text
gitUserEmail :: !Text
    , GitUser -> UTCTime
gitUserDate  :: !UTCTime
    }
  deriving (Int -> GitUser -> ShowS
[GitUser] -> ShowS
GitUser -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitUser] -> ShowS
$cshowList :: [GitUser] -> ShowS
show :: GitUser -> String
$cshow :: GitUser -> String
showsPrec :: Int -> GitUser -> ShowS
$cshowsPrec :: Int -> GitUser -> ShowS
Show, Typeable GitUser
GitUser -> DataType
GitUser -> Constr
(forall b. Data b => b -> b) -> GitUser -> GitUser
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
gmapT :: (forall b. Data b => b -> b) -> GitUser -> GitUser
$cgmapT :: (forall b. Data b => b -> b) -> GitUser -> GitUser
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
dataTypeOf :: GitUser -> DataType
$cdataTypeOf :: GitUser -> DataType
toConstr :: GitUser -> Constr
$ctoConstr :: GitUser -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
Data, Typeable, GitUser -> GitUser -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitUser -> GitUser -> Bool
$c/= :: GitUser -> GitUser -> Bool
== :: GitUser -> GitUser -> Bool
$c== :: GitUser -> GitUser -> Bool
Eq, Eq GitUser
GitUser -> GitUser -> Bool
GitUser -> GitUser -> Ordering
GitUser -> GitUser -> GitUser
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 :: GitUser -> GitUser -> GitUser
$cmin :: GitUser -> GitUser -> GitUser
max :: GitUser -> GitUser -> GitUser
$cmax :: GitUser -> GitUser -> GitUser
>= :: GitUser -> GitUser -> Bool
$c>= :: GitUser -> GitUser -> Bool
> :: GitUser -> GitUser -> Bool
$c> :: GitUser -> GitUser -> Bool
<= :: GitUser -> GitUser -> Bool
$c<= :: GitUser -> GitUser -> Bool
< :: GitUser -> GitUser -> Bool
$c< :: GitUser -> GitUser -> Bool
compare :: GitUser -> GitUser -> Ordering
$ccompare :: GitUser -> GitUser -> Ordering
Ord, forall x. Rep GitUser x -> GitUser
forall x. GitUser -> Rep GitUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitUser x -> GitUser
$cfrom :: forall x. GitUser -> Rep GitUser x
Generic)

instance NFData GitUser where rnf :: GitUser -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitUser

data File = File
    { File -> Maybe URL
fileBlobUrl   :: !(Maybe URL)
    , File -> Text
fileStatus    :: !Text
    , File -> Maybe URL
fileRawUrl    :: !(Maybe URL)
    , File -> Int
fileAdditions :: !Int
    , File -> Maybe Text
fileSha       :: !(Maybe Text)
    , File -> Int
fileChanges   :: !Int
    , File -> Maybe Text
filePatch     :: !(Maybe Text)
    , File -> Text
fileFilename  :: !Text
    , File -> Int
fileDeletions :: !Int
    }
  deriving (Int -> File -> ShowS
[File] -> ShowS
File -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [File] -> ShowS
$cshowList :: [File] -> ShowS
show :: File -> String
$cshow :: File -> String
showsPrec :: Int -> File -> ShowS
$cshowsPrec :: Int -> File -> ShowS
Show, Typeable File
File -> DataType
File -> Constr
(forall b. Data b => b -> b) -> File -> File
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> File -> u
forall u. (forall d. Data d => d -> u) -> File -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
gmapT :: (forall b. Data b => b -> b) -> File -> File
$cgmapT :: (forall b. Data b => b -> b) -> File -> File
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
dataTypeOf :: File -> DataType
$cdataTypeOf :: File -> DataType
toConstr :: File -> Constr
$ctoConstr :: File -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
Data, Typeable, File -> File -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: File -> File -> Bool
$c/= :: File -> File -> Bool
== :: File -> File -> Bool
$c== :: File -> File -> Bool
Eq, Eq File
File -> File -> Bool
File -> File -> Ordering
File -> File -> File
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 :: File -> File -> File
$cmin :: File -> File -> File
max :: File -> File -> File
$cmax :: File -> File -> File
>= :: File -> File -> Bool
$c>= :: File -> File -> Bool
> :: File -> File -> Bool
$c> :: File -> File -> Bool
<= :: File -> File -> Bool
$c<= :: File -> File -> Bool
< :: File -> File -> Bool
$c< :: File -> File -> Bool
compare :: File -> File -> Ordering
$ccompare :: File -> File -> Ordering
Ord, forall x. Rep File x -> File
forall x. File -> Rep File x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep File x -> File
$cfrom :: forall x. File -> Rep File x
Generic)

instance NFData File where rnf :: File -> ()
rnf = forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary File

-- JSON instances

instance FromJSON Stats where
    parseJSON :: Value -> Parser Stats
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Stats" forall a b. (a -> b) -> a -> b
$ \Object
o -> Int -> Int -> Int -> Stats
Stats
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"additions"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"deletions"

instance FromJSON Commit where
    parseJSON :: Value -> Parser Commit
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Commit" forall a b. (a -> b) -> a -> b
$ \Object
o -> Name Commit
-> Vector Tree
-> URL
-> GitCommit
-> Maybe SimpleUser
-> Maybe SimpleUser
-> Vector File
-> Maybe Stats
-> Commit
Commit
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"parents"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"committer"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"author"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"files" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Vector a
V.empty
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stats"

instance FromJSON Tree where
    parseJSON :: Value -> Parser Tree
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Tree" forall a b. (a -> b) -> a -> b
$ \Object
o -> Name Tree -> URL -> Vector GitTree -> Tree
Tree
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tree" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Vector a
V.empty

instance FromJSON GitTree where
    parseJSON :: Value -> Parser GitTree
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitTree" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> Name GitTree
-> Maybe URL
-> Maybe Int
-> Text
-> Text
-> GitTree
GitTree
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"mode"

instance FromJSON GitCommit where
    parseJSON :: Value -> Parser GitCommit
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitCommit" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> URL
-> GitUser
-> GitUser
-> Tree
-> Maybe (Name GitCommit)
-> Vector Tree
-> GitCommit
GitCommit
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"committer"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"author"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tree"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parents" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Vector a
V.empty

instance FromJSON GitUser where
    parseJSON :: Value -> Parser GitUser
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitUser" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> UTCTime -> GitUser
GitUser
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"date"

instance FromJSON File where
    parseJSON :: Value -> Parser File
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"File" forall a b. (a -> b) -> a -> b
$ \Object
o -> Maybe URL
-> Text
-> Maybe URL
-> Int
-> Maybe Text
-> Int
-> Maybe Text
-> Text
-> Int
-> File
File
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"blob_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"raw_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"additions"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"changes"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"patch"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"filename"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"deletions"

instance ToJSON NewGitReference where
    toJSON :: NewGitReference -> Value
toJSON (NewGitReference Text
r Text
s) = [Pair] -> Value
object [ Key
"ref" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
r, Key
"sha" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
s  ]

instance FromJSON GitReference where
    parseJSON :: Value -> Parser GitReference
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitReference" forall a b. (a -> b) -> a -> b
$ \Object
o -> GitObject -> URL -> Name GitReference -> GitReference
GitReference
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ref"

instance FromJSON GitObject where
    parseJSON :: Value -> Parser GitObject
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitObject" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> URL -> GitObject
GitObject
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"

instance FromJSON Diff where
    parseJSON :: Value -> Parser Diff
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Diff" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> Int
-> URL
-> URL
-> Commit
-> Vector Commit
-> Int
-> URL
-> Vector File
-> Int
-> URL
-> URL
-> Diff
Diff
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"behind_by"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"patch_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"base_commit"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"commits" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Vector a
V.empty
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_commits"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"files" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Vector a
V.empty
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ahead_by"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"diff_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permalink_url"

instance FromJSON Blob where
    parseJSON :: Value -> Parser Blob
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Blob" forall a b. (a -> b) -> a -> b
$ \Object
o -> URL -> Text -> Text -> Name Blob -> Int -> Blob
Blob
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"encoding"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"content"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"size"

instance FromJSON Tag where
    parseJSON :: Value -> Parser Tag
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Tag" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> URL -> URL -> BranchCommit -> Tag
Tag
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zipball_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tarball_url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"

instance FromJSON Branch where
    parseJSON :: Value -> Parser Branch
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Branch" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> BranchCommit -> Branch
Branch
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"

instance FromJSON BranchCommit where
    parseJSON :: Value -> Parser BranchCommit
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BranchCommit" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> URL -> BranchCommit
BranchCommit
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"