fix!: rework lockfile to handle libdeps installed in multiple environments

fixes #8

Author: nathanregner

cli/src/lockfile.rs

@@ -1,39 +1,40 @@
-use std::{collections::BTreeMap, fmt::Display, path::PathBuf};
+use std::{collections::BTreeMap, fmt::Display};
 
 use base64::prelude::*;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
 use crate::{
     manifest::{ExternalSpec, PackageManifest},
-    registry,
+    registry::{self, SystemSpec},
 };
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "version")]
 pub enum Lockfile {
-    V1 {
+    #[serde(rename = "2")]
+    V2 {
         dependencies: BTreeMap<String, Dependency>,
     },
 }
 
 impl Default for Lockfile {
     fn default() -> Self {
-        Self::V1 {
+        Self::V2 {
             dependencies: BTreeMap::default(),
         }
     }
 }
 
 impl Lockfile {
-    pub fn add_dependency(&mut self, dependency: Dependency) {
-        let Self::V1 { dependencies, .. } = self;
-        if let Some(old) = dependencies.insert(dependency.name.clone(), dependency) {
-            let new = &dependencies[&old.name];
+    pub fn add_dependency(&mut self, install_path: String, dependency: Dependency) {
+        let Self::V2 { dependencies, .. } = self;
+        if let Some(old) = dependencies.insert(install_path.clone(), dependency) {
+            let new = &dependencies[&install_path];
             if old.manifest != new.manifest {
                 log::warn!(r#"Found duplicate dependency "{old}", using "{new}"#)
             }
-        }
+        };
     }
 }
 
@@ -69,74 +70,58 @@ impl NixSystem {
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Dependency {
     pub name: String,
-    pub install_path: PathBuf,
-    pub version: String,
-    pub manifest: String,
-    pub systems: BTreeMap<NixSystem, FetchUrl>,
+    pub manifest: PackageManifest,
+    pub src: Src,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub enum Src {
+    Universal(FetchUrl),
+    Systems(BTreeMap<NixSystem, FetchUrl>),
 }
 
 impl Dependency {
-    pub fn from_url(
-        manifest: &PackageManifest,
-        install_path: PathBuf,
-        package_spec: &ExternalSpec,
-        sha256: &[u8],
-    ) -> Self {
-        let systems = NixSystem::ALL
-            .iter()
-            .map(|nix_system| (*nix_system, FetchUrl::new(package_spec.uri.clone(), sha256)))
-            .collect();
-        Self::new(
-            manifest,
-            install_path,
-            package_spec.name.clone(),
-            manifest.version.clone(),
-            systems,
-        )
+    pub fn from_url(manifest: PackageManifest, package_spec: &ExternalSpec, sha256: &[u8]) -> Self {
+        let src = Src::Universal(FetchUrl::new(package_spec.uri.clone(), sha256));
+        Self::new(manifest, package_spec.name.clone(), src)
     }
 
-    pub fn from_registry(
-        manifest: &PackageManifest,
-        install_path: PathBuf,
-        package_spec: registry::PackageSpec,
-    ) -> Self {
-        let version = package_spec.version;
-        let systems = NixSystem::ALL
+    pub fn from_registry(manifest: PackageManifest, package_spec: registry::PackageSpec) -> Self {
+        let src = if let Some(universal) = package_spec
+            .version
+            .files
             .iter()
-            .filter_map(|nix_system| {
-                let file = version.supports(&nix_system.to_registry());
-                file.map(|file| (*nix_system, FetchUrl::from(file)))
-            })
-            .collect();
-        Self::new(
-            manifest,
-            install_path,
-            package_spec.name,
-            version.name.clone(),
-            systems,
-        )
+            .find(|f| f.system == SystemSpec::Wildcard)
+        {
+            Src::Universal(FetchUrl::from(universal))
+        } else {
+            Src::Systems(
+                NixSystem::ALL
+                    .iter()
+                    .filter_map(|nix_system| {
+                        let file = package_spec.version.supports(&nix_system.to_registry());
+                        file.map(|file| (*nix_system, FetchUrl::from(file)))
+                    })
+                    .collect(),
+            )
+        };
+
+        Self::new(manifest, package_spec.name, src)
     }
 
-    fn new(
-        manifest: &PackageManifest,
-        install_path: PathBuf,
-        name: String,
-        version: String,
-        systems: BTreeMap<NixSystem, FetchUrl>,
-    ) -> Self {
+    fn new(manifest: PackageManifest, name: String, src: Src) -> Self {
         Self {
             name,
-            install_path,
-            manifest: serde_json::to_string(manifest).expect("serializable manifest"),
-            version,
-            systems,
+            manifest,
+            src,
         }
     }
 }
 
 impl Display for Dependency {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}@{}", self.name, self.version)
+        write!(f, "{}@{}", self.name, self.manifest.version)
     }
 }
 

cli/src/main.rs

@@ -100,8 +100,11 @@ async fn main() -> eyre::Result<()> {
     let mut lockfile = Lockfile::default();
 
     for artifact in global.into_iter().chain(workspace.into_iter()) {
-        let dependency = client.resolve(artifact).await?;
-        lockfile.add_dependency(dependency);
+        let dependency = client.resolve(artifact.manifest).await?;
+        lockfile.add_dependency(
+            artifact.install_path.to_string_lossy().into_owned(),
+            dependency,
+        );
     }
 
     println!("{}", serde_json::to_string_pretty(&lockfile)?);

cli/src/manifest.rs

@@ -15,7 +15,7 @@ pub struct Artifact {
 }
 
 /// .piopm package manifest file
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct PackageManifest {
     #[serde(rename = "type")]
     pub ty: PackageType,
@@ -45,22 +45,22 @@ impl PackageType {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 #[serde(untagged)]
 pub enum PackageSpec {
     PlatformIO(PlatformIOSpec),
     External(ExternalSpec),
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct PlatformIOSpec {
     pub owner: String,
     pub name: String,
     #[serde(flatten)]
     _extra: BTreeMap<String, Value>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct ExternalSpec {
     pub name: String,
     pub uri: Url,

cli/src/registry/mod.rs

@@ -40,34 +40,23 @@ impl Default for RegistryClient {
 }
 
 impl RegistryClient {
-    pub async fn resolve(&self, artifact: Artifact) -> eyre::Result<Dependency> {
-        match &artifact.manifest.spec {
+    pub async fn resolve(&self, manifest: PackageManifest) -> eyre::Result<Dependency> {
+        match &manifest.spec {
             crate::manifest::PackageSpec::PlatformIO(PlatformIOSpec { owner, name, .. }) => {
                 let package_spec = self
-                    .get_package_spec(
-                        owner,
-                        artifact.manifest.ty,
-                        name,
-                        Some(artifact.manifest.version.to_string()),
-                    )
+                    .get_package_spec(owner, manifest.ty, name, Some(manifest.version.to_string()))
                     .await?;
-                Ok(Dependency::from_registry(
-                    &artifact.manifest,
-                    artifact.install_path,
-                    package_spec,
-                ))
+                Ok(Dependency::from_registry(manifest, package_spec))
             }
             crate::manifest::PackageSpec::External(package_spec) => {
-                self.get_external(&artifact.manifest, artifact.install_path, package_spec)
-                    .await
+                self.get_external(&manifest, package_spec).await
             }
         }
     }
 
-    pub async fn get_external(
+    async fn get_external(
         &self,
         manifest: &PackageManifest,
-        install_path: PathBuf,
         package_spec: &ExternalSpec,
     ) -> eyre::Result<Dependency> {
         let response = self.client.get(package_spec.uri.clone()).send().await?;
@@ -76,15 +65,10 @@ impl RegistryClient {
         let mut hash = Sha256::new();
         hash.update(bytes);
         let hash = hash.finalize();
-        Ok(Dependency::from_url(
-            manifest,
-            install_path,
-            package_spec,
-            &hash,
-        ))
+        Ok(Dependency::from_url(manifest.clone(), package_spec, &hash))
     }
 
-    pub async fn get_package_spec(
+    async fn get_package_spec(
         &self,
         owner: &str,
         ty: PackageType,

examples/external-deps/package.nix

@@ -13,7 +13,7 @@ let
     lockfile = ./platformio2nix.lock;
     overrides = (
       final: prev: {
-        SlowSoftWire = prev.SlowSoftWire.overrideAttrs (drv: {
+        "libdeps/uno/SlowSoftWire" = prev."libdeps/uno/SlowSoftWire".overrideAttrs (drv: {
           nativeBuildInputs = [ libarchive ];
 
           unpackPhase = ''