upgrade_radar 0.1.0

data/lib/upgrade_radar/matchers/method_call_matcher.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class MethodCallMatcher < Base
+      def initialize(pattern)
+        super
+        @expected_names = Array(pattern["name"]).map(&:to_sym)
+        @receiver_spec = pattern["receiver"]
+        @receiver_chain = pattern["receiver_chain"]
+        @receiver_method = pattern["receiver_method"]
+        @conditions = pattern.fetch("conditions", []) || []
+      end
+
+      def match?(node, **_opts)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless name_matches?(node)
+        return false unless receiver_matches?(node)
+        return false unless conditions_match?(node)
+        true
+      end
+
+      private
+
+      def name_matches?(node)
+        @expected_names.include?(node.name)
+      end
+
+      def receiver_matches?(node)
+        if @receiver_chain
+          match_receiver_chain?(node)
+        elsif @receiver_method
+          match_receiver_method?(node)
+        elsif @receiver_spec.nil? || @receiver_spec == "null"
+          node.receiver.nil?
+        elsif @receiver_spec == "any"
+          true
+        else
+          match_receiver_constant?(node, @receiver_spec)
+        end
+      end
+
+      def match_receiver_chain?(node)
+        chain = @receiver_chain
+        if chain.start_with?("**.")
+          method_name = chain.sub("**.", "").to_sym
+          node.receiver.is_a?(Prism::CallNode) && node.receiver.name == method_name
+        else
+          resolve_chain(node.receiver) == chain
+        end
+      end
+
+      def match_receiver_method?(node)
+        return false unless node.receiver.is_a?(Prism::CallNode)
+        node.receiver.name == @receiver_method.to_sym
+      end
+
+      def match_receiver_constant?(node, name)
+        return false unless node.receiver
+        resolve_constant_name(node.receiver) == name
+      end
+
+      def resolve_chain(node)
+        return nil unless node
+
+        parts = []
+        current = node
+        while current.is_a?(Prism::CallNode)
+          parts.unshift(current.name.to_s)
+          current = current.receiver
+        end
+
+        if current.is_a?(Prism::ConstantReadNode)
+          parts.unshift(current.name.to_s)
+        elsif current.is_a?(Prism::ConstantPathNode)
+          parts.unshift(resolve_constant_name(current))
+        end
+
+        parts.join(".")
+      end
+
+      def resolve_constant_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parts = []
+          current = node
+          while current.is_a?(Prism::ConstantPathNode)
+            parts.unshift(current.name.to_s)
+            current = current.parent
+          end
+          parts.unshift(current.name.to_s) if current.is_a?(Prism::ConstantReadNode)
+          parts.join("::")
+        else
+          node.to_s
+        end
+      end
+
+      def conditions_match?(node)
+        @conditions.all? { |cond| evaluate_condition(cond, node) }
+      end
+
+      def evaluate_condition(condition, node)
+        key, value = condition.is_a?(Hash) ? condition.first : [condition, true]
+        case key
+        when "no_keyword"
+          !has_keyword_arg?(node, value)
+        when "has_block_pass"
+          has_block_pass?(node)
+        when "first_arg_starts_with"
+          first_string_arg_starts_with?(node, value)
+        when "first_arg_type"
+          first_arg_is_type?(node, value)
+        when "keyword_value"
+          has_keyword_with_value?(node, value["key"], value["value"])
+        when "has_keywords"
+          has_any_keywords?(node)
+        when "min_positional_args"
+          positional_arg_count(node) >= value
+        else
+          true
+        end
+      end
+
+      def args_list(node)
+        node.arguments&.arguments || []
+      end
+
+      def has_keyword_arg?(node, key_name)
+        args_list(node).any? do |arg|
+          next false unless arg.is_a?(Prism::KeywordHashNode)
+          arg.elements.any? do |elem|
+            elem.is_a?(Prism::AssocNode) &&
+              elem.key.is_a?(Prism::SymbolNode) &&
+              elem.key.value == key_name
+          end
+        end
+      end
+
+      def has_block_pass?(node)
+        node.block.is_a?(Prism::BlockArgumentNode) ||
+          args_list(node).any? { |a| a.is_a?(Prism::BlockArgumentNode) }
+      end
+
+      def first_string_arg_starts_with?(node, prefix)
+        first = positional_args(node).first
+        first.is_a?(Prism::StringNode) && first.unescaped.start_with?(prefix)
+      end
+
+      def first_arg_is_type?(node, type_name)
+        first = args_list(node).first
+        return false unless first
+
+        case type_name
+        when "string"
+          first.is_a?(Prism::StringNode)
+        when "hash"
+          first.is_a?(Prism::KeywordHashNode)
+        when "symbol"
+          first.is_a?(Prism::SymbolNode)
+        when "constant"
+          first.is_a?(Prism::ConstantReadNode) || first.is_a?(Prism::ConstantPathNode)
+        else
+          false
+        end
+      end
+
+      def has_keyword_with_value?(node, key, expected_value)
+        args_list(node).any? do |arg|
+          next false unless arg.is_a?(Prism::KeywordHashNode)
+          arg.elements.any? do |elem|
+            next false unless elem.is_a?(Prism::AssocNode)
+            next false unless elem.key.is_a?(Prism::SymbolNode) && elem.key.value == key
+            case expected_value
+            when "nil"
+              elem.value.is_a?(Prism::NilNode)
+            when "true"
+              elem.value.is_a?(Prism::TrueNode)
+            when "false"
+              elem.value.is_a?(Prism::FalseNode)
+            else
+              elem.value.is_a?(Prism::StringNode) && elem.value.unescaped == expected_value
+            end
+          end
+        end
+      end
+
+      def has_any_keywords?(node)
+        args_list(node).any? { |a| a.is_a?(Prism::KeywordHashNode) }
+      end
+
+      def positional_args(node)
+        args_list(node).reject { |a| a.is_a?(Prism::KeywordHashNode) || a.is_a?(Prism::BlockArgumentNode) }
+      end
+
+      def positional_arg_count(node)
+        positional_args(node).size
+      end
+    end
+  end
+end

data/lib/upgrade_radar/matchers/string_mutation_matcher.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class StringMutationMatcher < Base
+      MUTATING_METHODS = %i[<< replace gsub! sub! clear []= capitalize! chomp!
+                            chop! delete! downcase! encode! lstrip! rstrip!
+                            strip! squeeze! swapcase! tr! tr_s! upcase!
+                            prepend setbyte unicode_normalize!].freeze
+
+      def match?(node, **_opts)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless MUTATING_METHODS.include?(node.name)
+        return false unless string_literal_receiver?(node.receiver)
+        true
+      end
+
+      private
+
+      def string_literal_receiver?(receiver)
+        case receiver
+        when Prism::StringNode, Prism::InterpolatedStringNode
+          true
+        when Prism::ParenthesesNode
+          receiver.body&.body&.first.is_a?(Prism::StringNode)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/upgrade_radar/result.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class Result
+    attr_reader :findings, :files_scanned, :scan_duration, :from_version, :to_version
+
+    def initialize(findings:, files_scanned:, scan_duration:, from_version: nil, to_version: nil)
+      @findings = findings
+      @files_scanned = files_scanned
+      @scan_duration = scan_duration
+      @from_version = from_version
+      @to_version = to_version
+    end
+
+    def breaking_count
+      findings.count { |f| f.severity == :breaking }
+    end
+
+    def warning_count
+      findings.count { |f| f.severity == :warning }
+    end
+
+    def findings_by_file
+      findings.group_by(&:filepath)
+    end
+
+    def findings_by_rule
+      findings.group_by(&:id)
+    end
+
+    def findings_by_severity
+      findings.group_by(&:severity)
+    end
+
+    def total_effort_minutes
+      findings.sum(&:effort_minutes)
+    end
+
+    def affected_files_count
+      findings.map(&:filepath).uniq.size
+    end
+
+    def exit_code
+      breaking_count > 0 ? 1 : 0
+    end
+  end
+end

data/lib/upgrade_radar/rule.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class Rule
+    attr_reader :id, :framework, :introduced_in, :breaking_in,
+                :pattern, :message, :replacement, :docs, :effort_minutes, :confidence
+
+    def initialize(attrs)
+      @id = attrs.fetch("id")
+      @framework = attrs.fetch("framework")
+      @introduced_in = Gem::Version.new(attrs.fetch("introduced_in").to_s)
+      @breaking_in = Gem::Version.new(attrs.fetch("breaking_in").to_s)
+      @pattern = attrs.fetch("pattern")
+      @message = attrs.fetch("message").strip
+      @replacement = attrs["replacement"]&.strip
+      @docs = attrs["docs"]
+      @effort_minutes = attrs.fetch("effort_minutes", 10)
+      @confidence = attrs.fetch("confidence", "high")
+    end
+
+    def applies?(from_version, to_version)
+      breaking_in >= from_version && introduced_in <= to_version
+    end
+
+    def low_confidence?
+      confidence == "low"
+    end
+
+    # Low-confidence rules can't tell statically whether the receiver is
+    # affected, so they never fail a scan on their own.
+    def severity_for(to_version)
+      return :warning if low_confidence?
+
+      to_version >= breaking_in ? :breaking : :warning
+    end
+
+    def node_types
+      case pattern["type"]
+      when "method_call", "string_mutation"
+        [:call_node]
+      when "constant_reference"
+        [:constant_read_node, :constant_path_node]
+      when "block_parameter"
+        [:call_node]
+      when "gemfile_dependency"
+        [:special]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/upgrade_radar/rule_registry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class RuleRegistry
+    attr_reader :rules
+
+    def initialize
+      @rules = []
+    end
+
+    def load_builtin_rules
+      Dir[File.join(UpgradeRadar::RULES_PATH, "**", "*.yml")].sort.each do |path|
+        load_file(path)
+      end
+      self
+    end
+
+    def load_custom_rules(path)
+      Dir[File.join(path, "**", "*.yml")].sort.each do |file_path|
+        load_file(file_path)
+      end
+      self
+    end
+
+    def rules_for(from_range, to_range)
+      @rules.select do |rule|
+        rule.framework == from_range.framework &&
+          rule.applies?(from_range.version, to_range.version)
+      end
+    end
+
+    private
+
+    def load_file(path)
+      entries = YAML.safe_load_file(path, permitted_classes: []) || []
+      entries.each do |attrs|
+        rule = Rule.new(attrs)
+        raise "Duplicate rule id: #{rule.id}" if @rules.any? { |r| r.id == rule.id }
+        @rules << rule
+      end
+    end
+  end
+end

data/lib/upgrade_radar/runtime/collector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Runtime
+    class Collector
+      attr_reader :warnings
+
+      def initialize
+        @warnings = []
+        @mutex = Mutex.new
+        @seen = Set.new
+      end
+
+      def add(message, source: nil, backtrace: nil)
+        key = message.strip
+        @mutex.synchronize do
+          return if @seen.include?(key)
+          @seen << key
+          @warnings << {
+            message: key,
+            source: source,
+            backtrace: backtrace&.first(5)&.map(&:to_s),
+            timestamp: Time.now
+          }
+        end
+      end
+
+      def to_findings
+        @warnings.map do |w|
+          location = parse_location(w[:backtrace]&.first)
+          RuntimeFinding.new(
+            message: w[:message],
+            source: w[:source],
+            filepath: location[:file],
+            line: location[:line]
+          )
+        end
+      end
+
+      def size
+        @warnings.size
+      end
+
+      def clear
+        @mutex.synchronize do
+          @warnings.clear
+          @seen.clear
+        end
+      end
+
+      private
+
+      def parse_location(backtrace_line)
+        return { file: nil, line: nil } unless backtrace_line
+        if backtrace_line =~ /\A(.+):(\d+)/
+          { file: $1, line: $2.to_i }
+        else
+          { file: nil, line: nil }
+        end
+      end
+    end
+
+    class RuntimeFinding
+      attr_reader :message, :source, :filepath, :line
+
+      def initialize(message:, source:, filepath:, line:)
+        @message = message
+        @source = source
+        @filepath = filepath
+        @line = line
+      end
+    end
+  end
+end

data/lib/upgrade_radar/runtime/middleware.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "collector"
+require_relative "rails_hook"
+require_relative "ruby_warning_hook"
+
+module UpgradeRadar
+  module Runtime
+    class Middleware
+      attr_reader :collector
+
+      def initialize(app, collector: nil)
+        @app = app
+        @collector = collector || Collector.new
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def self.setup_for_rspec(collector = nil)
+        collector ||= Collector.new
+
+        RSpec.configure do |config|
+          config.before(:suite) do
+            RailsHook.install(collector)
+            RubyWarningHook.install(collector)
+          end
+
+          config.after(:suite) do
+            if collector.size > 0
+              $stderr.puts "\n\nUpgrade Radar: #{collector.size} runtime deprecation(s) captured"
+              collector.to_findings.each do |f|
+                $stderr.puts "  #{f.filepath}:#{f.line} #{f.message}"
+              end
+            end
+          end
+        end
+
+        collector
+      end
+
+      def self.setup_for_minitest(collector = nil)
+        collector ||= Collector.new
+        RailsHook.install(collector)
+        RubyWarningHook.install(collector)
+        collector
+      end
+    end
+  end
+end

data/lib/upgrade_radar/runtime/rails_hook.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Runtime
+    class RailsHook
+      def self.install(collector)
+        return unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+        if Rails.application.respond_to?(:deprecators)
+          Rails.application.deprecators.each do |deprecator|
+            original = Array(deprecator.behavior)
+            deprecator.behavior = original + [
+              ->(message, callstack, *) { collector.add(message, source: :rails, backtrace: callstack) }
+            ]
+          end
+        elsif defined?(ActiveSupport::Deprecation)
+          ActiveSupport::Deprecation.behavior = ActiveSupport::Deprecation.behavior + [
+            ->(message, callstack, *) { collector.add(message, source: :rails, backtrace: callstack) }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/upgrade_radar/runtime/ruby_warning_hook.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Runtime
+    class RubyWarningHook
+      def self.install(collector)
+        Warning[:deprecated] = true if Warning.respond_to?(:[]=)
+
+        hook = Module.new do
+          define_method(:warn) do |message, category: nil, **|
+            if category == :deprecated
+              collector.add(message, source: :ruby, backtrace: caller)
+            end
+            super(message, category: category)
+          end
+        end
+
+        Warning.extend(hook)
+      end
+    end
+  end
+end

data/lib/upgrade_radar/scanner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class Scanner
+    def initialize(from:, to:, config:)
+      @from = from
+      @to = to
+      @config = config
+      @registry = RuleRegistry.new
+    end
+
+    def run
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      @registry.load_builtin_rules
+      @registry.load_custom_rules(@config.custom_rules_path) if @config.custom_rules_path
+
+      active_rules = @registry.rules_for(@from, @to)
+      ast_rules = active_rules.reject { |r| r.pattern["type"] == "gemfile_dependency" }
+      gemfile_rules = active_rules.select { |r| r.pattern["type"] == "gemfile_dependency" }
+
+      finder = FileFinder.new(@config.scan_path, exclude_patterns: @config.exclude_patterns)
+      ruby_files = finder.ruby_files
+      findings = []
+
+      ruby_files.each do |filepath|
+        scan_file(filepath, ast_rules, findings)
+      end
+
+      check_gemfile(gemfile_rules, finder, ruby_files, findings)
+
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+      Result.new(
+        findings: findings,
+        files_scanned: ruby_files.size,
+        scan_duration: elapsed,
+        from_version: @from,
+        to_version: @to
+      )
+    end
+
+    private
+
+    def scan_file(filepath, rules, findings)
+      parse_result = Prism.parse_file(filepath)
+      visitor = AuditVisitor.new(filepath, rules, @to.version)
+      visitor.visit(parse_result.value)
+      findings.concat(visitor.findings)
+    rescue => e
+      $stderr.puts "upgrade_radar: error scanning #{filepath}: #{e.message}"
+    end
+
+    def check_gemfile(gemfile_rules, finder, ruby_files, findings)
+      gemfile_rules.each do |rule|
+        matcher = Matchers::GemfileMatcher.new(rule.pattern)
+        missing = matcher.check_gemfile(finder.gemfile_path, ruby_files)
+        missing.each do |gem_name|
+          findings << Finding.new(
+            rule: rule,
+            filepath: finder.gemfile_path || "Gemfile",
+            line: 1,
+            column: 0,
+            source: "missing: gem '#{gem_name}'",
+            severity: rule.severity_for(@to.version)
+          )
+        end
+      end
+    end
+  end
+end