ruby-reforge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab4619d1d1f5500df76531c2c3483b1ac972c2b513e5a2ac9017a271219ad605
+  data.tar.gz: a4c5435975e097dd6e3241ddc4122fb6e9830bd55e9101a987edbb6f3b392a37
+SHA512:
+  metadata.gz: 106c1ed7177fc8010264651a160cf50434f5768762a6cd1ed1536c373464e1f8f32950f0e5d815fcf0b393070a48719ba3bca1e84ddf0b98c84f200676ea32a4
+  data.tar.gz: cf2e590eaa44a0d37aff8081d1dc32a338c817be793a88c6c355db628752288e9a2ede674d924270c1e683a6eaf0fd47f8d74be5a52646c4f974c94c439847d1

data/.rspec

@@ -0,0 +1,4 @@
+--require spec_helper
+--color
+--format documentation
+

data/.ruby-version

@@ -0,0 +1,2 @@
+3.1.0
+

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2024-01-XX
+
+### Added
+- Initial release
+- CLI interface with `upgrade`, `report`, and `ai-fix` commands
+- Automatic version file updates (`.ruby-version`, `Gemfile`, `gemspec`)
+- Code scanner using Prism for AST parsing
+- Migration rules for Ruby 3.0, 3.1, 3.2, and 3.3
+- Rails-specific deprecation rules
+- Interactive mode for reviewing changes
+- Dry-run mode
+- Git integration (branch creation and commits)
+- Detailed reporting with colorized output
+
+### Features
+- Detects and fixes deprecated methods (`File.exists?`, `Dir.exists?`, etc.)
+- Pattern-based code rewriting
+- Rails filter to action migrations
+- Comprehensive upgrade reports
+

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ruby-reforge.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+group :development, :test do
+  gem "rspec", "~> 3.12"
+  gem "rubocop", "~> 1.50"
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Ruby Reforge Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/QUICKSTART.md

@@ -0,0 +1,77 @@
+# Quick Start Guide
+
+## Building the Gem
+
+```bash
+cd ruby-reforge
+gem build ruby-reforge.gemspec
+```
+
+This will create a `ruby-reforge-0.1.0.gem` file.
+
+## Installing Locally
+
+```bash
+gem install ./ruby-reforge-0.1.0.gem
+```
+
+Or install from the local directory:
+
+```bash
+bundle install
+bundle exec ruby-reforge --help
+```
+
+## Development Setup
+
+```bash
+bundle install
+bundle exec rspec  # Run tests
+```
+
+## Usage Examples
+
+### Generate a report
+
+```bash
+ruby-reforge report
+```
+
+### Upgrade to Ruby 3.3
+
+```bash
+ruby-reforge upgrade 3.3
+```
+
+### Interactive mode
+
+```bash
+ruby-reforge upgrade 3.3 --interactive
+```
+
+### Dry run (see what would change)
+
+```bash
+ruby-reforge upgrade 3.3 --dry-run
+```
+
+## Project Structure
+
+```
+ruby-reforge/
+├── lib/
+│   └── ruby/
+│       └── reforge/
+│           ├── cli.rb              # CLI interface
+│           ├── scanner.rb          # Code scanner
+│           ├── rewriter.rb         # Code rewriter
+│           ├── version_updater.rb  # Version file updates
+│           ├── migration_rules.rb  # Ruby version rules
+│           ├── rails_rules.rb      # Rails-specific rules
+│           ├── reporter.rb         # Report generator
+│           └── git_integration.rb  # Git operations
+├── exe/
+│   └── ruby-reforge            # Executable
+├── spec/                          # Tests
+└── ruby-reforge.gemspec        # Gem specification
+```

data/README.md

@@ -0,0 +1,115 @@
+# Ruby Reforge
+
+🚀 Automatically upgrade Ruby projects to newer versions and fix deprecated code.
+
+## Overview
+
+`ruby-reforge` is a gem that scans a Ruby or Rails project, detects incompatible code for a target Ruby version (e.g., upgrading from 3.1 → 3.3), and automatically rewrites or suggests fixes.
+
+## Features
+
+- ✅ Updates `.ruby-version`, `Gemfile`, and `gemspec` files
+- ✅ Fixes deprecated Ruby syntax automatically
+- ✅ Detects and fixes removed features
+- ✅ Rewrites code for new Ruby syntax
+- ✅ Generates detailed upgrade reports
+- ✅ Interactive mode for reviewing changes
+- ✅ Git integration (creates branches, commits changes)
+
+## Installation
+
+```bash
+gem install ruby-reforge
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'ruby-reforge', group: :development
+```
+
+## Usage
+
+### Upgrade to a new Ruby version
+
+```bash
+ruby-reforge upgrade 3.3
+```
+
+This will:
+1. Update version files (`.ruby-version`, `Gemfile`, `gemspec`)
+2. Scan your codebase for deprecated patterns
+3. Automatically fix issues
+4. Create a git branch and commit changes
+
+### Generate a report
+
+```bash
+ruby-reforge report
+```
+
+Shows what needs to be fixed without making changes.
+
+### Interactive mode
+
+```bash
+ruby-reforge upgrade 3.3 --interactive
+```
+
+Prompts before making each change.
+
+### Dry run
+
+```bash
+ruby-reforge upgrade 3.3 --dry-run
+```
+
+Shows what would be changed without making any changes.
+
+## What It Fixes
+
+### Deprecated Methods
+
+- `File.exists?` → `File.exist?`
+- `Dir.exists?` → `Dir.exist?`
+- `URI.escape` → `CGI.escape`
+- And more...
+
+### Version Files
+
+- Updates `.ruby-version`
+- Updates `Gemfile` ruby version
+- Updates `gemspec` required_ruby_version
+
+### Ruby 3.0+ Keyword Arguments
+
+Detects and suggests fixes for keyword argument changes.
+
+## Examples
+
+```bash
+# Upgrade to Ruby 3.3
+ruby-reforge upgrade 3.3
+
+# Generate report for Ruby 3.2
+ruby-reforge report --target 3.2
+
+# Interactive upgrade
+ruby-reforge upgrade 3.3 --interactive
+```
+
+## Roadmap
+
+- [ ] Rails-specific deprecations
+- [ ] Gem dependency compatibility checker
+- [ ] AI-assisted fixes for complex code
+- [ ] Test framework updates
+- [ ] Performance improvement suggestions
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+

data/exe/ruby-reforge

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "ruby/reforge"
+
+Ruby::Reforge::CLI.start(ARGV)
+

data/lib/ruby/reforge/cli.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "thor"
+require "rainbow"
+require "tty-prompt"
+
+module Ruby
+  module Reforge
+    class CLI < Thor
+      include Thor::Actions
+
+      desc "upgrade VERSION", "Upgrade Ruby project to target version"
+      option :interactive, type: :boolean, aliases: "-i", desc: "Interactive mode - prompts before changes"
+      option :dry_run, type: :boolean, aliases: "-d", desc: "Show what would be changed without making changes"
+      option :branch, type: :string, desc: "Git branch name (default: upgrade/ruby-VERSION)"
+      def upgrade(version)
+        say "🚀 Ruby Reforge - Upgrading to Ruby #{version}", :green
+        say ""
+
+        target_version = normalize_version(version)
+        current_version = detect_current_ruby_version
+
+        if current_version == target_version
+          say "✓ Already on Ruby #{target_version}", :green
+          exit 0
+        end
+
+        say "Current Ruby version: #{current_version || 'unknown'}", :yellow
+        say "Target Ruby version: #{target_version}", :yellow
+        say ""
+
+        # Create git branch if in git repo
+        if git_integration.available?
+          branch_name = options[:branch] || "upgrade/ruby-#{target_version}"
+          git_integration.create_branch(branch_name) unless options[:dry_run]
+        end
+
+        # Scan for issues
+        say "🔍 Scanning codebase...", :cyan
+        issues = scanner.scan(target_version)
+
+        # Generate report
+        reporter.report(issues, current_version, target_version)
+
+        if options[:dry_run]
+          say "\n🔍 DRY RUN - No changes made", :yellow
+          exit 0
+        end
+
+        # Interactive mode
+        if options[:interactive]
+          prompt = TTY::Prompt.new
+          unless prompt.yes?("Proceed with automatic fixes?")
+            say "Aborted.", :red
+            exit 0
+          end
+        end
+
+        # Update version files
+        say "\n📝 Updating version files...", :cyan
+        version_updater.update(target_version)
+
+        # Apply fixes
+        say "\n🔧 Applying fixes...", :cyan
+        rewriter.rewrite(issues, interactive: options[:interactive])
+
+        # Commit changes
+        if git_integration.available? && !options[:dry_run]
+          git_integration.commit_version_files
+          git_integration.commit_code_changes
+        end
+
+        say "\n✅ Upgrade complete!", :green
+        say "\nNext steps:"
+        say "  1. Review the changes"
+        say "  2. Run your test suite"
+        say "  3. Update dependencies: bundle update"
+        say "  4. Check for any manual fixes needed"
+      end
+
+      desc "report", "Generate a report of deprecated code and upgrade issues"
+      option :target, type: :string, desc: "Target Ruby version (default: latest stable)"
+      def report
+        say "📊 Ruby Reforge - Generating Report", :green
+        say ""
+
+        current_version = detect_current_ruby_version
+        target_version = options[:target] ? normalize_version(options[:target]) : "3.3.0"
+
+        say "Current Ruby version: #{current_version || 'unknown'}", :yellow
+        say "Target Ruby version: #{target_version}", :yellow
+        say ""
+
+        say "🔍 Scanning codebase...", :cyan
+        issues = scanner.scan(target_version)
+
+        reporter.report(issues, current_version, target_version)
+      end
+
+      desc "ai-fix", "Use AI to fix complex deprecated code (experimental)"
+      option :model, type: :string, default: "local", desc: "AI model to use (local, openai, anthropic)"
+      def ai_fix
+        say "🤖 AI-Assisted Fix Mode (Experimental)", :green
+        say "This feature is coming soon!", :yellow
+      end
+
+      private
+
+      def normalize_version(version)
+        # Normalize version string (e.g., "3.3" -> "3.3.0")
+        parts = version.split(".").map(&:to_i)
+        parts << 0 while parts.size < 3
+        parts[0..2].join(".")
+      end
+
+      def detect_current_ruby_version
+        version_updater.detect_current_version
+      end
+
+      def scanner
+        @scanner ||= Scanner.new(source_root)
+      end
+
+      def rewriter
+        @rewriter ||= Rewriter.new(source_root)
+      end
+
+      def version_updater
+        @version_updater ||= VersionUpdater.new(source_root)
+      end
+
+      def reporter
+        @reporter ||= Reporter.new
+      end
+
+      def git_integration
+        @git_integration ||= GitIntegration.new(source_root)
+      end
+
+      def source_root
+        @source_root ||= Dir.pwd
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/git_integration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ruby
+  module Reforge
+    class GitIntegration
+      def initialize(root_path)
+        @root_path = root_path
+      end
+
+      def available?
+        git_dir = File.join(@root_path, ".git")
+        File.directory?(git_dir) && system("git --version > /dev/null 2>&1")
+      end
+
+      def create_branch(branch_name)
+        return unless available?
+
+        system("cd #{@root_path} && git checkout -b #{branch_name} 2>/dev/null") ||
+          system("cd #{@root_path} && git checkout #{branch_name} 2>/dev/null")
+      end
+
+      def commit_version_files
+        return unless available?
+
+        files = [".ruby-version", "Gemfile"]
+        files += Dir.glob(File.join(@root_path, "**/*.gemspec"))
+
+        staged_files = files.select { |f| File.exist?(File.join(@root_path, f)) }
+        return if staged_files.empty?
+
+        system("cd #{@root_path} && git add #{staged_files.join(' ')}")
+        system("cd #{@root_path} && git commit -m 'chore: update Ruby version files'")
+      end
+
+      def commit_code_changes
+        return unless available?
+
+        # Get list of modified Ruby files
+        modified = `cd #{@root_path} && git diff --name-only --diff-filter=M`.split("\n")
+        ruby_files = modified.select { |f| f.end_with?(".rb") }
+
+        return if ruby_files.empty?
+
+        system("cd #{@root_path} && git add #{ruby_files.join(' ')}")
+        system("cd #{@root_path} && git commit -m 'fix: update deprecated Ruby syntax'")
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/migration_rules.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Reforge
+    class MigrationRules
+      RULES = {
+        "3.0.0" => {
+          deprecated_methods: {
+            "File.exists?" => "File.exist?",
+            "Dir.exists?" => "Dir.exist?",
+            "URI.escape" => "CGI.escape",
+            "URI.unescape" => "CGI.unescape"
+          },
+          deprecated_patterns: {
+            /File\.exists\?/ => "File.exist?",
+            /Dir\.exists\?/ => "Dir.exist?",
+            /URI\.escape/ => "CGI.escape",
+            /URI\.unescape/ => "CGI.unescape"
+          },
+          breaking_changes: [
+            "Keyword arguments are now separated from positional arguments"
+          ]
+        },
+        "3.1.0" => {
+          deprecated_methods: {
+            "File.exists?" => "File.exist?",
+            "Dir.exists?" => "Dir.exist?"
+          },
+          deprecated_patterns: {
+            /File\.exists\?/ => "File.exist?",
+            /Dir\.exists\?/ => "Dir.exist?"
+          }
+        },
+        "3.2.0" => {
+          deprecated_methods: {
+            "File.exists?" => "File.exist?",
+            "Dir.exists?" => "Dir.exist?"
+          },
+          deprecated_patterns: {
+            /File\.exists\?/ => "File.exist?",
+            /Dir\.exists\?/ => "Dir.exist?"
+          }
+        },
+        "3.3.0" => {
+          deprecated_methods: {
+            "File.exists?" => "File.exist?",
+            "Dir.exists?" => "Dir.exist?"
+          },
+          deprecated_patterns: {
+            /File\.exists\?/ => "File.exist?",
+            /Dir\.exists\?/ => "Dir.exist?"
+          }
+        }
+      }.freeze
+
+      def self.for_version(version)
+        # Find the most appropriate rule set
+        target = normalize_version(version)
+        rule_key = RULES.keys.select { |k| normalize_version(k) <= target }.max || RULES.keys.first
+        new(RULES[rule_key] || {})
+      end
+
+      def self.normalize_version(version)
+        parts = version.to_s.split(".").map(&:to_i)
+        parts << 0 while parts.size < 3
+        parts[0..2].join(".")
+      end
+
+      attr_reader :deprecated_methods, :deprecated_patterns, :breaking_changes
+
+      def initialize(rules = {})
+        @deprecated_methods = rules[:deprecated_methods] || {}
+        @deprecated_patterns = rules[:deprecated_patterns] || {}
+        @breaking_changes = rules[:breaking_changes] || []
+      end
+    end
+  end
+end
+

data/lib/ruby/reforge/rails_rules.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Reforge
+    class RailsRules
+      RAILS_DEPRECATIONS = {
+        "before_filter" => "before_action",
+        "after_filter" => "after_action",
+        "around_filter" => "around_action",
+        "skip_before_filter" => "skip_before_action",
+        "skip_after_filter" => "skip_after_action",
+        "skip_around_filter" => "skip_around_action",
+        "update_attributes" => "update",
+        "update_attributes!" => "update!",
+        "render :text" => "render plain:",
+        "render :nothing" => "head :ok"
+      }.freeze
+
+      RAILS_PATTERNS = {
+        /before_filter/ => "before_action",
+        /after_filter/ => "after_action",
+        /around_filter/ => "around_action",
+        /skip_before_filter/ => "skip_before_action",
+        /skip_after_filter/ => "skip_after_action",
+        /skip_around_filter/ => "skip_around_action",
+        /\.update_attributes\(/ => ".update(",
+        /\.update_attributes!/ => ".update!",
+        /render\s+:text\s*=>/ => "render plain:",
+        /render\s+:nothing/ => "head :ok"
+      }.freeze
+
+      def self.deprecated_methods
+        RAILS_DEPRECATIONS
+      end
+
+      def self.deprecated_patterns
+        RAILS_PATTERNS
+      end
+
+      def self.detect_rails_project?(root_path)
+        File.exist?(File.join(root_path, "config", "application.rb")) ||
+          File.exist?(File.join(root_path, "Gemfile")) && File.read(File.join(root_path, "Gemfile")).include?("rails")
+      end
+    end
+  end
+end
+