module Ecluse.Core.Registry.ServedDocument (
assembleAcross,
serialiseAcross,
RenderRefused (..),
overlaySurvivors,
uniqueEntries,
overlayObjectSurvivors,
overlayObjectSources,
safeDocumentName,
rebaseArtifactUrl,
artifactUrlPacked,
documentObject,
stringField,
objectField,
adjustField,
) where
import Data.Aeson (Encoding, Value (Object, String))
import Data.Aeson.Encoding (emptyObject_, encodingToLazyByteString)
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap (KeyMap)
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Map.Strict qualified as Map
import Data.Text qualified as T
import Data.Vector (Vector)
import Data.Vector qualified as V
import Data.Vector.Mutable qualified as MV
import Ecluse.Core.Package.Entry (AdmittedEntry (..), EntryKey (..), validEntryKey)
import Ecluse.Core.Package.Merge (MergePlan (mpArtifacts, mpSurvivors), SourceId)
import Ecluse.Core.Registry.CachedDocument (CachedDoc)
import Ecluse.Core.Registry.Json.Packed (Packed, withoutHole)
import Ecluse.Core.Snapshot (ContentDigest, Snapshot (..))
import Ecluse.Core.Text (urlFilename)
assembleAcross ::
(source -> CachedDoc, CachedDoc -> Maybe source) ->
source ->
(Text -> Map SourceId (Snapshot source) -> MergePlan -> source -> source) ->
Text ->
Map SourceId (Snapshot CachedDoc) ->
MergePlan ->
Maybe CachedDoc ->
CachedDoc
assembleAcross :: forall source.
(source -> CachedDoc, CachedDoc -> Maybe source)
-> source
-> (Text
-> Map SourceId (Snapshot source) -> MergePlan -> source -> source)
-> Text
-> Map SourceId (Snapshot CachedDoc)
-> MergePlan
-> Maybe CachedDoc
-> CachedDoc
assembleAcross (source -> CachedDoc
inject, CachedDoc -> Maybe source
project) source
emptySource Text
-> Map SourceId (Snapshot source) -> MergePlan -> source -> source
assemble Text
mountBase Map SourceId (Snapshot CachedDoc)
bySource MergePlan
plan Maybe CachedDoc
base =
source -> CachedDoc
inject
( Text
-> Map SourceId (Snapshot source) -> MergePlan -> source -> source
assemble
Text
mountBase
((Snapshot CachedDoc -> Maybe (Snapshot source))
-> Map SourceId (Snapshot CachedDoc)
-> Map SourceId (Snapshot source)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe ((CachedDoc -> Maybe source)
-> Snapshot CachedDoc -> Maybe (Snapshot source)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Snapshot a -> f (Snapshot b)
traverse CachedDoc -> Maybe source
project) Map SourceId (Snapshot CachedDoc)
bySource)
MergePlan
plan
(source -> Maybe source -> source
forall a. a -> Maybe a -> a
fromMaybe source
emptySource (CachedDoc -> Maybe source
project (CachedDoc -> Maybe source) -> Maybe CachedDoc -> Maybe source
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe CachedDoc
base))
)
serialiseAcross :: (CachedDoc -> Maybe Encoding) -> CachedDoc -> LByteString
serialiseAcross :: (CachedDoc -> Maybe Encoding) -> CachedDoc -> LByteString
serialiseAcross CachedDoc -> Maybe Encoding
project = Encoding -> LByteString
forall a. Encoding' a -> LByteString
encodingToLazyByteString (Encoding -> LByteString)
-> (CachedDoc -> Encoding) -> CachedDoc -> LByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Encoding -> Maybe Encoding -> Encoding
forall a. a -> Maybe a -> a
fromMaybe Encoding
emptyObject_ (Maybe Encoding -> Encoding)
-> (CachedDoc -> Maybe Encoding) -> CachedDoc -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CachedDoc -> Maybe Encoding
project
data RenderRefused = RenderRefused
deriving stock (RenderRefused -> RenderRefused -> Bool
(RenderRefused -> RenderRefused -> Bool)
-> (RenderRefused -> RenderRefused -> Bool) -> Eq RenderRefused
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RenderRefused -> RenderRefused -> Bool
== :: RenderRefused -> RenderRefused -> Bool
$c/= :: RenderRefused -> RenderRefused -> Bool
/= :: RenderRefused -> RenderRefused -> Bool
Eq, SourceId -> RenderRefused -> ShowS
[RenderRefused] -> ShowS
RenderRefused -> String
(SourceId -> RenderRefused -> ShowS)
-> (RenderRefused -> String)
-> ([RenderRefused] -> ShowS)
-> Show RenderRefused
forall a.
(SourceId -> a -> ShowS)
-> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: SourceId -> RenderRefused -> ShowS
showsPrec :: SourceId -> RenderRefused -> ShowS
$cshow :: RenderRefused -> String
show :: RenderRefused -> String
$cshowList :: [RenderRefused] -> ShowS
showList :: [RenderRefused] -> ShowS
Show)
instance Exception RenderRefused
overlaySurvivors :: (src -> [(EntryKey, entry)]) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlaySurvivors :: forall src entry.
(src -> [(EntryKey, entry)])
-> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlaySurvivors src -> [(EntryKey, entry)]
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan =
[ (Text, entry)
selected
| (SourceId
sid, Snapshot src
source) <- Map SourceId (Snapshot src) -> [(SourceId, Snapshot src)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map SourceId (Snapshot src)
bySource
, (Text, entry)
selected <- [(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
[(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries (MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
forall src.
MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions MergePlan
plan SourceId
sid Snapshot src
source) (src -> [(EntryKey, entry)]
entriesOf (Snapshot src -> src
forall a. Snapshot a -> a
snapshotValue Snapshot src
source))
]
sourceAdmissions :: MergePlan -> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions :: forall src.
MergePlan
-> SourceId -> Snapshot src -> [(EntryKey, (Text, AdmittedEntry))]
sourceAdmissions MergePlan
plan SourceId
sid Snapshot src
source =
[ (AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry, (Text
version, AdmittedEntry
entry))
| (Text
version, NonEmpty AdmittedEntry
entries) <- Map Text (NonEmpty AdmittedEntry)
-> [(Text, NonEmpty AdmittedEntry)]
forall k a. Map k a -> [(k, a)]
Map.toList (MergePlan -> Map Text (NonEmpty AdmittedEntry)
mpArtifacts MergePlan
plan)
, Text -> Map Text SourceId -> Maybe SourceId
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
version (MergePlan -> Map Text SourceId
mpSurvivors MergePlan
plan) Maybe SourceId -> Maybe SourceId -> Bool
forall a. Eq a => a -> a -> Bool
== SourceId -> Maybe SourceId
forall a. a -> Maybe a
Just SourceId
sid
, AdmittedEntry
entry <- NonEmpty AdmittedEntry -> [AdmittedEntry]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty AdmittedEntry
entries
, AdmittedEntry -> ContentDigest
admittedSnapshot AdmittedEntry
entry ContentDigest -> ContentDigest -> Bool
forall a. Eq a => a -> a -> Bool
== Snapshot src -> ContentDigest
forall a. Snapshot a -> ContentDigest
snapshotDigest Snapshot src
source
]
selectEntries :: [(EntryKey, (Text, AdmittedEntry))] -> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries :: forall entry.
[(EntryKey, (Text, AdmittedEntry))]
-> [(EntryKey, entry)] -> [(Text, entry)]
selectEntries [(EntryKey, (Text, AdmittedEntry))]
admissions [(EntryKey, entry)]
entries = case [(EntryKey, entry)] -> Maybe SourceId
forall entry. [(EntryKey, entry)] -> Maybe SourceId
lastAscending [(EntryKey, entry)]
entries of
Just SourceId
end | SourceId
end SourceId -> SourceId -> Bool
forall a. Ord a => a -> a -> Bool
< SourceId
6 SourceId -> SourceId -> SourceId
forall a. Num a => a -> a -> a
* [(EntryKey, (Text, AdmittedEntry))] -> SourceId
forall a. [a] -> SourceId
forall (t :: * -> *) a. Foldable t => t a -> SourceId
length [(EntryKey, (Text, AdmittedEntry))]
admissions -> Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
forall entry. Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted (SourceId -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots SourceId
end [(EntryKey, (Text, AdmittedEntry))]
admissions) [(EntryKey, entry)]
entries
Just SourceId
_ -> Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed ([(EntryKey, (Text, AdmittedEntry))]
-> Map EntryKey (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, (Text, AdmittedEntry))]
admissions) [(EntryKey, entry)]
entries
Maybe SourceId
Nothing -> Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed ([(EntryKey, (Text, AdmittedEntry))]
-> Map EntryKey (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, (Text, AdmittedEntry))]
admissions) (((EntryKey, entry) -> Bool)
-> [(EntryKey, entry)] -> [(EntryKey, entry)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(EntryKey
key, entry
_) -> EntryKey -> Map EntryKey entry -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member EntryKey
key Map EntryKey entry
unrepeated) [(EntryKey, entry)]
entries)
where
unrepeated :: Map EntryKey entry
unrepeated = [(EntryKey, entry)] -> Map EntryKey entry
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries [(EntryKey, entry)]
entries
lastAscending :: [(EntryKey, entry)] -> Maybe Int
lastAscending :: forall entry. [(EntryKey, entry)] -> Maybe SourceId
lastAscending = SourceId -> [(EntryKey, entry)] -> Maybe SourceId
forall {b}. SourceId -> [(EntryKey, b)] -> Maybe SourceId
go (-SourceId
1)
where
go :: SourceId -> [(EntryKey, b)] -> Maybe SourceId
go !SourceId
previous = \case
(ArrayEntry SourceId
position, b
_) : [(EntryKey, b)]
rest | SourceId
position SourceId -> SourceId -> Bool
forall a. Ord a => a -> a -> Bool
> SourceId
previous -> SourceId -> [(EntryKey, b)] -> Maybe SourceId
go SourceId
position [(EntryKey, b)]
rest
[] -> SourceId -> Maybe SourceId
forall a. a -> Maybe a
Just SourceId
previous
[(EntryKey, b)]
_ -> Maybe SourceId
forall a. Maybe a
Nothing
data Slot = Vacant | Admitted Text AdmittedEntry | Ambiguous
admissionSlots :: Int -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots :: SourceId -> [(EntryKey, (Text, AdmittedEntry))] -> Vector Slot
admissionSlots SourceId
end [(EntryKey, (Text, AdmittedEntry))]
admissions = (forall s. ST s (MVector s Slot)) -> Vector Slot
forall a. (forall s. ST s (MVector s a)) -> Vector a
V.create ((forall s. ST s (MVector s Slot)) -> Vector Slot)
-> (forall s. ST s (MVector s Slot)) -> Vector Slot
forall a b. (a -> b) -> a -> b
$ do
slots <- SourceId -> Slot -> ST s (MVector (PrimState (ST s)) Slot)
forall (m :: * -> *) a.
PrimMonad m =>
SourceId -> a -> m (MVector (PrimState m) a)
MV.replicate (SourceId
end SourceId -> SourceId -> SourceId
forall a. Num a => a -> a -> a
+ SourceId
1) Slot
Vacant
for_ admissions $ \case
(ArrayEntry SourceId
position, (Text
version, AdmittedEntry
kept)) ->
MVector (PrimState (ST s)) Slot -> SourceId -> ST s (Maybe Slot)
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> SourceId -> m (Maybe a)
MV.readMaybe MVector s Slot
MVector (PrimState (ST s)) Slot
slots SourceId
position ST s (Maybe Slot) -> (Maybe Slot -> ST s ()) -> ST s ()
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Slot -> ST s ()) -> Maybe Slot -> ST s ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (\Slot
slot -> MVector (PrimState (ST s)) Slot -> SourceId -> Slot -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> SourceId -> a -> m ()
MV.write MVector s Slot
MVector (PrimState (ST s)) Slot
slots SourceId
position (Slot -> ST s ()) -> Slot -> ST s ()
forall a b. (a -> b) -> a -> b
$! Text -> AdmittedEntry -> Slot -> Slot
occupy Text
version AdmittedEntry
kept Slot
slot)
(EntryKey, (Text, AdmittedEntry))
_ -> ST s ()
forall (f :: * -> *). Applicative f => f ()
pass
pure slots
occupy :: Text -> AdmittedEntry -> Slot -> Slot
occupy :: Text -> AdmittedEntry -> Slot -> Slot
occupy Text
version AdmittedEntry
kept = \case
Slot
Vacant -> Text -> AdmittedEntry -> Slot
Admitted Text
version AdmittedEntry
kept
Slot
_ -> Slot
Ambiguous
slotted :: Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted :: forall entry. Vector Slot -> [(EntryKey, entry)] -> [(Text, entry)]
slotted Vector Slot
slots [(EntryKey, entry)]
entries =
[ (Text
version, entry
entry)
| (ArrayEntry SourceId
position, entry
entry) <- [(EntryKey, entry)]
entries
, Just (Admitted Text
version AdmittedEntry
kept) <- [Vector Slot
slots Vector Slot -> SourceId -> Maybe Slot
forall a. Vector a -> SourceId -> Maybe a
V.!? SourceId
position]
, AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
]
keyed :: Map EntryKey (Text, AdmittedEntry) -> [(EntryKey, entry)] -> [(Text, entry)]
keyed :: forall entry.
Map EntryKey (Text, AdmittedEntry)
-> [(EntryKey, entry)] -> [(Text, entry)]
keyed Map EntryKey (Text, AdmittedEntry)
admitted [(EntryKey, entry)]
entries =
[ (Text
version, entry
entry)
| (EntryKey
key, entry
entry) <- [(EntryKey, entry)]
entries
, Just (Text
version, AdmittedEntry
kept) <- [EntryKey
-> Map EntryKey (Text, AdmittedEntry)
-> Maybe (Text, AdmittedEntry)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup EntryKey
key Map EntryKey (Text, AdmittedEntry)
admitted]
, AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
]
overlayObjectSurvivors :: (src -> KeyMap entry) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlayObjectSurvivors :: forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlayObjectSurvivors src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan = [(Text
version, entry
entry) | (Text
version, SourceId
_, entry
entry) <- (src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
overlayObjectSources src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan]
overlayObjectSources :: (src -> KeyMap entry) -> Map SourceId (Snapshot src) -> MergePlan -> [(Text, SourceId, entry)]
overlayObjectSources :: forall src entry.
(src -> KeyMap entry)
-> Map SourceId (Snapshot src)
-> MergePlan
-> [(Text, SourceId, entry)]
overlayObjectSources src -> KeyMap entry
entriesOf Map SourceId (Snapshot src)
bySource MergePlan
plan =
[ (Text
version, SourceId
sid, entry
entry)
| ((SourceId
sid, ContentDigest
digest, ObjectEntry Text
key), (Text
version, AdmittedEntry
kept)) <- Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
-> [((SourceId, ContentDigest, EntryKey), (Text, AdmittedEntry))]
forall k a. Map k a -> [(k, a)]
Map.toAscList (MergePlan
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex MergePlan
plan)
, AdmittedEntry -> Bool
usableEntry AdmittedEntry
kept
, Just Snapshot src
source <- [SourceId -> Map SourceId (Snapshot src) -> Maybe (Snapshot src)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup SourceId
sid Map SourceId (Snapshot src)
bySource]
, Snapshot src -> ContentDigest
forall a. Snapshot a -> ContentDigest
snapshotDigest Snapshot src
source ContentDigest -> ContentDigest -> Bool
forall a. Eq a => a -> a -> Bool
== ContentDigest
digest
, Just entry
entry <- [Key -> KeyMap entry -> Maybe entry
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup (Text -> Key
Key.fromText Text
key) (src -> KeyMap entry
entriesOf (Snapshot src -> src
forall a. Snapshot a -> a
snapshotValue Snapshot src
source))]
]
admittedIndex :: MergePlan -> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex :: MergePlan
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
admittedIndex MergePlan
plan =
[((SourceId, ContentDigest, EntryKey), (Text, AdmittedEntry))]
-> Map (SourceId, ContentDigest, EntryKey) (Text, AdmittedEntry)
forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries
[ ((SourceId
sid, AdmittedEntry -> ContentDigest
admittedSnapshot AdmittedEntry
entry, AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry), (Text
version, AdmittedEntry
entry))
| (Text
version, NonEmpty AdmittedEntry
entries) <- Map Text (NonEmpty AdmittedEntry)
-> [(Text, NonEmpty AdmittedEntry)]
forall k a. Map k a -> [(k, a)]
Map.toList (MergePlan -> Map Text (NonEmpty AdmittedEntry)
mpArtifacts MergePlan
plan)
, Just SourceId
sid <- [Text -> Map Text SourceId -> Maybe SourceId
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
version (MergePlan -> Map Text SourceId
mpSurvivors MergePlan
plan)]
, AdmittedEntry
entry <- NonEmpty AdmittedEntry -> [AdmittedEntry]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty AdmittedEntry
entries
]
usableEntry :: AdmittedEntry -> Bool
usableEntry :: AdmittedEntry -> Bool
usableEntry AdmittedEntry
entry = EntryKey -> Bool
validEntryKey (AdmittedEntry -> EntryKey
admittedKey AdmittedEntry
entry) Bool -> Bool -> Bool
&& Bool -> Bool
not (Text -> Bool
T.null (AdmittedEntry -> Text
admittedFilename AdmittedEntry
entry))
uniqueEntries :: (Ord key) => [(key, value)] -> Map key value
uniqueEntries :: forall key value. Ord key => [(key, value)] -> Map key value
uniqueEntries = (Maybe value -> Maybe value)
-> Map key (Maybe value) -> Map key value
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe Maybe value -> Maybe value
forall a. a -> a
id (Map key (Maybe value) -> Map key value)
-> ([(key, value)] -> Map key (Maybe value))
-> [(key, value)]
-> Map key value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe value -> Maybe value -> Maybe value)
-> [(key, Maybe value)] -> Map key (Maybe value)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith (\Maybe value
_ Maybe value
_ -> Maybe value
forall a. Maybe a
Nothing) ([(key, Maybe value)] -> Map key (Maybe value))
-> ([(key, value)] -> [(key, Maybe value)])
-> [(key, value)]
-> Map key (Maybe value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((key, value) -> (key, Maybe value))
-> [(key, value)] -> [(key, Maybe value)]
forall a b. (a -> b) -> [a] -> [b]
map ((value -> Maybe value) -> (key, value) -> (key, Maybe value)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second value -> Maybe value
forall a. a -> Maybe a
Just)
safeDocumentName :: (Text -> Maybe a) -> KeyMap Value -> Maybe a
safeDocumentName :: forall a. (Text -> Maybe a) -> KeyMap Value -> Maybe a
safeDocumentName Text -> Maybe a
parse KeyMap Value
document = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
"name" KeyMap Value
document of
Just (String Text
name) -> Text -> Maybe a
parse Text
name
Maybe Value
_ -> Maybe a
forall a. Maybe a
Nothing
rebaseArtifactUrl :: (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl :: (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl Text -> Maybe Text
renderMountUrl Text
url = do
filename <- Text -> Maybe Text
urlFilename Text
url
guard (trimmed == url || isJust (urlFilename trimmed))
renderMountUrl filename
where
trimmed :: Text
trimmed = Text -> Text
T.strip Text
url
artifactUrlPacked :: Maybe Text -> Packed -> Packed
artifactUrlPacked :: Maybe Text -> Packed -> Packed
artifactUrlPacked Maybe Text
url Packed
packed
| Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Text
url Maybe Text -> (Text -> Maybe Text) -> Maybe Text
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Text -> Maybe Text) -> Text -> Maybe Text
rebaseArtifactUrl Text -> Maybe Text
forall a. a -> Maybe a
Just) = Packed
packed
| Bool
otherwise = Packed -> Packed
withoutHole Packed
packed
documentObject :: Value -> KeyMap Value
documentObject :: Value -> KeyMap Value
documentObject = \case
Object KeyMap Value
o -> KeyMap Value
o
Value
_ -> KeyMap Value
forall a. Monoid a => a
mempty
stringField :: Key.Key -> KeyMap Value -> Maybe Text
stringField :: Key -> KeyMap Value -> Maybe Text
stringField Key
key KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
Just (String Text
s) -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
s
Maybe Value
_ -> Maybe Text
forall a. Maybe a
Nothing
objectField :: Key.Key -> KeyMap Value -> Maybe (KeyMap Value)
objectField :: Key -> KeyMap Value -> Maybe (KeyMap Value)
objectField Key
key KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
Just (Object KeyMap Value
inner) -> KeyMap Value -> Maybe (KeyMap Value)
forall a. a -> Maybe a
Just KeyMap Value
inner
Maybe Value
_ -> Maybe (KeyMap Value)
forall a. Maybe a
Nothing
adjustField :: Key.Key -> (Value -> Value) -> KeyMap Value -> KeyMap Value
adjustField :: Key -> (Value -> Value) -> KeyMap Value -> KeyMap Value
adjustField Key
key Value -> Value
edit KeyMap Value
o = case Key -> KeyMap Value -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key KeyMap Value
o of
Just Value
v -> Key -> Value -> KeyMap Value -> KeyMap Value
forall v. Key -> v -> KeyMap v -> KeyMap v
KeyMap.insert Key
key (Value -> Value
edit Value
v) KeyMap Value
o
Maybe Value
Nothing -> KeyMap Value
o