Address PR review feedback: fix bugs and improve version checking

- Fix wrong version in pro package install command (use pro gem version
  instead of base gem version for react-on-rails-pro)
- Fix sync_versions skipping range specs (^16.5.0) when normalized version
  already matches by tracking non_exact flag in parse_supported_spec
- Restrict strip_range_prefix to forward-looking ranges (^, ~, >=, >),
  treating upper-bound constraints (<, <=) as unsupported
- Reorder auto_fix_versions before wildcard checks so FIX=true resolved
  issues don't appear as errors
- Check all four dependency sections (including optionalDependencies and
  peerDependencies) in doctor npm wildcard check
- Remove duplicate wildcard checks from system_checker (now solely in doctor)
- Skip workspace:/file:/link: specs in version sync check
- Use EXACT_VERSION_REGEX whitelist for npm version detection (catches tags
  like "latest", "beta" that the old blacklist missed)
- Use Gem::Requirement.exact? for Gemfile constraint detection (catches
  all non-exact operators including >, <, <=)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: justin808

react_on_rails/lib/react_on_rails/doctor.rb

@@ -144,9 +144,10 @@ def check_environment
     def check_react_on_rails_versions
       # Use system_checker for comprehensive package validation instead of duplicating
       checker.check_react_on_rails_packages
-      check_version_wildcards
       check_pro_package_consistency
+      # Auto-fix before wildcard checks so resolved issues don't appear as errors
       auto_fix_versions if fix
+      check_version_wildcards
     end
 
     def check_packages
@@ -528,18 +529,35 @@ def check_gem_wildcard_for(gemfile_content, gem_name)
       react_line = gemfile_content.lines.find { |line| line.match(/^\s*gem\s+['"]#{gem_name}['"]/) }
       return unless react_line
 
-      if /['"][~^]/.match?(react_line) || />=\s*/.match?(react_line)
+      version_match = react_line.match(/gem\s+['"]#{gem_name}['"]\s*,\s*['"]([^'"]+)['"]/)
+      unless version_match
+        checker.add_success("✅ Gemfile uses exact version for #{gem_name}")
+        return
+      end
+
+      exact = begin
+        Gem::Requirement.new(version_match[1]).exact?
+      rescue Gem::Requirement::BadRequirementError
+        false
+      end
+
+      if exact
+        checker.add_success("✅ Gemfile uses exact version for #{gem_name}")
+      else
+        version = if gem_name == "react_on_rails_pro"
+                    ReactOnRails::Utils.react_on_rails_pro_version
+                  else
+                    ReactOnRails::VERSION
+                  end
         checker.add_error(<<~MSG.strip)
           🚫 Gemfile uses a non-exact version constraint for #{gem_name}.
 
           React on Rails requires exact version matching between the gem and npm package.
-          Non-exact constraints (~ ^ >=) can cause the gem and npm package to drift apart.
+          Non-exact constraints can cause the gem and npm package to drift apart.
 
           Fix: Use an exact version in your Gemfile:
-            gem '#{gem_name}', '#{gem_name == 'react_on_rails_pro' ? ReactOnRails::Utils.react_on_rails_pro_version : ReactOnRails::VERSION}'
+            gem '#{gem_name}', '#{version}'
         MSG
-      else
-        checker.add_success("✅ Gemfile uses exact version for #{gem_name}")
       end
     end
 
@@ -549,7 +567,9 @@ def check_npm_wildcards
 
       begin
         package_json = JSON.parse(File.read(package_json_path))
-        all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+        all_deps = ReactOnRails::VersionSynchronizer::PACKAGE_SECTIONS.each_with_object({}) do |section, deps|
+          deps.merge!(package_json[section] || {})
+        end
 
         check_npm_wildcard_for(all_deps, "react-on-rails")
         check_npm_wildcard_for(all_deps, "react-on-rails-pro") if ReactOnRails::Utils.react_on_rails_pro?
@@ -564,9 +584,16 @@ def check_npm_wildcard_for(all_deps, package_name)
       npm_version = all_deps[package_name]
       return unless npm_version
 
-      if /[~^><*]/.match?(npm_version) || npm_version.include?(" ")
+      if ReactOnRails::VersionSynchronizer::EXACT_VERSION_REGEX.match?(npm_version)
+        checker.add_success("✅ package.json uses exact version for #{package_name}")
+      else
+        gem_version = if package_name == "react-on-rails-pro"
+                        ReactOnRails::Utils.react_on_rails_pro_version
+                      else
+                        ReactOnRails::VERSION
+                      end
         install_cmd = ReactOnRails::Utils.package_manager_install_exact_command(
-          package_name, ReactOnRails::VersionSyntaxConverter.new.rubygem_to_npm(ReactOnRails::VERSION)
+          package_name, ReactOnRails::VersionSyntaxConverter.new.rubygem_to_npm(gem_version)
         )
         checker.add_error(<<~MSG.strip)
           🚫 package.json uses a non-exact version for #{package_name}: #{npm_version}
@@ -577,8 +604,6 @@ def check_npm_wildcard_for(all_deps, package_name)
           Fix: #{install_cmd}
           Or run: bundle exec rake react_on_rails:sync_versions WRITE=true
         MSG
-      else
-        checker.add_success("✅ package.json uses exact version for #{package_name}")
       end
     end
 

react_on_rails/lib/react_on_rails/system_checker.rb

@@ -169,11 +169,12 @@ def check_shakapacker_in_gemfile
     end
 
     # React on Rails package validation
+    # NOTE: Wildcard/non-exact version checks (Gemfile and npm) are handled by
+    # Doctor#check_version_wildcards to avoid duplicate error messages.
     def check_react_on_rails_packages
       check_react_on_rails_gem
       check_react_on_rails_npm_package
       check_package_version_sync
-      check_gemfile_version_patterns
     end
 
     def check_react_on_rails_gem
@@ -221,6 +222,9 @@ def check_package_version_sync
 
         return unless npm_version && defined?(ReactOnRails::VERSION)
 
+        # Skip workspace/local-link specs that cannot be compared or rewritten
+        return if npm_version.match?(/\A(?:workspace:|file:|link:)/)
+
         # Normalize NPM version format to Ruby gem format for comparison
         # Uses existing VersionSyntaxConverter to handle dash/dot differences
         # (e.g., "16.2.0-beta.10" → "16.2.0.beta.10")
@@ -230,7 +234,6 @@ def check_package_version_sync
 
         if normalized_npm_version == gem_version
           add_success("✅ React on Rails gem and #{package_name} NPM package versions match (#{gem_version})")
-          check_version_patterns(npm_version, gem_version)
         else
           # Check for major version differences
           gem_major = gem_version.split(".")[0].to_i

react_on_rails/lib/react_on_rails/version_synchronizer.rb

@@ -59,7 +59,7 @@ def parse_package_json
       raise ReactOnRails::Error, "Unable to read #{package_json_path}: #{e.message}"
     end
 
-    def detect_changes(package_json_data)
+    def detect_changes(package_json_data) # rubocop:disable Metrics/CyclomaticComplexity
       expected_versions = expected_package_versions
       changes = []
       unsupported_specs = []
@@ -85,7 +85,7 @@ def detect_changes(package_json_data)
             next
           end
           normalized_current_version = converter.rubygem_to_npm(parsed_spec[:version])
-          next if normalized_current_version == expected_version
+          next if normalized_current_version == expected_version && !parsed_spec[:non_exact]
 
           changes << {
             section: section,
@@ -146,18 +146,20 @@ def exact_version?(version)
       version.is_a?(String) && version.match?(EXACT_VERSION_REGEX)
     end
 
-    # Strips semver range prefixes (^, ~, >=, etc.) and returns the bare version if valid.
+    # Strips forward-looking semver range prefixes (^, ~, >=, >) and returns the bare version.
+    # Excludes < and <= because those are upper-bound constraints with different semantics
+    # that should not be silently pinned to an exact version.
     def strip_range_prefix(version_spec)
       return nil unless version_spec.is_a?(String)
 
-      stripped = version_spec.sub(/\A[~^>=<]+\s*/, "")
-      return stripped if exact_version?(stripped)
+      stripped = version_spec.sub(/\A(?:\^|~|>=?)\s*/, "")
+      return stripped if stripped != version_spec && exact_version?(stripped)
 
       nil
     end
 
     def parse_supported_spec(version_spec)
-      return { version: version_spec, prefix: nil } if exact_version?(version_spec)
+      return { version: version_spec, prefix: nil, non_exact: false } if exact_version?(version_spec)
 
       # Handle npm alias syntax: npm:@scope/pkg@version
       if version_spec.is_a?(String) && version_spec.start_with?(NPM_ALIAS_PREFIX)
@@ -166,7 +168,7 @@ def parse_supported_spec(version_spec)
 
       # Handle range prefixes: ^16.5.0, ~16.5.0, >=16.5.0, etc.
       stripped = strip_range_prefix(version_spec)
-      return { version: stripped, prefix: nil } if stripped
+      return { version: stripped, prefix: nil, non_exact: true } if stripped
 
       nil
     end
@@ -177,11 +179,11 @@ def parse_npm_alias_spec(version_spec)
 
       alias_version = version_spec[(at_index + 1)..]
       prefix = version_spec[0..at_index]
-      return { version: alias_version, prefix: prefix } if exact_version?(alias_version)
+      return { version: alias_version, prefix: prefix, non_exact: false } if exact_version?(alias_version)
 
       # Try stripping range prefix from alias version (e.g., npm:@scope/pkg@^16.5.0)
       stripped = strip_range_prefix(alias_version)
-      return { version: stripped, prefix: prefix } if stripped
+      return { version: stripped, prefix: prefix, non_exact: true } if stripped
 
       nil
     end

react_on_rails/spec/lib/react_on_rails/system_checker_spec.rb

@@ -440,12 +440,14 @@
         allow(File).to receive(:read).with("package.json").and_return(package_json_content)
       end
 
-      it "adds a success message and version pattern error" do
+      it "adds a success message (wildcard detection is handled by Doctor)" do
         checker.send(:check_package_version_sync)
         expect(checker.messages.any? do |msg|
           msg[:type] == :success && msg[:content].include?("versions match")
         end).to be true
-        expect(checker.errors?).to be true
+        # Version pattern errors are now detected by Doctor#check_version_wildcards
+        # to avoid duplicate error messages
+        expect(checker.errors?).to be false
       end
     end