feat(core): update semver in git urls, aliases etc

Closes #213

Author: JamieMason

src/dependency.rs

@@ -125,12 +125,12 @@ impl Dependency {
       .instances
       .borrow()
       .iter()
-      .filter(|instance| instance.descriptor.specifier.is_basic_semver())
+      .filter(|instance| instance.descriptor.specifier.get_node_version().is_some())
       .map(|instance| instance.descriptor.specifier.clone())
       .fold(None, |preferred, specifier| match preferred {
         None => Some(specifier),
         Some(preferred) => {
-          if specifier.cmp(&preferred) == preferred_order {
+          if specifier.get_node_version().cmp(&preferred.get_node_version()) == preferred_order {
             Some(specifier)
           } else {
             Some(preferred)

src/specifier.rs

@@ -218,7 +218,7 @@ impl Specifier {
     }
   }
 
-  fn get_node_version(&self) -> Option<&Version> {
+  pub fn get_node_version(&self) -> Option<&Version> {
     match self {
       Self::Alias(inner) => inner.semver.as_ref().map(|semver| &semver.node_version),
       Self::BasicSemver(inner) => Some(&inner.node_version),
@@ -233,20 +233,38 @@ impl Specifier {
     self.get_semver().map(|semver| &semver.range_variant)
   }
 
-  /// Replace a new instance with the given semver range applied to it when it
-  /// is possible to do so, otherwise the same instance is returned
+  /// Return a new `Specifier` with the given semver range applied to it when it
+  /// is possible to do so, otherwise the same `Specifier` is returned
   pub fn with_range(self, range: &SemverRange) -> Self {
     match self {
-      Self::Alias(inner) => Self::Alias(inner.with_range(range)),
-      Self::BasicSemver(inner) => Self::BasicSemver(inner.with_range(range)),
-      Self::ComplexSemver(inner) => Self::ComplexSemver(inner.with_range(range)),
-      Self::File(inner) => Self::File(inner.with_range(range)),
-      Self::Git(inner) => Self::Git(inner.with_range(range)),
+      Self::Alias(s) => Self::Alias(s.with_range(range)),
+      Self::BasicSemver(s) => Self::BasicSemver(s.with_range(range)),
+      Self::ComplexSemver(s) => Self::ComplexSemver(s.with_range(range)),
+      Self::File(s) => Self::File(s.with_range(range)),
+      Self::Git(s) => Self::Git(s.with_range(range)),
       Self::None => Self::None,
-      Self::Tag(inner) => Self::Tag(inner.with_range(range)),
-      Self::Unsupported(inner) => Self::Unsupported(inner.with_range(range)),
-      Self::Url(inner) => Self::Url(inner.with_range(range)),
-      Self::WorkspaceProtocol(inner) => Self::WorkspaceProtocol(inner.with_range(range)),
+      Self::Tag(s) => Self::Tag(s.with_range(range)),
+      Self::Unsupported(s) => Self::Unsupported(s.with_range(range)),
+      Self::Url(s) => Self::Url(s.with_range(range)),
+      Self::WorkspaceProtocol(s) => Self::WorkspaceProtocol(s.with_range(range)),
+    }
+  }
+
+  /// Return a new `Specifier` with the given semver version number applied to
+  /// it when it is possible to do so, otherwise the same `Specifier` is
+  /// returned. The range is also changed.
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    match self {
+      Self::Alias(s) => Self::Alias(s.with_semver(semver)),
+      Self::BasicSemver(s) => Self::BasicSemver(s.with_semver(semver)),
+      Self::ComplexSemver(s) => Self::ComplexSemver(s.with_semver(semver)),
+      Self::File(s) => Self::File(s.with_semver(semver)),
+      Self::Git(s) => Self::Git(s.with_semver(semver)),
+      Self::None => Self::None,
+      Self::Tag(s) => Self::Tag(s.with_semver(semver)),
+      Self::Unsupported(s) => Self::Unsupported(s.with_semver(semver)),
+      Self::Url(s) => Self::Url(s.with_semver(semver)),
+      Self::WorkspaceProtocol(s) => Self::WorkspaceProtocol(s.with_semver(semver)),
     }
   }
 

src/specifier/alias.rs

@@ -35,4 +35,12 @@ impl Alias {
       self
     }
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    Self {
+      raw: format!("npm:{}@{}", self.name, semver.raw),
+      name: self.name,
+      semver: Some(semver.clone()),
+    }
+  }
 }

src/specifier/basic_semver.rs

@@ -148,4 +148,8 @@ impl BasicSemver {
       }
     }
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    semver.clone()
+  }
 }

src/specifier/complex_semver.rs

@@ -1,4 +1,8 @@
-use {super::semver_range::SemverRange, log::debug, node_semver::Range};
+use {
+  super::{basic_semver::BasicSemver, semver_range::SemverRange},
+  log::debug,
+  node_semver::Range,
+};
 
 /// A specifier containing multiple ranges and/or versions
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
@@ -17,4 +21,9 @@ impl ComplexSemver {
     debug!("Cannot apply semver range '{:?}' to specifier '{}'", range, self.raw);
     self
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    debug!("Cannot apply semver '{:?}' to specifier '{}'", semver, self.raw);
+    self
+  }
 }

src/specifier/git.rs

@@ -51,4 +51,20 @@ impl Git {
       self
     }
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    if let Some(current_semver) = self.semver {
+      Self {
+        raw: self.raw.replace(&current_semver.node_version.to_string(), &semver.raw),
+        origin: self.origin,
+        semver: Some(semver.clone()),
+      }
+    } else {
+      Self {
+        raw: format!("{}#{}", self.origin, semver.raw),
+        origin: self.origin,
+        semver: Some(semver.clone()),
+      }
+    }
+  }
 }

src/specifier/raw.rs

@@ -1,4 +1,7 @@
-use {super::semver_range::SemverRange, log::debug};
+use {
+  super::{basic_semver::BasicSemver, semver_range::SemverRange},
+  log::debug,
+};
 
 /// A specifier not containing semver so not much can be done with it
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
@@ -12,4 +15,9 @@ impl Raw {
     debug!("Cannot apply semver range '{:?}' to specifier '{}'", range, self.raw);
     self
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    debug!("Cannot apply semver '{:?}' to specifier '{}'", semver, self.raw);
+    self
+  }
 }

src/specifier/workspace_protocol.rs

@@ -29,4 +29,12 @@ impl WorkspaceProtocol {
       semver,
     }
   }
+
+  pub fn with_semver(self, semver: &BasicSemver) -> Self {
+    Self {
+      raw: format!("workspace:{}", semver.raw),
+      local_version: self.local_version,
+      semver: semver.clone(),
+    }
+  }
 }

src/specifier_test.rs

@@ -716,6 +716,12 @@ fn comparison() {
     ("workspace:<=0.0.0", "<0.0.0", Ordering::Greater),
     ("workspace:0.0.0", "0.0.0", Ordering::Equal),
     ("workspace:~", "~1.2.3", Ordering::Equal),
+    /* git with a semver tag is ignored and the semver is used */
+    ("github:org/repo#v0.0.0", "github:org/repo#v0.0.0", Ordering::Equal),
+    ("github:org/repo#v0.0.0", "github:org/repo#0.0.0", Ordering::Equal),
+    ("github:org/repo#v0.0.0", "0.0.0", Ordering::Equal),
+    ("github:org/repo#v0.0.1", "0.0.0", Ordering::Greater),
+    ("github:org/repo#0.0.1", "0.0.0", Ordering::Greater),
   ];
   for (str_a, str_b, expected) in cases {
     let local_version = BasicSemver::new("1.2.3");
@@ -765,3 +771,38 @@ fn satisfies_all() {
     );
   }
 }
+
+#[test]
+fn issue_213_git_tags_starting_with_v() {
+  for git_url in git_urls() {
+    let value = "github:uNetworking/uWebSockets.js#v20.43.0";
+    match Specifier::new(value, None) {
+      Specifier::Git(actual) => {
+        assert_eq!(actual.raw, value);
+        assert_eq!(actual.origin, "github:uNetworking/uWebSockets.js");
+        let semver = actual.semver.as_ref().unwrap();
+        assert_eq!(semver.raw, "20.43.0");
+        assert_eq!(semver.variant, BasicSemverVariant::Patch);
+        assert_eq!(semver.range_variant, SemverRange::Exact);
+        assert_eq!(semver.node_version.major, 20);
+        assert_eq!(semver.node_version.minor, 43);
+        assert_eq!(semver.node_version.patch, 0);
+        assert!(semver.node_version.pre_release.is_empty());
+
+        let next_semver = BasicSemver::new("1.2.3").unwrap();
+        let edited = actual.with_semver(&next_semver);
+        assert_eq!(edited.raw, "github:uNetworking/uWebSockets.js#v1.2.3");
+        assert_eq!(edited.origin, "github:uNetworking/uWebSockets.js");
+        let semver = edited.semver.unwrap();
+        assert_eq!(semver.raw, "1.2.3");
+        assert_eq!(semver.variant, BasicSemverVariant::Patch);
+        assert_eq!(semver.range_variant, SemverRange::Exact);
+        assert_eq!(semver.node_version.major, 1);
+        assert_eq!(semver.node_version.minor, 2);
+        assert_eq!(semver.node_version.patch, 3);
+        assert!(semver.node_version.pre_release.is_empty());
+      }
+      _ => panic!("Expected Git"),
+    };
+  }
+}