module Hix.Managed.Data.ProjectState where

import Distribution.Pretty (Pretty (pretty))
import Text.PrettyPrint (hang, ($+$))

import Hix.Class.EncodeNix (EncodeNix)
import Hix.Data.Overrides (Overrides)
import Hix.Managed.Data.Envs (Envs)
import Hix.Managed.Data.Mutable (MutableBounds, MutableVersions)
import Hix.Managed.Data.Packages (Packages)

data ProjectState =
  ProjectState {
    ProjectState -> Packages MutableBounds
bounds :: Packages MutableBounds,
    ProjectState -> Envs MutableVersions
versions :: Envs MutableVersions,
    ProjectState -> Envs MutableVersions
initial :: Envs MutableVersions,
    ProjectState -> Envs Overrides
overrides :: Envs Overrides,
    ProjectState -> Bool
resolving :: Bool
  }
  deriving stock (ProjectState -> ProjectState -> Bool
(ProjectState -> ProjectState -> Bool)
-> (ProjectState -> ProjectState -> Bool) -> Eq ProjectState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectState -> ProjectState -> Bool
== :: ProjectState -> ProjectState -> Bool
$c/= :: ProjectState -> ProjectState -> Bool
/= :: ProjectState -> ProjectState -> Bool
Eq, Int -> ProjectState -> ShowS
[ProjectState] -> ShowS
ProjectState -> String
(Int -> ProjectState -> ShowS)
-> (ProjectState -> String)
-> ([ProjectState] -> ShowS)
-> Show ProjectState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectState -> ShowS
showsPrec :: Int -> ProjectState -> ShowS
$cshow :: ProjectState -> String
show :: ProjectState -> String
$cshowList :: [ProjectState] -> ShowS
showList :: [ProjectState] -> ShowS
Show, (forall x. ProjectState -> Rep ProjectState x)
-> (forall x. Rep ProjectState x -> ProjectState)
-> Generic ProjectState
forall x. Rep ProjectState x -> ProjectState
forall x. ProjectState -> Rep ProjectState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ProjectState -> Rep ProjectState x
from :: forall x. ProjectState -> Rep ProjectState x
$cto :: forall x. Rep ProjectState x -> ProjectState
to :: forall x. Rep ProjectState x -> ProjectState
Generic)
  deriving anyclass (ProjectState -> Expr
(ProjectState -> Expr) -> EncodeNix ProjectState
forall a. (a -> Expr) -> EncodeNix a
$cencodeNix :: ProjectState -> Expr
encodeNix :: ProjectState -> Expr
EncodeNix)

instance Pretty ProjectState where
  pretty :: ProjectState -> Doc
pretty ProjectState {Bool
Packages MutableBounds
Envs Overrides
Envs MutableVersions
bounds :: ProjectState -> Packages MutableBounds
versions :: ProjectState -> Envs MutableVersions
initial :: ProjectState -> Envs MutableVersions
overrides :: ProjectState -> Envs Overrides
resolving :: ProjectState -> Bool
bounds :: Packages MutableBounds
versions :: Envs MutableVersions
initial :: Envs MutableVersions
overrides :: Envs Overrides
resolving :: Bool
..} =
    Doc -> Int -> Doc -> Doc
hang Doc
"bounds:" Int
2 (Packages MutableBounds -> Doc
forall a. Pretty a => a -> Doc
pretty Packages MutableBounds
bounds) Doc -> Doc -> Doc
$+$
    Doc -> Int -> Doc -> Doc
hang Doc
"versions:" Int
2 (Envs MutableVersions -> Doc
forall a. Pretty a => a -> Doc
pretty Envs MutableVersions
versions) Doc -> Doc -> Doc
$+$
    Doc -> Int -> Doc -> Doc
hang Doc
"initial:" Int
2 (Envs MutableVersions -> Doc
forall a. Pretty a => a -> Doc
pretty Envs MutableVersions
initial) Doc -> Doc -> Doc
$+$
    Doc -> Int -> Doc -> Doc
hang Doc
"overrides:" Int
2 (Envs Overrides -> Doc
forall a. Pretty a => a -> Doc
pretty Envs Overrides
overrides)

instance Default ProjectState where
  def :: ProjectState
def = ProjectState {bounds :: Packages MutableBounds
bounds = Packages MutableBounds
forall a. Monoid a => a
mempty, versions :: Envs MutableVersions
versions = Envs MutableVersions
forall a. Monoid a => a
mempty, overrides :: Envs Overrides
overrides = Envs Overrides
forall a. Monoid a => a
mempty, initial :: Envs MutableVersions
initial = Envs MutableVersions
forall a. Monoid a => a
mempty, resolving :: Bool
resolving = Bool
False}