Enum StartPoint 

pub enum StartPoint {
    Given {
        reference: String,
    },
    RemoteTrunk {
        remote: String,
        branch: String,
    },
    RemoteBranch {
        remote: String,
        branch: String,
        fetched: bool,
    },
    LocalTrunk {
        branch: String,
        unreachable: Option<String>,
        reason: Option<String>,
        behind: Option<u64>,
    },
    Head,
}

Where a new branch started, and why there.

The local trunk of a long-lived checkout is routinely hundreds of commits behind its remote, because nothing advances it; a branch cut from it carries none of that work and every worker had to reset it by hand. So the default is the remote’s trunk, fetched at the moment of creation, and the local trunk only when the remote cannot be read — said, never silent.

use majordomus_cli::worktree::StartPoint;
let p = StartPoint::RemoteTrunk { remote: "origin".into(), branch: "master".into() };
assert_eq!(p.reference(), "origin/master");
assert!(p.fallback().is_none());
let fell = StartPoint::LocalTrunk {
    branch: "master".into(),
    unreachable: Some("origin".into()),
    reason: Some("no answer within 60s".into()),
    behind: Some(779),
};
assert_eq!(fell.reference(), "master");
assert!(fell.fallback().unwrap().contains("779 commits behind origin/master"));

Variants

Given

The ref --base named, as given; never fetched.

Fields

reference: String

The ref.

RemoteTrunk

The trunk on its remote, fetched by this command.

Fields

remote: String

The remote.

branch: String

The trunk branch.

RemoteBranch

The branch already on the remote: the local branch is created at it and tracks it.

Fields

remote: String

The remote.

branch: String

The branch, the same name on both sides.

fetched: bool

Whether it was fetched now; false is the remote-tracking ref as last fetched, because the remote could not be read.

LocalTrunk

The local trunk: the trunk has no remote, or its remote could not be read.

Fields

branch: String

The trunk branch.

unreachable: Option<String>

The remote that could not be read; None when the trunk has no remote.

reason: Option<String>

Why it could not be read.

behind: Option<u64>

How many commits the remote’s trunk, as last fetched, has that the local trunk lacks; None when it was never fetched.

Head

HEAD, because no trunk is known.

Implementations

impl StartPoint

pub fn reference(&self) -> String

The ref git is given to start the branch from.

use majordomus_cli::worktree::StartPoint;

let remote = StartPoint::RemoteTrunk { remote: "origin".into(), branch: "master".into() };
assert_eq!(remote.reference(), "origin/master");
assert_eq!(StartPoint::Head.reference(), "HEAD");

pub fn fallback(&self) -> Option<String>

The sentence a person must read when the start is not the remote’s state as it is now; None when it is, or when nothing better could have been asked.

use majordomus_cli::worktree::StartPoint;

let stale = StartPoint::LocalTrunk {
    branch: "master".into(),
    unreachable: Some("origin".into()),
    reason: Some("offline".into()),
    behind: Some(3),
};
let said = stale.fallback().expect("a stale start is said");
assert!(said.contains("3 commits behind origin/master"), "{said}");
let remote = StartPoint::RemoteTrunk { remote: "origin".into(), branch: "master".into() };
assert_eq!(remote.fallback(), None);

Trait Implementations

impl Clone for StartPoint

fn clone(&self) -> StartPoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StartPoint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StartPoint

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StartPoint

impl JsonSchema for StartPoint

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 PartialEq for StartPoint

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

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 StartPoint