🥮 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::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::path

    source

    Return the path associated with this audit issue.

    ConfigAuditIssueKind

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

    Describes why a configuration audit reported an issue.

    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::path

    source

    Return the path inspected by this rule.

    ConfigAuditRule::required

    source

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

    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::name

    source

    Return the name associated with this baseline snapshot.

    ConfigCompatibilityBaseline::new

    source

    Create a named compatibility baseline.

    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::impact

    source

    Return the compatibility impact assigned to this change.

    ConfigCompatibilityChange::message

    source

    Render a concise description of the change.

    ConfigCompatibilityChange::path

    source

    Return the path affected by this compatibility change.

    ConfigCompatibilityContract

    source
    pub struct ConfigCompatibilityContract {
      candidate_path : String
      baseline_paths : Array[String]
      policy : ConfigCompatibilityPolicy
    } 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::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 an optional fail_on field. fail_on defaults to breaking. Unknown object fields are ignored so the manifest can grow without breaking older clients.

    ConfigCompatibilityContract::policy

    source

    Return the release gate selected by the manifest.

    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::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::passes

    source

    Return whether this baseline passes the selected release policy.

    ConfigCompatibilityMatrixEntry::report

    source

    Return the compatibility report for this baseline.

    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::failed_count

    source

    Return the number of baselines that violate the selected policy.

    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.

    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::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::is_compatible

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

    Return whether this report contains no breaking changes.

    ConfigCompatibilityReport::passes

    source

    Return whether this report passes a release policy.

    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::later_kind

    source

    Return the kind supplied by the later configuration.

    ConfigConflict::path

    source

    Return the path where this conflict occurred.

    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::kind

    source

    Return the category of this difference.

    ConfigDiff::path

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

    Return the path at which this difference occurred.

    ConfigDiffKind

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

    Describes how one configuration path differs between two values.

    ConfigDiffKind::to_string

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

    Return a stable lowercase name for this difference category.

    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::kind

    source

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

    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::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::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::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::length

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

    Return the number of segments in the path.

    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_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::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::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::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.

    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::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::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.

    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::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::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::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::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 issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io