Struct ManifestWriter

pub struct ManifestWriter {
    path: PathBuf,
    doc: TypedDocument<Manifest>,
    lock: Lockfile,
    resolved: ResolvedSets,
}

A writer for atom.toml manifests that ensures the atom.lock file is kept in sync.

Example

use std::path::Path;

use atom::id::Tag;
use atom::manifest::deps::ManifestWriter;
use atom::uri::Uri;

async {
    let mut writer = ManifestWriter::new(None, Path::new("/path/to/atom.toml"))
        .await
        .unwrap();
    let uri = "my-atom@^1.0.0".parse::<Uri>().unwrap();
    let key = "my-atom".parse::<Tag>().unwrap();
    writer.add_uri(uri, Some(key)).unwrap();
    writer.write_atomic().unwrap();
};

Fields

path: PathBuf

doc: TypedDocument<Manifest>

lock: Lockfile

resolved: ResolvedSets

Implementations

impl ManifestWriter

const ATOM_BUG: &str = "bug, `AtomId` construction is infallible when derived directly from a \ root and doesn't need to be calculated"

const RESOLUTION_ERR_MSG: &str = "unlocked dependency could not be resolved remotely"

const UPDATE_DEPENDENCY: &str = "updating out of date dependency in accordance with spec"

pub async fn new( repo: Option<&ThreadSafeRepository>, path: &Path, ) -> Result<Self, AtomError>

Constructs a new ManifestWriter, ensuring that the manifest and lock file constraints are respected.

async fn reconcile(&mut self, manifest: Manifest) -> Result<(), DocError>

Runs the sanitization process, and then the synchronization process to ensure a fully consistent manifest and lock. This function is called in the ManifestWriter constructor to ensure that we are never operating on a stale manifest.

fn set_sets(&mut self)

fn sanitize(&mut self, manifest: &Manifest)

Removes any dependencies from the lockfile that are no longer present in the manifest, ensuring the lockfile only contains entries that are still relevant, then calls into synchronization logic to ensure consistency.

fn insert_or_update_and_log( &mut self, key: Either<AtomId<Root>, Name>, dep: &Dep, )

fn lock_atom( &mut self, req: VersionReq, id: AtomId<Root>, set_tag: Tag, ) -> Result<Dep, Error>

fn synchronize_atom( &mut self, req: VersionReq, id: AtomId<Root>, set_tag: Tag, ) -> Result<(), Error>

pub(crate) async fn synchronize( &mut self, manifest: Manifest, ) -> Result<(), DocError>

Updates the lockfile to match the dependencies specified in the manifest. It resolves any new dependencies, updates existing ones if their version requirements have changed, and ensures the lockfile is fully consistent.

async fn resolve_nix( &self, dep: NixFetch, key: Option<&Name>, ) -> Result<(Name, Dep), DocError>

fn resolve_from_uri( &self, uri: &Uri, root: &Root, ) -> Result<(AtomReq, AtomDep), Error>

fn resolve_from_local( &self, uri: &Uri, repo: &Repository, ) -> Result<(AtomReq, AtomDep), Error>

fn resolve_uri( &mut self, uri: &Uri, mirror: &SetMirror, ) -> Result<(AtomReq, AtomDep), Error>

fn get_set_tag( &self, lock_entry: &AtomDep, uri: &Uri, set_tag_from_user: Option<Tag>, ) -> Tag

fn update_lock_set(&mut self, set: GitDigest, mirror: SetMirror, tag: Tag)

pub fn add_uri(&mut self, uri: Uri, set_tag: Option<Tag>) -> Result<(), Error>

Adds a user-requested atom URI to the manifest and lock files, ensuring they remain in sync.

pub async fn add_url( &mut self, url: AliasedUrl, key: Option<Name>, git: Option<GitSpec>, tar: Option<bool>, build: bool, unpack: Option<bool>, ) -> Result<(), DocError>

Adds a user-requested pin URL to the manifest and lock files, ensuring they remain in sync.

pub fn write_atomic(&mut self) -> Result<(), DocError>

Atomically writes the changes to the manifest and lock files on disk. This method should be called last, after all changes have been processed.

fn resolved(&self) -> &ResolvedSets

pub fn lock(&self) -> &Lockfile

acquire a reference to the lockfile structure