Merge branch 'dev'

Author: nomnomab

README.md

@@ -7,6 +7,9 @@
 - Project creation
   - Select a template to start from, or start from scratch
   - Select the specific packages you want
+    - Supports internal packages
+    - Supports git packages
+    - Supports local file packages
   - Select the files/folders you want from the template
   - Can override the template's internal project entirely
 - Template creation

src-tauri/src/generate.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, path::PathBuf};
 
 use flate2::{read::GzDecoder, write::GzEncoder};
 
-use crate::{app::{self, AppState}, editor::UnityEditorInstall, errors, io_utils, package::MinimalPackage, template::SurfaceTemplate};
+use crate::{app::{self, AppState}, editor::UnityEditorInstall, errors, io_utils, package::{self, MinimalPackage}, template::SurfaceTemplate};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -39,7 +39,7 @@ pub fn generate_project(app: &tauri::AppHandle, project_info: &ProjectInfoForGen
 
   let package_cache_dir = io_utils::get_cache_appended_dir(app, "new_project_package");
   unpack_package_into_cache(&package_cache_dir, &template_info)?;
-  modify_package_json(&package_cache_dir, &template_info.packages)?;
+  modify_package_json(&package_cache_dir, &template_info.packages, &package_cache_dir_out)?;
 
   // create project directory
   std::fs::create_dir(&package_cache_dir_out)?;
@@ -88,8 +88,10 @@ pub fn generate_project(app: &tauri::AppHandle, project_info: &ProjectInfoForGen
 // generate a new template file
 pub fn generate_template(app: &tauri::AppHandle, app_state: &tauri::State<AppState>, template_info: &NewTemplateInfo) -> Result<PathBuf, errors::AnyError> {
   let package_cache_dir = io_utils::get_cache_appended_dir(app, "new_template_package");
+  let package_cache_dir_out = io_utils::get_cache_appended_dir(app, "new_template_package_output");
+
   unpack_package_into_cache(&package_cache_dir, &template_info.template)?;
-  modify_package_json(&package_cache_dir, &template_info.template.packages)?;
+  modify_package_json(&package_cache_dir, &template_info.template.packages, &package_cache_dir_out)?;
 
   // modify package.json
   let package_json_path = package_cache_dir
@@ -115,8 +117,6 @@ pub fn generate_template(app: &tauri::AppHandle, app_state: &tauri::State<AppSta
   });
   println!("Writing new package.json: {}", package_json_path.display());
   std::fs::write(&package_json_path, serde_json::to_string_pretty(&new_package_json)?)?;
-  
-  let package_cache_dir_out = io_utils::get_cache_appended_dir(app, "new_template_package_output");
 
   // copy contents from package to output
   let data_root = PathBuf::from("package");
@@ -217,7 +217,7 @@ fn unpack_package_into_cache(output: &PathBuf, template_info: &TemplateInfoForGe
   Ok(())
 }
 
-fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackage>) -> Result<(), errors::AnyError> {
+fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackage>, output_path: &PathBuf) -> Result<(), errors::AnyError> {
   // modify package.json for dependencies
   let packages_dir = package_cache_dir
     .join("package")
@@ -235,18 +235,68 @@ fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackag
     std::fs::remove_file(&packages_lock_json)?;
   }
 
+  // read any local packages
+  let local_packages = packages
+    .iter()
+    .filter(|x| x._type == package::PackageType::Local)
+    .collect::<Vec<_>>();
+
+  let rest_packages = packages
+    .iter()
+    .filter(|x| x._type != package::PackageType::Local)
+    .collect::<Vec<_>>();
+
+  println!("Local packages: {:?}", local_packages);
+  println!("Rest packages: {:?}", rest_packages);
+
   let manifest_json_contents = std::fs::read_to_string(&manifest_json)?;
   let mut manifest_json_contents: HashMap<String, serde_json::Value> 
     = serde_json::from_str(&manifest_json_contents)?;
 
   let mut dependencies: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
 
   // override the dependencies
-  for package in packages.iter() {
+  for package in rest_packages.iter() {
+    println!("Rest package: {:?}", package);
     let name = package.name.clone();
     let version = package.version.clone();
     dependencies.insert(name, serde_json::Value::String(version));
   }
+
+  // local ones now
+  for package in local_packages.iter() {
+    println!("Local package: {:?}", package);
+    // get local path from this project to the json path in name
+    let package_json_path = std::path::Path::new(&package.name).to_path_buf();
+    let package_json_path_parent = package_json_path
+      .parent()
+      .ok_or(errors::str_error("Failed to get parent"))?;
+    let relative_path = io_utils::diff_paths(&package_json_path_parent, &output_path.join("Packages"));
+
+    let relative_path = match relative_path {
+      Some(path) => path.to_path_buf(),
+      None => package_json_path.clone()
+    };
+
+    let json = std::fs::read_to_string(&package_json_path)?;
+    let json: serde_json::Value = serde_json::from_str(&json)?;
+    let name = json.as_object()
+      .ok_or(errors::str_error(&format!("Failed to get json object from {}", package_json_path.display())))?
+      .get("name")
+      .ok_or(errors::str_error(&format!("Failed to get name from {}", package_json_path.display())))?
+      .as_str()
+      .ok_or(errors::str_error(&format!("Failed to get name from {}", package_json_path.display())))?
+      .to_string();
+    
+    let name = name.clone();
+    let version = format!("file:{}", relative_path
+      .to_str()
+      .ok_or(errors::str_error("Failed to get str"))?
+      .replace("\\", "/")
+    );
+    dependencies.insert(name, serde_json::Value::String(version));
+  }
+  
   manifest_json_contents.insert("dependencies".to_string(), serde_json::Value::Object(dependencies));
 
   // save to disk

src-tauri/src/git.rs

@@ -0,0 +1,115 @@
+use serde::{Deserialize, Serialize};
+
+use crate::errors;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(default, rename_all = "camelCase")]
+pub struct PackageJson {
+    name: String,
+    version: String,
+}
+
+impl Default for PackageJson {
+    fn default() -> Self {
+        Self {
+            name: "nomnom-unity-hub".to_string(),
+            version: "0.0.0".to_string(),
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn cmd_get_git_package_json(app: tauri::AppHandle, url: String) -> Result<PackageJson, errors::AnyError> {
+    // extract ?path= if it has it
+    let mut url = url;
+    let mut path = None;
+    let mut branch = None;
+
+    if url.contains("#") {
+      let split = url.split("#").collect::<Vec<_>>();
+      if split.len() > 1 {
+        branch = Some(split[1].to_string());
+        url = split[0].to_string();
+      }
+    }
+    
+    if url.contains("?path=") {
+        let split = url
+          .split("?path=")
+          .collect::<Vec<_>>();
+
+        let test_path = split.get(1)
+          .ok_or(errors::str_error("Invalid git url"))?;
+        let test_url = split.get(0)
+          .ok_or(errors::str_error("Invalid git url"))?;
+        
+        path = Some(test_path.to_string());
+        url = test_url.to_string();
+    }
+
+    let cache_dir = app
+      .path_resolver()
+      .app_cache_dir()
+      .ok_or(errors::str_error("Failed to get app cache dir"))?;
+    let cache_path = cache_dir.join("temp-git");
+
+    if cache_path.exists() {
+        std::fs::remove_dir_all(&cache_path)?;
+    }
+    
+    let cache_path_str = cache_path.to_str()
+      .ok_or(errors::str_error("Failed to get app cache dir"))?;
+    
+    std::fs::create_dir_all(&cache_path)?;
+
+    fn run_clone(args: Vec<&str>) -> bool {
+      std::process::Command::new("git")
+        .args(args.as_slice())
+        .output()
+        .inspect(|x| println!("{:?}", x))
+        .is_ok_and(|x| x.status.success())
+    }
+
+    let clone_success = {
+      if let Some(branch) = branch {
+        let args = vec!["clone", "-b", &branch, &url, cache_path_str];
+        run_clone(args)
+      } else {
+        let args = vec!["clone", &url, cache_path_str];
+        run_clone(args)
+      }
+    };
+
+    if !clone_success {
+        std::fs::remove_dir_all(&cache_path)?;
+        return Err(errors::str_error("Failed to clone repository"));
+    }
+
+    let package_json = {
+      let package_json_path = {
+        if let Some(path) = &path {
+            cache_path
+              .clone()
+              .join(path)
+        } else {
+            cache_path.clone()
+        }
+      };
+
+      let package_json_path = package_json_path
+        .join("package")
+        .with_extension("json");
+
+      println!("package_json_path: {}", package_json_path.display());
+      
+      let contents = std::fs::read_to_string(&package_json_path)
+        .map_err(|_| errors::str_error("Failed to read package.json"))?;
+      let package_json: PackageJson = serde_json::from_str(&contents)
+        .map_err(|_| errors::str_error("Invalid package.json"))?;
+
+      Ok(package_json)
+    };
+
+    std::fs::remove_dir_all(&cache_path)?;
+    package_json
+}

src-tauri/src/io_utils.rs

@@ -158,4 +158,65 @@ pub fn build_ids(node: &mut FileDir, id: &mut u64) {
         *id = *id + 1u64;
         build_ids(c, id);
     }
+}
+
+/// Construct a relative path from a provided base directory path to the provided path
+///
+/// ```rust
+/// use pathdiff::diff_paths;
+/// use std::path::*;
+///
+/// let baz: PathBuf = "/foo/bar/baz".into();
+/// let bar: PathBuf = "/foo/bar".into();
+/// let quux: PathBuf = "/foo/bar/quux".into();
+/// assert_eq!(diff_paths(&bar, &baz), Some("../".into()));
+/// assert_eq!(diff_paths(&baz, &bar), Some("baz".into()));
+/// assert_eq!(diff_paths(&quux, &baz), Some("../quux".into()));
+/// assert_eq!(diff_paths(&baz, &quux), Some("../baz".into()));
+/// assert_eq!(diff_paths(&bar, &quux), Some("../".into()));
+///
+/// ```
+/// Under MIT LICENSE
+pub fn diff_paths(path: &Path, base: &Path) -> Option<std::path::PathBuf> {
+    // This routine is adapted from the *old* Path's `path_relative_from`
+    // function, which works differently from the new `relative_from` function.
+    // In particular, this handles the case on unix where both paths are
+    // absolute but with only the root as the common directory.
+    use std::path::Component;
+
+    if path.is_absolute() != base.is_absolute() {
+        if path.is_absolute() {
+            Some(std::path::PathBuf::from(path))
+        } else {
+            None
+        }
+    } else {
+        let mut ita = path.components();
+        let mut itb = base.components();
+        let mut comps: Vec<Component> = vec![];
+        loop {
+            match (ita.next(), itb.next()) {
+                (None, None) => break,
+                (Some(a), None) => {
+                    comps.push(a);
+                    comps.extend(ita.by_ref());
+                    break;
+                }
+                (None, _) => comps.push(Component::ParentDir),
+                (Some(a), Some(b)) if comps.is_empty() && a == b => (),
+                (Some(a), Some(b)) if b == Component::CurDir => comps.push(a),
+                (Some(_), Some(b)) if b == Component::ParentDir => return None,
+                (Some(a), Some(_)) => {
+                    comps.push(Component::ParentDir);
+                    for _ in itb {
+                        comps.push(Component::ParentDir);
+                    }
+                    comps.push(a);
+                    comps.extend(ita.by_ref());
+                    break;
+                }
+            }
+        }
+        Some(comps.iter().map(|c| c.as_os_str()).collect())
+    }
 }

src-tauri/src/main.rs

@@ -12,6 +12,7 @@ mod errors;
 mod package;
 mod prefs;
 mod project;
+mod git;
 mod io_utils;
 mod template;
 mod generate;
@@ -56,6 +57,8 @@ fn main() {
             // generate
             generate::cmd_generate_project,
             generate::cmd_generate_template,
+            // git
+            git::cmd_get_git_package_json
         ])
         .setup(|app| {
             let app_handle = app.handle();