Enum HooksPath 

pub enum HooksPath {
    NotConfigured,
    Own {
        path: String,
    },
    Set {
        path: String,
        enabled: Vec<String>,
    },
    Shared {
        path: String,
    },
    Untracked {
        missing: String,
        runs: String,
    },
    Failed {
        message: String,
    },
}

What became of the hooks directory of a worktree that was just created, found or moved.

It travels in the JSON of worktree create, ensure, migrate and repair, tagged by outcome, so a reader branches on one word rather than parsing the line:

use majordomus_cli::worktree::HooksPath;

let set = HooksPath::Set {
    path: "/r-wt/fix/x/.githooks".into(),
    enabled: vec![],
};
let json = serde_json::to_value(&set).unwrap();
assert_eq!(json["outcome"], "set");
assert_eq!(json["path"], "/r-wt/fix/x/.githooks");
let back: HooksPath = serde_json::from_value(json).unwrap();
assert_eq!(back, set);

Variants

NotConfigured

The repository’s configuration sets no core.hooksPath: git’s own hooks directory in the common directory (or a value of the user’s) serves every worktree, and there is no tracked directory to follow.

Own

Git already resolves this worktree’s hooks to its own directory; nothing was set.

Fields

path: String

The directory git runs the hooks from.

Set

This worktree’s core.hooksPath was set, per worktree, to its own directory.

Fields

path: String

The directory it now runs the hooks from.

enabled: Vec<String>

Repository settings switched on so that a per-worktree value is honoured, as key=value; empty when they were on already.

Shared

The hooks directory is outside the primary checkout — one directory shared on purpose — and every worktree runs it; nothing was set.

Fields

path: String

The directory every worktree runs the hooks from.

Untracked

The primary checkout’s hooks directory has no counterpart in this worktree’s tree, so the worktree keeps running the primary’s: pointing it at a directory that does not exist would switch its hooks off.

Fields

missing: String

The directory that would be the worktree’s own, and is not there.

runs: String

The directory the worktree runs the hooks from instead.

Failed

Git was asked and refused, or could not be run; the message is its own.

Fields

message: String

What went wrong.

Implementations

impl HooksPath

pub fn describe(&self) -> String

One line for a person, after the path the worktree is at.

use majordomus_cli::worktree::HooksPath;

let set = HooksPath::Set {
    path: "/r-wt/fix/x/.githooks".into(),
    enabled: vec!["extensions.worktreeConfig=true".into()],
};
assert_eq!(
    set.describe(),
    "hooks   /r-wt/fix/x/.githooks, its own (git config --worktree core.hooksPath; \
     enabled extensions.worktreeConfig=true)"
);
assert!(HooksPath::NotConfigured.describe().contains("no core.hooksPath"));

Trait Implementations

impl Clone for HooksPath

fn clone(&self) -> HooksPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HooksPath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HooksPath

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for HooksPath

impl JsonSchema for HooksPath

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 HooksPath

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

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 HooksPath