Struct Deduplicated 

pub struct Deduplicated {
    pub kept: String,
    pub dropped: Vec<String>,
    pub key: String,
    pub detail: String,
    pub paths: usize,
}

Two names, one thing. The compiler keeps one entry and records the collapse here, so that “why is this ADR listed once when four things point at it” has an answer that is state rather than a log line.

One type covers two different collapses, and dropped is how a reader tells them apart. Structural collapse is the same identifier reached several ways: nothing was discarded, so dropped is empty and paths is the count that makes the row worth printing — this is the record that four things pointing at one ADR produced one entry. Semantic collapse is two different identifiers standing for one thing, one file indexed under two kinds or one rule at two versions: there dropped names what lost, because something really was discarded and a reader is entitled to know what.

use majordomus_cli::devcontext::Deduplicated;
use serde_json::json;

// structural: one identifier, four ways in, nothing discarded
let structural: Deduplicated = serde_json::from_value(json!({
    "kept": "majordomus://adr/0052",
    "dropped": [],
    "key": "uri",
    "detail": "one object reached by 4 discovery path(s)",
    "paths": 4,
})).unwrap();
assert!(structural.dropped.is_empty(), "nothing lost; this is a record, not a decision");
assert!(structural.paths > 1, "which is what makes the row worth printing");
assert_eq!(structural.key, "uri");

// semantic: two identifiers for one rule, and the older version lost
let semantic: Deduplicated = serde_json::from_value(json!({
    "kept": "majordomus://rule/project.x@2",
    "dropped": ["majordomus://rule/project.x@1"],
    "key": "identity",
    "detail": "one rule at two versions; the newer is in the answer",
    "paths": 1,
})).unwrap();
assert_eq!(semantic.dropped, ["majordomus://rule/project.x@1"]);
assert_ne!(semantic.kept, semantic.dropped[0], "two names, and one of them lost");

Fields

kept: String

The entry that survived.

dropped: Vec<String>

What was folded into it, or dropped for it.

key: String

What made them the same thing: uri, path or identity.

detail: String

The same, in words.

paths: usize

How many discovery paths reached the surviving entry.

Trait Implementations

impl Clone for Deduplicated

fn clone(&self) -> Deduplicated

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Deduplicated

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Deduplicated

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Deduplicated

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ordered for Deduplicated

Filed under what made the two the same thing, then by the entry that survived — which is unique, because one entry is kept once under one key.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for Deduplicated

fn eq(&self, other: &Deduplicated) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Deduplicated

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Deduplicated