Struct LockFile 

pub struct LockFile {
    pub locked_dependencies: Vec<LockedDependency>,
    pub lockfile_version: u32,
    pub config_hash: String,
    pub generated_at: String,
    pub config_modified: Option<String>,
}

Lock file containing all resolved dependencies and metadata

The lock file ensures reproducible builds by recording exact versions and integrity information for all dependencies.

Fields

locked_dependencies: Vec<LockedDependency>

List of all locked dependencies

lockfile_version: u32

Version of the lockfile format for compatibility

config_hash: String

Hash of the configuration that generated this lock

generated_at: String

Timestamp when this lock was generated (nanoseconds since epoch)

config_modified: Option<String>

Configuration file modification time (nanoseconds since epoch)

Implementations

impl LockFile

pub fn load(path: &Path) -> Result<Self>

Load a lock file from disk

Arguments

• path - Path to the lock file

Returns

Parsed lock file structure

Errors

Returns error if file cannot be read or parsed as valid YAML

pub fn save(&self, path: &Path) -> Result<()>

Save the lock file to disk

Arguments

• path - Path where to save the lock file

Errors

Returns error if file cannot be written or serialized

pub fn new( locked_dependencies: Vec<LockedDependency>, config_hash: String, ) -> Self

Create a new lockfile with current timestamp and version

Arguments

• locked_dependencies - Vector of resolved dependencies
• config_hash - Hash of the configuration that generated this lock

pub fn with_config_modified( locked_dependencies: Vec<LockedDependency>, config_hash: String, config_modified: Option<String>, ) -> Self

Create a new lockfile with config modification time

Arguments

• locked_dependencies - Vector of resolved dependencies
• config_hash - Hash of the configuration
• config_modified - Optional config file modification timestamp

pub fn is_compatible_with_config(&self, config_hash: &str) -> bool

Check if this lockfile is compatible with the given config hash

pub fn is_newer_than_config(&self, config_path: &Path) -> Result<bool>

Check if the lockfile is up-to-date based on config file modification time

pub fn is_up_to_date( &self, config_path: &Path, current_config_hash: &str, dependencies: &[LockedDependency], ) -> Result<bool>

Enhanced lockfile validation that checks multiple criteria

pub fn dependencies_match(&self, other_deps: &[LockedDependency]) -> bool

Compare two sets of locked dependencies, accounting for order independence

pub fn compute_config_hash( config_content: &str, dependencies: &[DependencyConfig], ) -> String

Compute a hash of the relevant configuration that affects locking This focuses only on the dependency specifications, not formatting/comments

pub fn get_config_modification_time(config_path: &Path) -> Result<String>

Get the modification time of a config file as nanoseconds since epoch

Trait Implementations

impl Debug for LockFile

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LockFile

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LockFile

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

where __S: Serializer,

Serialize this value into the given Serde serializer.