rigortype 0.1.9 → 0.1.11

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/analyzer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class RailsRoutes < Rigor::Plugin::Base
+      # Walks a parsed file's AST looking for `*_path` /
+      # `*_url` calls and validates each against the
+      # plugin's {HelperTable}. Emits info diagnostics for
+      # recognised helpers and error diagnostics for typos /
+      # arity mismatches.
+      module Analyzer
+        DID_YOU_MEAN_DISTANCE = 3
+
+        # Built-in Rails helpers we don't want to flag as
+        # unknown. The plugin's HelperTable describes
+        # user-declared routes; Rails ships built-in helpers
+        # (`url_for`, `polymorphic_path`, …) the plugin
+        # deliberately ignores.
+        BUILTIN_PASSTHROUGH = %w[
+          url_for_path url_for_url
+          polymorphic_path polymorphic_url
+        ].freeze
+
+        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+
+        module_function
+
+        # @param path [String] file being analysed
+        # @param root [Prism::Node]
+        # @param helper_table [HelperTable]
+        # @return [Array<Diagnostic>]
+        def diagnose(path:, root:, helper_table:)
+          diagnostics = []
+          walk(root) do |call_node|
+            name = call_node.name.to_s
+            next unless name.end_with?("_path") || name.end_with?("_url")
+            next if BUILTIN_PASSTHROUGH.include?(name)
+
+            entry = helper_table.find(name)
+            if entry
+              diagnostics << info_diagnostic(path, call_node, entry)
+              arity_diagnostic = arity_check(path, call_node, entry, helper_table)
+              diagnostics << arity_diagnostic if arity_diagnostic
+            else
+              diagnostics << unknown_helper_diagnostic(path, call_node, name, helper_table)
+            end
+          end
+          diagnostics
+        end
+
+        def walk(node, &)
+          return unless node.is_a?(Prism::Node)
+
+          yield node if node.is_a?(Prism::CallNode) && implicit_helper_call?(node)
+          node.compact_child_nodes.each { |child| walk(child, &) }
+        end
+
+        # `*_path` / `*_url` calls without an explicit
+        # receiver. Calls like `obj.users_path` or
+        # `Foo::users_path` are NOT route-helper invocations
+        # in Rails — controllers / views call helpers
+        # implicitly.
+        def implicit_helper_call?(node)
+          node.receiver.nil? && (node.name.to_s.end_with?("_path") || node.name.to_s.end_with?("_url"))
+        end
+
+        def info_diagnostic(path, call_node, entry)
+          location = call_node.location
+          method_label = entry.http_method ? entry.http_method.to_s.upcase : "*"
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :info,
+            rule: "helper",
+            message: "`#{entry.name}` → #{method_label} #{entry.path}"
+          )
+        end
+
+        def arity_check(path, call_node, entry, helper_table)
+          actual = (call_node.arguments&.arguments || []).size
+          # Uncountable nouns (`news` / `series` / `media`) cause
+          # Rails to register two entries under the same helper
+          # name — `news_path` accepts both arity 0 (index) and
+          # arity 1 (show). The HelperTable multimap stores both;
+          # accepts_arity? checks the full set.
+          return nil if helper_table.accepts_arity?(entry.name, actual)
+
+          arities = helper_table.acceptable_arities(entry.name).sort
+          expected = arities.length == 1 ? arities.first.to_s : "#{arities.first}..#{arities.last}"
+          location = call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :error,
+            rule: "wrong-arity",
+            message: "`#{entry.name}` expects #{expected} argument(s), got #{actual}"
+          )
+        end
+
+        def unknown_helper_diagnostic(path, call_node, name, helper_table)
+          location = call_node.location
+          suggestion = did_you_mean(name, helper_table.names)
+          message = "no route helper `#{name}`"
+          message += " (did you mean `#{suggestion}`?)" if suggestion
+
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            severity: :error,
+            rule: "unknown-helper",
+            message: message
+          )
+        end
+
+        # Levenshtein-style nearest neighbour. Returns the
+        # closest known helper within {DID_YOU_MEAN_DISTANCE}
+        # edits, or nil.
+        def did_you_mean(name, candidates)
+          best = nil
+          best_distance = DID_YOU_MEAN_DISTANCE + 1
+          candidates.each do |candidate|
+            d = levenshtein(name, candidate)
+            if d < best_distance
+              best = candidate
+              best_distance = d
+            end
+          end
+          best
+        end
+
+        # Standard iterative Levenshtein. Lifted from
+        # rigor-routes' equivalent helper for parity.
+        def levenshtein(left, right)
+          return right.length if left.empty?
+          return left.length if right.empty?
+
+          rows = Array.new(left.length + 1) { Array.new(right.length + 1, 0) }
+          (0..left.length).each { |i| rows[i][0] = i }
+          (0..right.length).each { |j| rows[0][j] = j }
+
+          (1..left.length).each do |i|
+            (1..right.length).each do |j|
+              cost = left[i - 1] == right[j - 1] ? 0 : 1
+              rows[i][j] = [
+                rows[i - 1][j] + 1,
+                rows[i][j - 1] + 1,
+                rows[i - 1][j - 1] + cost
+              ].min
+            end
+          end
+          rows[left.length][right.length]
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/helper_table.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class RailsRoutes < Rigor::Plugin::Base
+      # Frozen catalogue of route helpers parsed from
+      # `config/routes.rb`. Each entry maps a helper name
+      # (`users_path`, `edit_user_path`, …) to the metadata
+      # downstream consumers and the analyzer's per-call
+      # validation need:
+      #
+      # - `arity`: number of positional arguments the helper
+      #   takes. `users_path` → 0; `user_path(:id)` → 1;
+      #   `user_post_path(:user_id, :id)` → 2.
+      # - `path`: the path template Rails generates
+      #   (`/users/:user_id/posts/:id`).
+      # - `http_method`: `:get` / `:post` / `:patch` / `:put` /
+      #   `:delete` for the canonical action; `nil` for
+      #   helpers that span multiple methods (a `resources`
+      #   show helper isn't HTTP-method-specific in the
+      #   helper sense — it's path-sensitive only).
+      # - `action`: `:index` / `:show` / `:new` / `:edit` /
+      #   `:create` / `:update` / `:destroy` for resourceful
+      #   routes; `:custom` for explicit `get`/`post`/etc.;
+      #   `:root` for the root route.
+      #
+      # Both `_path` and `_url` forms share the same metadata —
+      # the table records each helper twice (once with `_path`,
+      # once with `_url`) for `O(1)` lookup at the call site.
+      class HelperTable
+        Entry = Data.define(:name, :arity, :path, :http_method, :action)
+
+        attr_reader :entries
+
+        # @param entries [Array<Entry>] freshly built; the
+        #   factory below is the canonical construction path.
+        def initialize(entries)
+          @entries = entries.freeze
+          # Multimap: a single helper name can map to multiple
+          # entries when an uncountable-noun resource registers
+          # both an arity-0 index helper and an arity-1 show
+          # helper under the same `news_path` name. `find`
+          # returns the first entry (preserving the previous
+          # API); `accepts_arity?` checks against every entry.
+          @by_name = entries.group_by(&:name).transform_values(&:freeze).freeze
+          freeze
+        end
+
+        # @return [Entry, nil] First matching entry; for the
+        #   uncountable-noun case this is the index helper
+        #   (the show helper is also registered but starts
+        #   second).
+        def find(helper_name)
+          @by_name[helper_name.to_s]&.first
+        end
+
+        # @return [Boolean]
+        def known?(helper_name)
+          @by_name.key?(helper_name.to_s)
+        end
+
+        # @return [Boolean] true when any entry under this
+        #   helper name accepts the given positional arity.
+        def accepts_arity?(helper_name, arity)
+          (@by_name[helper_name.to_s] || []).any? { |entry| entry.arity == arity }
+        end
+
+        # @return [Array<Integer>] all accepted positional
+        #   arities for a helper name. Empty when unknown.
+        def acceptable_arities(helper_name)
+          (@by_name[helper_name.to_s] || []).map(&:arity).uniq
+        end
+
+        # All helper names — used by the "did you mean" suggester.
+        def names
+          @by_name.keys
+        end
+
+        def empty?
+          @entries.empty?
+        end
+
+        def size
+          @entries.size
+        end
+
+        def to_h
+          # Plain dump for fact-store publishing (ADR-9). Each
+          # name serialises as a small Hash for the FIRST entry
+          # under that name, with `acceptable_arities` carrying
+          # the full arity set so cross-plugin consumers can
+          # honour the uncountable-noun multi-arity case.
+          @by_name.transform_values do |group|
+            entry = group.first
+            { name: entry.name, arity: entry.arity, path: entry.path,
+              http_method: entry.http_method, action: entry.action,
+              acceptable_arities: group.map(&:arity).uniq }
+          end
+        end
+      end
+    end
+  end
+end