🥮 mooncakes.io

    Noverberrain/configscope/core does not have a README file

    ConfigAuditIssue

    source
    pub struct ConfigAuditIssue {
      path : ConfigPath
      kind : ConfigAuditIssueKind
      expected_kind : ConfigValueKind?
      actual_kind : ConfigValueKind?
    } derive(Eq, 
    Debug    )

    A single issue found while auditing a configuration value.

    ConfigAuditIssue::actual_kind

    source

    Return the actual value kind for a type mismatch.

    Other issue categories return None.

    ConfigAuditIssue::equal

    source

    ConfigAuditIssue::expected_kind

    source
    fn ConfigAuditIssue::expected_kind(self : ConfigAuditIssue) -> ConfigValueKind?

    Return the expected value kind for a type mismatch.

    Other issue categories return None.

    ConfigAuditIssue::kind

    source

    Return the category of this audit issue.

    ConfigAuditIssue::message

    source
    fn ConfigAuditIssue::message(self : ConfigAuditIssue) -> String

    Render a concise human-readable diagnostic for this audit issue.

    ConfigAuditIssue::not_equal

    source
    fn ConfigAuditIssue::not_equal(x : ConfigAuditIssue, y : ConfigAuditIssue) -> Bool

    ConfigAuditIssue::path

    source

    Return the path associated with this audit issue.

    ConfigAuditIssue::to_repr

    source

    ConfigAuditIssueKind

    source
    pub(all) enum ConfigAuditIssueKind {
      MissingRequired
      TypeMismatch
    } derive(Eq, 
    Debug    )

    Describes why a configuration audit reported an issue.

    ConfigAuditIssueKind::equal

    source

    ConfigAuditIssueKind::not_equal

    source

    ConfigAuditIssueKind::to_repr

    source

    ConfigAuditIssueKind::to_string

    source
    fn ConfigAuditIssueKind::to_string(self : ConfigAuditIssueKind) -> String

    Return a stable lowercase name for this audit issue category.

    ConfigAuditRule

    source
    pub(all) enum ConfigAuditRule {
      Required(ConfigPath)
      TypeIs(ConfigPath, ConfigValueKind)
    } derive(Eq, 
    Debug    )

    A validation rule applied to a configuration value.

    Rules can require a path to exist or require an existing value to have a particular JSON-compatible kind.

    ConfigAuditRule::equal

    source

    ConfigAuditRule::not_equal

    source
    fn ConfigAuditRule::not_equal(x : ConfigAuditRule, y : ConfigAuditRule) -> Bool

    ConfigAuditRule::path

    source

    Return the path inspected by this rule.

    ConfigAuditRule::required

    source

    Create a rule that requires one configuration path to be present.

    ConfigAuditRule::to_repr

    source

    ConfigAuditRule::type_is

    source
    fn ConfigAuditRule::type_is(path : ConfigPath, expected_kind : ConfigValueKind) -> ConfigAuditRule

    Create a rule that requires an existing value to have a particular kind.

    ConfigCompatibilityBaseline

    source
    pub struct ConfigCompatibilityBaseline {
      name : String
      value : ConfigValue
    } derive(Eq, 
    Debug    )

    A named historical configuration snapshot used as a compatibility baseline.

    ConfigCompatibilityBaseline::equal

    source

    ConfigCompatibilityBaseline::name

    source

    Return the name associated with this baseline snapshot.

    ConfigCompatibilityBaseline::new

    source

    Create a named compatibility baseline.

    ConfigCompatibilityBaseline::not_equal

    source

    ConfigCompatibilityBaseline::to_repr

    source

    ConfigCompatibilityChange

    source
    pub struct ConfigCompatibilityChange {
      difference : ConfigDiff
      impact : ConfigCompatibilityImpact
    } derive(Eq, 
    Debug    )

    A configuration difference together with its compatibility impact.

    ConfigCompatibilityChange::after

    source

    Return the later value, or None when the path was removed.

    ConfigCompatibilityChange::before

    source

    Return the earlier value, or None when the path was added.

    ConfigCompatibilityChange::difference_kind

    source

    Return the original difference category.

    ConfigCompatibilityChange::equal

    source

    ConfigCompatibilityChange::impact

    source

    Return the compatibility impact assigned to this change.

    ConfigCompatibilityChange::message

    source

    Render a concise description of the change.

    ConfigCompatibilityChange::not_equal

    source

    ConfigCompatibilityChange::path

    source

    Return the path affected by this compatibility change.

    ConfigCompatibilityChange::to_repr

    source

    ConfigCompatibilityContract

    source
    pub struct ConfigCompatibilityContract {
      candidate_path : String
      baseline_paths : Array[String]
      policy : ConfigCompatibilityPolicy
      ignored_paths : Array[ConfigPath]
      consumer_paths : Array[String]
    } derive(Eq, 
    Debug    )

    A versioned compatibility check described by a JSON manifest.

    The manifest contains one candidate snapshot, at least one historical baseline snapshot, and an optional release gate. Paths are kept as supplied so callers can resolve them relative to the manifest file.

    ConfigCompatibilityContract::baseline_paths

    source
    fn ConfigCompatibilityContract::baseline_paths(self : ConfigCompatibilityContract) -> Array[String]

    Return baseline snapshot paths in manifest order.

    ConfigCompatibilityContract::candidate_path

    source
    fn ConfigCompatibilityContract::candidate_path(self : ConfigCompatibilityContract) -> String

    Return the candidate snapshot path from the manifest.

    ConfigCompatibilityContract::consumer_paths

    source
    fn ConfigCompatibilityContract::consumer_paths(self : ConfigCompatibilityContract) -> Array[String]

    Return consumer declarations in manifest order, relative to the manifest.

    ConfigCompatibilityContract::equal

    source

    ConfigCompatibilityContract::from_value

    source
    fn ConfigCompatibilityContract::from_value(value : ConfigValue) -> Result[ConfigCompatibilityContract, String]

    Parse a compatibility contract from a JSON-compatible value.

    The accepted shape contains string field candidate, a non-empty string array field baselines, and optional fail_on and ignore_paths fields. Optional consumers references nonempty consumer-rule files. Unknown fields are rejected to prevent misspellings from silently disabling gates.

    ConfigCompatibilityContract::ignored_paths

    source

    Return exact configuration paths excluded by this contract.

    ConfigCompatibilityContract::not_equal

    source

    ConfigCompatibilityContract::policy

    source

    Return the release gate selected by the manifest.

    ConfigCompatibilityContract::to_repr

    source

    ConfigCompatibilityImpact

    source
    pub(all) enum ConfigCompatibilityImpact {
      Compatible
      Behavioral
      Breaking
    } derive(Eq, 
    Debug    )

    Classifies the impact of a configuration change for version evolution.

    This baseline classification treats added paths as compatible, changed values as behavioral changes, and removed or type-changed paths as breaking changes. A later policy layer can refine these defaults with schema rules.

    ConfigCompatibilityImpact::equal

    source

    ConfigCompatibilityImpact::not_equal

    source

    ConfigCompatibilityImpact::to_repr

    source

    ConfigCompatibilityImpact::to_string

    source

    Return a stable lowercase name for a compatibility impact.

    ConfigCompatibilityMatrixEntry

    source
    pub struct ConfigCompatibilityMatrixEntry {
      baseline_name : String
      report : ConfigCompatibilityReport
    } derive(Eq, 
    Debug    )

    One candidate-to-baseline result in a compatibility matrix.

    ConfigCompatibilityMatrixEntry::baseline_name

    source

    Return the name of the historical baseline.

    ConfigCompatibilityMatrixEntry::equal

    source

    ConfigCompatibilityMatrixEntry::not_equal

    source

    ConfigCompatibilityMatrixEntry::passes

    source

    Return whether this baseline passes the selected release policy.

    ConfigCompatibilityMatrixEntry::report

    source

    Return the compatibility report for this baseline.

    ConfigCompatibilityMatrixEntry::to_repr

    source

    ConfigCompatibilityMatrixEntry::violation_count

    source

    Return the number of policy violations for this baseline.

    ConfigCompatibilityMatrixReport

    source
    pub struct ConfigCompatibilityMatrixReport {
      entries : Array[ConfigCompatibilityMatrixEntry]
    } derive(Eq, 
    Debug    )

    The compatibility results for one candidate against multiple baselines.

    ConfigCompatibilityMatrixReport::baseline_count

    source

    Return the number of baselines checked.

    ConfigCompatibilityMatrixReport::entries

    source

    Return all matrix entries in the original baseline order.

    ConfigCompatibilityMatrixReport::entry

    source

    Return one matrix entry in the original baseline order.

    ConfigCompatibilityMatrixReport::equal

    source

    ConfigCompatibilityMatrixReport::excluding_path_patterns

    source

    Return a matrix with changes matching exact paths or trailing .* subtree patterns removed from every baseline report.

    ConfigCompatibilityMatrixReport::excluding_paths

    source

    Return a matrix with changes at the supplied exact paths removed from every baseline report.

    ConfigCompatibilityMatrixReport::failed_count

    source

    Return the number of baselines that violate the selected policy.

    ConfigCompatibilityMatrixReport::not_equal

    source

    ConfigCompatibilityMatrixReport::passed_count

    source

    Return the number of baselines that pass the selected policy.

    ConfigCompatibilityMatrixReport::passes

    source

    Return whether every baseline passes the selected policy.

    ConfigCompatibilityMatrixReport::to_repr

    source

    ConfigCompatibilityPolicy

    source
    pub(all) enum ConfigCompatibilityPolicy {
      BreakingOnly
      NoBehavioralChanges
      NoChanges
    } derive(Eq, 
    Debug    )

    Selects which compatibility impacts should fail a release gate.

    BreakingOnly is the default and rejects only breaking changes. NoBehavioralChanges also rejects behavioral changes, while NoChanges requires the two snapshots to be identical.

    ConfigCompatibilityPolicy::equal

    source

    ConfigCompatibilityPolicy::not_equal

    source

    ConfigCompatibilityPolicy::to_repr

    source

    ConfigCompatibilityPolicy::to_string

    source

    Return the stable command-line name for a compatibility policy.

    ConfigCompatibilityReport

    source
    pub struct ConfigCompatibilityReport {
      changes : Array[ConfigCompatibilityChange]
    } derive(Eq, 
    Debug    )

    The compatibility result for an earlier and a later configuration value.

    ConfigCompatibilityReport::behavioral_count

    source
    fn ConfigCompatibilityReport::behavioral_count(self : ConfigCompatibilityReport) -> Int

    Return the number of behavioral changes.

    ConfigCompatibilityReport::breaking_count

    source
    fn ConfigCompatibilityReport::breaking_count(self : ConfigCompatibilityReport) -> Int

    Return the number of breaking changes.

    ConfigCompatibilityReport::change

    source

    Return one change by its stable path order, or None when out of bounds.

    ConfigCompatibilityReport::change_count

    source

    Return the total number of configuration changes.

    ConfigCompatibilityReport::changes

    source

    Return all changes in stable path order.

    ConfigCompatibilityReport::compatible_count

    source
    fn ConfigCompatibilityReport::compatible_count(self : ConfigCompatibilityReport) -> Int

    Return the number of compatible changes.

    ConfigCompatibilityReport::equal

    source

    ConfigCompatibilityReport::excluding_path_patterns

    source

    Return a report without changes matching exact paths or trailing .* subtree patterns.

    ConfigCompatibilityReport::excluding_paths

    source

    Return a report without changes at the supplied exact paths.

    Matching is exact: excluding metadata does not exclude metadata.release_id.

    ConfigCompatibilityReport::is_compatible

    source
    fn ConfigCompatibilityReport::is_compatible(self : ConfigCompatibilityReport) -> Bool

    Return whether this report contains no breaking changes.

    ConfigCompatibilityReport::not_equal

    source

    ConfigCompatibilityReport::passes

    source

    Return whether this report passes a release policy.

    ConfigCompatibilityReport::to_repr

    source

    ConfigCompatibilityReport::violation_count

    source

    Return the number of changes that violate a release policy.

    ConfigConflict

    source
    pub struct ConfigConflict {
      path : ConfigPath
      earlier_kind : ConfigValueKind
      later_kind : ConfigValueKind
    } derive(Eq, 
    Debug    )

    A path at which recursive merge encountered incompatible structures.

    ConfigConflict::earlier_kind

    source
    fn ConfigConflict::earlier_kind(self : ConfigConflict) -> ConfigValueKind

    Return the kind supplied by the earlier configuration.

    ConfigConflict::equal

    source

    ConfigConflict::later_kind

    source

    Return the kind supplied by the later configuration.

    ConfigConflict::not_equal

    source
    fn ConfigConflict::not_equal(x : ConfigConflict, y : ConfigConflict) -> Bool

    ConfigConflict::path

    source

    Return the path where this conflict occurred.

    ConfigConflict::to_repr

    source

    ConfigConsumerBinding

    source
    pub struct ConfigConsumerBinding {
      consumer : String
      version : String
      baseline_id : String
      contract : ConfigConsumerContract
      baseline : ConfigValue
    }

    A supported consumer version bound to one declared contract and historical snapshot. Labels are supplied by the caller, not authenticated provenance.

    ConfigConsumerBinding::new

    source
    fn ConfigConsumerBinding::new(consumer : String, version : String, baseline_id : String, contract : ConfigConsumerContract, baseline : ConfigValue) -> Result[ConfigConsumerBinding, String]

    ConfigConsumerContract

    source
    pub struct ConfigConsumerContract {
      rules : Array[ConfigConsumerRule]
    } derive(Eq, 
    Debug    )

    ConfigConsumerContract::check

    source

    Return violations of the declared consumer expectations. A pass does not prove compatibility with undeclared application behavior.

    ConfigConsumerContract::equal

    source

    ConfigConsumerContract::evolution_to

    source

    Describe syntactically changed rules in lexical path order. Tightened means the new rule accepts a strict subset of the old rule's inputs at this path; Relaxed means a strict superset. Incomparable means neither includes the other. Conditions, overlapping paths and unsupported combinations remain Unknown. This is not a release gate or proof of whole-contract compatibility.

    ConfigConsumerContract::from_value

    source
    fn ConfigConsumerContract::from_value(source : ConfigValue) -> Result[ConfigConsumerContract, String]

    Parse a consumer declaration: {"rules":[{"path":"server.port", "required":true,"type":"number","allowed_values":[8080],"default":8080}]}. Only declared constraints are checked; unknown rule fields are rejected so misspellings cannot silently weaken the release gate.

    ConfigConsumerContract::not_equal

    source

    ConfigConsumerContract::to_repr

    source

    ConfigConsumerIssue

    source
    pub struct ConfigConsumerIssue {
      path : ConfigPath
      kind : ConfigConsumerIssueKind
    } derive(Eq, 
    Debug    )

    ConfigConsumerIssue::equal

    source

    ConfigConsumerIssue::kind

    source

    ConfigConsumerIssue::not_equal

    source

    ConfigConsumerIssue::path

    source

    ConfigConsumerIssue::to_repr

    source

    ConfigConsumerIssueKind

    source
    pub(all) enum ConfigConsumerIssueKind {
      MissingRequired
      TypeMismatch
      DisallowedValue
      BelowMinimum
      AboveMaximum
      NotInteger
      NonFiniteNumber
    } derive(Eq, 
    Debug    )

    ConfigConsumerIssueKind::equal

    source

    ConfigConsumerIssueKind::not_equal

    source

    ConfigConsumerIssueKind::to_repr

    source

    ConfigConsumerIssueKind::to_string

    source
    fn ConfigConsumerIssueKind::to_string(self : ConfigConsumerIssueKind) -> String

    ConfigConsumerRegression

    source
    pub struct ConfigConsumerRegression {
      consumer : String
      version : String
      baseline_id : String
      introduced : Array[ConfigConsumerIssue]
      persistent : Array[ConfigConsumerIssue]
      resolved : Array[ConfigConsumerIssue]
      effective_comparable : Bool
      effective_changes : Array[ConfigEffectiveChange]
    }

    A comparison under the SAME contract on both snapshots. Issue identity is (path, kind), not just path. Persistent issues do not imply unchanged values.

    ConfigConsumerRegression::baseline_id

    source
    fn ConfigConsumerRegression::baseline_id(self : ConfigConsumerRegression) -> String

    ConfigConsumerRegression::consumer

    source
    fn ConfigConsumerRegression::consumer(self : ConfigConsumerRegression) -> String

    ConfigConsumerRegression::effective_changes

    source

    ConfigConsumerRegression::effective_comparable

    source
    fn ConfigConsumerRegression::effective_comparable(self : ConfigConsumerRegression) -> Bool

    False if either snapshot violates the contract: an empty change array then means unknown, NOT unchanged. Callers must check this before interpreting it.

    ConfigConsumerRegression::introduced

    source

    ConfigConsumerRegression::passes

    source

    Strict candidate acceptance: historical violations are NOT grandfathered.

    ConfigConsumerRegression::persistent

    source

    ConfigConsumerRegression::preserves_effective_values

    source
    fn ConfigConsumerRegression::preserves_effective_values(self : ConfigConsumerRegression) -> Bool

    A separate, opt-in behavior-preservation gate. Candidate acceptance via passes() retains its original meaning. Unknown comparisons fail closed.

    ConfigConsumerRegression::resolved

    source

    ConfigConsumerRegression::version

    source

    ConfigConsumerReleaseReport

    source
    pub struct ConfigConsumerReleaseReport {
      entries : Array[ConfigConsumerRegression]
    }

    ConfigConsumerReleaseReport::check

    source

    Reject empty support sets and duplicate (consumer, version) identities. Results are ordered lexically by consumer then version (not semver). Per-category issues retain the checker's stable path order.

    ConfigConsumerReleaseReport::entries

    source

    ConfigConsumerReleaseReport::passes

    source

    All supplied versions are supported and must accept the candidate. This does not include structural gates or prove unchanged effective values.

    ConfigConsumerReleaseReport::preserves_effective_values

    source
    fn ConfigConsumerReleaseReport::preserves_effective_values(self : ConfigConsumerReleaseReport) -> Bool

    ConfigConsumerRule

    source
    pub struct ConfigConsumerRule {
      path : ConfigPath
      required : Bool
      expected_kind : ConfigValueKind?
      allowed_values : Array[ConfigValue]?
      default_value : ConfigValue?
      minimum : Double?
      maximum : Double?
      integer : Bool
      when : (ConfigPath, ConfigValue)?
    } derive(Eq, 
    Debug    )

    A declared expectation of a configuration consumer. Missing values may be supplied by the consumer's default before type and allowed-value checks.

    ConfigConsumerRule::equal

    source

    ConfigConsumerRule::not_equal

    source

    ConfigConsumerRule::to_repr

    source

    ConfigContractEvolutionChange

    source
    pub struct ConfigContractEvolutionChange {
      path : ConfigPath
      impact : ConfigContractEvolutionImpact
      reason : String
    }

    Value-free diagnostic. Reason is a stable code, never a configuration value.

    ConfigContractEvolutionChange::impact

    source

    ConfigContractEvolutionChange::path

    source

    ConfigContractEvolutionChange::reason

    source

    ConfigContractEvolutionImpact

    source
    pub(all) enum ConfigContractEvolutionImpact {
      Equivalent
      Tightened
      Relaxed
      Incomparable
      Unknown
    } derive(Eq, 
    Debug    )

    Classification of a SINGLE declared path, not whole-contract inclusion.

    ConfigContractEvolutionImpact::equal

    source

    ConfigContractEvolutionImpact::not_equal

    source

    ConfigContractEvolutionImpact::to_repr

    source

    ConfigDiff

    source
    pub struct ConfigDiff {
      path : ConfigPath
      kind : ConfigDiffKind
      before : ConfigValue?
      after : ConfigValue?
    } derive(Eq, 
    Debug    )

    A single difference between an earlier and a later configuration value.

    ConfigDiff::after

    source
    fn ConfigDiff::after(self : ConfigDiff) -> ConfigValue?

    Return the later value, or None when the path was removed.

    ConfigDiff::before

    source
    fn ConfigDiff::before(self : ConfigDiff) -> ConfigValue?

    Return the earlier value, or None when the path was added.

    ConfigDiff::equal

    source
    fn ConfigDiff::equal(ConfigDiff, ConfigDiff) -> Bool

    ConfigDiff::kind

    source

    Return the category of this difference.

    ConfigDiff::not_equal

    source
    fn ConfigDiff::not_equal(x : ConfigDiff, y : ConfigDiff) -> Bool

    ConfigDiff::path

    source
    fn ConfigDiff::path(self : ConfigDiff) -> ConfigPath

    Return the path at which this difference occurred.

    ConfigDiff::to_repr

    source

    ConfigDiffKind

    source
    pub(all) enum ConfigDiffKind {
      Added
      Removed
      Changed
      TypeChanged
    } derive(Eq, 
    Debug    )

    Describes how one configuration path differs between two values.

    ConfigDiffKind::equal

    source

    ConfigDiffKind::not_equal

    source
    fn ConfigDiffKind::not_equal(x : ConfigDiffKind, y : ConfigDiffKind) -> Bool

    ConfigDiffKind::to_repr

    source

    ConfigDiffKind::to_string

    source
    fn ConfigDiffKind::to_string(self : ConfigDiffKind) -> String

    Return a stable lowercase name for this difference category.

    ConfigEffectiveChange

    source
    pub struct ConfigEffectiveChange {
      path : ConfigPath
      before : ConfigEffectiveSource
      after : ConfigEffectiveSource
      value_changed : Bool
    }

    ConfigEffectiveChange::after

    source

    ConfigEffectiveChange::before

    source

    ConfigEffectiveChange::path

    source

    ConfigEffectiveChange::value_changed

    source
    fn ConfigEffectiveChange::value_changed(self : ConfigEffectiveChange) -> Bool

    True for unequal selected values or transitions between inactive, missing and present states. Equal explicit/default values are provenance-only.

    ConfigEffectiveSource

    source
    pub(all) enum ConfigEffectiveSource {
      Inactive
      Missing
      Explicit
      Default
    } derive(Eq, 
    Debug    )

    Source of a declared rule's effective selection. No configuration values are exposed in the public change report.

    ConfigEffectiveSource::equal

    source

    ConfigEffectiveSource::not_equal

    source

    ConfigEffectiveSource::to_repr

    source

    ConfigExplanation

    source
    pub struct ConfigExplanation {
      path : ConfigPath
      value : ConfigValue
      source : String
    } derive(Eq, 
    Debug    )

    A diagnostic view of one merged configuration field.

    The explanation combines the final value with the layer that supplied it.

    ConfigExplanation::equal

    source

    ConfigExplanation::kind

    source

    Return the kind of the final value found at the explained path.

    ConfigExplanation::not_equal

    source
    fn ConfigExplanation::not_equal(x : ConfigExplanation, y : ConfigExplanation) -> Bool

    ConfigExplanation::path

    source

    Return the explained configuration path.

    ConfigExplanation::source

    source
    fn ConfigExplanation::source(self : ConfigExplanation) -> String

    Return the name of the layer that supplied the final value.

    ConfigExplanation::to_repr

    source

    ConfigExplanation::value

    source

    Return the final value found at the explained path.

    ConfigLayer

    source
    pub struct ConfigLayer {
      name : String
      value : ConfigValue
    } derive(Eq, 
    Debug    )

    A named configuration source used by future layered merges.

    ConfigLayer::equal

    source
    fn ConfigLayer::equal(ConfigLayer, ConfigLayer) -> Bool

    ConfigLayer::name

    source
    fn ConfigLayer::name(self : ConfigLayer) -> String

    Return the source name associated with this layer.

    ConfigLayer::new

    source
    fn ConfigLayer::new(name : String, value : ConfigValue) -> ConfigLayer

    Create a configuration layer with a source name and value.

    ConfigLayer::not_equal

    source
    fn ConfigLayer::not_equal(x : ConfigLayer, y : ConfigLayer) -> Bool

    ConfigLayer::to_repr

    source

    ConfigLayer::value

    source
    fn ConfigLayer::value(self : ConfigLayer) -> ConfigValue

    Return the configuration value stored in this layer.

    ConfigPath

    source
    pub struct ConfigPath {
      segments : Array[String]
    } derive(Eq, 
    Debug    )

    A dot-separated path that identifies one value in a configuration tree.

    The first version intentionally supports only simple paths such as server.port. Escaping dots inside key names will be added separately if the project later needs it.

    ConfigPath::equal

    source
    fn ConfigPath::equal(ConfigPath, ConfigPath) -> Bool

    ConfigPath::length

    source
    fn ConfigPath::length(self : ConfigPath) -> Int

    Return the number of segments in the path.

    ConfigPath::not_equal

    source
    fn ConfigPath::not_equal(x : ConfigPath, y : ConfigPath) -> Bool

    ConfigPath::segment

    source
    fn ConfigPath::segment(self : ConfigPath, index : Int) -> String?

    Return one segment, or None when the index is outside the path.

    ConfigPath::to_repr

    source

    ConfigPath::to_string

    source
    fn ConfigPath::to_string(self : ConfigPath) -> String

    Convert the path back to its canonical dot-separated representation.

    ConfigPathError

    source
    pub(all) enum ConfigPathError {
      EmptyPath
      EmptySegment(Int)
    } derive(Eq, 
    Debug    )

    Describes why a textual configuration path could not be parsed.

    ConfigPathError::equal

    source

    ConfigPathError::not_equal

    source
    fn ConfigPathError::not_equal(x : ConfigPathError, y : ConfigPathError) -> Bool

    ConfigPathError::to_repr

    source

    ConfigPathError::to_string

    source
    fn ConfigPathError::to_string(self : ConfigPathError) -> String

    Render a concise diagnostic for an invalid path.

    ConfigValue

    source
    pub struct ConfigValue {
      raw : Json
    } derive(Eq, 
    Debug    )

    A JSON-compatible value used by ConfigScope's merge and analysis engine.

    The underlying representation is intentionally private. This keeps later merge and provenance work independent from the concrete JSON container.

    ConfigValue::array

    source
    fn ConfigValue::array(values : Array[ConfigValue]) -> ConfigValue

    Construct an array configuration value.

    The input array is copied into the private representation.

    ConfigValue::as_boolean

    source
    fn ConfigValue::as_boolean(self : ConfigValue) -> Bool?

    Return the boolean payload, or None for a different value kind.

    ConfigValue::as_number

    source
    fn ConfigValue::as_number(self : ConfigValue) -> Double?

    Return the numeric payload, or None for a different value kind.

    ConfigValue::as_string

    source
    fn ConfigValue::as_string(self : ConfigValue) -> String?

    Return the string payload, or None for a different value kind.

    ConfigValue::audit

    source

    Apply validation rules to this configuration value.

    Required paths count as present even when their value is null. Type rules only inspect paths that exist, allowing a separate required rule to control missing-path diagnostics. Issues are ordered lexicographically by path so diagnostics remain deterministic.

    ConfigValue::boolean

    source
    fn ConfigValue::boolean(value : Bool) -> ConfigValue

    Construct a boolean configuration value.

    ConfigValue::compatibility_matrix

    source

    Compare a candidate snapshot against multiple historical baselines.

    The receiver is the later candidate snapshot. Each baseline is compared to it in baseline-to-candidate order, and entries retain the input order.

    ConfigValue::compatibility_with

    source
    fn ConfigValue::compatibility_with(self : ConfigValue, later : ConfigValue) -> ConfigCompatibilityReport

    Compare two configuration snapshots for version compatibility.

    This API intentionally compares already materialized JSON-compatible values. It does not parse configuration files or merge runtime layers. Differences retain the deterministic path order of ConfigValue::diff.

    ConfigValue::contains_field

    source
    fn ConfigValue::contains_field(self : ConfigValue, key : String) -> Bool

    Return whether an object contains a field with the given key.

    ConfigValue::deep_merge

    source
    fn ConfigValue::deep_merge(self : ConfigValue, later : ConfigValue) -> ConfigValue

    Recursively merge two configuration values, with the later value winning.

    Nested objects preserve fields from both inputs. A later scalar, array, or type change replaces the earlier value at that field.

    ConfigValue::deep_merge_with_report

    source
    fn ConfigValue::deep_merge_with_report(self : ConfigValue, later : ConfigValue) -> MergeResult

    Describe a recursive merge together with structural type conflicts.

    ConfigValue::diff

    source
    fn ConfigValue::diff(self : ConfigValue, later : ConfigValue) -> Array[ConfigDiff]

    Compare this configuration with a later value.

    Object fields are compared recursively. Added and removed object fields are reported as one difference for the whole field. Arrays are compared as whole values in this first diff implementation. Results are ordered by path.

    ConfigValue::element

    source
    fn ConfigValue::element(self : ConfigValue, index : Int) -> ConfigValue?

    Read one array element, or None if this is not an array or the index is outside its bounds.

    ConfigValue::empty_object

    source
    fn ConfigValue::empty_object() -> ConfigValue

    Construct an empty object configuration value.

    ConfigValue::equal

    source
    fn ConfigValue::equal(ConfigValue, ConfigValue) -> Bool

    ConfigValue::field

    source
    fn ConfigValue::field(self : ConfigValue, key : String) -> ConfigValue?

    Read one object field, or None if this is not an object or the key is absent.

    ConfigValue::get

    source
    fn ConfigValue::get(self : ConfigValue, path : ConfigPath) -> ConfigValue?

    Read a nested value using a dot-separated configuration path.

    The lookup succeeds only when every path segment selects an object field. Arrays are intentionally not indexed by this first path API.

    ConfigValue::kind

    source

    Return the kind of this value.

    ConfigValue::length

    source
    fn ConfigValue::length(self : ConfigValue) -> Int?

    Return the number of elements for an array or fields for an object. Scalar values return None.

    ConfigValue::merge

    source
    fn ConfigValue::merge(self : ConfigValue, later : ConfigValue) -> ConfigValue

    Merge an earlier configuration value with a later override.

    Object fields are combined at the current level, and fields from the override replace fields with the same key. Nested objects are replaced as whole values; recursive merging will be added separately.

    ConfigValue::not_equal

    source
    fn ConfigValue::not_equal(x : ConfigValue, y : ConfigValue) -> Bool

    ConfigValue::null

    source
    fn ConfigValue::null() -> ConfigValue

    Construct a null configuration value.

    ConfigValue::number

    source
    fn ConfigValue::number(value : Double) -> ConfigValue

    Construct a numeric configuration value.

    ConfigValue::object

    source
    fn ConfigValue::object(fields : Map[String, ConfigValue]) -> ConfigValue

    Construct an object configuration value.

    The input map is copied into the private representation, so later changes to the caller's map do not change the constructed value.

    ConfigValue::parse_json

    source

    Parse a JSON text into a configuration value.

    The parser accepts every JSON value, including a root scalar or array.

    ConfigValue::redact

    source
    fn ConfigValue::redact(self : ConfigValue, paths : Array[ConfigPath]) -> ConfigValue

    Replace selected configuration paths with a fixed redaction marker.

    Redaction matches complete paths only. The input value is not modified.

    ConfigValue::string

    source
    fn ConfigValue::string(value : String) -> ConfigValue

    Construct a string configuration value.

    ConfigValue::to_json_string

    source
    fn ConfigValue::to_json_string(self : ConfigValue) -> String

    Render this configuration value as compact JSON text.

    ConfigValue::to_repr

    source

    ConfigValueKind

    source
    pub(all) enum ConfigValueKind {
      Null
      Boolean
      Number
      String
      Array
      Object
    } derive(Eq, 
    Debug    )

    The JSON-compatible kinds represented by a configuration value.

    ConfigValueKind::equal

    source

    ConfigValueKind::not_equal

    source
    fn ConfigValueKind::not_equal(x : ConfigValueKind, y : ConfigValueKind) -> Bool

    ConfigValueKind::to_repr

    source

    ConfigValueKind::to_string

    source
    fn ConfigValueKind::to_string(self : ConfigValueKind) -> String

    Return the stable lowercase name used in diagnostics and reports.

    LayeredConfig

    source
    pub struct LayeredConfig {
      layers : Array[ConfigLayer]
    } derive(Eq, 
    Debug    )

    An ordered collection of named configuration layers.

    Layers are merged from first to last, so later layers have higher precedence.

    LayeredConfig::empty

    source

    Return an empty ordered configuration.

    LayeredConfig::equal

    source

    LayeredConfig::layer

    source
    fn LayeredConfig::layer(self : LayeredConfig, index : Int) -> ConfigLayer?

    Return one layer by position, or None when the index is out of bounds.

    LayeredConfig::length

    source
    fn LayeredConfig::length(self : LayeredConfig) -> Int

    Return the number of layers in this configuration.

    LayeredConfig::merge

    source

    Merge all layers from first to last, or return None for no layers.

    LayeredConfig::merge_with_provenance

    source
    fn LayeredConfig::merge_with_provenance(self : LayeredConfig) -> LayeredMergeResult?

    Merge all layers while retaining the source of each final configuration path.

    An empty configuration has no value to merge and returns None.

    LayeredConfig::merge_with_report

    source
    fn LayeredConfig::merge_with_report(self : LayeredConfig) -> MergeResult?

    Merge all layers from first to last and report structural conflicts.

    An empty configuration has no value to merge and returns None.

    LayeredConfig::new

    source

    Create an ordered configuration from the supplied layers.

    The input array is copied, so later changes to the caller's array do not change the layer ordering stored by this value.

    LayeredConfig::not_equal

    source
    fn LayeredConfig::not_equal(x : LayeredConfig, y : LayeredConfig) -> Bool

    LayeredConfig::to_repr

    source

    LayeredMergeResult

    source
    pub struct LayeredMergeResult {
      value : ConfigValue
      conflicts : Array[ConfigConflict]
      sources : Map[String, String]
    } derive(Eq, 
    Debug    )

    The merged configuration together with the source of each final field.

    LayeredMergeResult::conflict

    source
    fn LayeredMergeResult::conflict(self : LayeredMergeResult, index : Int) -> ConfigConflict?

    Return one structural conflict, or None when the index is out of bounds.

    LayeredMergeResult::conflict_count

    source
    fn LayeredMergeResult::conflict_count(self : LayeredMergeResult) -> Int

    Return the number of structural conflicts found during the merge.

    LayeredMergeResult::equal

    source

    LayeredMergeResult::explain

    source

    Explain one final configuration field, or return None when the path is missing from the merged value or has no tracked source.

    LayeredMergeResult::not_equal

    source

    LayeredMergeResult::source

    source
    fn LayeredMergeResult::source(self : LayeredMergeResult, path : ConfigPath) -> String?

    Return the name of the layer that supplied the final value at a path.

    LayeredMergeResult::source_count

    source
    fn LayeredMergeResult::source_count(self : LayeredMergeResult) -> Int

    Return the number of tracked configuration paths.

    LayeredMergeResult::to_repr

    source

    LayeredMergeResult::value

    source

    Return the merged configuration value.

    MergeResult

    source
    pub struct MergeResult {
      value : ConfigValue
      conflicts : Array[ConfigConflict]
    } derive(Eq, 
    Debug    )

    The merged value and structural conflicts found while producing it.

    MergeResult::conflict

    source
    fn MergeResult::conflict(self : MergeResult, index : Int) -> ConfigConflict?

    Return one structural conflict, or None when the index is out of bounds.

    MergeResult::conflict_count

    source
    fn MergeResult::conflict_count(self : MergeResult) -> Int

    Return the number of structural conflicts found by the merge.

    MergeResult::equal

    source
    fn MergeResult::equal(MergeResult, MergeResult) -> Bool

    MergeResult::not_equal

    source
    fn MergeResult::not_equal(x : MergeResult, y : MergeResult) -> Bool

    MergeResult::to_repr

    source

    MergeResult::value

    source
    fn MergeResult::value(self : MergeResult) -> ConfigValue

    Return the value produced by the reported merge.

    parse_path

    source
    fn parse_path(source : String) -> Result[ConfigPath, ConfigPathError]

    Parse a simple dot-separated configuration path.

    Empty paths and empty segments are rejected, so .server, server..port, and server. are invalid.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io