ai_refactor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db3b53eb0cea61e83d0d7f5632316be07ced02da11e065626cc5d72329191538
+  data.tar.gz: 9b475208c15ccfaf9185d8c516e62efc28632dc2a6dab6d25beaba28be726278
+SHA512:
+  metadata.gz: 97e8c839f7c5e2dd6fc1edc12b6c46f45e99e07701da53c313c7677a159529dffd91a724cf54cb33b0c51d1b84939fb07e94c9dae516906a72030b30f3c9fcaa
+  data.tar.gz: cd4250db8c71efad4daf61ac551b930904a103b573c595cbc3f2a8be7d6b9947576b00bce52f9c8f5858962802eb8827959b8aba5d32193a3732acfb7a108aeb

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.7

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-05-19
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ai_refactor.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "standard", "~> 1.3"

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: .
+  specs:
+    ai_refactor (0.1.0)
+      colorize (< 2.0)
+      open3 (< 2.0)
+      ruby-openai (>= 3.4.0, < 5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    colorize (0.8.1)
+    faraday (2.7.4)
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (3.0.2)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.0.0)
+    minitest (5.18.0)
+    multipart-post (2.3.0)
+    open3 (0.1.2)
+    parallel (1.23.0)
+    parser (3.2.2.1)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.0)
+    rexml (3.2.5)
+    rubocop (1.50.2)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.1)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.16.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-openai (4.1.0)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    standard (1.28.2)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.0.1)
+    standard-custom (1.0.0)
+      lint_roller (~> 1.0)
+    standard-performance (1.0.1)
+      lint_roller (~> 1.0)
+      rubocop-performance (~> 1.16.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  ai_refactor!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Stephen Ierodiaconou
+
+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/README.md

@@ -0,0 +1,86 @@
+# AI Refactor
+
+AI Refactor is an experimental tool to see how AI (specifically [OpenAI's ChatGPT](https://platform.openai.com/)) can be used to help apply refactoring to code.
+
+The goal is **not** that the AI decides what refactoring to do, but rather, given refactoring tasks specified by the human user,
+the AI can help identify which code to change and apply the relevant refactor.
+
+This is based on the assumption that the LLM AIs are pretty good at identifying patterns.
+
+## Available refactors
+
+Currently only one is available:
+
+### `rspec_to_minitest_rails`
+
+Converts RSpec tests to minitest tests for Rails test suites (ie generated minitest tests are actually `ActiveSupport::TestCase`s).
+
+The tool first runs the original RSpec spec file and then runs the generated minitest test file, and compares the output of both.
+
+The comparison is simply the count of successful and failed tests but this is probably enough to determine if the conversion worked.
+
+```shellq
+stephen$ OPENAI_API_KEY=my-key ai_refactor rspec_to_minitest_rails spec/models/my_thing_spec.rb -v
+AI Refactor 1 files(s)/dir(s) '["spec/models/my_thing_spec.rb"]' with rspec_to_minitest_rails refactor
+====================
+Processing spec/models/my_thing_spec.rb...
+[Run spec spec/models/my_thing_spec.rb... (bundle exec rspec spec/models/my_thing_spec.rb)]
+Do you wish to overwrite test/models/company_buyer_test.rb? (y/n)
+y
+[Converting spec/models/my_thing_spec.rb...]
+[Generate AI output. Generation attempts left: 3]
+[OpenAI finished, with reason 'stop'...]
+[Used tokens: 1869]
+[Converted spec/models/my_thing_spec.rb to test/models/company_buyer_test.rb...]
+[Run generated test file test/models/company_buyer_test.rb (bundle exec rails test test/models/company_buyer_test.rb)...]
+[Done converting spec/models/my_thing_spec.rb to test/models/company_buyer_test.rb...]
+No differences found! Conversion worked!
+Refactor succeeded on spec/models/my_thing_spec.rb
+
+Done processing all files!
+```
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add ai_refactor
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install ai_refactor
+
+## Usage
+
+See `ai_refactor --help` for more information.
+
+```
+Usage: ai_refactor REFACTOR_TYPE INPUT_FILE_OR_DIR [options]
+
+Where REFACTOR_TYPE is one of: ["generic", "rspec_to_minitest_rails", "minitest_to_rspec"]
+
+    -p, --prompt PROMPT_FILE         Specify path to a text file that contains the ChatGPT 'system' prompt.
+    -c, --continue [MAX_MESSAGES]    If ChatGPT stops generating due to the maximum token count being reached, continue to generate more messages, until a stop condition or MAX_MESSAGES. MAX_MESSAGES defaults to 3
+    -m, --model MODEL_NAME           Specify a ChatGPT model to use (default gpt-3.5-turbo).
+        --temperature TEMP           Specify the temperature parameter for ChatGPT (default 0.7).
+        --max-tokens MAX_TOKENS      Specify the max number of tokens of output ChatGPT can generate. Max will depend on the size of the prompt (default 1500)
+    -t, --timeout SECONDS            Specify the max wait time for ChatGPT response.
+    -v, --verbose                    Show extra output and progress info
+    -d, --debug                      Show debugging output to help diagnose issues
+    -h, --help                       Prints this help
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/stevegeek/ai_refactor.
+
+## 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,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/ai_refactor.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/ai_refactor/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ai_refactor"
+  spec.version = AIRefactor::VERSION
+  spec.authors = ["Stephen Ierodiaconou"]
+  spec.email = ["stevegeek@gmail.com"]
+
+  spec.summary = "Use AI to convert a Rails RSpec test suite to minitest."
+  spec.description = "Use OpenAI's ChatGPT to automate converting Rails RSpec tests to minitest (ActiveSupport::TestCase)."
+  spec.homepage = "https://github.com/stevegeek/ai_refactor"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/stevegeek/ai_refactor"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "colorize", "< 2.0"
+  spec.add_dependency "open3", "< 2.0"
+  spec.add_dependency "ruby-openai", ">= 3.4.0", "< 5.0"
+end

data/exe/ai_refactor

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "colorize"
+require "openai"
+require_relative "../lib/ai_refactor"
+
+options = {}
+
+supported_refactors = AIRefactor::Refactors.all
+supported_names = AIRefactor::Refactors.names
+
+# General options for all refactor types
+option_parser = OptionParser.new do |parser|
+  parser.banner = "Usage: ai_refactor REFACTOR_TYPE INPUT_FILE_OR_DIR [options]\n\nWhere REFACTOR_TYPE is one of: #{supported_names}\n\n"
+
+  # todo: support for a sort of generic process which uses a custom prompt file
+  parser.on("-p", "--prompt PROMPT_FILE", String, "Specify path to a text file that contains the ChatGPT 'system' prompt.") do |f|
+    options[:prompt_file_path] = f
+  end
+
+  parser.on("-c", "--continue [MAX_MESSAGES]", Integer, "If ChatGPT stops generating due to the maximum token count being reached, continue to generate more messages, until a stop condition or MAX_MESSAGES. MAX_MESSAGES defaults to 3") do |c|
+    options[:ai_max_attempts] = c || 3
+  end
+
+  parser.on("-m", "--model MODEL_NAME", String, "Specify a ChatGPT model to use (default gpt-3.5-turbo).") do |m|
+    options[:ai_model] = m
+  end
+
+  parser.on(nil, "--temperature TEMP", Float, "Specify the temperature parameter for ChatGPT (default 0.7).") do |p|
+    options[:ai_temperature] = p
+  end
+
+  parser.on(nil, "--max-tokens MAX_TOKENS", Integer, "Specify the max number of tokens of output ChatGPT can generate. Max will depend on the size of the prompt (default 1500)") do |m|
+    options[:ai_max_tokens] = m
+  end
+
+  parser.on("-t", "--timeout SECONDS", Integer, "Specify the max wait time for ChatGPT response.") do |m|
+    options[:ai_timeout] = m
+  end
+
+  parser.on("-v", "--verbose", "Show extra output and progress info") do
+    options[:verbose] = true
+  end
+
+  parser.on("-d", "--debug", "Show debugging output to help diagnose issues") do
+    options[:debug] = true
+  end
+
+  supported_refactors.each do |_name, refactorer|
+    refactorer.command_line_options.each do |option|
+      parser.on(option[:short], option[:long], option[:type], option[:help]) do |o|
+        options[option[:key]] = o
+      end
+    end
+  end
+
+  parser.on("-h", "--help", "Prints this help") do
+    puts parser
+    exit
+  end
+end
+
+option_parser.parse!
+
+logger = AIRefactor::Logger.new(verbose: options[:verbose], debug: options[:debug])
+
+refactoring_type = ARGV.shift
+input_file_path = ARGV
+
+if !AIRefactor::Refactors.supported?(refactoring_type) || input_file_path.nil? || input_file_path.empty?
+  puts option_parser.help
+  exit 1
+end
+
+OpenAI.configure do |config|
+  config.access_token = ENV.fetch("OPENAI_API_KEY")
+  config.organization_id = ENV.fetch("OPENAI_ORGANIZATION_ID", nil)
+  config.request_timeout = options[:ai_timeout] || 240
+end
+
+refactorer = AIRefactor::Refactors.get(refactoring_type)
+
+inputs = input_file_path.map do |path|
+  File.exist?(path) ? path : Dir.glob(path)
+end.flatten
+
+logger.info "AI Refactor #{inputs.size} files(s)/dir(s) '#{input_file_path}' with #{refactorer.refactor_name} refactor\n"
+logger.info "====================\n"
+
+inputs.each do |file|
+  logger.info "Processing #{file}..."
+
+  refactor = refactorer.new(file, options, logger)
+
+  if refactor.run
+    logger.success "Refactor succeeded on #{file}\n"
+  else
+    logger.warn "Refactor failed on #{file}\n"
+  end
+end
+logger.info "Done processing all files!"

data/lib/ai_refactor/file_processor.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "openai"
+require "json"
+
+module AIRefactor
+  class FileProcessor
+    attr_reader :file_path, :output_path, :logger
+
+    def initialize(file_path, output_path, prompt_file_path:, ai_client:, logger:)
+      @file_path = file_path
+      @output_path = output_path
+      @prompt_file_path = prompt_file_path
+      @ai_client = ai_client
+      @logger = logger
+    end
+
+    def output_exists?
+      File.exist?(output_path)
+    end
+
+    def process!(options)
+      logger.debug("Processing #{file_path} with prompt in #{@prompt_file_path}")
+      prompt = File.read(@prompt_file_path)
+      input = File.read(@file_path)
+      messages = [
+        {role: "system", content: prompt},
+        {role: "user", content: "Convert: ```#{input}```"}
+      ]
+      content, finished_reason, usage = generate_next_message(messages, prompt, options, options[:ai_max_attempts] || 3)
+
+      if content && content.length > 0
+        processed = block_given? ? yield(content) : content
+        File.write(output_path, processed)
+      end
+
+      [content, finished_reason, usage]
+    end
+
+    private
+
+    def generate_next_message(messages, prompt, options, attempts_left)
+      logger.verbose "Generate AI output. Generation attempts left: #{attempts_left}"
+      logger.debug "Options: #{options.inspect}"
+      logger.debug "Messages: #{messages.inspect}"
+
+      response = @ai_client.chat(
+        parameters: {
+          model: options[:ai_model] || "gpt-3.5-turbo",
+          messages: messages,
+          temperature: options[:ai_temperature] || 0.7,
+          max_tokens: options[:ai_max_tokens] || 1500
+        }
+      )
+
+      if response["error"]
+        raise StandardError.new("OpenAI error: #{response["error"]["type"]}: #{response["error"]["message"]} (#{response["error"]["code"]})")
+      end
+
+      content = response.dig("choices", 0, "message", "content")
+      finished_reason = response.dig("choices", 0, "finish_reason")
+
+      if finished_reason == "length" && attempts_left > 0
+        generate_next_message(messages + [
+          {role: "assistant", content: content},
+          {role: "user", content: "Continue"}
+        ], prompt, options, attempts_left - 1)
+      else
+        previous_messages = messages.filter { |m| m[:role] == "assistant" }.map { |m| m[:content] }.join
+        content = if previous_messages.length > 0
+          content ? previous_messages + content : previous_messages
+        else
+          content
+        end
+        [content, finished_reason, response["usage"]]
+      end
+    end
+  end
+end

data/lib/ai_refactor/logger.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  class Logger
+    def initialize(verbose: false, debug: false)
+      @verbose = verbose
+      @debug = debug
+    end
+
+    def info(message)
+      puts message
+    end
+
+    def debug(message)
+      return unless @debug
+      puts message.colorize(:light_black)
+    end
+
+    def verbose(message)
+      return unless @verbose
+      puts "[#{message}]".colorize(:light_blue)
+    end
+
+    def warn(message)
+      puts message.colorize(:yellow)
+    end
+
+    def success(message)
+      puts message.colorize(color: :green, mode: :bold)
+    end
+
+    def error(message, bold: false)
+      puts message.colorize(color: :red, mode: bold ? :bold : :default)
+    end
+  end
+end

data/lib/ai_refactor/refactors/generic.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    class Generic
+      attr_reader :input_file, :options, :logger
+
+      def initialize(input_file, options, logger)
+        @input_file = input_file
+        @options = options
+        @logger = logger
+      end
+
+      def run
+        raise "Not implemented"
+      end
+
+      private
+
+      def ai_client
+        @ai_client ||= OpenAI::Client.new
+      end
+
+      class << self
+        def command_line_options
+          []
+        end
+
+        def refactor_name
+          name.split("::")
+            .last
+            .gsub(/::/, "/")
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr("-", "_")
+            .downcase
+        end
+
+        def prompt_file_path
+          File.join(File.dirname(File.expand_path(__FILE__)), "prompts", "#{refactor_name}.md")
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/minitest_to_rspec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    class MinitestToRspec < Generic
+      def run
+        raise "Not implemented"
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/prompts/rspec_to_minitest_rails.md

@@ -0,0 +1,233 @@
+You convert RSpec tests to ActiveSupport::TestCase tests for Ruby on Rails.
+ActiveSupport::TestCase uses MiniTest under the hood.
+Remember that MiniTest does not support `context` blocks, instead these should be removed and the context
+specified in them should be moved directly into the relevant tests.
+Always enclose the output code in triple backticks (```).
+
+Here are some examples to use as a guide:
+
+Example 1) RSpec:
+```
+require "rails_helper"
+
+RSpec.describe Address, type: :model do
+  subject(:model) { described_class.new }
+
+  it { is_expected.not_to have_many(:assigned_companies) }
+  it { is_expected.not_to belong_to(:delivery_location) }
+end
+```
+
+Result 1) minitest:
+```
+require "test_helper"
+
+class AddressTest < ActiveSupport::TestCase
+  @model = Address.new
+
+  test "model should not have any assigned_companies" do
+    assert_empty @model.assigned_companies
+  end
+
+  test "model should not have a delivery_location" do
+    refute @model.delivery_location
+  end
+end
+```
+
+Example 2) RSpec:
+```
+subject(:model) { create(:order_state) }
+
+context "when rejected" do
+  before { model.rejected_at = 1.day.ago }
+
+  context "with reason and message" do
+    before do
+      model.rejected_message = reason
+      model.rejected_reason = RejectedReasons.reason(:out_of_stock)
+    end
+
+    let(:reason) { "my reason" }
+
+    it "should be valid" do
+      expect(model).to be_valid
+    end
+
+    it "should have a rejected message" do
+      expect(model.rejected_message).to eq reason
+    end
+  end
+end
+```
+
+Result 2) minitest:
+```
+setup do
+  @model = FactoryBot.create(:order_state)
+  @reason = "my reason"
+end
+
+test "when rejected, with reason and message, model should be valid" do
+  @model.rejected_at = 1.day.ago
+  @model.rejected_message = @reason
+  @model.rejected_reason = RejectedReasons.reason(:out_of_stock)
+  assert @model.valid?
+  assert_equal @reason, @model.rejected_message
+end
+```
+
+Example 3) RSpec:
+```
+RSpec.describe Address, type: :model do
+  subject(:model) { build_stubbed(:address, geo: point_1) }
+
+  let(:factory) { RGeo::Geographic.spherical_factory(srid: 4326) }
+  let(:point_1) { factory.point(-84.3804222, 33.6502466) }
+  let(:point_2) { factory.point(-84.00, 33.00) }
+
+  it { is_expected.to be_instance_of(described_class) }
+end
+```
+
+Result 3) minitest:
+```
+class AddressTest < ActiveSupport::TestCase
+  setup do
+    @factory = RGeo::Geographic.spherical_factory(srid: 4326)
+    @point_1 = @factory.point(-84.3804222, 33.6502466)
+    @point_2 = @factory.point(-84.00, 33.00)
+    @model = FactoryBot.build_stubbed(:address, geo: @point_1)
+  end
+
+  test "model should be an instance of the Address" do
+    assert_instance_of Address, @model
+  end
+end
+```
+
+Example 4) RSpec:
+```
+describe "geocoding" do
+  context "when address line changed" do
+    before { model.line_1 = "1 Test Road" }
+
+    it "geocodes when validated" do
+      model.validate
+      expect(model.geo).to eq point_2
+    end
+  end
+end
+```
+
+Result 4) minitest:
+```
+test "model should geocode, when address line changed, and when validated" do
+  @model.line_1 = "1 Test Road"
+  @model.validate
+  assert_equal @point_2, @model.geo
+end
+```
+
+Example 5) RSpec:
+```
+context "when address line changed" do
+  it "geocodes when address changed" do
+    expect(PointFromLatLng).to receive(:call).with(33.00, -84.00).and_call_original
+    model.validate
+    expect(model.geo).to eq point_2
+  end
+end
+```
+
+Result 5) minitest:
+```
+test "model should geocode, when address line changed, and when address changed" do
+  mock = Minitest::Mock.new
+  mock.expect :call, @point_2, [33.00, -84.00]
+
+  PointFromLatLng.stub :call, mock do
+    @model.line_1 = "1 Test Road"
+    @model.validate
+    assert_equal @point_2, @model.geo
+  end
+
+  mock.verify
+end
+```
+
+Example 6) RSpec:
+```
+context "when address line changed" do
+  describe "setting timezone" do
+    it "sets timezone on successful fetch" do
+      other = build(:address)
+      expect(model).to be_valid
+      expect(model.timezone).to eq "America/New_York"
+    end
+
+    it "sets default timezone on timezone error" do
+      allow(Timezone).to receive(:lookup).and_raise(Timezone::Error::Base)
+      expect(model).to be_valid
+      expect(model.timezone).to eq ::Config[:vendor_location_info][:timezone]
+    end
+  end
+end
+```
+
+Result 6) minitest:
+```
+test "when address line changed, model should set timezone on successful fetch" do
+  @model.line_1 = "1 Test Road"
+  other = FactoryBot.build(:address)
+  assert @model.valid?
+  assert_equal "America/New_York", @model.timezone
+end
+
+test "when address line changed, model should set default timezone on timezone error" do
+  @model.line_1 = "1 Test Road"
+  Timezone.stub :lookup, ->(*) { raise Timezone::Error::Base.new } do
+    assert @model.valid?
+    assert_equal ::Config[:vendor_location_info][:timezone], @model.timezone
+  end
+end
+```
+
+Example 7) RSpec:
+```
+context "when address line untouched" do
+  it "does not geocode" do
+    expect(PointFromLatLng).not_to receive(:call)
+    expect(model).to be_valid
+    expect(model.geo).to eq point_1
+  end
+end
+```
+
+Result 7) minitest:
+```
+test "when address line untouched, model should not geocode" do
+  PointFromLatLng.stub(:call, ->(*) { raise "shouldn't be called" }) do
+    assert @model.valid?
+    assert_equal @point_1, @model.geo
+  end
+end
+```
+
+Example 8) RSpec:
+```
+it "stubs any instance" do
+  allow_any_instance_of(PointFromLatLng).to receive(:foo).and_return(true)
+  expect(model).to be_valid
+end
+
+```
+
+Result 8) minitest:
+```
+test "stubs any instance" do
+  PointFromLatLng.stub_any_instance :foo, true do
+    assert @model.valid?
+  end
+end
+```

data/lib/ai_refactor/refactors/rspec_to_minitest_rails.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "tests/test_run_result"
+require_relative "tests/rspec_runner"
+require_relative "tests/minitest_runner"
+require_relative "tests/test_run_diff_report"
+
+module AIRefactor
+  module Refactors
+    class RspecToMinitestRails < Generic
+      def run
+        spec_runner = AIRefactor::Tests::RSpecRunner.new(input_file)
+        logger.verbose "Run spec #{input_file}... (#{spec_runner.command})"
+
+        spec_run = spec_runner.run
+
+        if spec_run.failed?
+          logger.warn "Skipping #{input_file}..."
+          logger.error "Failed to run #{input_file}, exited with status #{spec_run.exitstatus}. Stdout: #{spec_run.stdout}\n\nStderr: #{spec_run.stderr}\n\n"
+          return false
+        end
+
+        logger.debug "Original test run results:"
+        logger.debug ">> Examples: #{spec_run.example_count}, Failures: #{spec_run.failure_count}, Pendings: #{spec_run.pending_count}"
+
+        output_path = input_file.gsub("_spec.rb", "_test.rb").gsub("spec/", "test/")
+
+        processor = AIRefactor::FileProcessor.new(
+          input_file,
+          output_path,
+          prompt_file_path: self.class.prompt_file_path,
+          ai_client: ai_client,
+          logger: logger
+        )
+
+        if processor.output_exists?
+          logger.info "Do you wish to overwrite #{output_path}? (y/n)"
+          answer = $stdin.gets.chomp
+          unless answer == "y" || answer == "Y"
+            logger.warn "Skipping #{input_file}..."
+            return false
+          end
+        end
+
+        logger.verbose "Converting #{input_file}..."
+
+        begin
+          output_content, finished_reason, usage = processor.process!(options) do |content|
+            content.gsub("```", "")
+          end
+        rescue => e
+          logger.error "Request to OpenAI failed: #{e.message}"
+          logger.warn "Skipping #{input_file}..."
+          return false
+        end
+
+        logger.verbose "OpenAI finished, with reason '#{finished_reason}'..."
+        logger.verbose "Used tokens: #{usage["total_tokens"]}".colorize(:light_black) if usage
+
+        if finished_reason == "length"
+          logger.warn "Translation may contain an incomplete output as the max token length was reached. You can try using the '--continue' option next time to increase the length of generated output."
+          logger.warn "Continuing to test the translated file... but it is likely to fail."
+        end
+
+        if !output_content || output_content.length == 0
+          logger.warn "Skipping #{input_file}, no translated output..."
+          logger.error "Failed to translate #{input_file}, finished reason #{finished_reason}"
+          return false
+        end
+
+        logger.verbose "Converted #{input_file} to #{output_path}..."
+
+        minitest_runner = AIRefactor::Tests::MinitestRunner.new(processor.output_path)
+
+        logger.verbose "Run generated test file #{output_path} (#{minitest_runner.command})..."
+        test_run = minitest_runner.run
+
+        if test_run.failed?
+          logger.warn "Skipping #{input_file}..."
+          logger.error "Failed to run translated #{output_path}, exited with status #{test_run.exitstatus}. Stdout: #{test_run.stdout}\n\nStderr: #{test_run.stderr}\n\n"
+          logger.error "Conversion failed!", bold: true
+          return false
+        end
+
+        logger.debug "Translated test file results:"
+        logger.debug ">> Runs: #{test_run.example_count}, Failures: #{test_run.failure_count}, Skips: #{test_run.pending_count}"
+
+        report = AIRefactor::Tests::TestRunDiffReport.new(spec_run, test_run)
+
+        if report.no_differences?
+          logger.verbose "Done converting #{input_file} to #{output_path}..."
+          logger.success "No differences found! Conversion worked!"
+          true
+        else
+          logger.warn report.diff.colorize(:yellow)
+          logger.verbose "Done converting #{input_file} to #{output_path}..."
+          logger.error "Differences found! Conversion failed!", bold: true
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/tests/minitest_runner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module AIRefactor
+  module Tests
+    class MinitestRunner
+      def initialize(file_path, command_template: "bundle exec rails test __FILE__")
+        @file_path = file_path
+        @command_template = command_template
+      end
+
+      def command
+        @command_template.gsub("__FILE__", @file_path)
+      end
+
+      def run
+        stdout, stderr, status = Open3.capture3(command)
+        _matched, runs, _assertions, failures, errors, skips = stdout.match(/(\d+) runs, (\d+) assertions, (\d+) failures, (\d+) errors, (\d+) skips/).to_a
+        TestRunResult.new(stdout, stderr, status, runs, failures, skips, errors)
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/tests/rspec_runner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module AIRefactor
+  module Tests
+    class RSpecRunner
+      def initialize(file_path, command_template: "bundle exec rspec __FILE__")
+        @file_path = file_path
+        @command_template = command_template
+      end
+
+      def command
+        @command_template.gsub("__FILE__", @file_path)
+      end
+
+      def run
+        stdout, stderr, status = Open3.capture3(command)
+        _matched, example_count, failure_count = stdout.match(/(\d+) examples?, (\d+) failures?/).to_a
+        pending_count = stdout.match(/(\d+) pending/)&.values_at(1) || "0"
+        errored = stdout.match(/, (\d+) errors? occurred outside of examples/)&.values_at(1) || "0"
+        TestRunResult.new(stdout, stderr, status, example_count, failure_count, pending_count, errored)
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/tests/test_run_diff_report.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Tests
+    class TestRunDiffReport
+      def initialize(previous_test_run_result, test_run_result)
+        @current = test_run_result
+        @previous = previous_test_run_result
+      end
+
+      def no_differences?
+        @current.example_count == @previous.example_count && @current.failure_count == @previous.failure_count && @current.pending_count == @previous.pending_count
+      end
+
+      def diff
+        report = ""
+        if @current.example_count != @previous.example_count
+          report += "Example count mismatch: #{@current.example_count} != #{@previous.example_count}"
+        end
+        if @current.failure_count != @previous.failure_count
+          report += "Failure count mismatch: #{@current.failure_count} != #{@previous.failure_count}"
+        end
+        if @current.pending_count != @previous.pending_count
+          report += "Pending count mismatch: #{@current.pending_count} != #{@previous.pending_count}"
+        end
+        report
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/tests/test_run_result.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Tests
+    class TestRunResult
+      attr_reader :stdout, :stderr, :example_count, :failure_count, :pending_count
+
+      def initialize(stdout, stderr, status, example_count, failure_count, pending_count, errored)
+        @stdout = stdout
+        @stderr = stderr
+        @status = status
+        @example_count = example_count
+        @failure_count = failure_count
+        @pending_count = pending_count
+        @errored = errored
+      end
+
+      def failed?
+        return true unless @status.success?
+        @errored && @errored.to_i > 0
+      end
+
+      def exitstatus
+        @status.exitstatus
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    def get(name)
+      all[name]
+    end
+    module_function :get
+
+    def names
+      all.keys
+    end
+    module_function :names
+
+    def all
+      @all ||= constants.map { |n| const_get(n) }.select { |c| c.is_a? Class }.each_with_object({}) do |klass, hash|
+        hash[klass.refactor_name] = klass
+      end
+    end
+    module_function :all
+
+    def supported?(name)
+      names.include?(name)
+    end
+    module_function :supported?
+  end
+end

data/lib/ai_refactor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  VERSION = "0.1.0"
+end

data/lib/ai_refactor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "ai_refactor/version"
+
+require_relative "ai_refactor/logger"
+require_relative "ai_refactor/file_processor"
+
+require_relative "ai_refactor/refactors"
+require_relative "ai_refactor/refactors/generic"
+require_relative "ai_refactor/refactors/rspec_to_minitest_rails"
+require_relative "ai_refactor/refactors/minitest_to_rspec"

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: ai_refactor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephen Ierodiaconou
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: open3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Use OpenAI's ChatGPT to automate converting Rails RSpec tests to minitest
+  (ActiveSupport::TestCase).
+email:
+- stevegeek@gmail.com
+executables:
+- ai_refactor
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- ai_refactor.gemspec
+- exe/ai_refactor
+- lib/ai_refactor.rb
+- lib/ai_refactor/file_processor.rb
+- lib/ai_refactor/logger.rb
+- lib/ai_refactor/refactors.rb
+- lib/ai_refactor/refactors/generic.rb
+- lib/ai_refactor/refactors/minitest_to_rspec.rb
+- lib/ai_refactor/refactors/prompts/minitest_to_rspec.md
+- lib/ai_refactor/refactors/prompts/rspec_to_minitest_rails.md
+- lib/ai_refactor/refactors/rspec_to_minitest_rails.rb
+- lib/ai_refactor/refactors/tests/minitest_runner.rb
+- lib/ai_refactor/refactors/tests/rspec_runner.rb
+- lib/ai_refactor/refactors/tests/test_run_diff_report.rb
+- lib/ai_refactor/refactors/tests/test_run_result.rb
+- lib/ai_refactor/version.rb
+homepage: https://github.com/stevegeek/ai_refactor
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/stevegeek/ai_refactor
+  source_code_uri: https://github.com/stevegeek/ai_refactor
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Use AI to convert a Rails RSpec test suite to minitest.
+test_files: []