upgrade_radar 0.1.0

data/lib/upgrade_radar/cli.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module UpgradeRadar
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "scan", "Scan codebase for deprecations and breaking changes"
+    option :from, required: true, type: :string, desc: "Source version (e.g., rails-7.2, ruby-3.3)"
+    option :to, required: true, type: :string, desc: "Target version (e.g., rails-8.0, ruby-3.4)"
+    option :path, type: :string, default: ".", desc: "Path to scan"
+    option :format, type: :string, default: "text", enum: %w[text json html], desc: "Output format"
+    option :output, type: :string, desc: "Output file path (default: stdout)"
+    option :exclude, type: :array, default: [], desc: "Glob patterns to exclude"
+    option :config, type: :string, desc: "Path to config file"
+    def scan
+      from, to = VersionRange.parse(options[:from], options[:to])
+      config = Configuration.new(options)
+      scanner = Scanner.new(from: from, to: to, config: config)
+      result = scanner.run
+
+      formatter = Formatters::Base.for(options[:format])
+      output = formatter.format(result)
+
+      if options[:output]
+        File.write(options[:output], output)
+        $stderr.puts "Report written to #{options[:output]}"
+      else
+        puts output
+      end
+
+      exit(result.exit_code)
+    rescue ArgumentError => e
+      $stderr.puts "Error: #{e.message}"
+      exit(2)
+    end
+
+    desc "rules", "List available rules for a version range"
+    option :from, required: true, type: :string
+    option :to, required: true, type: :string
+    option :format, type: :string, default: "text", enum: %w[text json]
+    def rules
+      from, to = VersionRange.parse(options[:from], options[:to])
+      registry = RuleRegistry.new.load_builtin_rules
+      matching = registry.rules_for(from, to)
+
+      if options[:format] == "json"
+        data = matching.map do |r|
+          { id: r.id, severity: r.severity_for(to.version), message: r.message, docs: r.docs }
+        end
+        puts JSON.pretty_generate(data)
+      else
+        puts "Rules for #{from} → #{to} (#{matching.size} rules):\n\n"
+        matching.each do |r|
+          severity = r.severity_for(to.version)
+          badge = severity == :breaking ? "[BREAKS]" : "[WARN]  "
+          puts "  #{badge} #{r.id}"
+          puts "    #{r.message}"
+          puts ""
+        end
+      end
+    rescue ArgumentError => e
+      $stderr.puts "Error: #{e.message}"
+      exit(2)
+    end
+
+    desc "version", "Print version"
+    def version
+      puts "upgrade_radar #{UpgradeRadar::VERSION}"
+    end
+
+    map %w[-v --version] => :version
+  end
+end

data/lib/upgrade_radar/configuration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class Configuration
+    attr_reader :scan_path, :exclude_patterns, :custom_rules_path, :severity_threshold
+
+    DEFAULT_CONFIG_FILE = ".upgrade_radar.yml"
+
+    def initialize(options = {})
+      @scan_path = File.expand_path(options[:path] || ".")
+      @exclude_patterns = options[:exclude] || []
+      @custom_rules_path = nil
+      @severity_threshold = :all
+
+      load_config_file(options[:config])
+    end
+
+    private
+
+    def load_config_file(explicit_path)
+      config_path = explicit_path || File.join(@scan_path, DEFAULT_CONFIG_FILE)
+      return unless File.exist?(config_path)
+
+      config = YAML.safe_load_file(config_path, permitted_classes: []) || {}
+
+      @exclude_patterns += Array(config["exclude"])
+      @custom_rules_path = config["custom_rules_path"]
+      @severity_threshold = config["severity_threshold"]&.to_sym || @severity_threshold
+    end
+  end
+end

data/lib/upgrade_radar/effort_estimator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class EffortEstimator
+    EFFORT_LABELS = {
+      trivial: 0..30,
+      small: 31..120,
+      medium: 121..480,
+      large: 481..Float::INFINITY
+    }.freeze
+
+    def initialize(result)
+      @result = result
+    end
+
+    def summary
+      total = @result.total_effort_minutes
+      {
+        total_findings: @result.findings.size,
+        breaking: @result.breaking_count,
+        warnings: @result.warning_count,
+        files_affected: @result.affected_files_count,
+        total_effort_minutes: total,
+        total_effort_human: humanize_minutes(total),
+        effort_level: effort_level(total),
+        by_rule: effort_by_rule
+      }
+    end
+
+    private
+
+    def effort_level(minutes)
+      EFFORT_LABELS.each do |label, range|
+        return label if range.include?(minutes)
+      end
+      :large
+    end
+
+    def effort_by_rule
+      @result.findings_by_rule.transform_values do |findings|
+        {
+          count: findings.size,
+          total_minutes: findings.sum(&:effort_minutes),
+          severity: findings.first.severity
+        }
+      end
+    end
+
+    def humanize_minutes(minutes)
+      return "none" if minutes == 0
+
+      if minutes < 60
+        "#{minutes} minutes"
+      elsif minutes < 480
+        hours = (minutes / 60.0).round(1)
+        "~#{hours} hours"
+      else
+        days = (minutes / 480.0).round(1)
+        "~#{days} days"
+      end
+    end
+  end
+end

data/lib/upgrade_radar/file_finder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class FileFinder
+    RUBY_EXTENSIONS = %w[.rb .rake .gemspec].freeze
+    SPECIAL_FILES = %w[Gemfile Rakefile].freeze
+    DEFAULT_EXCLUDES = %w[vendor/** node_modules/** tmp/** log/**].freeze
+
+    def initialize(base_path, exclude_patterns: [])
+      @base_path = File.expand_path(base_path)
+      @exclude_patterns = DEFAULT_EXCLUDES + exclude_patterns
+    end
+
+    def ruby_files
+      pattern = File.join(@base_path, "**", "*")
+      Dir.glob(pattern).select { |f| ruby_file?(f) && !excluded?(f) }.sort
+    end
+
+    def gemfile_path
+      path = File.join(@base_path, "Gemfile")
+      File.exist?(path) ? path : nil
+    end
+
+    private
+
+    def ruby_file?(path)
+      return false unless File.file?(path)
+
+      ext = File.extname(path)
+      return true if RUBY_EXTENSIONS.include?(ext)
+
+      SPECIAL_FILES.include?(File.basename(path))
+    end
+
+    def excluded?(path)
+      relative = path.sub("#{@base_path}/", "")
+      @exclude_patterns.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
+    end
+  end
+end

data/lib/upgrade_radar/finding.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  class Finding
+    attr_reader :rule, :filepath, :line, :column, :source, :severity
+
+    def initialize(rule:, filepath:, line:, column:, source:, severity:)
+      @rule = rule
+      @filepath = filepath
+      @line = line
+      @column = column
+      @source = source.to_s.strip
+      @severity = severity
+    end
+
+    def id
+      rule.id
+    end
+
+    def message
+      rule.message
+    end
+
+    def effort_minutes
+      rule.effort_minutes
+    end
+
+    def to_h
+      {
+        id: rule.id,
+        severity: severity,
+        file: filepath,
+        line: line,
+        column: column,
+        source: source,
+        message: rule.message,
+        replacement: rule.replacement,
+        docs: rule.docs,
+        effort_minutes: effort_minutes
+      }
+    end
+  end
+end

data/lib/upgrade_radar/formatters/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Formatters
+    class Base
+      def format(_result)
+        raise NotImplementedError
+      end
+
+      def self.for(format_name)
+        case format_name.to_s
+        when "text" then TextFormatter.new
+        when "json" then JsonFormatter.new
+        when "html" then HtmlFormatter.new
+        else raise ArgumentError, "Unknown format: #{format_name}. Supported: text, json, html"
+        end
+      end
+    end
+  end
+end

data/lib/upgrade_radar/formatters/html_formatter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Formatters
+    class HtmlFormatter < Base
+      include ERB::Util
+
+      TEMPLATE_PATH = File.expand_path("../templates/report.html.erb", __dir__)
+
+      def format(result)
+        @result = result
+        @estimator = EffortEstimator.new(result)
+        @summary = @estimator.summary
+        template = File.read(TEMPLATE_PATH)
+        erb = ERB.new(template, trim_mode: "-")
+        erb.result(binding)
+      end
+    end
+  end
+end

data/lib/upgrade_radar/formatters/json_formatter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Formatters
+    class JsonFormatter < Base
+      def format(result)
+        estimator = EffortEstimator.new(result)
+
+        data = {
+          metadata: {
+            upgrade_radar_version: UpgradeRadar::VERSION,
+            from: result.from_version&.to_s,
+            to: result.to_version&.to_s,
+            scanned_at: Time.now.strftime("%Y-%m-%dT%H:%M:%S%z"),
+            scan_duration_seconds: result.scan_duration.round(3),
+            files_scanned: result.files_scanned
+          },
+          summary: estimator.summary,
+          findings: result.findings.map(&:to_h)
+        }
+
+        JSON.pretty_generate(data)
+      end
+    end
+  end
+end

data/lib/upgrade_radar/formatters/text_formatter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Formatters
+    class TextFormatter < Base
+      COLORS = {
+        red: "\e[31m",
+        yellow: "\e[33m",
+        green: "\e[32m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        reset: "\e[0m"
+      }.freeze
+
+      def format(result)
+        output = []
+
+        output << header(result)
+        output << ""
+
+        if result.findings.empty?
+          output << colorize("  No deprecations or breaking changes found!", :green)
+        else
+          result.findings_by_file.each do |filepath, findings|
+            output << colorize(filepath, :bold)
+            findings.sort_by(&:line).each do |f|
+              output << format_finding(f)
+            end
+            output << ""
+          end
+        end
+
+        output << effort_summary(result)
+        output.join("\n")
+      end
+
+      private
+
+      def header(result)
+        lines = []
+        lines << colorize("Upgrade Radar v#{UpgradeRadar::VERSION}", :bold)
+        if result.from_version && result.to_version
+          lines << "Scanning for: #{result.from_version} → #{result.to_version}"
+        end
+        lines << "Files scanned: #{result.files_scanned}"
+        lines.join("\n")
+      end
+
+      def format_finding(finding)
+        badge = if finding.severity == :breaking
+                  colorize("[BREAKS]", :red)
+                else
+                  colorize("[WARN]  ", :yellow)
+                end
+
+        lines = []
+        lines << "  #{badge} Line #{finding.line}: #{finding.message}"
+        lines << "    #{colorize('Source:', :dim)} #{truncate(finding.source, 100)}"
+        lines << "    #{colorize('Fix:', :dim)} #{finding.rule.replacement}" if finding.rule.replacement
+        lines << "    #{colorize('Docs:', :dim)} #{finding.rule.docs}" if finding.rule.docs
+        lines.join("\n")
+      end
+
+      def effort_summary(result)
+        estimator = EffortEstimator.new(result)
+        summary = estimator.summary
+
+        lines = []
+        lines << colorize("=" * 60, :dim)
+        lines << colorize("UPGRADE SUMMARY", :bold)
+        lines << colorize("=" * 60, :dim)
+        lines << "  Total findings:  #{summary[:total_findings]}"
+        lines << "  Breaking:        #{colorize(summary[:breaking].to_s, summary[:breaking] > 0 ? :red : :green)}"
+        lines << "  Warnings:        #{colorize(summary[:warnings].to_s, summary[:warnings] > 0 ? :yellow : :green)}"
+        lines << "  Files affected:  #{summary[:files_affected]}"
+        lines << "  Estimated effort: #{colorize(summary[:total_effort_human], :bold)} (#{summary[:effort_level]})"
+        lines << ""
+        lines << "  Scan completed in #{result.scan_duration.round(2)}s"
+        lines.join("\n")
+      end
+
+      def colorize(text, color)
+        if $stdout.tty?
+          "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+        else
+          text
+        end
+      end
+
+      def truncate(text, max)
+        clean = text.gsub(/\s+/, " ")
+        clean.length > max ? "#{clean[0...max]}..." : clean
+      end
+    end
+  end
+end

data/lib/upgrade_radar/matchers/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class Base
+      def self.for(pattern)
+        case pattern["type"]
+        when "method_call"
+          MethodCallMatcher.new(pattern)
+        when "constant_reference"
+          ConstantReferenceMatcher.new(pattern)
+        when "block_parameter"
+          BlockParameterMatcher.new(pattern)
+        when "gemfile_dependency"
+          GemfileMatcher.new(pattern)
+        when "string_mutation"
+          StringMutationMatcher.new(pattern)
+        else
+          raise ArgumentError, "Unknown pattern type: #{pattern['type']}"
+        end
+      end
+
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      def match?(_node, **_opts)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/upgrade_radar/matchers/block_parameter_matcher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class BlockParameterMatcher < Base
+      def match?(node, in_parameterless_block: false, **_opts)
+        return false unless in_parameterless_block
+        if node.is_a?(Prism::ItLocalVariableReadNode)
+          return true
+        end
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless node.name == :it
+        return false unless node.receiver.nil?
+        return false if node.arguments && !node.arguments.arguments.empty?
+        true
+      end
+    end
+  end
+end

data/lib/upgrade_radar/matchers/constant_reference_matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class ConstantReferenceMatcher < Base
+      def initialize(pattern)
+        super
+        @expected_name = pattern["name"]
+        @context = pattern["context"]
+      end
+
+      def match?(node, context: nil, **_opts)
+        return false unless constant_name(node) == @expected_name
+        return false if @context == "rescue" && context != :rescue
+        true
+      end
+
+      private
+
+      def constant_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          build_constant_path(node)
+        else
+          nil
+        end
+      end
+
+      def build_constant_path(node)
+        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("::")
+      end
+    end
+  end
+end

data/lib/upgrade_radar/matchers/gemfile_matcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module UpgradeRadar
+  module Matchers
+    class GemfileMatcher < Base
+      def initialize(pattern)
+        super
+        @required_gems = pattern["gems"] || []
+      end
+
+      def match?(_node, **_opts)
+        false
+      end
+
+      def check_gemfile(gemfile_path, ruby_files)
+        return [] unless gemfile_path && File.exist?(gemfile_path)
+
+        declared = extract_gem_declarations(gemfile_path)
+        missing = []
+
+        @required_gems.each do |gem_name|
+          next if declared.include?(gem_name)
+          next unless used_in_code?(gem_name, ruby_files)
+          missing << gem_name
+        end
+
+        missing
+      end
+
+      private
+
+      def extract_gem_declarations(gemfile_path)
+        content = File.read(gemfile_path)
+        result = Prism.parse(content)
+        gems = Set.new
+
+        visitor = GemfileVisitor.new
+        visitor.visit(result.value)
+        gems.merge(visitor.gem_names)
+
+        gems
+      end
+
+      def used_in_code?(gem_name, ruby_files)
+        ruby_files.any? do |f|
+          content = File.read(f)
+          content.include?("require \"#{gem_name}\"") ||
+            content.include?("require '#{gem_name}'")
+        end
+      end
+
+      class GemfileVisitor < Prism::Visitor
+        attr_reader :gem_names
+
+        def initialize
+          super
+          @gem_names = Set.new
+        end
+
+        def visit_call_node(node)
+          if node.name == :gem && node.receiver.nil?
+            first_arg = node.arguments&.arguments&.first
+            @gem_names << first_arg.unescaped if first_arg.is_a?(Prism::StringNode)
+          end
+          super
+        end
+      end
+    end
+  end
+end