refactor: make aliases case-insensitive

Previously, aliases: `foo` and `Foo` were treated
as different aliases. This could cause issues with
linking on case-insensitive filesystems. This
commit makes aliases case-insensitive, but they
will be stored in the case they were defined in.

CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Changed
+- Make aliases case-insensitive by @daimond113
+
 ## [0.6.0-rc.6] - 2025-02-10
 ### Fixed
 - Fix double path long prefix issues on Windows by @daimond113

src/manifest/mod.rs

@@ -14,6 +14,7 @@ use serde::{Deserialize, Serialize};
 use std::{
 	collections::{BTreeMap, HashMap},
 	fmt::Display,
+	hash::Hash,
 	str::FromStr,
 };
 use tracing::instrument;
@@ -100,13 +101,25 @@ pub struct Manifest {
 	pub engines: BTreeMap<EngineKind, VersionReq>,
 
 	/// The standard dependencies of the package
-	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+	#[serde(
+		default,
+		skip_serializing_if = "BTreeMap::is_empty",
+		deserialize_with = "crate::util::deserialize_no_dup_keys"
+	)]
 	pub dependencies: BTreeMap<Alias, DependencySpecifiers>,
 	/// The peer dependencies of the package
-	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+	#[serde(
+		default,
+		skip_serializing_if = "BTreeMap::is_empty",
+		deserialize_with = "crate::util::deserialize_no_dup_keys"
+	)]
 	pub peer_dependencies: BTreeMap<Alias, DependencySpecifiers>,
 	/// The dev dependencies of the package
-	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+	#[serde(
+		default,
+		skip_serializing_if = "BTreeMap::is_empty",
+		deserialize_with = "crate::util::deserialize_no_dup_keys"
+	)]
 	pub dev_dependencies: BTreeMap<Alias, DependencySpecifiers>,
 	/// The user-defined fields of the package
 	#[cfg_attr(test, schemars(skip))]
@@ -115,10 +128,37 @@ pub struct Manifest {
 }
 
 /// An alias of a dependency
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+/// Equality checks (Ord, PartialOrd, PartialEq, Eq, Hash) are case-insensitive
+#[derive(Debug, Clone)]
 pub struct Alias(String);
 ser_display_deser_fromstr!(Alias);
 
+impl Ord for Alias {
+	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+		self.0.to_lowercase().cmp(&other.0.to_lowercase())
+	}
+}
+
+impl PartialOrd for Alias {
+	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl PartialEq for Alias {
+	fn eq(&self, other: &Self) -> bool {
+		self.0.to_lowercase() == other.0.to_lowercase()
+	}
+}
+
+impl Eq for Alias {}
+
+impl Hash for Alias {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		self.0.to_lowercase().hash(state)
+	}
+}
+
 impl Display for Alias {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.pad(&self.0)

src/util.rs

@@ -2,10 +2,14 @@ use crate::AuthConfig;
 use fs_err::tokio as fs;
 use gix::bstr::BStr;
 use semver::Version;
-use serde::{Deserialize, Deserializer, Serializer};
+use serde::{
+	de::{MapAccess, Visitor},
+	Deserialize, Deserializer, Serializer,
+};
 use sha2::{Digest, Sha256};
 use std::{
 	collections::{BTreeMap, HashSet},
+	fmt::{Display, Formatter},
 	path::Path,
 };
 
@@ -132,8 +136,54 @@ macro_rules! ser_display_deser_fromstr {
 				D: serde::de::Deserializer<'de>,
 			{
 				let s = String::deserialize(deserializer)?;
-				Self::from_str(&s).map_err(serde::de::Error::custom)
+				s.parse().map_err(serde::de::Error::custom)
 			}
 		}
 	};
 }
+
+pub fn deserialize_no_dup_keys<'de, D, K, V>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>
+where
+	K: Display + Ord + Deserialize<'de>,
+	V: Deserialize<'de>,
+	D: Deserializer<'de>,
+{
+	struct NoDupKeysVisitor<K, V> {
+		map: BTreeMap<K, V>,
+	}
+
+	impl<'de, K, V> Visitor<'de> for NoDupKeysVisitor<K, V>
+	where
+		K: Display + Ord + Deserialize<'de>,
+		V: Deserialize<'de>,
+	{
+		type Value = BTreeMap<K, V>;
+
+		fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+			formatter.write_str("a map with no duplicate keys")
+		}
+
+		fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+		where
+			A: MapAccess<'de>,
+		{
+			let mut map = self.map;
+
+			while let Some((key, value)) = access.next_entry()? {
+				if map.contains_key(&key) {
+					return Err(serde::de::Error::custom(format!(
+						"duplicate key `{key}` at line"
+					)));
+				}
+
+				map.insert(key, value);
+			}
+
+			Ok(map)
+		}
+	}
+
+	deserializer.deserialize_map(NoDupKeysVisitor {
+		map: BTreeMap::new(),
+	})
+}