feat(core): write a new specifier parser

Closes #261

Author: JamieMason

src/context.rs

@@ -6,6 +6,7 @@ use {
     package_json::{FormatMismatch, FormatMismatchVariant, PackageJson},
     packages::Packages,
     semver_group::SemverGroup,
+    specifier::basic_semver::BasicSemver,
     version_group::VersionGroup,
   },
   std::{cell::RefCell, collections::HashMap, rc::Rc},
@@ -17,6 +18,8 @@ pub struct Context {
   pub config: Config,
   /// Every instance in the project
   pub instances: Vec<Rc<Instance>>,
+  /// Index of every local package with a valid name and version
+  pub local_versions: HashMap<String, BasicSemver>,
   /// Every package.json in the project
   pub packages: Packages,
   /// All semver groups
@@ -30,28 +33,39 @@ impl Context {
     let mut instances = vec![];
     let dependency_groups = config.rcfile.get_dependency_groups(&packages);
     let semver_groups = config.rcfile.get_semver_groups(&packages);
-    let version_groups = config.rcfile.get_version_groups(&packages);
+    let mut version_groups = config.rcfile.get_version_groups(&packages);
+    let local_versions = packages.get_local_versions();
 
-    packages.get_all_instances(&config, |instance| {
-      let instance = Rc::new(instance);
-      instances.push(Rc::clone(&instance));
-      if let Some(dependency_group) = dependency_groups.iter().find(|alias| alias.can_add(&instance)) {
-        instance.set_internal_name(&dependency_group.label);
+    packages.get_all_instances(&config, |mut descriptor| {
+      let dependency_group = dependency_groups.iter().find(|alias| alias.can_add(&descriptor));
+
+      if let Some(group) = dependency_group {
+        descriptor.internal_name = group.label.clone();
       }
-      if let Some(semver_group) = semver_groups.iter().find(|semver_group| semver_group.selector.can_add(&instance)) {
-        instance.set_semver_group(semver_group);
+
+      if let Some(cli_group) = &config.cli.filter {
+        descriptor.matches_cli_filter = cli_group.can_add(&descriptor);
       }
-      if let Some(version_group) = version_groups
-        .iter()
-        .find(|version_group| version_group.selector.can_add(&instance))
-      {
-        version_group.add_instance(instance, &config.cli.filter);
+
+      let semver_group = semver_groups.iter().find(|group| group.selector.can_add(&descriptor));
+      let version_group = version_groups.iter_mut().find(|group| group.selector.can_add(&descriptor));
+      let instance = Rc::new(Instance::new(descriptor));
+
+      instances.push(Rc::clone(&instance));
+
+      if let Some(group) = semver_group {
+        instance.set_semver_group(group);
+      }
+
+      if let Some(group) = version_group {
+        group.add_instance(instance);
       }
     });
 
     Self {
       config,
       instances,
+      local_versions,
       packages,
       semver_groups,
       version_groups,

src/dependency.rs

@@ -3,7 +3,7 @@ use {
     instance::Instance,
     instance_state::InstanceState,
     package_json::PackageJson,
-    specifier::{orderable::IsOrderable, semver::Semver, simple_semver::SimpleSemver, Specifier},
+    specifier::{semver_range::SemverRange, Specifier},
     version_group::VersionGroupVariant,
   },
   itertools::Itertools,
@@ -26,9 +26,9 @@ pub struct Dependency {
   /// If this dependency is a local package, this is the local instance.
   pub local_instance: RefCell<Option<Rc<Instance>>>,
   /// Does every instance match the filter options provided via the CLI?
-  pub matches_cli_filter: RefCell<bool>,
+  pub matches_cli_filter: bool,
   /// The name of the dependency
-  pub name_internal: String,
+  pub internal_name: String,
   /// The version to pin all instances to when variant is `Pinned`
   pub pinned_specifier: Option<Specifier>,
   /// package.json files developed in the monorepo when variant is `SnappedTo`
@@ -39,7 +39,7 @@ pub struct Dependency {
 
 impl Dependency {
   pub fn new(
-    name_internal: String,
+    internal_name: String,
     variant: VersionGroupVariant,
     pinned_specifier: Option<Specifier>,
     snapped_to_packages: Option<Vec<Rc<RefCell<PackageJson>>>>,
@@ -48,8 +48,8 @@ impl Dependency {
       expected: RefCell::new(None),
       instances: RefCell::new(vec![]),
       local_instance: RefCell::new(None),
-      matches_cli_filter: RefCell::new(false),
-      name_internal,
+      matches_cli_filter: true,
+      internal_name,
       pinned_specifier,
       snapped_to_packages,
       variant,
@@ -68,7 +68,7 @@ impl Dependency {
       .instances
       .borrow()
       .iter()
-      .map(|instance| instance.actual_specifier.clone())
+      .map(|instance| instance.descriptor.specifier.clone())
       .collect();
     set.into_iter().collect()
   }
@@ -95,8 +95,8 @@ impl Dependency {
   pub fn get_instances_by_specifier(&self) -> BTreeMap<String, Vec<Rc<Instance>>> {
     let mut map = BTreeMap::new();
     for instance in self.instances.borrow().iter() {
-      let specifier = instance.actual_specifier.unwrap();
-      map.entry(specifier).or_insert_with(Vec::new).push(Rc::clone(instance));
+      let raw = instance.descriptor.specifier.get_raw();
+      map.entry(raw).or_insert_with(Vec::new).push(Rc::clone(instance));
     }
     map
   }
@@ -111,30 +111,32 @@ impl Dependency {
       .local_instance
       .borrow()
       .as_ref()
-      .map(|instance| instance.actual_specifier.clone())
+      .map(|instance| instance.descriptor.specifier.clone())
   }
 
   pub fn has_local_instance(&self) -> bool {
     self.local_instance.borrow().is_some()
   }
 
   pub fn has_local_instance_with_invalid_specifier(&self) -> bool {
-    self.has_local_instance()
-      && !matches!(
-        self.get_local_specifier().unwrap(),
-        Specifier::Semver(Semver::Simple(SimpleSemver::Exact(_)))
-      )
+    self.get_local_specifier().is_some_and(|local| {
+      if let Specifier::BasicSemver(semver) = local {
+        !matches!(semver.range_variant, SemverRange::Exact)
+      } else {
+        true
+      }
+    })
   }
 
   /// Does every instance in this group have a specifier which is exactly the
   /// same?
   pub fn every_specifier_is_already_identical(&self) -> bool {
-    if let Some(first_actual) = self.instances.borrow().first().map(|instance| &instance.actual_specifier) {
+    if let Some(first_actual) = self.instances.borrow().first().map(|instance| &instance.descriptor.specifier) {
       self
         .instances
         .borrow()
         .iter()
-        .all(|instance| instance.actual_specifier == *first_actual)
+        .all(|instance| instance.descriptor.specifier == *first_actual)
     } else {
       false
     }
@@ -148,15 +150,13 @@ impl Dependency {
       .instances
       .borrow()
       .iter()
-      .filter(|instance| instance.actual_specifier.is_simple_semver())
-      .map(|instance| instance.actual_specifier.clone())
+      .filter(|instance| instance.descriptor.specifier.is_basic_semver())
+      .map(|instance| instance.descriptor.specifier.clone())
       .fold(None, |preferred, specifier| match preferred {
         None => Some(specifier),
         Some(preferred) => {
-          let a = specifier.get_orderable();
-          let b = preferred.get_orderable();
-          if a.cmp(&b) == preferred_order {
-            Some(specifier.clone())
+          if specifier.cmp(&preferred) == preferred_order {
+            Some(specifier)
           } else {
             Some(preferred)
           }
@@ -175,10 +175,10 @@ impl Dependency {
   pub fn get_snapped_to_specifier(&self, every_instance_in_the_project: &[Rc<Instance>]) -> Option<Specifier> {
     if let Some(snapped_to_packages) = &self.snapped_to_packages {
       for instance in every_instance_in_the_project {
-        if *instance.name_internal.borrow() == *self.name_internal {
+        if *instance.internal_name == *self.internal_name {
           for snapped_to_package in snapped_to_packages {
             if instance.package.borrow().name == snapped_to_package.borrow().name {
-              return Some(instance.actual_specifier.clone());
+              return Some(instance.descriptor.specifier.clone());
             }
           }
         }
@@ -203,13 +203,13 @@ impl Dependency {
         if matches!(*b.state.borrow(), InstanceState::Valid(_)) && !matches!(*a.state.borrow(), InstanceState::Valid(_)) {
           return Ordering::Greater;
         }
-        if matches!(&a.actual_specifier, Specifier::None) {
+        if matches!(&a.descriptor.specifier, Specifier::None) {
           return Ordering::Greater;
         }
-        if matches!(&b.actual_specifier, Specifier::None) {
+        if matches!(&b.descriptor.specifier, Specifier::None) {
           return Ordering::Less;
         }
-        let specifier_order = b.actual_specifier.unwrap().cmp(&a.actual_specifier.unwrap());
+        let specifier_order = b.descriptor.specifier.cmp(&a.descriptor.specifier);
         if matches!(specifier_order, Ordering::Equal) {
           a.package.borrow().name.cmp(&b.package.borrow().name)
         } else {

src/effects/fix.rs

@@ -11,7 +11,6 @@ use {
 /// Run the fix command side effects
 pub fn run(ctx: Context) -> Context {
   let ui = Ui { ctx: &ctx };
-  let has_cli_filter = ctx.config.cli.filter.is_some();
   let running_multiple_commands = ctx.config.cli.inspect_mismatches && ctx.config.cli.inspect_formatting;
 
   if ctx.config.cli.inspect_mismatches {
@@ -24,9 +23,9 @@ pub fn run(ctx: Context) -> Context {
     let mut suspect = 0;
 
     ctx.instances.iter().for_each(|instance| {
-      let name_internal = &instance.name_internal.borrow();
+      let internal_name = &instance.internal_name;
 
-      if has_cli_filter && !*instance.matches_cli_filter.borrow() {
+      if !instance.matches_cli_filter {
         return;
       }
 
@@ -47,17 +46,17 @@ pub fn run(ctx: Context) -> Context {
             match variant {
               FixableInstance::IsBanned => instance.remove(),
               _ => {
-                let actual = instance.actual_specifier.unwrap().red();
+                let actual = instance.descriptor.specifier.get_raw().red();
                 let arrow = ui.dim_right_arrow();
-                let expected = instance.expected_specifier.borrow().as_ref().unwrap().unwrap().green();
-                info!("{name_internal} {actual} {arrow} {expected} {location} {state_link}");
+                let expected = instance.expected_specifier.borrow().as_ref().unwrap().get_raw().green();
+                info!("{internal_name} {actual} {arrow} {expected} {location} {state_link}");
                 instance.package.borrow().copy_expected_specifier(instance);
               }
             }
           }
           InvalidInstance::Conflict(_) | InvalidInstance::Unfixable(_) => {
             unfixable += 1;
-            warn!("Unfixable: {name_internal} {location} {state_link}");
+            warn!("Unfixable: {internal_name} {location} {state_link}");
           }
         },
         InstanceState::Suspect(variant) => match variant {
@@ -67,7 +66,7 @@ pub fn run(ctx: Context) -> Context {
           | SuspectInstance::RefuseToSnapLocal
           | SuspectInstance::InvalidLocalVersion => {
             suspect += 1;
-            warn!("Suspect: {name_internal} {location} {state_link}");
+            warn!("Suspect: {internal_name} {location} {state_link}");
           }
         },
       }

src/effects/lint.rs

@@ -3,15 +3,14 @@ use crate::{context::Context, effects::ui::Ui, instance_state::InstanceState, ve
 /// Run the lint command side effects
 pub fn run(ctx: Context) -> Context {
   let ui = Ui { ctx: &ctx };
-  let has_cli_filter = ctx.config.cli.filter.is_some();
   let running_multiple_commands = ctx.config.cli.inspect_mismatches && ctx.config.cli.inspect_formatting;
 
   if ctx.config.cli.inspect_mismatches {
     if running_multiple_commands {
       ui.print_command_header("SEMVER RANGES AND VERSION MISMATCHES");
     }
     ctx.version_groups.iter().for_each(|group| {
-      if has_cli_filter && !*group.matches_cli_filter.borrow() {
+      if !group.matches_cli_filter {
         return;
       }
       ui.print_group_header(group);
@@ -25,13 +24,13 @@ pub fn run(ctx: Context) -> Context {
         return;
       }
       group.for_each_dependency(&ctx.config.cli.sort, |dependency| {
-        if has_cli_filter && !*dependency.matches_cli_filter.borrow() {
+        if !dependency.matches_cli_filter {
           return;
         }
         ui.print_dependency(dependency, &group.variant);
         dependency.for_each_instance(|instance| {
           if !matches!(*instance.state.borrow(), InstanceState::Valid(_)) || ctx.config.cli.show_instances {
-            if has_cli_filter && !*instance.matches_cli_filter.borrow() {
+            if !instance.matches_cli_filter {
               return;
             }
             ui.print_instance(instance, &group.variant);

src/effects/ui.rs

@@ -68,7 +68,7 @@ impl Ui<'_> {
     };
     let instances_len = dependency.instances.borrow().len();
     let count = self.count_column(instances_len);
-    let name = &dependency.name_internal;
+    let name = &dependency.internal_name;
     let name = if self.ctx.config.cli.show_hints && dependency.local_instance.borrow().is_some() {
       let local_hint = "(local)".blue();
       format!("{name} {local_hint}").normal()
@@ -79,7 +79,7 @@ impl Ui<'_> {
       .expected
       .borrow()
       .clone()
-      .map(|expected| expected.unwrap())
+      .map(|expected| expected.get_raw())
       .unwrap_or("".to_string())
       .dimmed();
 
@@ -241,7 +241,12 @@ impl Ui<'_> {
     } else {
       state_link
     };
-    let actual = instance.actual_specifier.unwrap();
+    let actual = instance.descriptor.specifier.get_raw();
+    let actual = if actual.is_empty() {
+      "VERSION_IS_MISSING".yellow()
+    } else {
+      actual.normal()
+    };
     let location = self.instance_location(instance).dimmed();
     match &state {
       InstanceState::Valid(variant) => {
@@ -311,7 +316,7 @@ impl Ui<'_> {
             FixableInstance::SemverRangeMismatch => {
               let arrow = self.dim_right_arrow();
               let expected = instance.get_specifier_with_preferred_semver_range();
-              let expected = expected.unwrap().unwrap();
+              let expected = expected.unwrap().get_raw();
               let expected = expected.green();
               info!("          {icon} {actual} {arrow} {expected} {location} {state_link}");
             }