Struct ChildRef 

#[non_exhaustive]
pub struct ChildRef {
    pub url: String,
    pub path: Option<String>,
    pub ref: Option<String>,
}

Reference to a child pack from a children: entry.

path is intentionally left None at parse time — callers that need the on-disk directory name should invoke ChildRef::effective_path which extracts the last URL segment as the default.

Marked #[non_exhaustive] so spec growth (e.g. pin, shallow) does not break library consumers who destructure the struct.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

url: String

Upstream git URL (any scheme gix can resolve).

path: Option<String>

Optional override for the on-disk directory name. Preserved as None when absent so callers can distinguish “defaulted” from “explicitly set to the default value”.

ref: Option<String>

Optional git ref (branch / tag / commit). Serialized as ref: via the raw-identifier field.

Implementations

impl ChildRef

pub fn effective_path(&self) -> String

Resolve the on-disk directory name. When path is explicitly set it wins; otherwise the last path segment of url (stripped of a trailing .git) is used.

Safety precondition (callers MUST validate first)

This method returns its input verbatim — it does not check for path separators, . / .., the empty string, or other path-traversal shapes. Callers using the returned string for any filesystem operation MUST first run plan-phase validation via PackManifest::validate_plan (which invokes validate::run_all, including the internal bare-name validator). The sync orchestrator and the tree walker do this before dispatch; in-crate callers that reach ChildRef directly must follow the same discipline.

Validation lives at plan phase — not here — to keep this method side-effect-free and out of the hot dispatch path. Re-running the regex on every call would amount to per-step paranoia for zero added safety, since plan validation already short-circuits the entire walk on a bad child path.

Trait Implementations

impl Clone for ChildRef

fn clone(&self) -> ChildRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChildRef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChildRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ChildRef

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ChildRef

impl StructuralPartialEq for ChildRef