feat: separate versions.json into individual files

Author: helton

src/files/index.rs

@@ -2,15 +2,9 @@ use crate::files::variables::AppConfig;
 use crate::serialization::parse_json;
 use log::debug;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::error::Error;
 use std::path::Path;
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Root {
-    pub packages: HashMap<String, Package>,
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Package {
     pub image: String,
@@ -66,23 +60,23 @@ fn load_package(
 
     if override_file.exists() {
         debug!("Using override config at {:?}", &override_file);
-        parse_json(&override_file)
+        Ok(parse_json(&override_file)?)
+    } else if index_file.exists() {
+        debug!("Using index config at {:?}", &index_file);
+        Ok(parse_json(&index_file)?)
     } else {
-        debug!("Using normal config at {:?}", &index_file);
-        parse_json(&index_file)
+        debug!("No config file found for {}, using default values", &name);
+        Ok(Package::new(name))
     }
 }
 
-pub fn parse(name: String) -> Result<Root, Box<dyn Error>> {
+pub fn parse(name: String) -> Result<Package, Box<dyn Error>> {
     let config = AppConfig::new();
     let index_path = config.index_path().to_owned();
     let package_dir = Path::new(&index_path);
     let overrides_path = config.overrides_path().to_owned();
     let overrides_dir = Path::new(&overrides_path);
-    let mut packages = HashMap::new();
-
     let package = load_package(&name, package_dir, overrides_dir)?;
-    packages.insert(name, package);
 
-    Ok(Root { packages })
+    Ok(package)
 }

src/files/variables.rs

@@ -36,7 +36,7 @@ impl AppConfig {
     }
 
     pub fn versions_path(&self) -> PathBuf {
-        self.base_dir.join("versions.json")
+        self.base_dir.join("versions")
     }
 
     pub fn shims_path(&self) -> PathBuf {

src/files/versions.rs

@@ -3,11 +3,7 @@ use crate::serialization::{parse_json, save_json};
 use log::debug;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Root {
-    pub packages: std::collections::HashMap<String, Package>,
-}
+use std::fs::remove_file;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Package {
@@ -24,25 +20,32 @@ impl Package {
     }
 }
 
-pub fn parse() -> Result<Root, Box<dyn Error>> {
+pub fn parse(name: String) -> Result<Option<Package>, Box<dyn Error>> {
     let config = AppConfig::new();
-    parse_json(&config.versions_path())
+    let version_file = config.versions_path().join(format!("{}.json", name));
+    if version_file.exists() {
+        Ok(parse_json(&version_file)?)
+    } else {
+        Ok(None)
+    }
 }
 
 pub fn upsert(name: &str, package: crate::packages::Package) -> Result<(), Box<dyn Error>> {
     debug!("Adding/Updating package '{}'", name);
     let config = AppConfig::new();
-    let mut root = parse()?;
-    root.packages.insert(String::from(name), package.versions);
-    save_json(&root, &config.versions_path())?;
+    let version_file = config.versions_path().join(format!("{}.json", name));
+    debug!("Saving file {:?}", &version_file);
+    save_json(&package.versions, &version_file)?;
     Ok(())
 }
 
 pub fn remove(name: &str) -> Result<(), Box<dyn Error>> {
     debug!("Removing package: '{}'", name);
     let config = AppConfig::new();
-    let mut root = parse()?;
-    root.packages.remove(name);
-    save_json(&root, &config.versions_path())?;
+    let version_file = config.versions_path().join(format!("{}.json", name));
+    if version_file.exists() {
+        debug!("Removing file {:?}", &version_file);
+        remove_file(&version_file)?
+    }
     Ok(())
 }

src/packages.rs

@@ -1,7 +1,9 @@
 use crate::files::index::Package as IndexPackage;
+use crate::files::variables::AppConfig;
 use crate::files::versions::Package as VersionsPackage;
-use log::info;
+use log::{debug, info};
 use std::error::Error;
+use std::fs;
 
 #[derive(Debug, Clone)]
 pub struct Package {
@@ -13,12 +15,7 @@ pub struct Package {
 // Public API
 impl Package {
     pub fn new(name: &str, versions_package: VersionsPackage) -> Result<Self, Box<dyn Error>> {
-        let index_packages = crate::files::index::parse(name.to_owned())?;
-        let index_package = index_packages
-            .packages
-            .get(name)
-            .map(|pkg| pkg.to_owned())
-            .unwrap_or_else(|| IndexPackage::new(name));
+        let index_package = crate::files::index::parse(name.to_owned())?;
         Ok(Self {
             name: String::from(name),
             index: index_package,
@@ -27,23 +24,34 @@ impl Package {
     }
 
     pub fn load(name: &str) -> Result<Option<Self>, Box<dyn Error>> {
-        let index_package = crate::files::index::parse(name.to_owned())?
-            .packages
-            .remove(name);
-        let versions_package = crate::files::versions::parse()?.packages.remove(name);
-        Self::make_from(name, index_package, versions_package)
+        if let Some(versions_package) = crate::files::versions::parse(name.to_owned())? {
+            let index_package = crate::files::index::parse(name.to_owned())?;
+            let package = Self::make_from(name, index_package, versions_package)?;
+            Ok(Some(package))
+        } else {
+            Ok(None)
+        }
     }
 
     pub fn load_all() -> Result<Vec<Self>, Box<dyn Error>> {
-        let versions_config = crate::files::versions::parse()?;
         let mut packages: Vec<Self> = Vec::new();
+        let config = AppConfig::new();
+        for entry in fs::read_dir(config.versions_path())? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("json") {
+                let name = path
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .ok_or("Invalid package name")?
+                    .to_string();
 
-        for name in versions_config.packages.keys() {
-            if let Some(package) = Self::load(name)? {
-                packages.push(package);
+                if let Some(package) = Self::load(&name)? {
+                    debug!("Loading package {}", name);
+                    packages.push(package);
+                }
             }
         }
-
         Ok(packages)
     }
 
@@ -93,21 +101,13 @@ impl Package {
 impl Package {
     fn make_from(
         name: &str,
-        index_package: Option<IndexPackage>,
-        versions_package: Option<VersionsPackage>,
-    ) -> Result<Option<Self>, Box<dyn Error>> {
-        match (index_package, versions_package) {
-            (Some(index_package), Some(versions_package)) => Ok(Some(Self {
-                name: String::from(name),
-                index: index_package,
-                versions: versions_package,
-            })),
-            (None, Some(versions_package)) => Ok(Some(Self {
-                name: String::from(name),
-                index: IndexPackage::new(name),
-                versions: versions_package,
-            })),
-            (_, None) => Ok(None),
-        }
+        index_package: IndexPackage,
+        versions_package: VersionsPackage,
+    ) -> Result<Self, Box<dyn Error>> {
+        Ok(Self {
+            name: String::from(name),
+            index: index_package,
+            versions: versions_package,
+        })
     }
 }

src/shims.rs

@@ -1,4 +1,5 @@
 use crate::files::variables::AppConfig;
+use log::debug;
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::PathBuf;
@@ -10,6 +11,7 @@ pub fn add_shim(name: &str, binary: Option<&str>) -> std::io::Result<()> {
 
     if !shims_file_path.exists() {
         fs::create_dir_all(shims_file_path.parent().unwrap())?;
+        debug!("Creating shim {:?}", &shims_file_path);
         let mut shim_file = File::create(&shims_file_path)?;
 
         let command = match binary {
@@ -43,6 +45,7 @@ pub fn remove_shim(name: &str) -> std::io::Result<()> {
     let shims_file_path = get_shims_path(name, config);
 
     if shims_file_path.exists() {
+        debug!("Removing shim {:?}", &shims_file_path);
         fs::remove_file(shims_file_path)?;
     }
     Ok(())