Enum ResolvedSource 

pub enum ResolvedSource {
    Git {
        git: Url,
        commit: GitCommit,
        selector: GitSelector,
        path: Option<GitModulePath>,
    },
    Path {
        path: PathBuf,
    },
}

The resolved source of a dependency.

Variants

Git

A Git source resolved to a specific commit.

Fields

git: Url

The Git repository URL.

commit: GitCommit

The 40-character lowercase hex commit SHA.

selector: GitSelector

The selector from module.json that produced this entry.

Tag and branch selectors carry mutable refs that cannot be validated from the resolved commit alone, so this field is required to allow integrity checks without a full relock.

path: Option<GitModulePath>

The sub-path within the repository where the module lives.

Omitted when the module sits at the repository root.

Path

A local filesystem source.

Fields

path: PathBuf

The local path to the module directory.

Implementations

impl ResolvedSource

pub fn source_url(&self) -> String

Returns the source URL as a string suitable for trust-store lookups.

pub fn source_path(&self) -> Option<&str>

Returns the sub-path within the source, or None when the module sits at the source root.

Trait Implementations

impl Clone for ResolvedSource

fn clone(&self) -> ResolvedSource

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedSource

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResolvedSource

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ResolvedSource

impl PartialEq for ResolvedSource

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

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 ResolvedSource