Struct Conflict 

pub struct Conflict {
    pub current: String,
    pub against: String,
    pub kind: String,
    pub detail: String,
}

Two things in the answer that do not agree, named rather than silently ordered.

The compiler could have resolved every disagreement by keeping one side, and for deduplication it does. A conflict is what is left when both sides are legitimately in the answer and they still do not agree — so the resolution belongs to the session reading it, and the compiler’s job is to make sure the disagreement is visible rather than implied by the order of two rows.

current is the side the compiler treats as current, which is a statement about recency, not correctness: supersedes means the layer declared one to replace the other, version means two versions of one thing are both here.

use majordomus_cli::devcontext::Conflict;
use majordomus_cli::order::canonical;
use serde_json::json;

let row = |current: &str, against: &str, kind: &str| -> Conflict {
    serde_json::from_value(json!({
        "current": current, "against": against, "kind": kind,
        "detail": "both are in the answer and they disagree",
    })).unwrap()
};

let mut conflicts = vec![
    row("majordomus://rule/project.x@2", "majordomus://rule/project.x@1", "version"),
    row("majordomus://adr/0052", "majordomus://adr/0031", "supersedes"),
];
canonical(&mut conflicts);

// filed under the kind of disagreement, so like reads with like
let kinds: Vec<&str> = conflicts.iter().map(|c| c.kind.as_str()).collect();
assert_eq!(kinds, ["supersedes", "version"]);

// and both sides are always named: the pair is the fact, not the winner alone
for c in &conflicts {
    assert_ne!(c.current, c.against);
    assert!(!c.detail.is_empty());
}

Fields

current: String

The entry the compiler treats as current.

against: String

The entry it stands against.

kind: String

What kind of disagreement: supersedes or version.

detail: String

The same, in words.

Trait Implementations

impl Clone for Conflict

fn clone(&self) -> Conflict

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Conflict

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Conflict

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Conflict

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 Conflict

Filed under the kind of disagreement, then the current entry, and ended by the entry it stands against — the pair is what makes one conflict distinct from another under a kind.

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 Conflict

fn eq(&self, other: &Conflict) -> 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 Conflict

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 Conflict