Enum DraftReason 

pub enum DraftReason {
    AwaitingRelease {
        awaiting: String,
        target: TargetName,
        reference: String,
        because: String,
    },
    Held {
        because: String,
    },
}

Why a change request is a draft, in the shape a machine reads it.

A draft is a change request that must not land yet, and there are two reasons one is held. A change that has gone as far as it can and stopped short of the one step that would make something temporary permanent — a dependency pinned to a branch rather than to a release — is AwaitingRelease, and what it is waiting for is the whole of the reason: which repository, which of that repository’s release targets, and the reference the change is pinned to in the meantime. A change whose work is still being made — evidence gathered, a description started — is Held by the session that opened it, and the one line a person reads is the whole of that reason. The kind tag is what a consumer routes on; because is the same fact as a sentence, for whoever reads it rather than routes on it.

It is recorded on the session’s own event stream — the publication record — and nowhere else. Nothing is written into the change request’s body, under a marker heading or anywhere: a body is prose a reviewer reads and a drafting caller may rewrite, and deciding a control action from it would turn an editorial act into one. The cost of that is carried openly: somebody looking at the draft change request without access to this host sees that it is a draft and not why.

Variants

AwaitingRelease

A change pinned to a dependency’s branch until that dependency releases — what a fast-adoption publication carries.

Fields

awaiting: String

The repository identity whose release is awaited, as the registry keys one.

A String rather than a newtype because an identity key is one everywhere this crate spells one — Identity::origin, Recoverable::identity, the registry document’s own map key — so a narrower type here would disagree with every type it is compared against. What must not be representable is a value that renders as something other than itself in a refusal or an event payload, and checked refuses exactly that at every boundary one arrives at.

target: TargetName

Which release target of it is awaited.

reference: String

The reference this change is pinned to until that release arrives — the branch of the awaited repository the pin names.

A String for the reason awaiting above is, and one more of its own: this is the awaited repository’s branch name rather than one this repository’s git could be asked about, so the parser that would decide it is not this host’s. checked refuses the values that would render as something else.

because: String

One line a person reads, saying why the change is not ready.

Prose, so there is nothing for a type to narrow. The one shape that matters is where it lands — a single rendered line — and checked is what holds it to that.

Held

A change request the session that opened it is holding open as a draft while its work is still being made: evidence gathered, description started. Lifted by onevcs change ready, or taken by a later publication of the same session carrying no reason into the draft lifecycle — which keeps it a draft when green on a change-open identity whose approvals are required.

Fields

because: String

One line a person reads, saying why the session is holding it. Prose, held to the one line it is printed on by checked, as the line above is.

Implementations

impl DraftReason

pub fn checked(&self) -> Result<()>

The rule a publication holds a reason to, or the refusal that this is not one.

Every field here is printed: into a refusal, into an event payload a consumer reads back, and — through --draft — at a host. So the check is the one that decides whether a value renders as itself: nothing empty, and nothing carrying a control character, which is what turns one line of a record into two.

Public for the reason MergePolicy::narrow and FailureKind::of are: it belongs to publication rather than to any one implementation of it, so a supplied Vcs applies this rule at its own boundary rather than a restatement of it that could accept what the real one refuses. It is a method rather than a conversion because the contract fixes the fields as public and settable, so there is no constructor for a check to live in.

Errors

Error::Invalid naming the field that would not render as itself.

Trait Implementations

impl Clone for DraftReason

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DraftReason

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DraftReason

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DraftReason

impl PartialEq for DraftReason

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DraftReason

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 DraftReason