ruby-reforge 0.1.0

data/lib/ruby/reforge/reporter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rainbow"
+
+module Ruby
+  module Reforge
+    class Reporter
+      def report(issues, current_version, target_version)
+        say "\n" + "=" * 80, :cyan
+        say "📊 Upgrade Report: Ruby #{current_version || 'unknown'} → #{target_version}", :cyan
+        say "=" * 80, :cyan
+        say ""
+
+        if issues.empty?
+          say "✅ No issues found! Your code is ready for Ruby #{target_version}.", :green
+          return
+        end
+
+        # Group issues by type
+        by_type = issues.group_by(&:type)
+        by_severity = issues.group_by(&:severity)
+
+        # Summary
+        say "Summary:", :yellow
+        say "  Total issues found: #{issues.size}", :white
+        say "  Errors: #{by_severity[:error]&.size || 0}", :red
+        say "  Warnings: #{by_severity[:warning]&.size || 0}", :yellow
+        say "  Info: #{by_severity[:info]&.size || 0}", :blue
+        say ""
+
+        # Issues by file
+        by_file = issues.group_by(&:file)
+        say "Issues by file:", :yellow
+        say ""
+
+        by_file.each do |file, file_issues|
+          relative_path = file.start_with?("/") ? file : file
+          say "  #{relative_path} (#{file_issues.size} issue(s))", :white
+          file_issues.each do |issue|
+            severity_color = case issue.severity
+            when :error then :red
+            when :warning then :yellow
+            else :blue
+            end
+
+            say "    Line #{issue.line}: #{issue.message}", severity_color
+            if issue.old_code && issue.new_code
+              say "      Old: #{issue.old_code}", :red
+              say "      New: #{issue.new_code}", :green
+            end
+          end
+          say ""
+        end
+
+        # Breaking changes
+        if by_type[:breaking_change]
+          say "⚠️  Breaking Changes:", :red
+          by_type[:breaking_change].each do |issue|
+            say "  - #{issue.message}", :red
+          end
+          say ""
+        end
+
+        # Recommendations
+        say "Recommendations:", :yellow
+        say "  1. Review all deprecated method calls", :white
+        say "  2. Test thoroughly after applying fixes", :white
+        say "  3. Update dependencies: bundle update", :white
+        say "  4. Check for gem compatibility with Ruby #{target_version}", :white
+        say ""
+
+        say "Run 'ruby-reforge upgrade #{target_version}' to apply automatic fixes.", :green
+      end
+
+      private
+
+      def say(message, color = nil)
+        puts Rainbow(message).color(color)
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/rewriter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ruby
+  module Reforge
+    class Rewriter
+      def initialize(root_path)
+        @root_path = root_path
+      end
+
+      def rewrite(issues, interactive: false)
+        grouped_issues = issues.group_by(&:file)
+        fixed_count = 0
+
+        grouped_issues.each do |file_path, file_issues|
+          next unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          lines = content.lines
+          modified = false
+
+          # Sort issues by line number (descending) to avoid offset issues
+          file_issues.sort_by { |i| -i.line }.each do |issue|
+            case issue.type
+            when :deprecated_method, :deprecated_pattern
+              if interactive
+                next unless confirm_fix?(issue)
+              end
+
+              line_index = issue.line - 1
+              if line_index < lines.length
+                old_line = lines[line_index]
+                new_line = apply_fix(old_line, issue)
+                if old_line != new_line
+                  lines[line_index] = new_line
+                  modified = true
+                  fixed_count += 1
+                end
+              end
+            end
+          end
+
+          if modified
+            File.write(file_path, lines.join)
+            say "✓ Fixed #{file_issues.size} issue(s) in #{File.basename(file_path)}", :green
+          end
+        end
+
+        fixed_count
+      end
+
+      private
+
+      def apply_fix(line, issue)
+        case issue.type
+        when :deprecated_method
+          # Replace deprecated method calls
+          if issue.old_code && issue.new_code
+            # Try exact match first
+            if line.include?(issue.old_code)
+              line.gsub(issue.old_code, issue.new_code)
+            else
+              # Try with method call syntax
+              line.gsub(/#{Regexp.escape(issue.old_code)}/, issue.new_code)
+            end
+          else
+            line
+          end
+        when :deprecated_pattern
+          # Apply pattern-based fixes - use the new_code which should be the replacement
+          # The issue.new_code contains the full line replacement
+          if issue.new_code
+            issue.new_code
+          else
+            line
+          end
+        else
+          line
+        end
+      end
+
+      def confirm_fix?(issue)
+        require "tty-prompt"
+        prompt = TTY::Prompt.new
+        prompt.yes?("Fix: #{issue.message} at #{File.basename(issue.file)}:#{issue.line}?")
+      end
+
+      def say(message, color = nil)
+        require "rainbow"
+        puts Rainbow(message).color(color)
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/scanner.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "prism"
+require "find"
+
+module Ruby
+  module Reforge
+    class Scanner
+      def initialize(root_path)
+        @root_path = root_path
+        @issues = []
+      end
+
+      def scan(target_version)
+        @target_version = normalize_version(target_version)
+        @issues = []
+
+        # Get migration rules for target version
+        rules = MigrationRules.for_version(@target_version)
+
+        # Add Rails rules if Rails project detected
+        if RailsRules.detect_rails_project?(@root_path)
+          rules = merge_rails_rules(rules)
+        end
+
+        # Scan Ruby files
+        scan_ruby_files(rules)
+
+        @issues
+      end
+
+      private
+
+      def scan_ruby_files(rules)
+        ruby_files.each do |file_path|
+          begin
+            content = File.read(file_path)
+            parse_result = Prism.parse(content, file_path)
+
+            if parse_result.success?
+              scan_ast(parse_result.value, file_path, rules)
+            else
+              # File has syntax errors, but we can still scan for patterns
+              scan_file_content(content, file_path, rules)
+            end
+          rescue => e
+            # Skip files that can't be parsed
+            next
+          end
+        end
+      end
+
+      def scan_ast(node, file_path, rules)
+        # Scan for keyword argument issues (Ruby 3.0+)
+        if @target_version >= "3.0.0"
+          scan_keyword_arguments(node, file_path)
+        end
+
+        # Scan for deprecated method calls
+        scan_deprecated_methods(node, file_path, rules)
+
+        # Recursively scan child nodes
+        node.child_nodes.each do |child|
+          scan_ast(child, file_path, rules) if child.respond_to?(:child_nodes)
+        end
+      end
+
+      def scan_keyword_arguments(node, file_path)
+        # Detect method definitions that might need **args
+        if node.is_a?(Prism::DefNode)
+          # Check if method accepts keyword arguments without **
+          # This is a simplified check - real implementation would be more sophisticated
+        end
+      end
+
+      def scan_deprecated_methods(node, file_path, rules)
+        rules.deprecated_methods.each do |deprecated_method, replacement|
+          if node.is_a?(Prism::CallNode) && node.name == deprecated_method.to_sym
+            @issues << Issue.new(
+              type: :deprecated_method,
+              file: file_path,
+              line: node.location.start_line,
+              message: "#{deprecated_method} is deprecated, use #{replacement} instead",
+              old_code: deprecated_method.to_s,
+              new_code: replacement.to_s
+            )
+          end
+        end
+      end
+
+      def scan_file_content(content, file_path, rules)
+        lines = content.lines
+
+        rules.deprecated_patterns.each do |pattern, replacement|
+          lines.each_with_index do |line, index|
+            if line.match?(pattern)
+              # Preserve indentation when replacing
+              indent = line[/\A\s*/]
+              new_line = line.gsub(pattern, replacement)
+              # Ensure new line ends properly
+              new_line = new_line.chomp + "\n" unless new_line.end_with?("\n")
+              
+              @issues << Issue.new(
+                type: :deprecated_pattern,
+                file: file_path,
+                line: index + 1,
+                message: "Deprecated pattern found: #{pattern.source}",
+                old_code: line,
+                new_code: new_line
+              )
+            end
+          end
+        end
+      end
+
+
+      def ruby_files
+        @ruby_files ||= begin
+          files = []
+          Find.find(@root_path) do |path|
+            next if File.directory?(path)
+            next if path.include?("/vendor/")
+            next if path.include?("/node_modules/")
+            next if path.include?("/.git/")
+            next if path.include?("/tmp/")
+            next if path.include?("/log/")
+
+            files << path if path.end_with?(".rb")
+          end
+          files
+        end
+      end
+
+      def normalize_version(version)
+        parts = version.to_s.split(".").map(&:to_i)
+        parts << 0 while parts.size < 3
+        parts[0..2].join(".")
+      end
+
+      def merge_rails_rules(rules)
+        # Merge Rails deprecations into existing rules
+        merged_methods = rules.deprecated_methods.merge(RailsRules.deprecated_methods)
+        merged_patterns = rules.deprecated_patterns.merge(RailsRules.deprecated_patterns)
+        
+        merged_rules = MigrationRules.new
+        merged_rules.instance_variable_set(:@deprecated_methods, merged_methods)
+        merged_rules.instance_variable_set(:@deprecated_patterns, merged_patterns)
+        merged_rules.instance_variable_set(:@breaking_changes, rules.breaking_changes)
+        merged_rules
+      end
+    end
+
+    class Issue
+      attr_reader :type, :file, :line, :message, :old_code, :new_code
+
+      def initialize(type:, file:, line:, message:, old_code: nil, new_code: nil)
+        @type = type
+        @file = file
+        @line = line
+        @message = message
+        @old_code = old_code
+        @new_code = new_code
+      end
+
+      def severity
+        case @type
+        when :deprecated_method, :deprecated_pattern
+          :warning
+        when :breaking_change
+          :error
+        else
+          :info
+        end
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Reforge
+    VERSION = "0.1.0"
+  end
+end
+

data/lib/ruby/reforge/version_updater.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ruby
+  module Reforge
+    class VersionUpdater
+      def initialize(root_path)
+        @root_path = root_path
+      end
+
+      def update(target_version)
+        updated_files = []
+
+        # Update .ruby-version
+        ruby_version_path = File.join(@root_path, ".ruby-version")
+        if File.exist?(ruby_version_path)
+          File.write(ruby_version_path, "#{target_version}\n")
+          updated_files << ".ruby-version"
+        end
+
+        # Update Gemfile
+        gemfile_path = File.join(@root_path, "Gemfile")
+        if File.exist?(gemfile_path)
+          update_gemfile(gemfile_path, target_version)
+          updated_files << "Gemfile"
+        end
+
+        # Update gemspec files
+        Dir.glob(File.join(@root_path, "**/*.gemspec")).each do |gemspec_path|
+          update_gemspec(gemspec_path, target_version)
+          updated_files << gemspec_path
+        end
+
+        updated_files
+      end
+
+      def detect_current_version
+        # Try .ruby-version first
+        ruby_version_path = File.join(@root_path, ".ruby-version")
+        if File.exist?(ruby_version_path)
+          version = File.read(ruby_version_path).strip
+          return version if version.match?(/^\d+\.\d+\.\d+/)
+        end
+
+        # Try Gemfile
+        gemfile_path = File.join(@root_path, "Gemfile")
+        if File.exist?(gemfile_path)
+          content = File.read(gemfile_path)
+          if match = content.match(/ruby\s+['"]([\d.]+)['"]/)
+            return normalize_version(match[1])
+          end
+        end
+
+        # Try gemspec
+        Dir.glob(File.join(@root_path, "**/*.gemspec")).each do |gemspec_path|
+          content = File.read(gemspec_path)
+          if match = content.match(/required_ruby_version\s*[>=<]+\s*['"]([\d.]+)['"]/)
+            return normalize_version(match[1])
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def update_gemfile(gemfile_path, target_version)
+        content = File.read(gemfile_path)
+        updated_content = content.gsub(
+          /ruby\s+['"][\d.]+['"]/,
+          "ruby '#{target_version}'"
+        )
+
+        # If no ruby version specified, add it after source
+        unless content.match(/ruby\s+['"][\d.]+['"]/)
+          updated_content = updated_content.sub(
+            /(source\s+['"][^'"]+['"])/,
+            "\\1\nruby '#{target_version}'"
+          )
+        end
+
+        File.write(gemfile_path, updated_content)
+      end
+
+      def update_gemspec(gemspec_path, target_version)
+        content = File.read(gemspec_path)
+        updated_content = content.gsub(
+          /required_ruby_version\s*[>=<]+\s*['"][\d.]+['"]/,
+          "required_ruby_version = \">= #{target_version}\""
+        )
+
+        # If no required_ruby_version specified, add it
+        unless content.match(/required_ruby_version/)
+          updated_content = updated_content.sub(
+            /(spec\.version\s*=.*)/,
+            "\\1\n  spec.required_ruby_version = \">= #{target_version}\""
+          )
+        end
+
+        File.write(gemspec_path, updated_content)
+      end
+
+      def normalize_version(version)
+        parts = version.split(".").map(&:to_i)
+        parts << 0 while parts.size < 3
+        parts[0..2].join(".")
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "reforge/version"
+require_relative "reforge/cli"
+require_relative "reforge/scanner"
+require_relative "reforge/rewriter"
+require_relative "reforge/version_updater"
+require_relative "reforge/migration_rules"
+require_relative "reforge/rails_rules"
+require_relative "reforge/reporter"
+require_relative "reforge/git_integration"
+
+module Ruby
+  module Reforge
+    class Error < StandardError; end
+  end
+end
+

data/ruby-reforge.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruby/reforge/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-reforge"
+  spec.version       = Ruby::Reforge::VERSION
+  spec.authors       = ["Afshin Amini"]
+  spec.email         = ["afshmini@gmail.com"]
+
+  spec.summary       = "Automatically upgrade Ruby projects to newer versions and fix deprecated code"
+  spec.description   = <<~DESC
+    ruby-reforge is a gem that scans a Ruby or Rails project, detects incompatible code
+    for a target Ruby version, and automatically rewrites or suggests fixes. It updates
+    version files, fixes deprecated syntax, rewrites code for new Ruby syntax, and
+    suggests Rails-level incompatibilities.
+  DESC
+  spec.homepage      = "https://github.com/afshmini/ruby-reforge"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 1.0"
+  spec.add_dependency "prism", "~> 0.24"
+  spec.add_dependency "parser", "~> 3.3"
+  spec.add_dependency "unparser", "~> 0.6"
+  spec.add_dependency "rainbow", "~> 3.1"
+  spec.add_dependency "tty-prompt", "~> 0.23"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "rubocop", "~> 1.50"
+end
+