refactor: introduce PackageName for luarocks package names

rocks-lib/src/build/mod.rs

@@ -60,7 +60,7 @@ pub fn build(rockspec: Rockspec, config: &Config) -> Result<()> {
         .dependencies
         .current_platform()
         .iter()
-        .find(|val| val.rock_name == "lua")
+        .find(|val| val.rock_name == "lua".into())
         .map(|dependency| {
             for (possibility, version) in [
                 ("5.4.0", LuaVersion::Lua54),

rocks-lib/src/lib.rs

@@ -1,6 +1,6 @@
 pub mod build;
 pub mod config;
-pub mod luarock;
+pub mod lua_package;
 pub mod manifest;
 pub mod operations;
 pub mod project;

rocks-lib/src/lua_package/mod.rs

@@ -0,0 +1,69 @@
+use eyre::Result;
+use semver::Version;
+use serde::Deserialize;
+use std::fmt::Display;
+
+mod version;
+
+pub use version::{parse_version, parse_version_req};
+
+// TODO: We probably need a better name for this
+pub struct LuaPackage {
+    name: PackageName,
+    version: Version,
+}
+
+impl LuaPackage {
+    pub fn new(name: String, version: String) -> Result<Self> {
+        Ok(Self {
+            name: PackageName::new(name),
+            version: parse_version(&version)?,
+        })
+    }
+    pub fn name(&self) -> &PackageName {
+        &self.name
+    }
+    pub fn version(&self) -> &Version {
+        &self.version
+    }
+}
+
+/// A luarocks package name, which is always lowercase
+#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
+pub struct PackageName {
+    name: String,
+}
+
+impl PackageName {
+    pub fn new(name: String) -> Self {
+        Self {
+            // TODO: validations?
+            name: name.to_lowercase(),
+        }
+    }
+}
+
+impl From<&str> for PackageName {
+    fn from(value: &str) -> Self {
+        Self::new(value.into())
+    }
+}
+
+impl Display for PackageName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.name.as_str())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn parse_name() {
+        let mut package_name: PackageName = "neorg".into();
+        assert_eq!(package_name.to_string(), "neorg");
+        package_name = "LuaFileSystem".into();
+        assert_eq!(package_name.to_string(), "luafilesystem");
+    }
+}

rocks-lib/src/rockspec/dependency.rs

@@ -5,39 +5,39 @@ use itertools::Itertools;
 use semver::VersionReq;
 use serde::{de, Deserialize, Deserializer};
 
-use crate::luarock::{parse_version_req, LuaRock};
+use crate::lua_package::{parse_version_req, LuaPackage, PackageName};
 
 use super::{PartialOverride, PerPlatform, PlatformOverridable};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct LuaDependency {
-    pub rock_name: String,
+    pub rock_name: PackageName,
     pub rock_version_req: VersionReq,
 }
 
 impl FromStr for LuaDependency {
     type Err = eyre::Error;
 
     fn from_str(str: &str) -> Result<Self> {
-        let rock_name = str
+        let rock_name_str = str
             .chars()
             .peeking_take_while(|t| t.is_alphanumeric() || matches!(t, '-' | '_'))
             .collect::<String>();
 
-        if rock_name.is_empty() {
+        if rock_name_str.is_empty() {
             return Err(eyre!(
                 "Could not parse dependency name from {}",
                 str.to_string()
             ));
         }
 
-        let constraints = str.trim_start_matches(&rock_name).trim();
+        let constraints = str.trim_start_matches(&rock_name_str).trim();
         let rock_version_req = match constraints {
             "" => VersionReq::default(),
             constraints => parse_version_req(constraints.trim_start())?,
         };
         Ok(Self {
-            rock_name,
+            rock_name: PackageName::new(rock_name_str),
             rock_version_req,
         })
     }
@@ -48,9 +48,9 @@ impl LuaDependency {
         Self::from_str(&pkg_constraints.to_string())
     }
 
-    pub fn matches(&self, rock: &LuaRock) -> bool {
-        if self.rock_name == rock.name {
-            self.rock_version_req.matches(&rock.version)
+    pub fn matches(&self, rock: &LuaPackage) -> bool {
+        if &self.rock_name == rock.name() {
+            self.rock_version_req.matches(rock.version())
         } else {
             false
         }
@@ -74,10 +74,13 @@ impl PartialOverride for Vec<LuaDependency> {
     fn apply_overrides(&self, override_vec: &Self) -> Self {
         let mut result_map: HashMap<String, LuaDependency> = self
             .iter()
-            .map(|dep| (dep.rock_name.clone(), dep.clone()))
+            .map(|dep| (dep.rock_name.clone().to_string(), dep.clone()))
             .collect();
         for override_dep in override_vec {
-            result_map.insert(override_dep.rock_name.clone(), override_dep.clone());
+            result_map.insert(
+                override_dep.rock_name.clone().to_string(),
+                override_dep.clone(),
+            );
         }
         result_map.into_values().collect()
     }
@@ -133,31 +136,31 @@ mod tests {
 
     #[tokio::test]
     async fn parse_luarock() {
-        let neorg = LuaRock::new("neorg".into(), "1.0.0".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.0.0".into()).unwrap();
         let expected_version = Version::parse("1.0.0").unwrap();
-        assert_eq!(neorg.name, "neorg");
-        assert_eq!(neorg.version, expected_version);
-        let neorg = LuaRock::new("neorg".into(), "1.0".into()).unwrap();
-        assert_eq!(neorg.version, expected_version);
-        let neorg = LuaRock::new("neorg".into(), "1".into()).unwrap();
-        assert_eq!(neorg.version, expected_version);
+        assert_eq!(neorg.name().to_string(), "neorg");
+        assert_eq!(*neorg.version(), expected_version);
+        let neorg = LuaPackage::new("neorg".into(), "1.0".into()).unwrap();
+        assert_eq!(*neorg.version(), expected_version);
+        let neorg = LuaPackage::new("neorg".into(), "1".into()).unwrap();
+        assert_eq!(*neorg.version(), expected_version);
     }
 
     #[tokio::test]
     async fn parse_dependency() {
         let dep: LuaDependency = "lua >= 5.1".parse().unwrap();
-        assert_eq!(dep.rock_name, "lua");
+        assert_eq!(dep.rock_name.to_string(), "lua");
         let dep: LuaDependency = "lua>=5.1".parse().unwrap();
-        assert_eq!(dep.rock_name, "lua");
+        assert_eq!(dep.rock_name.to_string(), "lua");
         let dep: LuaDependency = "toml-edit >= 0.1.0".parse().unwrap();
-        assert_eq!(dep.rock_name, "toml-edit");
+        assert_eq!(dep.rock_name.to_string(), "toml-edit");
         let dep: LuaDependency = "lfs".parse().unwrap();
-        assert_eq!(dep.rock_name, "lfs");
+        assert_eq!(dep.rock_name.to_string(), "lfs");
         let dep: LuaDependency = "neorg 1.0.0".parse().unwrap();
-        assert_eq!(dep.rock_name, "neorg");
-        let neorg = LuaRock::new("neorg".into(), "1.0.0".into()).unwrap();
+        assert_eq!(dep.rock_name.to_string(), "neorg");
+        let neorg = LuaPackage::new("neorg".into(), "1.0.0".into()).unwrap();
         assert!(dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "2.0.0".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "2.0.0".into()).unwrap();
         assert!(!dep.matches(&neorg));
         let dep: LuaDependency = "neorg 2.0.0".parse().unwrap();
         assert!(dep.matches(&neorg));
@@ -168,36 +171,36 @@ mod tests {
         let dep: LuaDependency = "neorg &equals; 2.0.0".parse().unwrap();
         assert!(dep.matches(&neorg));
         let dep: LuaDependency = "neorg >= 1.0, &lt; 2.0".parse().unwrap();
-        let neorg = LuaRock::new("neorg".into(), "1.5".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.5".into()).unwrap();
         assert!(dep.matches(&neorg));
         let dep: LuaDependency = "neorg &gt; 1.0, &lt; 2.0".parse().unwrap();
-        let neorg = LuaRock::new("neorg".into(), "1.11.0".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.11.0".into()).unwrap();
         assert!(dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "3.0.0".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "3.0.0".into()).unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "0.5".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "0.5".into()).unwrap();
         assert!(!dep.matches(&neorg));
         let dep: LuaDependency = "neorg ~> 1".parse().unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "3".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "3".into()).unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.5".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.5".into()).unwrap();
         assert!(dep.matches(&neorg));
         let dep: LuaDependency = "neorg ~> 1.4".parse().unwrap();
-        let neorg = LuaRock::new("neorg".into(), "1.3".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.3".into()).unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.5".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.5".into()).unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.4.10".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.4.10".into()).unwrap();
         assert!(dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.4".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.4".into()).unwrap();
         assert!(dep.matches(&neorg));
         let dep: LuaDependency = "neorg ~> 1.0.5".parse().unwrap();
-        let neorg = LuaRock::new("neorg".into(), "1.0.4".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.0.4".into()).unwrap();
         assert!(!dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.0.5".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.0.5".into()).unwrap();
         assert!(dep.matches(&neorg));
-        let neorg = LuaRock::new("neorg".into(), "1.0.6".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "1.0.6".into()).unwrap();
         assert!(!dep.matches(&neorg));
     }
 

rocks-lib/src/rockspec/mod.rs

@@ -122,7 +122,7 @@ mod tests {
 
     use std::path::PathBuf;
 
-    use crate::luarock::LuaRock;
+    use crate::lua_package::LuaPackage;
     use crate::rockspec::PlatformIdentifier;
 
     use super::*;
@@ -270,19 +270,19 @@ mod tests {
         assert!(!rockspec
             .supported_platforms
             .is_supported(&PlatformIdentifier::Windows));
-        let neorg = LuaRock::new("neorg".into(), "6.0.0".into()).unwrap();
+        let neorg = LuaPackage::new("neorg".into(), "6.0.0".into()).unwrap();
         assert!(rockspec
             .dependencies
             .default
             .into_iter()
             .any(|dep| dep.matches(&neorg)));
-        let foo = LuaRock::new("foo".into(), "1.0.0".into()).unwrap();
+        let foo = LuaPackage::new("foo".into(), "1.0.0".into()).unwrap();
         assert!(rockspec
             .build_dependencies
             .default
             .into_iter()
             .any(|dep| dep.matches(&foo)));
-        let busted = LuaRock::new("busted".into(), "2.2.0".into()).unwrap();
+        let busted = LuaPackage::new("busted".into(), "2.2.0".into()).unwrap();
         assert_eq!(
             *rockspec.external_dependencies.default.get("FOO").unwrap(),
             ExternalDependency::Header("foo.h".into())
@@ -584,9 +584,9 @@ mod tests {
         "
         .to_string();
         let rockspec = Rockspec::new(&rockspec_content).unwrap();
-        let neorg_override = LuaRock::new("neorg".into(), "5.0.0".into()).unwrap();
-        let toml_edit = LuaRock::new("toml-edit".into(), "1.0.0".into()).unwrap();
-        let toml = LuaRock::new("toml".into(), "1.0.0".into()).unwrap();
+        let neorg_override = LuaPackage::new("neorg".into(), "5.0.0".into()).unwrap();
+        let toml_edit = LuaPackage::new("toml-edit".into(), "1.0.0".into()).unwrap();
+        let toml = LuaPackage::new("toml".into(), "1.0.0".into()).unwrap();
         assert_eq!(rockspec.dependencies.default.len(), 2);
         let per_platform = &rockspec.dependencies.per_platform;
         assert_eq!(