Activate selected overlay collection policies
This commit is contained in:
@@ -52,8 +52,194 @@ func (a *assemblyAccumulator) applyOverlay(overlay *document.Node, incomingOrigi
|
||||
return nil
|
||||
}
|
||||
|
||||
// applyOverlayWithCollectionPolicy is the shared recursive-precedence entry for
|
||||
// overlays. The caller supplies only the policy and declarations owned by this
|
||||
// contribution; layered loading can use the same operation when its lifecycle
|
||||
// reaches this boundary.
|
||||
func (a *assemblyAccumulator) applyOverlayWithCollectionPolicy(
|
||||
overlay *document.Node,
|
||||
incomingOrigins map[string]Origin,
|
||||
applications []historyApplication,
|
||||
layer Layer,
|
||||
sequencePolicy sequencePolicy,
|
||||
declarations []sequenceDeclarationSpec,
|
||||
) []Diagnostic {
|
||||
if a == nil || a.current == nil || a.current.root == nil || a.current.root.Kind != document.Mapping || overlay == nil || overlay.Kind != document.Mapping {
|
||||
return invalidOverlayDocument()
|
||||
}
|
||||
mergeOriginContribution(a.current.origins, Path{}, incomingOrigin(incomingOrigins, Path{}, overlay, layer))
|
||||
sequences, diagnostics := mergeOverlayMappingsWithCollectionPolicy(a, overlay, incomingOrigins, layer, sequencePolicy, declarations)
|
||||
if len(diagnostics) != 0 {
|
||||
return diagnostics
|
||||
}
|
||||
if len(applications) == 0 {
|
||||
application := historyApplication{layer: layer, value: overlay, sequences: sequences}
|
||||
application.sequencesByPath = indexSequenceHistoryContributions(application.sequences)
|
||||
a.current.applications = append(a.current.applications, application)
|
||||
} else {
|
||||
for _, application := range applications {
|
||||
application.layer = layer
|
||||
a.current.applications = append(a.current.applications, application)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func mergeOverlayMappingsWithCollectionPolicy(
|
||||
assembly *assemblyAccumulator,
|
||||
overlay *document.Node,
|
||||
incomingOrigins map[string]Origin,
|
||||
layer Layer,
|
||||
sequencePolicy sequencePolicy,
|
||||
declarations []sequenceDeclarationSpec,
|
||||
) ([]sequenceHistoryContribution, []Diagnostic) {
|
||||
result := assembly.current
|
||||
claims := compositionClaims{byPath: make(map[string][]compositionClaim)}
|
||||
claims.append(overlay, Path{}, 0)
|
||||
identityFieldsByPath, resolvedPolicies, diagnostics := resolveStrictCollectionPolicies(
|
||||
claims.ordered, sequencePolicy, result.collectionPolicies, declarations,
|
||||
)
|
||||
if len(diagnostics) != 0 {
|
||||
return nil, diagnostics
|
||||
}
|
||||
declarationsByPath := make(map[string][]sequenceDeclarationSpec, len(declarations))
|
||||
registeredPaths := make(map[string]Path)
|
||||
for _, declaration := range declarations {
|
||||
key := declaration.destination.String()
|
||||
declarationsByPath[key] = append(declarationsByPath[key], declaration)
|
||||
registeredPaths[key] = declaration.destination.clone()
|
||||
}
|
||||
registered := make(map[string]bool)
|
||||
for _, claim := range claims.ordered {
|
||||
if claim.kind == document.Sequence {
|
||||
if _, ok := sequencePolicy.identityFieldsAt(claim.path); ok {
|
||||
registered[claim.path.String()] = true
|
||||
registeredPaths[claim.path.String()] = claim.path.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
for key := range declarationsByPath {
|
||||
registered[key] = true
|
||||
}
|
||||
for key := range result.collectionPolicies.collections {
|
||||
if node, found := documentAtPath(overlay, result.collectionPolicies.collections[key].destination); found && node != nil {
|
||||
registered[key] = true
|
||||
registeredPaths[key] = result.collectionPolicies.collections[key].destination.clone()
|
||||
}
|
||||
}
|
||||
|
||||
resolutions := make(map[string]collectionPolicyResolution, len(registered))
|
||||
for key := range registered {
|
||||
path := registeredPaths[key]
|
||||
policy, hasPolicy := resolvedPolicies.at(path)
|
||||
if !hasPolicy {
|
||||
continue
|
||||
}
|
||||
operation := sequenceModeReplace
|
||||
if policy.explicitModePresent {
|
||||
operation = policy.explicitMode
|
||||
} else if len(identityFieldsByPath[key]) != 0 {
|
||||
operation = sequenceModeUpsert
|
||||
}
|
||||
resolutions[key] = collectionPolicyResolution{
|
||||
policy: policy, operation: operation,
|
||||
effectiveIdentityFields: cloneStrings(identityFieldsByPath[key]),
|
||||
}
|
||||
}
|
||||
|
||||
sequenceApplications := make(map[string]sequenceHistoryContribution)
|
||||
policyValues := make(map[string]bool)
|
||||
var combinationDiagnostics []Diagnostic
|
||||
mergeOverlayMappingsWithHooks(result.root, overlay, Path{}, &assembly.index,
|
||||
recursiveMergeHooks{
|
||||
added: func(path Path, incoming *document.Node) {
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, incoming, path, layer)
|
||||
},
|
||||
combined: func(path Path, incoming *document.Node) {
|
||||
mergeOriginContribution(result.origins, path, incomingOrigin(incomingOrigins, path, incoming, layer))
|
||||
},
|
||||
replaced: func(path Path, existing, incoming *document.Node) {
|
||||
assembly.current.collectionPolicies.retireCollectionPoliciesAtOrBelow(path)
|
||||
recordOverlayReplacement(result, path, existing, incoming, layer, true, incomingOrigins)
|
||||
},
|
||||
merge: func(path Path, existing, incoming *document.Node) (*document.Node, bool) {
|
||||
resolution, active := resolutions[path.String()]
|
||||
if !active {
|
||||
return nil, false
|
||||
}
|
||||
combined, issues := combineSequence(existing, incoming, resolution, sequenceCombinationContext{destination: path})
|
||||
if len(issues) != 0 {
|
||||
combinationDiagnostics = append(combinationDiagnostics, issues...)
|
||||
return existing, false
|
||||
}
|
||||
applyOverlaySequenceEvidence(result, path, existing, incoming, combined, resolution, incomingOrigins, layer)
|
||||
policyValues[path.String()] = true
|
||||
history := sequenceHistoryContribution{path: path.clone(), mode: sequenceHistoryMapped}
|
||||
if resolution.operation == sequenceModeReplace {
|
||||
history.mode = sequenceHistoryReplace
|
||||
if incoming != nil && incoming.Kind == document.Sequence {
|
||||
history.length = len(incoming.Sequence)
|
||||
}
|
||||
} else {
|
||||
history.items = append([]sequenceItemProjection(nil), combined.higherItems...)
|
||||
history.replacements = append([]sequenceItemReplacement(nil), combined.replacements...)
|
||||
}
|
||||
sequenceApplications[path.String()] = history
|
||||
return combined.value, true
|
||||
},
|
||||
},
|
||||
)
|
||||
if len(combinationDiagnostics) != 0 {
|
||||
return nil, canonicalDiagnostics(combinationDiagnostics)
|
||||
}
|
||||
|
||||
for key, grouped := range declarationsByPath {
|
||||
if policyValues[key] {
|
||||
continue
|
||||
}
|
||||
path := grouped[0].destination
|
||||
applicationIdentity, _ := sequencePolicy.identityFieldsAt(path)
|
||||
current, diagnostics := resolveCollectionPolicy(path, grouped, applicationIdentity, nil)
|
||||
if len(diagnostics) != 0 {
|
||||
combinationDiagnostics = append(combinationDiagnostics, diagnostics...)
|
||||
continue
|
||||
}
|
||||
lower, found := assembly.current.collectionPolicies.at(path)
|
||||
var lowerPolicy *collectionPolicy
|
||||
if found {
|
||||
lowerPolicy = &lower
|
||||
}
|
||||
retained, _ := documentAtPath(assembly.current.root, path)
|
||||
if retained != nil && retained.Kind == document.Sequence && len(current.effectiveIdentityFields) != 0 {
|
||||
if _, issues := validateSequenceIdentity(retained, path, current.effectiveIdentityFields, sequenceIdentityDiagnosticCodes{invalid: CodeSequenceInvalid, conflict: CodeSequenceConflict}); len(issues) != 0 {
|
||||
combinationDiagnostics = append(combinationDiagnostics, issues...)
|
||||
continue
|
||||
}
|
||||
}
|
||||
policy, issues := collectionPolicyWithoutValue(lowerPolicy, current.policy, retained, path)
|
||||
if len(issues) != 0 {
|
||||
combinationDiagnostics = append(combinationDiagnostics, issues...)
|
||||
continue
|
||||
}
|
||||
assembly.current.collectionPolicies.set(path, policy)
|
||||
}
|
||||
if len(combinationDiagnostics) != 0 {
|
||||
return nil, canonicalDiagnostics(combinationDiagnostics)
|
||||
}
|
||||
keys := make([]string, 0, len(sequenceApplications))
|
||||
for key := range sequenceApplications {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
slices.Sort(keys)
|
||||
sequences := make([]sequenceHistoryContribution, 0, len(keys))
|
||||
for _, key := range keys {
|
||||
sequences = append(sequences, sequenceApplications[key])
|
||||
}
|
||||
return sequences, nil
|
||||
}
|
||||
|
||||
func mergeOverlayMappings(result *composedDocument, target, overlay *document.Node, current Path, layer Layer, recordReplacements bool, incomingOrigins map[string]Origin, index *mappingIndex) {
|
||||
mergeRecursiveMappings(target, overlay, current, index, recursiveMergeHooks{
|
||||
mergeOverlayMappingsWithHooks(target, overlay, current, index, recursiveMergeHooks{
|
||||
added: func(path Path, incoming *document.Node) {
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, incoming, path, layer)
|
||||
},
|
||||
@@ -78,6 +264,147 @@ func mergeOverlayMappings(result *composedDocument, target, overlay *document.No
|
||||
})
|
||||
}
|
||||
|
||||
func mergeOverlayMappingsWithHooks(
|
||||
target, overlay *document.Node,
|
||||
current Path,
|
||||
index *mappingIndex,
|
||||
hooks recursiveMergeHooks,
|
||||
) {
|
||||
mergeRecursiveMappings(target, overlay, current, index, hooks)
|
||||
}
|
||||
|
||||
func recordOverlayReplacement(
|
||||
result *composedDocument,
|
||||
path Path,
|
||||
existing, incoming *document.Node,
|
||||
layer Layer,
|
||||
recordReplacement bool,
|
||||
incomingOrigins map[string]Origin,
|
||||
) {
|
||||
var displaced []displacedDefinition
|
||||
var previous Origin
|
||||
if existing != nil {
|
||||
displaced = displacedOrigins(existing, result.origins, path)
|
||||
previous = cloneOrigin(result.origins[path.String()])
|
||||
deleteOriginSubtree(result.origins, path, existing)
|
||||
}
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, incoming, path, layer)
|
||||
if recordReplacement && existing != nil {
|
||||
result.overlays = append(result.overlays, overlayRecord{
|
||||
change: Change{
|
||||
Path: path.clone(), Origin: incomingOrigin(incomingOrigins, path, incoming, layer),
|
||||
Previous: previousOrigins(previous),
|
||||
},
|
||||
displaced: displaced,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func applyOverlaySequenceEvidence(
|
||||
result *composedDocument,
|
||||
path Path,
|
||||
lower, higher *document.Node,
|
||||
combined sequenceCombinationResult,
|
||||
resolution collectionPolicyResolution,
|
||||
incomingOrigins map[string]Origin,
|
||||
layer Layer,
|
||||
) {
|
||||
lowerPolicy, hadLowerPolicy := result.collectionPolicies.at(path)
|
||||
if resolution.operation == sequenceModeReplace {
|
||||
var lowerValue *collectionPolicy
|
||||
if hadLowerPolicy {
|
||||
lowerValue = &lowerPolicy
|
||||
}
|
||||
result.collectionPolicies.retireCollectionPoliciesAtOrBelow(path)
|
||||
resolution.policy = collectionPolicyForReplacement(lowerValue, resolution.policy)
|
||||
}
|
||||
|
||||
if combined.value == nil || combined.value.Kind != document.Sequence {
|
||||
recordOverlayReplacement(result, path, lower, higher, layer, true, incomingOrigins)
|
||||
result.collectionPolicies.set(path, resolution.policy)
|
||||
return
|
||||
}
|
||||
|
||||
if resolution.operation == sequenceModeReplace {
|
||||
var displaced []displacedDefinition
|
||||
var previous Origin
|
||||
if lower != nil {
|
||||
displaced = displacedOrigins(lower, result.origins, path)
|
||||
previous = cloneOrigin(result.origins[path.String()])
|
||||
deleteOriginSubtree(result.origins, path, lower)
|
||||
}
|
||||
mergeOriginContribution(result.origins, path, incomingOrigin(incomingOrigins, path, higher, layer))
|
||||
for _, projection := range combined.higherItems {
|
||||
if higher != nil && higher.Kind == document.Sequence && projection.inputIndex >= 0 && projection.inputIndex < len(higher.Sequence) {
|
||||
source := higher.Sequence[projection.inputIndex]
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, source, path.Index(projection.outputIndex), layer)
|
||||
}
|
||||
}
|
||||
if lower != nil {
|
||||
result.overlays = append(result.overlays, overlayRecord{
|
||||
change: Change{
|
||||
Path: path.clone(), Origin: incomingOrigin(incomingOrigins, path, higher, layer),
|
||||
Previous: previousOrigins(previous),
|
||||
}, displaced: displaced,
|
||||
})
|
||||
}
|
||||
} else {
|
||||
mergeOriginContribution(result.origins, path, incomingOrigin(incomingOrigins, path, higher, layer))
|
||||
for _, replacement := range combined.replacements {
|
||||
lowerPath := path.Index(replacement.lowerIndex)
|
||||
higherPath := path.Index(replacement.higherIndex)
|
||||
outputPath := path.Index(replacement.outputIndex)
|
||||
if lower == nil || lower.Kind != document.Sequence || replacement.lowerIndex < 0 || replacement.lowerIndex >= len(lower.Sequence) ||
|
||||
higher == nil || higher.Kind != document.Sequence || replacement.higherIndex < 0 || replacement.higherIndex >= len(higher.Sequence) {
|
||||
continue
|
||||
}
|
||||
lowerItem := lower.Sequence[replacement.lowerIndex]
|
||||
higherItem := higher.Sequence[replacement.higherIndex]
|
||||
displaced := displacedOrigins(lowerItem, result.origins, lowerPath)
|
||||
previous := cloneOrigin(result.origins[lowerPath.String()])
|
||||
deleteOriginSubtree(result.origins, lowerPath, lowerItem)
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, higherItem, outputPath, layer)
|
||||
result.overlays = append(result.overlays, overlayRecord{
|
||||
change: Change{
|
||||
Path: outputPath.clone(), Origin: incomingOrigin(incomingOrigins, higherPath, higherItem, layer),
|
||||
Previous: previousOrigins(previous),
|
||||
},
|
||||
displaced: displaced,
|
||||
})
|
||||
}
|
||||
for _, projection := range combined.higherItems {
|
||||
if higher != nil && higher.Kind == document.Sequence && projection.inputIndex >= 0 && projection.inputIndex < len(higher.Sequence) {
|
||||
higherItem := higher.Sequence[projection.inputIndex]
|
||||
collectOverlayOriginsFrom(result.origins, incomingOrigins, higherItem, path.Index(projection.outputIndex), layer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
policy := cloneCollectionPolicy(resolution.policy)
|
||||
policy.recordOrder = nil
|
||||
policy.recordPolicies = nil
|
||||
if hadLowerPolicy && resolution.operation != sequenceModeReplace {
|
||||
lowerProjection := newSequenceItemProjectionIndex(combined.lowerItems)
|
||||
higherProjection := newSequenceItemProjectionIndex(combined.higherItems)
|
||||
for outputIndex := range combined.value.Sequence {
|
||||
if _, replaced := higherProjection.inputForOutput(outputIndex); replaced {
|
||||
policy.setRecordPolicyAt(outputIndex, replacedCollectionRecordPolicy())
|
||||
continue
|
||||
}
|
||||
if lowerIndex, retained := lowerProjection.inputForOutput(outputIndex); retained {
|
||||
if record, found := lowerPolicy.recordPolicyAt(lowerIndex); found {
|
||||
policy.setRecordPolicyAt(outputIndex, retainedCollectionRecordPolicy(record))
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for outputIndex := range combined.value.Sequence {
|
||||
policy.setRecordPolicyAt(outputIndex, replacedCollectionRecordPolicy())
|
||||
}
|
||||
}
|
||||
result.collectionPolicies.set(path, policy)
|
||||
}
|
||||
|
||||
func collectOverlayOrigins(origins map[string]Origin, node *document.Node, path Path, layer Layer) {
|
||||
collectOverlayOriginsFrom(origins, nil, node, path, layer)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user