Make sure metadata is updated along with env.

Signed-off-by: victor.linroth.sensmetry <victor.linroth@sensmetry.com>

Author: victor-linroth-sensmetry

core/src/commands/sources.rs

@@ -79,14 +79,14 @@ pub fn do_sources_local_src_project_no_deps(
     project: &LocalSrcProject,
     include_index: bool,
 ) -> Result<Vec<Utf8PathBuf>, LocalSourcesError> {
-    let unix_srcs = do_sources_project_no_deps(project, include_index)?;
+    let unix_sources = do_sources_project_no_deps(project, include_index)?;
 
-    let srcs: Result<Vec<_>, _> = unix_srcs
+    let sources: Result<Vec<_>, _> = unix_sources
         .iter()
         .map(|path| project.get_source_path(path))
         .collect();
 
-    Ok(srcs?)
+    Ok(sources?)
 }
 
 /// Transitively resolve a list of usages (typically the usages of some project)

core/src/env/local_directory/metadata.rs

@@ -59,9 +59,9 @@ impl Lock {
                 metadata.projects.push(EnvProject {
                     publisher: project.publisher,
                     name: project.name,
-                    identifiers: project.identifiers,
                     version: project.version,
                     path,
+                    identifiers: project.identifiers,
                     usages,
                     editable: false,
                     files: None,
@@ -81,9 +81,9 @@ impl Lock {
                 metadata.projects.push(EnvProject {
                     publisher: project.publisher,
                     name: project.name,
-                    identifiers: project.identifiers,
                     version: project.version,
                     path: editable.as_str().into(),
+                    identifiers: project.identifiers,
                     usages,
                     editable: true,
                     files: Some(files),
@@ -98,6 +98,7 @@ impl Lock {
 #[derive(Debug, Deserialize)]
 pub struct EnvMetadata {
     pub version: String,
+    #[serde(rename = "project", skip_serializing_if = "Vec::is_empty", default)]
     pub projects: Vec<EnvProject>,
 }
 
@@ -189,6 +190,17 @@ impl EnvMetadata {
         }
     }
 
+    pub fn remove_project<S: AsRef<str>, V: AsRef<str>>(&mut self, iri: S, version: Option<V>) {
+        if let Some(v) = version {
+            self.projects.retain(|p| {
+                p.version != v.as_ref() || !p.identifiers.iter().any(|i| i == iri.as_ref())
+            });
+        } else {
+            self.projects
+                .retain(|p| !p.identifiers.iter().any(|i| i == iri.as_ref()));
+        }
+    }
+
     /// Add `LocalSrcProject` to env. Must have `nominal_path` set.
     pub fn add_local_project(
         &mut self,
@@ -202,11 +214,11 @@ impl EnvMetadata {
         let project = EnvProject {
             publisher: info.publisher,
             name: Some(info.name),
-            identifiers,
             version: info.version,
             path: project
                 .nominal_path
                 .expect("expected nominal path for project"),
+            identifiers,
             usages: info.usage.into_iter().map(|u| u.resource).collect(),
             editable,
             files: None,
@@ -230,24 +242,27 @@ pub struct EnvProject {
     pub publisher: Option<String>,
     /// Name of the project. Intended for display purposes.
     pub name: Option<String>,
-    /// List of identifiers (IRIs) used for the project.
-    /// The first identifier is to. be considered the canonical
-    /// identifier, and if the project is not `editable` this
-    /// is the IRI it is installed as. The rest are considered
-    /// as aliases. Can only be empty for `editable` projects.
-    pub identifiers: Vec<String>,
     /// Version of the project.
     pub version: String,
     /// Path to the root directory of the project.
     /// If the project is not `editable` this should be relative
     /// to the env directory and otherwise it should be relative
     /// to the workspace root.
     pub path: Utf8PathBuf,
+    /// List of identifiers (IRIs) used for the project.
+    /// The first identifier is to. be considered the canonical
+    /// identifier, and if the project is not `editable` this
+    /// is the IRI it is installed as. The rest are considered
+    /// as aliases. Can only be empty for `editable` projects.
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub identifiers: Vec<String>,
     /// Usages of the project. Intended for tools needing to
     /// track the interdependence of project in the environment.
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub usages: Vec<String>,
     /// Indicator of wether the project is fully installed in
     /// the environment or located elsewhere.
+    #[serde(skip_serializing_if = "bool::is_false", default)]
     pub editable: bool,
     /// In case of an `editable` project these are the files
     /// belonging to the project. Intended for tools that
@@ -266,14 +281,14 @@ impl EnvProject {
         if let Some(name) = &self.name {
             table.insert("name", value(name));
         }
+        table.insert("version", value(&self.version));
+        table.insert("path", value(self.path.as_str()));
         if !self.identifiers.is_empty() {
             table.insert(
                 "identifiers",
                 value(multiline_array(self.identifiers.iter())),
             );
         }
-        table.insert("version", value(&self.version));
-        table.insert("path", value(self.path.as_str()));
         if !self.usages.is_empty() {
             table.insert("usages", value(multiline_array(self.usages.iter())));
         }

core/src/env/local_directory/utils.rs

@@ -80,7 +80,7 @@ pub fn try_remove_files<P: AsRef<Utf8Path>, I: Iterator<Item = P>>(
                 moved.push(path.to_path_buf());
             }
             Err(cause) => {
-                // NOTE: This dance is to bypass the fact that std::io::error is not Clone-eable...
+                // NOTE: This dance is to bypass the fact that std::io::error is not cloneable...
                 let mut catastrophic_error = None;
                 for (j, recover) in moved.iter().enumerate() {
                     if let Err(err) = move_fs_item(tempdir.path().join(j.to_string()), recover) {

sysand/src/commands/add.rs

@@ -275,7 +275,6 @@ fn resolve_deps<P: AsRef<Utf8Path>, Policy: HTTPAuthentication>(
         command_sync(
             &lock,
             project_root,
-            true,
             &mut env,
             client,
             &provided_iris,

sysand/src/commands/clone.rs

@@ -142,7 +142,6 @@ pub fn command_clone<Policy: HTTPAuthentication>(
         command_sync(
             &lock,
             &project.inner().project_path,
-            true,
             &mut env,
             client,
             &provided_iris,

sysand/src/commands/env.rs

@@ -13,7 +13,7 @@ use sysand_core::{
     commands::{env::do_env_local_dir, lock::LockOutcome},
     config::Config,
     context::ProjectContext,
-    env::local_directory::LocalDirectoryEnvironment,
+    env::local_directory::{LocalDirectoryEnvironment, metadata::load_env_metadata},
     lock::Lock,
     model::InterchangeProjectUsage,
     project::{
@@ -120,7 +120,7 @@ pub fn command_env_install<Policy: HTTPAuthentication>(
     // TODO: don't use different root project resolution
     //       mechanisms depending on no_deps
     if no_deps {
-        let (_version, storage) =
+        let (version, storage) =
             crate::commands::clone::get_project_version(&iri, version, &resolver)?;
         sysand_core::commands::env::do_env_install_project(
             &iri,
@@ -129,6 +129,7 @@ pub fn command_env_install<Policy: HTTPAuthentication>(
             allow_overwrite,
             allow_multiple,
         )?;
+        add_single_env_project(iri, version.to_string(), env)?;
     } else {
         let usages = vec![InterchangeProjectUsage {
             resource: fluent_uri::Iri::from_str(iri.as_ref())?,
@@ -159,7 +160,6 @@ pub fn command_env_install<Policy: HTTPAuthentication>(
         command_sync(
             &lock,
             project_root,
-            false,
             &mut env,
             client,
             &provided_iris,
@@ -231,14 +231,14 @@ pub fn command_env_install_path<Policy: HTTPAuthentication>(
         Some(config.index_urls(index, vec![DEFAULT_INDEX_URL.to_string()], default_index)?)
     };
 
-    if let Some(version) = version {
-        let project_version = project
-            .get_info()?
-            .ok_or_else(|| anyhow!("missing project info"))?
-            .version;
-        if version != project_version {
-            bail!("given version {version} does not match project version {project_version}")
-        }
+    let project_version = project
+        .get_info()?
+        .ok_or_else(|| anyhow!("missing project info"))?
+        .version;
+    if let Some(version) = version
+        && version != project_version
+    {
+        bail!("given version {version} does not match project version {project_version}")
     }
 
     // TODO: Fix this hack. Currently installing manually then turning project into Editable to
@@ -296,24 +296,50 @@ pub fn command_env_install_path<Policy: HTTPAuthentication>(
         command_sync(
             &lock,
             project_root,
-            false,
             &mut env,
             client,
             &provided_iris,
             runtime,
             auth_policy,
         )?;
+    } else {
+        add_single_env_project(iri, project_version, env)?;
     }
 
     Ok(())
 }
 
-pub fn command_env_uninstall<S: AsRef<str>, Q: AsRef<str>>(
+fn add_single_env_project<S: AsRef<str>, V: AsRef<str>>(
     iri: S,
-    version: Option<Q>,
+    version: V,
     env: LocalDirectoryEnvironment,
 ) -> Result<()> {
-    sysand_core::commands::env::do_env_uninstall(iri, version, env)?;
+    let metadata_path = env.metadata_path();
+    let mut env_metadata = load_env_metadata(&metadata_path)?;
+    let project_path = env.project_path(&iri, version);
+    let project = LocalSrcProject {
+        nominal_path: Some(project_path.strip_prefix(env.root_path())?.to_owned()),
+        project_path,
+    };
+    env_metadata.add_local_project(vec![iri.as_ref().to_owned()], project, false)?;
+    wrapfs::write(metadata_path, env_metadata.to_string())?;
+
+    Ok(())
+}
+
+pub fn command_env_uninstall<S: AsRef<str>, V: AsRef<str>>(
+    iri: S,
+    version: Option<V>,
+    env: LocalDirectoryEnvironment,
+) -> Result<()> {
+    let metadata_path = env.metadata_path();
+
+    sysand_core::commands::env::do_env_uninstall(&iri, version.as_ref(), env)?;
+
+    let mut env_metadata = load_env_metadata(&metadata_path)?;
+    env_metadata.remove_project(iri, version);
+    wrapfs::write(metadata_path, env_metadata.to_string())?;
+
     Ok(())
 }
 

sysand/src/commands/sync.rs

@@ -9,7 +9,7 @@ use url::ParseError;
 
 use sysand_core::{
     auth::HTTPAuthentication,
-    env::local_directory::{DEFAULT_ENV_NAME, LocalDirectoryEnvironment, METADATA_PATH},
+    env::local_directory::{LocalDirectoryEnvironment, metadata::load_env_metadata},
     lock::Lock,
     project::{
         AsSyncProjectTokio, ProjectReadAsync,
@@ -27,7 +27,6 @@ use sysand_core::{
 pub fn command_sync<P: AsRef<Utf8Path>, Policy: HTTPAuthentication>(
     lock: &Lock,
     project_root: P,
-    update_metadata: bool,
     env: &mut LocalDirectoryEnvironment,
     client: reqwest_middleware::ClientWithMiddleware,
     provided_iris: &HashMap<String, Vec<InMemoryProject>>,
@@ -69,16 +68,16 @@ pub fn command_sync<P: AsRef<Utf8Path>, Policy: HTTPAuthentication>(
         provided_iris,
     )?;
 
-    if update_metadata {
-        let env_metadata = lock.to_env_metadata(env, &project_root)?;
-        wrapfs::write(
-            project_root
-                .as_ref()
-                .join(DEFAULT_ENV_NAME)
-                .join(METADATA_PATH),
-            env_metadata.to_string(),
-        )?;
-    }
+    let lock_metadata = lock.to_env_metadata(env, project_root)?;
+    let env_metadata = if wrapfs::is_file(env.metadata_path())? {
+        let mut env_metadata = load_env_metadata(env.metadata_path())?;
+        env_metadata.merge(lock_metadata);
+        env_metadata
+    } else {
+        lock_metadata
+    };
+
+    wrapfs::write(env.metadata_path(), env_metadata.to_string())?;
 
     Ok(())
 }

sysand/src/lib.rs

@@ -110,7 +110,7 @@ where
 
 fn set_panic_hook() {
     // TODO: use `panic::update_hook()` once it's stable
-    //       also set bactrace style once it's stable, but take
+    //       also set backtrace style once it's stable, but take
     //       into account the current level
     let default_hook = panic::take_hook();
     // panic::set_backtrace_style(panic::BacktraceStyle::Short);
@@ -181,7 +181,7 @@ pub fn run_cli(args: cli::Args) -> Result<()> {
             .unwrap(),
     );
 
-    let _runtime_keepalive = runtime.clone();
+    let _runtime_keep_alive = runtime.clone();
 
     // FIXME: This is a temporary implementation to provide credentials until
     //        https://github.com/sensmetry/sysand/pull/157
@@ -418,7 +418,6 @@ pub fn run_cli(args: cli::Args) -> Result<()> {
             command_sync(
                 &lock,
                 project_root,
-                true,
                 &mut local_environment,
                 client,
                 &provided_iris,

sysand/tests/cli_env.rs

@@ -7,7 +7,9 @@ use assert_cmd::prelude::*;
 use camino::Utf8Path;
 use mockito::Server;
 use predicates::prelude::*;
-use sysand_core::env::local_directory::{DEFAULT_ENV_NAME, ENTRIES_PATH, VERSIONS_PATH};
+use sysand_core::env::local_directory::{
+    DEFAULT_ENV_NAME, ENTRIES_PATH, METADATA_PATH, VERSIONS_PATH,
+};
 
 // pub due to https://github.com/rust-lang/rust/issues/46379
 mod common;
@@ -124,10 +126,12 @@ fn env_install_from_local_dir() -> Result<(), Box<dyn std::error::Error>> {
 
     let entries = std::fs::read_dir(cwd.join(env_path))?.collect::<Result<Vec<_>, _>>()?;
 
-    assert_eq!(entries.len(), 1);
+    assert_eq!(entries.len(), 2);
 
     assert_eq!(entries[0].file_name(), ENTRIES_PATH);
 
+    assert_eq!(entries[1].file_name(), METADATA_PATH);
+
     assert_eq!(std::fs::read_to_string(entries[0].path())?, "");
 
     Ok(())