{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-redundant-constraints #-}

-- NOTE: -Wno-redundant-constraints for
--
--   withCoreEnv :: (..., MonadDBus m, ...) => ...
--
-- on OSX.

module Shrun.Configuration.Data.Core
  ( -- * Types
    CoreConfigP (..),
    CoreConfigArgs,
    CoreConfigToml,
    CoreConfigMerged,

    -- * Functions
    mergeCoreConfig,
    withCoreEnv,
  )
where

import Shrun.Command.Types (CommandP1)
import Shrun.Configuration.Data.CommandLogging (CommandLoggingP, mergeCommandLogging)
import Shrun.Configuration.Data.CommandLogging qualified as CommandLogging
import Shrun.Configuration.Data.CommonLogging (CommonLoggingP, mergeCommonLogging)
import Shrun.Configuration.Data.CommonLogging qualified as CommonLogging
import Shrun.Configuration.Data.ConfigPhase
  ( ConfigPhase
      ( ConfigPhaseArgs,
        ConfigPhaseEnv,
        ConfigPhaseMerged,
        ConfigPhaseToml
      ),
    ConfigPhaseDisabledMaybeF,
  )
import Shrun.Configuration.Data.ConsoleLogging (ConsoleLoggingP, mergeConsoleLogging)
import Shrun.Configuration.Data.ConsoleLogging qualified as ConsoleLogging
import Shrun.Configuration.Data.Core.Timeout (Timeout)
import Shrun.Configuration.Data.FileLogging (FileLoggingP, mergeFileLogging)
import Shrun.Configuration.Data.FileLogging qualified as FileLogging
import Shrun.Configuration.Data.LegendKeysCache (LegendKeysCache)
import Shrun.Configuration.Data.Notify (NotifyP, mergeNotifications)
import Shrun.Configuration.Data.Notify qualified as Notify
import Shrun.Configuration.Data.Truncation (DetectResult (DetectNotRun))
import Shrun.Configuration.Data.WithDisabled (WithDisabled, (<|?|>))
import Shrun.Configuration.Default (Default (def), (<.>))
import Shrun.Prelude

-- | For types that are only guaranteed to exist for Args. Generally this
-- describes "aggregate" types e.g. CommandLoggingP, which always exists for
-- Args (as subfields can independently override toml), but is not
-- guaranteed to exist on toml/merged, since its presence in the latter two
-- indicates active status.
type family ArgsOnlyDetF p a where
  ArgsOnlyDetF ConfigPhaseArgs a = a
  ArgsOnlyDetF ConfigPhaseToml a = Maybe a
  ArgsOnlyDetF ConfigPhaseMerged a = Maybe a
  ArgsOnlyDetF ConfigPhaseEnv a = Maybe a

-- | For types that are optional only on the Toml.
type family TomlOptF p a where
  TomlOptF ConfigPhaseArgs a = a
  TomlOptF ConfigPhaseToml a = Maybe a
  TomlOptF ConfigPhaseMerged a = a
  TomlOptF ConfigPhaseEnv a = a

type family TimeoutF a where
  TimeoutF ConfigPhaseArgs = Maybe (WithDisabled Timeout)
  TimeoutF ConfigPhaseToml = Maybe (WithDisabled Timeout)
  TimeoutF ConfigPhaseMerged = WithDisabled Timeout
  TimeoutF ConfigPhaseEnv = WithDisabled Timeout

type family LegendKeysCacheF a where
  LegendKeysCacheF ConfigPhaseArgs = Maybe LegendKeysCache
  LegendKeysCacheF ConfigPhaseToml = Maybe LegendKeysCache
  LegendKeysCacheF ConfigPhaseMerged = LegendKeysCache
  LegendKeysCacheF ConfigPhaseEnv = ()

-- | Holds core configuration data.
type CoreConfigP :: ConfigPhase -> Type -> Type
data CoreConfigP p notifyEnv = MkCoreConfigP
  { -- | Shell logic to run before each command.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> ConfigPhaseDisabledMaybeF p Text
init :: ConfigPhaseDisabledMaybeF p Text,
    -- | Whether to save legend keys.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> LegendKeysCacheF p
legendKeysCache :: LegendKeysCacheF p,
    -- | Timeout.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> TimeoutF p
timeout :: TimeoutF p,
    -- | Holds common logging config.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> TomlOptF p (CommonLoggingP p)
commonLogging :: TomlOptF p (CommonLoggingP p),
    -- | Command log config.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> TomlOptF p (CommandLoggingP p)
commandLogging :: TomlOptF p (CommandLoggingP p),
    -- | Holds console logging config.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> TomlOptF p (ConsoleLoggingP p)
consoleLogging :: TomlOptF p (ConsoleLoggingP p),
    -- | File log config.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> ArgsOnlyDetF p (FileLoggingP p)
fileLogging :: ArgsOnlyDetF p (FileLoggingP p),
    -- | Notify config.
    forall (p :: ConfigPhase) notifyEnv.
CoreConfigP p notifyEnv -> ArgsOnlyDetF p (NotifyP p notifyEnv)
notifications :: ArgsOnlyDetF p (NotifyP p notifyEnv)
  }

instance
  ( k ~ A_Lens,
    a ~ ConfigPhaseDisabledMaybeF p Text,
    b ~ ConfigPhaseDisabledMaybeF p Text
  ) =>
  LabelOptic "init" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP b
ConfigPhaseDisabledMaybeF p Text
b LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
ConfigPhaseDisabledMaybeF p Text
a1)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ LegendKeysCacheF p,
    b ~ LegendKeysCacheF p
  ) =>
  LabelOptic "legendKeysCache" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 b
LegendKeysCacheF p
b TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
LegendKeysCacheF p
a2)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ TimeoutF p,
    b ~ TimeoutF p
  ) =>
  LabelOptic "timeout" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 b
TimeoutF p
b TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
TimeoutF p
a3)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ TomlOptF p (CommonLoggingP p),
    b ~ TomlOptF p (CommonLoggingP p)
  ) =>
  LabelOptic "commonLogging" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 b
TomlOptF p (CommonLoggingP p)
b TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
TomlOptF p (CommonLoggingP p)
a4)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ TomlOptF p (CommandLoggingP p),
    b ~ TomlOptF p (CommandLoggingP p)
  ) =>
  LabelOptic "commandLogging" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 b
TomlOptF p (CommandLoggingP p)
b TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
TomlOptF p (CommandLoggingP p)
a5)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ TomlOptF p (ConsoleLoggingP p),
    b ~ TomlOptF p (ConsoleLoggingP p)
  ) =>
  LabelOptic "consoleLogging" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 b
TomlOptF p (ConsoleLoggingP p)
b ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
TomlOptF p (ConsoleLoggingP p)
a6)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ ArgsOnlyDetF p (FileLoggingP p),
    b ~ ArgsOnlyDetF p (FileLoggingP p)
  ) =>
  LabelOptic "fileLogging" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 b
ArgsOnlyDetF p (FileLoggingP p)
b ArgsOnlyDetF p (NotifyP p r)
a8)
          (a -> f b
f a
ArgsOnlyDetF p (FileLoggingP p)
a7)
  {-# INLINE labelOptic #-}

instance
  ( k ~ A_Lens,
    a ~ ArgsOnlyDetF p (NotifyP p r),
    b ~ ArgsOnlyDetF p (NotifyP p r)
  ) =>
  LabelOptic "notifications" k (CoreConfigP p r) (CoreConfigP p r) a b
  where
  labelOptic :: Optic k NoIx (CoreConfigP p r) (CoreConfigP p r) a b
labelOptic =
    LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL
      (LensVL (CoreConfigP p r) (CoreConfigP p r) a b
 -> Lens (CoreConfigP p r) (CoreConfigP p r) a b)
-> LensVL (CoreConfigP p r) (CoreConfigP p r) a b
-> Lens (CoreConfigP p r) (CoreConfigP p r) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 ArgsOnlyDetF p (NotifyP p r)
a8) ->
        (b -> CoreConfigP p r) -> f b -> f (CoreConfigP p r)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\b
b -> ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p r)
-> CoreConfigP p r
forall (p :: ConfigPhase) notifyEnv.
ConfigPhaseDisabledMaybeF p Text
-> LegendKeysCacheF p
-> TimeoutF p
-> TomlOptF p (CommonLoggingP p)
-> TomlOptF p (CommandLoggingP p)
-> TomlOptF p (ConsoleLoggingP p)
-> ArgsOnlyDetF p (FileLoggingP p)
-> ArgsOnlyDetF p (NotifyP p notifyEnv)
-> CoreConfigP p notifyEnv
MkCoreConfigP ConfigPhaseDisabledMaybeF p Text
a1 LegendKeysCacheF p
a2 TimeoutF p
a3 TomlOptF p (CommonLoggingP p)
a4 TomlOptF p (CommandLoggingP p)
a5 TomlOptF p (ConsoleLoggingP p)
a6 ArgsOnlyDetF p (FileLoggingP p)
a7 b
ArgsOnlyDetF p (NotifyP p r)
b)
          (a -> f b
f a
ArgsOnlyDetF p (NotifyP p r)
a8)
  {-# INLINE labelOptic #-}

instance Semigroup (CoreConfigToml r) where
  CoreConfigToml r
l <> :: CoreConfigToml r -> CoreConfigToml r -> CoreConfigToml r
<> CoreConfigToml r
r =
    MkCoreConfigP
      { init :: ConfigPhaseDisabledMaybeF 'ConfigPhaseToml Text
init = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
-> Maybe (WithDisabled Text)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
#init Maybe (WithDisabled Text)
-> Maybe (WithDisabled Text) -> Maybe (WithDisabled Text)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
<|> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
-> Maybe (WithDisabled Text)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
#init,
        legendKeysCache :: LegendKeysCacheF 'ConfigPhaseToml
legendKeysCache = CoreConfigToml r
l CoreConfigToml r
-> Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
-> Maybe LegendKeysCache
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
#legendKeysCache Maybe LegendKeysCache
-> Maybe LegendKeysCache -> Maybe LegendKeysCache
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
<|> CoreConfigToml r
r CoreConfigToml r
-> Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
-> Maybe LegendKeysCache
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
#legendKeysCache,
        timeout :: TimeoutF 'ConfigPhaseToml
timeout = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
-> Maybe (WithDisabled Timeout)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
#timeout Maybe (WithDisabled Timeout)
-> Maybe (WithDisabled Timeout) -> Maybe (WithDisabled Timeout)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: Type -> Type) a. Alternative f => f a -> f a -> f a
<|> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
-> Maybe (WithDisabled Timeout)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
#timeout,
        commonLogging :: TomlOptF 'ConfigPhaseToml (CommonLoggingP 'ConfigPhaseToml)
commonLogging = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommonLoggingP 'ConfigPhaseToml))
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommonLoggingP 'ConfigPhaseToml))
#commonLogging Maybe (CommonLoggingP 'ConfigPhaseToml)
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
forall a. Semigroup a => a -> a -> a
<> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommonLoggingP 'ConfigPhaseToml))
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommonLoggingP 'ConfigPhaseToml))
#commonLogging,
        commandLogging :: TomlOptF 'ConfigPhaseToml (CommandLoggingP 'ConfigPhaseToml)
commandLogging = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommandLoggingP 'ConfigPhaseToml))
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommandLoggingP 'ConfigPhaseToml))
#commandLogging Maybe (CommandLoggingP 'ConfigPhaseToml)
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
forall a. Semigroup a => a -> a -> a
<> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommandLoggingP 'ConfigPhaseToml))
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommandLoggingP 'ConfigPhaseToml))
#commandLogging,
        consoleLogging :: TomlOptF 'ConfigPhaseToml (ConsoleLoggingP 'ConfigPhaseToml)
consoleLogging = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
#consoleLogging Maybe (ConsoleLoggingP 'ConfigPhaseToml)
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
forall a. Semigroup a => a -> a -> a
<> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
#consoleLogging,
        fileLogging :: ArgsOnlyDetF 'ConfigPhaseToml (FileLoggingP 'ConfigPhaseToml)
fileLogging = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (FileLoggingP 'ConfigPhaseToml))
-> Maybe (FileLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (FileLoggingP 'ConfigPhaseToml))
#fileLogging Maybe (FileLoggingP 'ConfigPhaseToml)
-> Maybe (FileLoggingP 'ConfigPhaseToml)
-> Maybe (FileLoggingP 'ConfigPhaseToml)
forall a. Semigroup a => a -> a -> a
<> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (FileLoggingP 'ConfigPhaseToml))
-> Maybe (FileLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (FileLoggingP 'ConfigPhaseToml))
#fileLogging,
        notifications :: ArgsOnlyDetF 'ConfigPhaseToml (NotifyP 'ConfigPhaseToml r)
notifications = CoreConfigToml r
l CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyP 'ConfigPhaseToml r))
-> Maybe (NotifyP 'ConfigPhaseToml r)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyP 'ConfigPhaseToml r))
#notifications Maybe (NotifyP 'ConfigPhaseToml r)
-> Maybe (NotifyP 'ConfigPhaseToml r)
-> Maybe (NotifyP 'ConfigPhaseToml r)
forall a. Semigroup a => a -> a -> a
<> CoreConfigToml r
r CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyP 'ConfigPhaseToml r))
-> Maybe (NotifyP 'ConfigPhaseToml r)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyP 'ConfigPhaseToml r))
#notifications
      }

instance Monoid (CoreConfigToml r) where
  mempty :: CoreConfigToml r
mempty =
    MkCoreConfigP
      { init :: ConfigPhaseDisabledMaybeF 'ConfigPhaseToml Text
init = Maybe (WithDisabled Text)
ConfigPhaseDisabledMaybeF 'ConfigPhaseToml Text
forall a. Maybe a
Nothing,
        legendKeysCache :: LegendKeysCacheF 'ConfigPhaseToml
legendKeysCache = Maybe LegendKeysCache
LegendKeysCacheF 'ConfigPhaseToml
forall a. Maybe a
Nothing,
        timeout :: TimeoutF 'ConfigPhaseToml
timeout = Maybe (WithDisabled Timeout)
TimeoutF 'ConfigPhaseToml
forall a. Maybe a
Nothing,
        commonLogging :: TomlOptF 'ConfigPhaseToml (CommonLoggingP 'ConfigPhaseToml)
commonLogging = Maybe (CommonLoggingP 'ConfigPhaseToml)
TomlOptF 'ConfigPhaseToml (CommonLoggingP 'ConfigPhaseToml)
forall a. Maybe a
Nothing,
        commandLogging :: TomlOptF 'ConfigPhaseToml (CommandLoggingP 'ConfigPhaseToml)
commandLogging = Maybe (CommandLoggingP 'ConfigPhaseToml)
TomlOptF 'ConfigPhaseToml (CommandLoggingP 'ConfigPhaseToml)
forall a. Maybe a
Nothing,
        consoleLogging :: TomlOptF 'ConfigPhaseToml (ConsoleLoggingP 'ConfigPhaseToml)
consoleLogging = Maybe (ConsoleLoggingP 'ConfigPhaseToml)
TomlOptF 'ConfigPhaseToml (ConsoleLoggingP 'ConfigPhaseToml)
forall a. Maybe a
Nothing,
        fileLogging :: ArgsOnlyDetF 'ConfigPhaseToml (FileLoggingP 'ConfigPhaseToml)
fileLogging = Maybe (FileLoggingP 'ConfigPhaseToml)
ArgsOnlyDetF 'ConfigPhaseToml (FileLoggingP 'ConfigPhaseToml)
forall a. Maybe a
Nothing,
        notifications :: ArgsOnlyDetF 'ConfigPhaseToml (NotifyP 'ConfigPhaseToml r)
notifications = Maybe (NotifyP 'ConfigPhaseToml r)
ArgsOnlyDetF 'ConfigPhaseToml (NotifyP 'ConfigPhaseToml r)
forall a. Maybe a
Nothing
      }

instance Pretty (CoreConfigMerged r) where
  pretty :: forall ann. CoreConfigMerged r -> Doc ann
pretty CoreConfigMerged r
c =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vcat
      ([Doc ann] -> Doc ann)
-> (Seq (Doc ann) -> [Doc ann]) -> Seq (Doc ann) -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall (t :: Type -> Type) a. Foldable t => t a -> [a]
toList @Seq
      (Seq (Doc ann) -> Doc ann) -> Seq (Doc ann) -> Doc ann
forall a b. (a -> b) -> a -> b
$ [ Doc ann
"init: " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Maybe Text -> Doc ann
forall a ann. Pretty a => Maybe a -> Doc ann
prettyMaybe (CoreConfigMerged r
c CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe Text)
-> Maybe Text
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe Text)
#init),
          Doc ann
"legend-keys-cache: " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> LegendKeysCache -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. LegendKeysCache -> Doc ann
pretty (CoreConfigMerged r
c CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) LegendKeysCache
-> LegendKeysCache
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) LegendKeysCache
#legendKeysCache),
          Doc ann
"timeout: " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> WithDisabled Timeout -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. WithDisabled Timeout -> Doc ann
pretty (CoreConfigMerged r
c CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) (WithDisabled Timeout)
-> WithDisabled Timeout
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) (WithDisabled Timeout)
#timeout),
          Item (Seq (Doc ann))
Doc ann
"common-logging:",
          Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
indentField (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ CommonLoggingP 'ConfigPhaseMerged -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. CommonLoggingP 'ConfigPhaseMerged -> Doc ann
pretty (CoreConfigMerged r
c CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CommonLoggingP 'ConfigPhaseMerged)
-> CommonLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CommonLoggingP 'ConfigPhaseMerged)
#commonLogging)
        ]
      Seq (Doc ann) -> Seq (Doc ann) -> Seq (Doc ann)
forall a. Semigroup a => a -> a -> a
<> Seq (Doc ann)
prettyCommandLogging
      Seq (Doc ann) -> Seq (Doc ann) -> Seq (Doc ann)
forall a. Semigroup a => a -> a -> a
<> [Item (Seq (Doc ann))
Doc ann
"console-logging:", Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
indentField (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ ConsoleLoggingP 'ConfigPhaseMerged -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ConsoleLoggingP 'ConfigPhaseMerged -> Doc ann
pretty (CoreConfigMerged r
c CoreConfigMerged r
-> Optic
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CoreConfigMerged r)
     (ConsoleLoggingP 'ConfigPhaseMerged)
     (ConsoleLoggingP 'ConfigPhaseMerged)
-> ConsoleLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (ConsoleLoggingP 'ConfigPhaseMerged)
  (ConsoleLoggingP 'ConfigPhaseMerged)
#consoleLogging)]
      Seq (Doc ann) -> Seq (Doc ann) -> Seq (Doc ann)
forall a. Semigroup a => a -> a -> a
<> Item (Seq (Doc ann))
-> Maybe (FileLoggingP 'ConfigPhaseMerged) -> Seq (Doc ann)
forall {l} {ann} {a}.
(Item l ~ Doc ann, IsList l, Pretty a) =>
Item l -> Maybe a -> l
prettyMField Item (Seq (Doc ann))
Doc ann
"file-logging:" (CoreConfigMerged r
c CoreConfigMerged r
-> Optic
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CoreConfigMerged r)
     (Maybe (FileLoggingP 'ConfigPhaseMerged))
     (Maybe (FileLoggingP 'ConfigPhaseMerged))
-> Maybe (FileLoggingP 'ConfigPhaseMerged)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
#fileLogging)
      Seq (Doc ann) -> Seq (Doc ann) -> Seq (Doc ann)
forall a. Semigroup a => a -> a -> a
<> Item (Seq (Doc ann))
-> Maybe (NotifyP 'ConfigPhaseMerged r) -> Seq (Doc ann)
forall {l} {ann} {a}.
(Item l ~ Doc ann, IsList l, Pretty a) =>
Item l -> Maybe a -> l
prettyMField Item (Seq (Doc ann))
Doc ann
"notify:" (CoreConfigMerged r
c CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (Maybe (NotifyP 'ConfigPhaseMerged r))
-> Maybe (NotifyP 'ConfigPhaseMerged r)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (Maybe (NotifyP 'ConfigPhaseMerged r))
#notifications)
    where
      -- If command logging is not on then there is no reason to print its
      -- config.
      prettyCommandLogging :: Seq (Doc ann)
prettyCommandLogging =
        if Bool
commandLoggingOn
          then [Item (Seq (Doc ann))
Doc ann
"command-logging:", Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
indentField (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ CommandLoggingP 'ConfigPhaseMerged -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. CommandLoggingP 'ConfigPhaseMerged -> Doc ann
pretty (CoreConfigMerged r
c CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CommandLoggingP 'ConfigPhaseMerged)
-> CommandLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CommandLoggingP 'ConfigPhaseMerged)
#commandLogging)]
          else [Item (Seq (Doc ann))
Doc ann
"command-logging: off"]

      commandLoggingOn :: Bool
commandLoggingOn =
        Optic' A_Lens NoIx (CoreConfigMerged r) Bool
-> CoreConfigMerged r -> Bool
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view (Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (ConsoleLoggingP 'ConfigPhaseMerged)
  (ConsoleLoggingP 'ConfigPhaseMerged)
#consoleLogging Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (ConsoleLoggingP 'ConfigPhaseMerged)
  (ConsoleLoggingP 'ConfigPhaseMerged)
-> Optic
     A_Lens
     NoIx
     (ConsoleLoggingP 'ConfigPhaseMerged)
     (ConsoleLoggingP 'ConfigPhaseMerged)
     ConsoleLogCmdSwitch
     ConsoleLogCmdSwitch
-> Optic
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CoreConfigMerged r)
     ConsoleLogCmdSwitch
     ConsoleLogCmdSwitch
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Lens
  NoIx
  (ConsoleLoggingP 'ConfigPhaseMerged)
  (ConsoleLoggingP 'ConfigPhaseMerged)
  ConsoleLogCmdSwitch
  ConsoleLogCmdSwitch
#commandLogging Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  ConsoleLogCmdSwitch
  ConsoleLogCmdSwitch
-> Optic
     An_Iso NoIx ConsoleLogCmdSwitch ConsoleLogCmdSwitch Bool Bool
-> Optic' A_Lens NoIx (CoreConfigMerged r) Bool
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic An_Iso NoIx ConsoleLogCmdSwitch ConsoleLogCmdSwitch Bool Bool
#unConsoleLogCmdSwitch) CoreConfigMerged r
c
          Bool -> Bool -> Bool
|| Optic'
  An_AffineTraversal
  NoIx
  (CoreConfigMerged r)
  (FileLoggingP 'ConfigPhaseMerged)
-> CoreConfigMerged r -> Bool
forall k (is :: IxList) s a.
Is k An_AffineFold =>
Optic' k is s a -> s -> Bool
is (Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
#fileLogging Optic
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CoreConfigMerged r)
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
-> Optic
     A_Prism
     NoIx
     (Maybe (FileLoggingP 'ConfigPhaseMerged))
     (Maybe (FileLoggingP 'ConfigPhaseMerged))
     (FileLoggingP 'ConfigPhaseMerged)
     (FileLoggingP 'ConfigPhaseMerged)
-> Optic'
     An_AffineTraversal
     NoIx
     (CoreConfigMerged r)
     (FileLoggingP 'ConfigPhaseMerged)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Prism
  NoIx
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
  (FileLoggingP 'ConfigPhaseMerged)
  (FileLoggingP 'ConfigPhaseMerged)
forall a b. Prism (Maybe a) (Maybe b) a b
_Just) CoreConfigMerged r
c

      prettyMField :: Item l -> Maybe a -> l
prettyMField Item l
k Maybe a
Nothing = [Item l
k Item l -> Item l -> Item l
forall a. Semigroup a => a -> a -> a
<> Item l
" off"]
      prettyMField Item l
k (Just a
x) = [Item l
k, Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
indentField (a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
x)]

type CoreConfigArgs = CoreConfigP ConfigPhaseArgs

type CoreConfigToml = CoreConfigP ConfigPhaseToml

type CoreConfigMerged = CoreConfigP ConfigPhaseMerged

type CoreConfigEnv = CoreConfigP ConfigPhaseEnv

deriving stock instance Eq (CoreConfigP ConfigPhaseArgs r)

deriving stock instance Show (CoreConfigP ConfigPhaseArgs r)

deriving stock instance Eq (CoreConfigP ConfigPhaseToml r)

deriving stock instance Show (CoreConfigP ConfigPhaseToml r)

deriving stock instance Eq (CoreConfigP ConfigPhaseMerged r)

deriving stock instance Show (CoreConfigP ConfigPhaseMerged r)

mergeCoreConfig ::
  ( HasCallStack,
    MonadCatch m,
    MonadIORef m,
    MonadTerminal m
  ) =>
  NESeq CommandP1 ->
  CoreConfigArgs r ->
  CoreConfigToml r ->
  m (CoreConfigMerged r)
mergeCoreConfig :: forall (m :: Type -> Type) r.
(HasCallStack, MonadCatch m, MonadIORef m, MonadTerminal m) =>
NESeq CommandP1
-> CoreConfigArgs r -> CoreConfigToml r -> m (CoreConfigMerged r)
mergeCoreConfig NESeq CommandP1
cmds CoreConfigArgs r
args CoreConfigToml r
toml = do
  IORef DetectResult
detectRef <- DetectResult -> m (IORef DetectResult)
forall a. HasCallStack => a -> m (IORef a)
forall (m :: Type -> Type) a.
(MonadIORef m, HasCallStack) =>
a -> m (IORef a)
newIORef' DetectResult
DetectNotRun

  ConsoleLoggingP 'ConfigPhaseMerged
consoleLogging <-
    IORef DetectResult
-> ConsoleLoggingP 'ConfigPhaseArgs
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
-> m (ConsoleLoggingP 'ConfigPhaseMerged)
forall (m :: Type -> Type).
(HasCallStack, MonadCatch m, MonadIORef m, MonadTerminal m) =>
IORef DetectResult
-> ConsoleLoggingP 'ConfigPhaseArgs
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
-> m (ConsoleLoggingP 'ConfigPhaseMerged)
mergeConsoleLogging
      IORef DetectResult
detectRef
      (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (ConsoleLoggingP 'ConfigPhaseArgs)
-> ConsoleLoggingP 'ConfigPhaseArgs
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigArgs r) (ConsoleLoggingP 'ConfigPhaseArgs)
#consoleLogging)
      (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
-> Maybe (ConsoleLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (ConsoleLoggingP 'ConfigPhaseToml))
#consoleLogging)

  Maybe (FileLoggingP 'ConfigPhaseMerged)
fileLogging <-
    NESeq CommandP1
-> IORef DetectResult
-> FileLoggingP 'ConfigPhaseArgs
-> Maybe (FileLoggingP 'ConfigPhaseToml)
-> m (Maybe (FileLoggingP 'ConfigPhaseMerged))
forall (m :: Type -> Type).
(HasCallStack, MonadCatch m, MonadIORef m, MonadTerminal m) =>
NESeq CommandP1
-> IORef DetectResult
-> FileLoggingP 'ConfigPhaseArgs
-> Maybe (FileLoggingP 'ConfigPhaseToml)
-> m (Maybe (FileLoggingP 'ConfigPhaseMerged))
mergeFileLogging
      NESeq CommandP1
cmds
      IORef DetectResult
detectRef
      (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (FileLoggingP 'ConfigPhaseArgs)
-> FileLoggingP 'ConfigPhaseArgs
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigArgs r) (FileLoggingP 'ConfigPhaseArgs)
#fileLogging)
      (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (FileLoggingP 'ConfigPhaseToml))
-> Maybe (FileLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (FileLoggingP 'ConfigPhaseToml))
#fileLogging)

  let (Bool
isFileLog, Bool
isFileLogMulti) = case Maybe (FileLoggingP 'ConfigPhaseMerged)
fileLogging of
        Maybe (FileLoggingP 'ConfigPhaseMerged)
Nothing -> (Bool
False, Bool
False)
        Just FileLoggingP 'ConfigPhaseMerged
fl -> (Bool
True, FileLoggingP 'ConfigPhaseMerged
fl FileLoggingP 'ConfigPhaseMerged
-> Optic' A_Lens NoIx (FileLoggingP 'ConfigPhaseMerged) Bool
-> Bool
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. (Optic
  A_Lens
  NoIx
  (FileLoggingP 'ConfigPhaseMerged)
  (FileLoggingP 'ConfigPhaseMerged)
  FileLogMultiSwitch
  FileLogMultiSwitch
#multi Optic
  A_Lens
  NoIx
  (FileLoggingP 'ConfigPhaseMerged)
  (FileLoggingP 'ConfigPhaseMerged)
  FileLogMultiSwitch
  FileLogMultiSwitch
-> Optic
     An_Iso NoIx FileLogMultiSwitch FileLogMultiSwitch Bool Bool
-> Optic' A_Lens NoIx (FileLoggingP 'ConfigPhaseMerged) Bool
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic An_Iso NoIx FileLogMultiSwitch FileLogMultiSwitch Bool Bool
#unFileLogMultiSwitch))
  CommandLoggingP 'ConfigPhaseMerged
commandLogging <-
    Bool
-> Bool
-> NESeq CommandP1
-> CommandLoggingP 'ConfigPhaseArgs
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
-> m (CommandLoggingP 'ConfigPhaseMerged)
forall (m :: Type -> Type).
(HasCallStack, MonadThrow m) =>
Bool
-> Bool
-> NESeq CommandP1
-> CommandLoggingP 'ConfigPhaseArgs
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
-> m (CommandLoggingP 'ConfigPhaseMerged)
mergeCommandLogging
      Bool
isFileLog
      Bool
isFileLogMulti
      NESeq CommandP1
cmds
      (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (CommandLoggingP 'ConfigPhaseArgs)
-> CommandLoggingP 'ConfigPhaseArgs
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigArgs r) (CommandLoggingP 'ConfigPhaseArgs)
#commandLogging)
      (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommandLoggingP 'ConfigPhaseToml))
-> Maybe (CommandLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommandLoggingP 'ConfigPhaseToml))
#commandLogging)

  let notifications :: Maybe (NotifyMerged r)
notifications =
        NotifyArgs r -> Maybe (NotifyToml r) -> Maybe (NotifyMerged r)
forall r.
NotifyArgs r -> Maybe (NotifyToml r) -> Maybe (NotifyMerged r)
mergeNotifications
          (CoreConfigArgs r
args CoreConfigArgs r
-> Optic' A_Lens NoIx (CoreConfigArgs r) (NotifyArgs r)
-> NotifyArgs r
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigArgs r) (NotifyArgs r)
#notifications)
          (CoreConfigToml r
toml CoreConfigToml r
-> Optic' A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyToml r))
-> Maybe (NotifyToml r)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe (NotifyToml r))
#notifications)

  pure
    $ MkCoreConfigP
      { timeout :: TimeoutF 'ConfigPhaseMerged
timeout = (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (Maybe (WithDisabled Timeout))
-> Maybe (WithDisabled Timeout)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigArgs r) (Maybe (WithDisabled Timeout))
#timeout) Maybe (WithDisabled Timeout)
-> Maybe (WithDisabled Timeout) -> WithDisabled Timeout
forall a. Default a => Maybe a -> Maybe a -> a
<.> (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
-> Maybe (WithDisabled Timeout)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Timeout))
#timeout),
        legendKeysCache :: LegendKeysCacheF 'ConfigPhaseMerged
legendKeysCache = (CoreConfigArgs r
args CoreConfigArgs r
-> Optic' A_Lens NoIx (CoreConfigArgs r) (Maybe LegendKeysCache)
-> Maybe LegendKeysCache
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigArgs r) (Maybe LegendKeysCache)
#legendKeysCache) Maybe LegendKeysCache -> Maybe LegendKeysCache -> LegendKeysCache
forall a. Default a => Maybe a -> Maybe a -> a
<.> (CoreConfigToml r
toml CoreConfigToml r
-> Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
-> Maybe LegendKeysCache
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe LegendKeysCache)
#legendKeysCache),
        init :: ConfigPhaseDisabledMaybeF 'ConfigPhaseMerged Text
init = (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (Maybe (WithDisabled Text))
-> Maybe (WithDisabled Text)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigArgs r) (Maybe (WithDisabled Text))
#init) Maybe (WithDisabled Text)
-> Maybe (WithDisabled Text) -> Maybe Text
forall a.
Maybe (WithDisabled a) -> Maybe (WithDisabled a) -> Maybe a
<|?|> (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
-> Maybe (WithDisabled Text)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigToml r) (Maybe (WithDisabled Text))
#init),
        commonLogging :: TomlOptF 'ConfigPhaseMerged (CommonLoggingP 'ConfigPhaseMerged)
commonLogging =
          CommonLoggingP 'ConfigPhaseArgs
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
-> CommonLoggingP 'ConfigPhaseMerged
mergeCommonLogging
            (CoreConfigArgs r
args CoreConfigArgs r
-> Optic'
     A_Lens NoIx (CoreConfigArgs r) (CommonLoggingP 'ConfigPhaseArgs)
-> CommonLoggingP 'ConfigPhaseArgs
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens NoIx (CoreConfigArgs r) (CommonLoggingP 'ConfigPhaseArgs)
#commonLogging)
            (CoreConfigToml r
toml CoreConfigToml r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigToml r)
     (Maybe (CommonLoggingP 'ConfigPhaseToml))
-> Maybe (CommonLoggingP 'ConfigPhaseToml)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigToml r)
  (Maybe (CommonLoggingP 'ConfigPhaseToml))
#commonLogging),
        ConsoleLoggingP 'ConfigPhaseMerged
TomlOptF 'ConfigPhaseMerged (ConsoleLoggingP 'ConfigPhaseMerged)
consoleLogging :: TomlOptF 'ConfigPhaseMerged (ConsoleLoggingP 'ConfigPhaseMerged)
consoleLogging :: ConsoleLoggingP 'ConfigPhaseMerged
consoleLogging,
        CommandLoggingP 'ConfigPhaseMerged
TomlOptF 'ConfigPhaseMerged (CommandLoggingP 'ConfigPhaseMerged)
commandLogging :: TomlOptF 'ConfigPhaseMerged (CommandLoggingP 'ConfigPhaseMerged)
commandLogging :: CommandLoggingP 'ConfigPhaseMerged
commandLogging,
        Maybe (FileLoggingP 'ConfigPhaseMerged)
ArgsOnlyDetF 'ConfigPhaseMerged (FileLoggingP 'ConfigPhaseMerged)
fileLogging :: ArgsOnlyDetF 'ConfigPhaseMerged (FileLoggingP 'ConfigPhaseMerged)
fileLogging :: Maybe (FileLoggingP 'ConfigPhaseMerged)
fileLogging,
        Maybe (NotifyMerged r)
ArgsOnlyDetF 'ConfigPhaseMerged (NotifyMerged r)
notifications :: ArgsOnlyDetF 'ConfigPhaseMerged (NotifyMerged r)
notifications :: Maybe (NotifyMerged r)
notifications
      }
{-# INLINEABLE mergeCoreConfig #-}

-- | Given a merged CoreConfig, constructs a ConfigEnv and calls the
-- continuation.
withCoreEnv ::
  forall m r a.
  ( HasCallStack,
    MonadAtomic m,
    MonadFileWriter m,
    MonadHandleWriter m,
    MonadMask m,
    MonadNotify m,
    MonadPathReader m,
    MonadPathWriter m,
    MonadPosixFiles m,
    MonadTerminal m,
    NotifyEnvF m ~ r
  ) =>
  CoreConfigMerged r ->
  (CoreConfigEnv r -> m a) ->
  m a
withCoreEnv :: forall (m :: Type -> Type) r a.
(HasCallStack, MonadAtomic m, MonadFileWriter m,
 MonadHandleWriter m, MonadMask m, MonadNotify m, MonadPathReader m,
 MonadPathWriter m, MonadPosixFiles m, MonadTerminal m,
 NotifyEnvF m ~ r) =>
CoreConfigMerged r -> (CoreConfigEnv r -> m a) -> m a
withCoreEnv CoreConfigMerged r
merged CoreConfigEnv r -> m a
onCoreConfigEnv = do
  Maybe (NotifyP 'ConfigPhaseEnv r)
notifications <- (NotifyMerged r -> m (NotifyP 'ConfigPhaseEnv r))
-> Maybe (NotifyMerged r) -> m (Maybe (NotifyP 'ConfigPhaseEnv r))
forall (t :: Type -> Type) (f :: Type -> Type) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse NotifyMerged r -> m (NotifyP 'ConfigPhaseEnv r)
forall (m :: Type -> Type) r.
(HasCallStack, MonadNotify m, MonadThrow m, NotifyEnvF m ~ r) =>
NotifyMerged r -> m (NotifyP 'ConfigPhaseEnv r)
Notify.toEnv (CoreConfigMerged r
merged CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe (NotifyMerged r))
-> Maybe (NotifyMerged r)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe (NotifyMerged r))
#notifications)

  Maybe (FileLoggingP 'ConfigPhaseMerged)
-> (Maybe FileLoggingEnv -> m a) -> m a
forall (m :: Type -> Type) a.
(HasCallStack, MonadAtomic m, MonadFileWriter m,
 MonadHandleWriter m, MonadMask m, MonadPathReader m,
 MonadPathWriter m, MonadPosixFiles m, MonadTerminal m) =>
Maybe (FileLoggingP 'ConfigPhaseMerged)
-> (Maybe FileLoggingEnv -> m a) -> m a
FileLogging.withFileLoggingEnv (CoreConfigMerged r
merged CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (Maybe (FileLoggingP 'ConfigPhaseMerged))
-> Maybe (FileLoggingP 'ConfigPhaseMerged)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (Maybe (FileLoggingP 'ConfigPhaseMerged))
#fileLogging) ((Maybe FileLoggingEnv -> m a) -> m a)
-> (Maybe FileLoggingEnv -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ \Maybe FileLoggingEnv
fileLoggingEnv -> do
    let coreConfigEnv :: CoreConfigEnv r
coreConfigEnv =
          MkCoreConfigP
            { init :: ConfigPhaseDisabledMaybeF 'ConfigPhaseEnv Text
init = CoreConfigMerged r
merged CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe Text)
-> Maybe Text
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) (Maybe Text)
#init,
              legendKeysCache :: LegendKeysCacheF 'ConfigPhaseEnv
legendKeysCache = (),
              timeout :: TimeoutF 'ConfigPhaseEnv
timeout = CoreConfigMerged r
merged CoreConfigMerged r
-> Optic' A_Lens NoIx (CoreConfigMerged r) (WithDisabled Timeout)
-> WithDisabled Timeout
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx (CoreConfigMerged r) (WithDisabled Timeout)
#timeout,
              commonLogging :: TomlOptF 'ConfigPhaseEnv (CommonLoggingP 'ConfigPhaseEnv)
commonLogging = CommonLoggingP 'ConfigPhaseMerged -> CommonLoggingP 'ConfigPhaseEnv
CommonLogging.toEnv (CoreConfigMerged r
merged CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CommonLoggingP 'ConfigPhaseMerged)
-> CommonLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CommonLoggingP 'ConfigPhaseMerged)
#commonLogging),
              commandLogging :: TomlOptF 'ConfigPhaseEnv (CommandLoggingP 'ConfigPhaseEnv)
commandLogging = CommandLoggingP 'ConfigPhaseMerged
-> CommandLoggingP 'ConfigPhaseEnv
CommandLogging.toEnv (CoreConfigMerged r
merged CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (CommandLoggingP 'ConfigPhaseMerged)
-> CommandLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (CommandLoggingP 'ConfigPhaseMerged)
#commandLogging),
              consoleLogging :: TomlOptF 'ConfigPhaseEnv (ConsoleLoggingP 'ConfigPhaseEnv)
consoleLogging = ConsoleLoggingP 'ConfigPhaseMerged
-> ConsoleLoggingP 'ConfigPhaseEnv
ConsoleLogging.toEnv (CoreConfigMerged r
merged CoreConfigMerged r
-> Optic'
     A_Lens
     NoIx
     (CoreConfigMerged r)
     (ConsoleLoggingP 'ConfigPhaseMerged)
-> ConsoleLoggingP 'ConfigPhaseMerged
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic'
  A_Lens
  NoIx
  (CoreConfigMerged r)
  (ConsoleLoggingP 'ConfigPhaseMerged)
#consoleLogging),
              fileLogging :: ArgsOnlyDetF 'ConfigPhaseEnv FileLoggingEnv
fileLogging = Maybe FileLoggingEnv
ArgsOnlyDetF 'ConfigPhaseEnv FileLoggingEnv
fileLoggingEnv,
              Maybe (NotifyP 'ConfigPhaseEnv r)
ArgsOnlyDetF 'ConfigPhaseEnv (NotifyP 'ConfigPhaseEnv r)
notifications :: ArgsOnlyDetF 'ConfigPhaseEnv (NotifyP 'ConfigPhaseEnv r)
notifications :: Maybe (NotifyP 'ConfigPhaseEnv r)
notifications
            }
     in CoreConfigEnv r -> m a
onCoreConfigEnv CoreConfigEnv r
coreConfigEnv
{-# INLINEABLE withCoreEnv #-}

instance Default (CoreConfigP ConfigPhaseArgs r) where
  def :: CoreConfigP 'ConfigPhaseArgs r
def =
    MkCoreConfigP
      { init :: ConfigPhaseDisabledMaybeF 'ConfigPhaseArgs Text
init = Maybe (WithDisabled Text)
ConfigPhaseDisabledMaybeF 'ConfigPhaseArgs Text
forall a. Maybe a
Nothing,
        legendKeysCache :: LegendKeysCacheF 'ConfigPhaseArgs
legendKeysCache = Maybe LegendKeysCache
LegendKeysCacheF 'ConfigPhaseArgs
forall a. Maybe a
Nothing,
        timeout :: TimeoutF 'ConfigPhaseArgs
timeout = Maybe (WithDisabled Timeout)
TimeoutF 'ConfigPhaseArgs
forall a. Maybe a
Nothing,
        commonLogging :: TomlOptF 'ConfigPhaseArgs (CommonLoggingP 'ConfigPhaseArgs)
commonLogging = CommonLoggingP 'ConfigPhaseArgs
TomlOptF 'ConfigPhaseArgs (CommonLoggingP 'ConfigPhaseArgs)
forall a. Default a => a
def,
        commandLogging :: TomlOptF 'ConfigPhaseArgs (CommandLoggingP 'ConfigPhaseArgs)
commandLogging = CommandLoggingP 'ConfigPhaseArgs
TomlOptF 'ConfigPhaseArgs (CommandLoggingP 'ConfigPhaseArgs)
forall a. Default a => a
def,
        consoleLogging :: TomlOptF 'ConfigPhaseArgs (ConsoleLoggingP 'ConfigPhaseArgs)
consoleLogging = ConsoleLoggingP 'ConfigPhaseArgs
TomlOptF 'ConfigPhaseArgs (ConsoleLoggingP 'ConfigPhaseArgs)
forall a. Default a => a
def,
        fileLogging :: ArgsOnlyDetF 'ConfigPhaseArgs (FileLoggingP 'ConfigPhaseArgs)
fileLogging = FileLoggingP 'ConfigPhaseArgs
ArgsOnlyDetF 'ConfigPhaseArgs (FileLoggingP 'ConfigPhaseArgs)
forall a. Default a => a
def,
        notifications :: ArgsOnlyDetF 'ConfigPhaseArgs (NotifyP 'ConfigPhaseArgs r)
notifications = NotifyP 'ConfigPhaseArgs r
ArgsOnlyDetF 'ConfigPhaseArgs (NotifyP 'ConfigPhaseArgs r)
forall a. Default a => a
def
      }