module Ecluse.Core.Registry.Cargo.Serving (
assembleCargoDocument,
serialiseCargoDocument,
) where
import Data.Map.Strict qualified as Map
import Data.Primitive.SmallArray (smallArrayFromList)
import Ecluse.Core.Package.Merge (MergePlan, SourceId)
import Ecluse.Core.Registry.CachedDocument (CachedDoc, cargoCached, cargoPacked, cargoRendered)
import Ecluse.Core.Registry.Cargo.Document (PackedIndex (..), packCargoDocument, packedIndexPlan)
import Ecluse.Core.Registry.Json.Packed (LinePlan (..), Piece (..), renderPackedLines)
import Ecluse.Core.Registry.ServedDocument (RenderRefused (RenderRefused), overlaySurvivors)
import Ecluse.Core.Snapshot (Snapshot, snapshotValue)
import Ecluse.Core.Strict (strictElements)
assembleCargoDocument :: Text -> Map SourceId (Snapshot CachedDoc) -> MergePlan -> Maybe CachedDoc -> CachedDoc
assembleCargoDocument :: Text
-> Map SourceId (Snapshot CachedDoc)
-> MergePlan
-> Maybe CachedDoc
-> CachedDoc
assembleCargoDocument Text
_ Map SourceId (Snapshot CachedDoc)
bySource MergePlan
plan Maybe CachedDoc
_ =
(LinePlan -> CachedDoc, CachedDoc -> Maybe LinePlan)
-> LinePlan -> CachedDoc
forall a b. (a, b) -> a
fst
(LinePlan -> CachedDoc, CachedDoc -> Maybe LinePlan)
cargoRendered
LinePlan
{ lineTables :: SmallArray DocTable
lineTables = [DocTable] -> SmallArray DocTable
forall a. [a] -> SmallArray a
smallArrayFromList [PackedIndex -> DocTable
indexTable (Snapshot PackedIndex -> PackedIndex
forall a. Snapshot a -> a
snapshotValue Snapshot PackedIndex
source) | Snapshot PackedIndex
source <- Map SourceId (Snapshot PackedIndex) -> [Snapshot PackedIndex]
forall k a. Map k a -> [a]
Map.elems Map SourceId (Snapshot PackedIndex)
packed]
, linePieces :: [Piece]
linePieces = [Piece] -> [Piece]
forall (t :: * -> *) a. Foldable t => t a -> t a
strictElements [Piece
piece | (Text
_, Piece
piece) <- ((SourceId, PackedIndex) -> [(EntryKey, Piece)])
-> Map SourceId (Snapshot (SourceId, PackedIndex))
-> MergePlan
-> [(Text, Piece)]
forall src entry.
(src -> [(EntryKey, entry)])
-> Map SourceId (Snapshot src) -> MergePlan -> [(Text, entry)]
overlaySurvivors (SourceId, PackedIndex) -> [(EntryKey, Piece)]
entriesOf Map SourceId (Snapshot (SourceId, PackedIndex))
indexed MergePlan
plan]
}
where
packed :: Map SourceId (Snapshot PackedIndex)
packed = (Snapshot CachedDoc -> Maybe (Snapshot PackedIndex))
-> Map SourceId (Snapshot CachedDoc)
-> Map SourceId (Snapshot PackedIndex)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe ((CachedDoc -> Maybe PackedIndex)
-> Snapshot CachedDoc -> Maybe (Snapshot PackedIndex)
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 PackedIndex
asPacked) Map SourceId (Snapshot CachedDoc)
bySource
asPacked :: CachedDoc -> Maybe PackedIndex
asPacked CachedDoc
document = (PackedIndex -> CachedDoc, CachedDoc -> Maybe PackedIndex)
-> CachedDoc -> Maybe PackedIndex
forall a b. (a, b) -> b
snd (PackedIndex -> CachedDoc, CachedDoc -> Maybe PackedIndex)
cargoPacked CachedDoc
document Maybe PackedIndex -> Maybe PackedIndex -> Maybe PackedIndex
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (CargoDocument -> PackedIndex
packCargoDocument (CargoDocument -> PackedIndex)
-> Maybe CargoDocument -> Maybe PackedIndex
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CargoDocument -> CachedDoc, CachedDoc -> Maybe CargoDocument)
-> CachedDoc -> Maybe CargoDocument
forall a b. (a, b) -> b
snd (CargoDocument -> CachedDoc, CachedDoc -> Maybe CargoDocument)
cargoCached CachedDoc
document)
indexed :: Map SourceId (Snapshot (SourceId, PackedIndex))
indexed = [(SourceId, Snapshot (SourceId, PackedIndex))]
-> Map SourceId (Snapshot (SourceId, PackedIndex))
forall k a. [(k, a)] -> Map k a
Map.fromDistinctAscList ((SourceId
-> (SourceId, Snapshot PackedIndex)
-> (SourceId, Snapshot (SourceId, PackedIndex)))
-> [SourceId]
-> [(SourceId, Snapshot PackedIndex)]
-> [(SourceId, Snapshot (SourceId, PackedIndex))]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\SourceId
index (SourceId
sid, Snapshot PackedIndex
source) -> (SourceId
sid, (SourceId
index,) (PackedIndex -> (SourceId, PackedIndex))
-> Snapshot PackedIndex -> Snapshot (SourceId, PackedIndex)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Snapshot PackedIndex
source)) [SourceId
0 ..] (Map SourceId (Snapshot PackedIndex)
-> [(SourceId, Snapshot PackedIndex)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map SourceId (Snapshot PackedIndex)
packed))
entriesOf :: (SourceId, PackedIndex) -> [(EntryKey, Piece)]
entriesOf (SourceId
index, PackedIndex
source) = [(EntryKey
key, SourceId -> Packed -> Piece
Piece SourceId
index Packed
record) | (EntryKey
key, Packed
record) <- PackedIndex -> [(EntryKey, Packed)]
indexRecords PackedIndex
source]
serialiseCargoDocument :: CachedDoc -> Either RenderRefused LByteString
serialiseCargoDocument :: CachedDoc -> Either RenderRefused LByteString
serialiseCargoDocument CachedDoc
document = do
plan <- RenderRefused -> Maybe LinePlan -> Either RenderRefused LinePlan
forall l r. l -> Maybe r -> Either l r
maybeToRight RenderRefused
RenderRefused ((LinePlan -> CachedDoc, CachedDoc -> Maybe LinePlan)
-> CachedDoc -> Maybe LinePlan
forall a b. (a, b) -> b
snd (LinePlan -> CachedDoc, CachedDoc -> Maybe LinePlan)
cargoRendered CachedDoc
document Maybe LinePlan -> Maybe LinePlan -> Maybe LinePlan
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PackedIndex -> LinePlan
packedIndexPlan (PackedIndex -> LinePlan) -> Maybe PackedIndex -> Maybe LinePlan
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PackedIndex -> CachedDoc, CachedDoc -> Maybe PackedIndex)
-> CachedDoc -> Maybe PackedIndex
forall a b. (a, b) -> b
snd (PackedIndex -> CachedDoc, CachedDoc -> Maybe PackedIndex)
cargoPacked CachedDoc
document) Maybe LinePlan -> Maybe LinePlan -> Maybe LinePlan
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PackedIndex -> LinePlan
packedIndexPlan (PackedIndex -> LinePlan)
-> (CargoDocument -> PackedIndex) -> CargoDocument -> LinePlan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CargoDocument -> PackedIndex
packCargoDocument (CargoDocument -> LinePlan)
-> Maybe CargoDocument -> Maybe LinePlan
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CargoDocument -> CachedDoc, CachedDoc -> Maybe CargoDocument)
-> CachedDoc -> Maybe CargoDocument
forall a b. (a, b) -> b
snd (CargoDocument -> CachedDoc, CachedDoc -> Maybe CargoDocument)
cargoCached CachedDoc
document))
maybeToRight RenderRefused (fromStrict <$> renderPackedLines plan)