feat: add package.json resolution

Cargo.toml

@@ -7,7 +7,9 @@ edition = "2021"
 
 [dependencies]
 base64ct = { version = "1.6.0", features = ["alloc"] }
+git2 = "0.18.1"
 glob = "0.3.1"
+path-clean = "1.0.1"
 serde = { version = "1.0.195", features = ["derive"] }
 serde_json = "1.0.111"
 sha2 = "0.10.8"

src/main.rs

@@ -4,6 +4,7 @@ mod utils;
 use package_json::PackageJson;
 
 fn main() {
-  let result = PackageJson::new("./examples/package.json").map(|p| p.generate_hash());
+  // TODO: 後で消す
+  let result = PackageJson::new("./examples/package.json").map(|p| p.resolve().generate_hash());
   dbg!(result.unwrap());
 }

src/package_json.rs

@@ -1,8 +1,9 @@
 use base64ct::{Base64, Encoding};
 use serde::{Deserialize, Serialize};
-use serde_json::Error;
-use sha2::{digest::typenum::Prod, Digest, Sha256};
-use std::{collections::BTreeMap, fs, hash::Hash};
+use sha2::{Digest, Sha256};
+use std::{collections::BTreeMap, fs, hash::Hash, io, path::Path};
+
+use crate::utils::path::to_absolute_path;
 
 const PACKAGE_JSON: &str = "package.json";
 
@@ -21,30 +22,53 @@ trait ToBytes {
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize, Hash, Debug)]
 pub struct PackageJson {
-  pub dependencies: Option<Dependencies>,
-  pub devDependencies: Option<Dependencies>,
-  pub peerDependencies: Option<Dependencies>,
-  pub optionalDependencies: Option<Dependencies>,
-  pub overrides: Option<Dependencies>,
-  pub workspaces: Option<Vec<String>>,
+  dependencies: Option<Dependencies>,
+  devDependencies: Option<Dependencies>,
+  peerDependencies: Option<Dependencies>,
+  overrides: Option<Dependencies>,
+  optionalDependencies: Option<Dependencies>,
+  workspaces: Option<Vec<String>>,
 }
 
 impl PackageJson {
-  pub fn new(file_path: &str) -> Result<PackageJson, Error> {
-    // TODO: error handling
-    let contents = fs::read_to_string(file_path).expect("Something went wrong reading the file");
+  pub fn new<T: AsRef<Path>>(file_path: T) -> io::Result<PackageJson> {
+    let contents = fs::read_to_string(&file_path).expect(
+      format!(
+        "No such file `{}`",
+        to_absolute_path(&file_path).to_string_lossy()
+      )
+      .as_str(),
+    );
     let json = serde_json::from_str::<PackageJson>(&contents)?;
     Ok(json)
   }
 
-  pub fn resolve() -> ProjectDependencies {}
+  pub fn resolve(&self) -> ProjectDependencies {
+    ProjectDependencies {
+      root: PackageDependencies {
+        dependencies: self.dependencies.clone().unwrap_or_default(),
+        dev_dependencies: self.devDependencies.clone().unwrap_or_default(),
+        peer_dependencies: self.peerDependencies.clone().unwrap_or_default(),
+        optional_dependencies: self.optionalDependencies.clone().unwrap_or_default(),
+        overrides: self.overrides.clone().unwrap_or_default(),
+      },
+      workspaces: self.resolve_workspaces(),
+    }
+  }
 
   fn resolve_workspaces(&self) -> BTreeMap<String, ProjectDependencies> {
-    if let Some(workspaces) = self.workspaces {
-      let packageJsons = workspaces
-        .iter()
-        .map(|w| PackageJson::new(&format!("{}/${PACKAGE_JSON}", w)))
-        .collect::<Result<Vec<_>, _>>();
+    let mut package_map = BTreeMap::<String, ProjectDependencies>::new();
+    match &self.workspaces {
+      Some(workspaces) => {
+        for workspace in workspaces.iter() {
+          let package_json_path = format!("{}/${PACKAGE_JSON}", workspace).to_string();
+          if let Ok(p) = PackageJson::new(&package_json_path) {
+            package_map.insert(package_json_path, p.resolve());
+          }
+        }
+        package_map
+      }
+      None => package_map,
     }
   }
 }
@@ -57,18 +81,33 @@ pub struct PackageDependencies {
   pub dependencies: Dependencies,
   pub dev_dependencies: Dependencies,
   pub peer_dependencies: Dependencies,
-  pub optional_dependencies: Dependencies,
   pub overrides: Dependencies,
+  pub optional_dependencies: Dependencies,
 }
 
 #[derive(Serialize, Deserialize, Hash, Debug)]
 pub struct ProjectDependencies {
   pub root: PackageDependencies,
-  pub workspaces: BTreeMap<String, PackageDependencies>,
+  pub workspaces: BTreeMap<String, ProjectDependencies>,
 }
 
 impl ToBytes for ProjectDependencies {}
 
+impl Default for ProjectDependencies {
+  fn default() -> Self {
+    ProjectDependencies {
+      root: PackageDependencies {
+        dependencies: BTreeMap::<String, String>::new(),
+        dev_dependencies: BTreeMap::<String, String>::new(),
+        optional_dependencies: BTreeMap::<String, String>::new(),
+        overrides: BTreeMap::<String, String>::new(),
+        peer_dependencies: BTreeMap::<String, String>::new(),
+      },
+      workspaces: BTreeMap::<String, ProjectDependencies>::new(),
+    }
+  }
+}
+
 impl ProjectDependencies {
   pub fn generate_hash(&self) -> serde_json::Result<String> {
     self.to_bytes().map(|bytes| {

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod path;