spec_ai 0.1.0

data/lib/spec_ai/generators/factory_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Generators
+    class FactoryGenerator
+      SKIP = %w[
+        id created_at updated_at encrypted_password
+        reset_password_token reset_password_sent_at remember_created_at
+      ].freeze
+
+      def initialize(snapshot, sandbox: Sandbox.new)
+        @snapshot = snapshot
+        @sandbox = sandbox
+      end
+
+      def relative_path
+        "spec/factories/#{@snapshot.target.table_name}.rb"
+      end
+
+      def write
+        @sandbox.write(relative_path, render)
+      end
+
+      def render
+        name = @snapshot.target.factory_name
+        assignments = assignment_lines
+        body = assignments.empty? ? "    # add attributes for #{name}\n" : assignments.join("\n")
+        <<~RUBY
+          # frozen_string_literal: true
+
+          FactoryBot.define do
+            factory :#{name} do
+          #{body}
+            end
+          end
+        RUBY
+      end
+
+      private
+
+      def assignment_lines
+        lines = []
+        attributes.each do |name|
+          line = assignment_for(name)
+          lines << "    #{line}" if line
+        end
+        lines
+      end
+
+      def attributes
+        @snapshot.known_attributes.reject { |name| SKIP.include?(name) }
+      end
+
+      def assignment_for(name)
+        case name
+        when "email"
+          %(sequence(:email) { |n| "user\#{n}@example.com" })
+        when "password"
+          %(password { "password123" })
+        when "password_confirmation"
+          %(password_confirmation { "password123" })
+        when "name"
+          %(name { "Test #{@snapshot.target.class_name}" })
+        else
+          %(#{name} { #{value_for(name)} })
+        end
+      end
+
+      def value_for(name)
+        excerpt = @snapshot.schema[:excerpt].to_s
+        return "true" if excerpt.match?(/t\.boolean\s+"#{Regexp.escape(name)}"/)
+        return "1" if excerpt.match?(/t\.(integer|bigint)\s+"#{Regexp.escape(name)}"/)
+
+        %("#{name}")
+      end
+    end
+  end
+end

data/lib/spec_ai/generators/rspec_generator.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Generators
+    class RspecGenerator
+      HELPER_RE = /require\s+["']spec_helper["']/.freeze
+
+      def self.patch_helper!(relative, sandbox:)
+        return false unless sandbox.exist?("spec/rails_helper.rb") && sandbox.exist?(relative)
+
+        contents = sandbox.read(relative)
+        updated = upgrade_helper_source(contents)
+        return false if updated == contents
+
+        sandbox.write(relative, updated)
+        true
+      end
+
+      def self.upgrade_helper_source(contents)
+        contents.to_s.sub(HELPER_RE, 'require "rails_helper"')
+      end
+
+      CATEGORY_TITLES = {
+        "validation" => "validations",
+        "association" => "associations",
+        "happy_path" => "happy path",
+        "edge_case" => "edge cases",
+        "error_handling" => "error handling"
+      }.freeze
+
+      def initialize(plan, snapshot, force: false, sandbox: Sandbox.new)
+        @plan = plan
+        @snapshot = snapshot
+        @force = force
+        @sandbox = sandbox
+      end
+
+      def write
+        relative = @snapshot.target.spec_path
+
+        if @sandbox.exist?(relative) && !@force
+          existing = upgrade_helper(@sandbox.read(relative))
+          filtered = @plan.without_existing(example_names(existing))
+          contents = filtered.nil? ? existing : merge(existing, render_groups(filtered))
+          @sandbox.write(relative, upgrade_helper(contents))
+        else
+          @sandbox.write(relative, render_file(@plan))
+        end
+      end
+
+      def render(plan = @plan)
+        render_file(plan)
+      end
+
+      private
+
+      def render_file(plan)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          #{helper_require}
+
+          RSpec.describe #{plan.target}, type: :model do
+          #{indent(render_groups(plan).rstrip, 2)}
+          end
+        RUBY
+      end
+
+      def render_groups(plan)
+        plan.scenarios.group_by(&:category).map do |category, scenarios|
+          title = CATEGORY_TITLES.fetch(category, category.to_s.tr("_", " "))
+          body = scenarios.map { |scenario| render_example(scenario) }.join("\n\n")
+          <<~RUBY.rstrip
+            describe #{title.inspect} do
+            #{indent(body, 2)}
+            end
+          RUBY
+        end.join("\n\n")
+      end
+
+      def render_example(scenario)
+        body = example_body(scenario)
+        <<~RUBY.rstrip
+          it #{scenario.name.inspect} do
+          #{indent(body, 2)}
+          end
+        RUBY
+      end
+
+      def example_body(scenario)
+        case scenario.category
+        when "association"
+          association_body(scenario)
+        when "validation"
+          validation_body(scenario)
+        when "happy_path"
+          happy_path_body(scenario)
+        else
+          generic_body(scenario)
+        end
+      end
+
+      def association_body(scenario)
+        name, macro = association_for(scenario)
+        return generic_body(scenario) unless name
+
+        lines = [
+          "association = described_class.reflect_on_association(#{name.to_sym.inspect})",
+          "expect(association).to be_present"
+        ]
+        lines << "expect(association.macro).to eq(#{macro.to_sym.inspect})" if macro && !macro.empty?
+        comment(scenario) + lines.join("\n")
+      end
+
+      def validation_body(scenario)
+        attribute = attribute_for(scenario)
+        unique = unique?(scenario)
+        value = ruby_value(scenario.value.nil? || scenario.value.to_s.empty? ? "nil" : scenario.value)
+        expect_valid = valid_expectation?(scenario)
+
+        lines = []
+        lines.concat(comment_lines(scenario))
+        if unique && !expect_valid
+          dup_value = scenario.value.to_s.empty? ? '"duplicate@example.com"' : ruby_value(scenario.value)
+          lines << persist_record(attribute ? "#{attribute}: #{dup_value}" : nil)
+          lines << "record = #{build_record(attribute ? "#{attribute}: #{dup_value}" : nil)}"
+        else
+          attrs = attribute ? "#{attribute}: #{value}" : nil
+          lines << "record = #{build_record(expect_valid ? nil : attrs)}"
+        end
+
+        if expect_valid
+          lines << "expect(record).to be_valid"
+        else
+          lines << "expect(record).not_to be_valid"
+          lines << "expect(record.errors[:#{attribute}]).to be_present" if attribute
+        end
+        lines.join("\n")
+      end
+
+      def happy_path_body(scenario)
+        lines = comment_lines(scenario)
+        lines << "record = #{build_record(nil)}"
+        lines << (valid_expectation?(scenario) ? "expect(record).to be_valid" : "expect(record).not_to be_valid")
+        lines.join("\n")
+      end
+
+      def generic_body(scenario)
+        lines = comment_lines(scenario)
+        attribute = attribute_for(scenario)
+        attrs = attribute ? "#{attribute}: #{ruby_value(scenario.value || 'nil')}" : nil
+        lines << "record = #{build_record(valid_expectation?(scenario) ? nil : attrs)}"
+        lines << (valid_expectation?(scenario) ? "expect(record).to be_valid" : "expect(record).not_to be_valid")
+        lines.join("\n")
+      end
+
+      def persist_record(attrs)
+        combined = combine_assignments(attrs)
+        if @snapshot.has_factory?
+          "create(:#{factory_name}#{combined ? ", #{combined}" : ""})"
+        else
+          "described_class.create(#{combined || ''})"
+        end
+      end
+
+      def build_record(attrs)
+        combined = combine_assignments(attrs)
+        if @snapshot.has_factory?
+          "build(:#{factory_name}#{combined ? ", #{combined}" : ""})"
+        else
+          "described_class.new(#{combined || ''})"
+        end
+      end
+
+      def combine_assignments(overrides)
+        synced = sync_password_confirmation(overrides)
+        defaults = default_assignments
+        return synced if @snapshot.has_factory?
+        return synced if defaults.empty?
+        return defaults if synced.to_s.empty?
+
+        "#{defaults}, #{synced}"
+      end
+
+      def sync_password_confirmation(attrs)
+        text = attrs.to_s
+        return attrs if text.empty?
+        return attrs unless @snapshot.known_attributes.include?("password_confirmation")
+        return attrs if text.match?(/password_confirmation:/)
+        return attrs unless text.match?(/\bpassword:/)
+
+        match = text.match(/password:\s*("[^"]*"|'[^']*'|nil)/)
+        return attrs unless match
+        return attrs if match[1] == "nil"
+
+        "#{text}, password_confirmation: #{match[1]}"
+      end
+
+      def default_assignments
+        parts = []
+        known = @snapshot.known_attributes
+        parts << 'email: "user@example.com"' if known.include?("email")
+        if known.include?("password")
+          parts << 'password: "password123"'
+          parts << 'password_confirmation: "password123"' if known.include?("password_confirmation")
+        end
+        parts.join(", ")
+      end
+
+      def factory_name
+        @snapshot.factories[:name] || @snapshot.target.factory_name
+      end
+
+      def helper_require
+        rails_helper? ? 'require "rails_helper"' : 'require "spec_helper"'
+      end
+
+      def upgrade_helper(contents)
+        return contents unless rails_helper?
+
+        self.class.upgrade_helper_source(contents)
+      end
+
+      def rails_helper?
+        @sandbox.exist?("spec/rails_helper.rb")
+      end
+
+      def attribute_for(scenario)
+        return scenario.attribute unless scenario.attribute.to_s.empty?
+
+        text = "#{scenario.name} #{Array(scenario.setup).join(' ')}"
+        attrs = Array(@snapshot.model[:validations]).flat_map { |item| Array(item[:attributes]) }
+        attrs.find { |attr| text.match?(/\b#{Regexp.escape(attr)}\b/i) }
+      end
+
+      def association_for(scenario)
+        known = Array(@snapshot.model[:associations])
+        name = scenario.association.to_s
+        if name != ""
+          match = known.find { |item| (item[:name] || item["name"]).to_s == name }
+          return [match[:name] || match["name"], match[:macro] || match["macro"]] if match
+
+          return [nil, nil]
+        end
+
+        text = "#{scenario.name} #{Array(scenario.setup).join(' ')}"
+        known.each do |association|
+          assoc_name = association[:name].to_s
+          macro = association[:macro].to_s
+          return [assoc_name, macro] if text.match?(/\b#{Regexp.escape(assoc_name)}\b/i) || text.match?(/#{macro.tr('_', ' ')}/i)
+        end
+        [nil, nil]
+      end
+
+      def unique?(scenario)
+        haystack = "#{scenario.name} #{scenario.expected_behavior} #{Array(scenario.setup).join(' ')}"
+        haystack.match?(/unique|uniqueness|duplicate/i)
+      end
+
+      def valid_expectation?(scenario)
+        scenario.expected_behavior.to_s.match?(/\bvalid\b/i) && !scenario.expected_behavior.to_s.match?(/invalid|not[_ ]valid/i)
+      end
+
+      def ruby_value(raw)
+        string = raw.to_s
+        return "nil" if string.empty? || string == "nil"
+        return "true" if string == "true"
+        return "false" if string == "false"
+        return string if string.match?(/\A-?\d+\z/)
+        return string if string.start_with?(":", '"', "'")
+
+        string.inspect
+      end
+
+      def comment(scenario)
+        lines = comment_lines(scenario)
+        lines.empty? ? "" : "#{lines.join("\n")}\n"
+      end
+
+      def comment_lines(scenario)
+        Array(scenario.setup).reject(&:empty?).map { |item| "# setup: #{item}" }
+      end
+
+      def example_names(content)
+        content.scan(/it\s+["']([^"']+)["']/).flatten
+      end
+
+      def merge(existing, addition)
+        stripped = existing.rstrip
+        return "#{stripped}\n\n#{indent(addition, 2)}\n" unless stripped.end_with?("end")
+
+        "#{stripped.sub(/end\z/, "")}#{indent(addition, 2)}\nend\n"
+      end
+
+      def indent(text, spaces)
+        prefix = " " * spaces
+        text.to_s.lines.map { |line| line.strip.empty? ? "\n" : "#{prefix}#{line.chomp}\n" }.join
+      end
+    end
+  end
+end

data/lib/spec_ai/generators/rspec_install.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Generators
+    class RspecInstall
+      def initialize(sandbox: Sandbox.new)
+        @sandbox = sandbox
+      end
+
+      def write
+        created = []
+        created << write_helper("spec/spec_helper.rb", spec_helper_source)
+        created << write_helper("spec/rails_helper.rb", rails_helper_source)
+        created.compact
+      end
+
+      private
+
+      def write_helper(relative, contents)
+        return if @sandbox.exist?(relative)
+
+        @sandbox.write(relative, contents)
+        relative
+      end
+
+      def spec_helper_source
+        <<~RUBY
+          # frozen_string_literal: true
+
+          RSpec.configure do |config|
+            config.expect_with :rspec do |expectations|
+              expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+            end
+
+            config.mock_with :rspec do |mocks|
+              mocks.verify_partial_doubles = true
+            end
+
+            config.shared_context_metadata_behavior = :apply_to_host_groups
+          end
+        RUBY
+      end
+
+      def rails_helper_source
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "spec_helper"
+          ENV["RAILS_ENV"] ||= "test"
+          require_relative "../config/environment"
+          abort("The Rails environment is running in production mode!") if Rails.env.production?
+          require "rspec/rails"
+
+          begin
+            ActiveRecord::Migration.maintain_test_schema!
+          rescue ActiveRecord::PendingMigrationError => error
+            abort error.to_s.strip
+          end
+
+          RSpec.configure do |config|
+            config.fixture_paths = [Rails.root.join("spec/fixtures")] if config.respond_to?(:fixture_paths=)
+            config.use_transactional_fixtures = true
+            config.infer_spec_type_from_file_location!
+            config.filter_rails_from_backtrace!
+            config.include FactoryBot::Syntax::Methods if defined?(FactoryBot)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/spec_ai/inflector.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Inflector
+    module_function
+
+    def underscore(camel_cased)
+      camel_cased.to_s
+                 .gsub("::", "/")
+                 .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                 .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                 .tr("-", "_")
+                 .downcase
+    end
+
+    def demodulize(name)
+      name.to_s.split("::").last
+    end
+
+    def pluralize(word)
+      word = word.to_s
+      return word[0..-2] + "ies" if word.end_with?("y") && !word.end_with?("ay", "ey", "oy", "uy")
+      return word + "es" if word.end_with?("s", "x", "z", "ch", "sh")
+
+      "#{word}s"
+    end
+
+    def singularize(word)
+      word = word.to_s
+      return word[0..-4] + "y" if word.end_with?("ies") && word.length > 4
+      return word[0..-3] if word.end_with?("ses", "xes", "zes", "ches", "shes")
+      return word[0..-2] if word.end_with?("s") && !word.end_with?("ss")
+
+      word
+    end
+
+    def table_name(class_name)
+      parts = underscore(class_name).split("/")
+      parts[-1] = pluralize(parts[-1])
+      parts.join("_")
+    end
+
+    def model_path(class_name)
+      "app/models/#{underscore(class_name)}.rb"
+    end
+
+    def spec_path(class_name)
+      "spec/models/#{underscore(class_name)}_spec.rb"
+    end
+
+    def factory_name(class_name)
+      underscore(demodulize(class_name))
+    end
+
+    def camelize(path_or_name)
+      path_or_name.to_s
+                  .sub(/\.rb\z/, "")
+                  .split("/")
+                  .map { |part| part.split("_").map(&:capitalize).join }
+                  .join("::")
+    end
+  end
+end

data/lib/spec_ai/knowledge/playbook.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Knowledge
+    class Playbook
+      def self.text
+        File.read(File.expand_path("rails_testing.md", __dir__))
+      end
+    end
+  end
+end

data/lib/spec_ai/knowledge/rails_testing.md

@@ -0,0 +1,42 @@
+# Rails / RSpec model testing playbook for Spec AI.
+
+Write scenarios that a Ruby generator can turn into RSpec. Do not emit Ruby code.
+
+Prefer:
+
+- type: :model specs
+- FactoryBot `build` / `create` when a factory exists; otherwise `described_class.new`
+- One example per behavior
+- Explicit attributes for validations (`attribute`, `value`)
+- Explicit association name and macro for association examples
+- expected_behavior of "valid", "invalid", "has_association", or a short phrase
+
+Validation coverage:
+
+- presence: build with the attribute nil, expect not_to be_valid, expect errors[attribute]
+- uniqueness: create one record, build a duplicate, expect invalid
+- format/length/numericality: include a concrete invalid value in `value`
+
+Association coverage:
+
+- reflect_on_association(name).macro eq(:has_many|:belongs_to|:has_one|:has_and_belongs_to_many)
+- dependent: :destroy can be an extra scenario if present on the model
+
+Happy path:
+
+- a valid record built from the factory / defaults should be_valid
+
+Do not invent columns, associations, or callbacks that are not in the provided context.
+Do not duplicate examples that already exist in the current spec.
+Do not add association examples when the model has none.
+Include edge_case scenarios when generation.include_edge_cases is true (empty strings, blank email, boolean flags).
+Keep scenario names short and unique.
+
+Devise (when the model uses devise :validatable):
+
+- FactoryBot should set email, password, and password_confirmation.
+- Devise password rules are presence and minimum length only. Do not require special characters, uppercase, or digits unless the model has a custom format validator.
+- Email format is permissive (`foo@bar`, `user@.com` are valid). Only treat values without `@` as invalid format.
+- Devise strips leading/trailing whitespace on email. Do not expect `" test@example.com"` to be invalid.
+- `password_confirmation` may be nil. Only test a mismatch, not a missing confirmation.
+

data/lib/spec_ai/pipeline/fix.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SpecAi
+  module Pipeline
+    class Fix
+      def initialize(input, ui: UI.new, sandbox: Sandbox.new)
+        @input = input
+        @ui = ui
+        @sandbox = sandbox
+      end
+
+      def run
+        @ui.header
+        target = Target.new(@input, app_root: @sandbox.root)
+        unless @sandbox.exist?(target.spec_path)
+          raise TargetNotFound, "no spec file at #{target.spec_path}"
+        end
+
+        snapshot = Context::Builder.new(target, sandbox: @sandbox).build
+        @ui.analyzing(target.class_name)
+        @ui.context_collected(snapshot)
+
+        runner = Runners::RspecRunner.new(app_root: @sandbox.root)
+        runner.ensure_available!
+        result = @ui.spin_running { runner.run(target.spec_path) }
+        @ui.rspec_result(result)
+
+        if result.passed?
+          @ui.already_passing(target.spec_path)
+          return Result.new(target: target, spec_path: target.spec_path, plan: nil, run: result)
+        end
+
+        spec_path = @sandbox.resolve!(target.spec_path)
+        if Generators::RspecGenerator.patch_helper!(target.spec_path, sandbox: @sandbox)
+          @ui.writing(relative(spec_path))
+          result = @ui.spin_running { runner.run(spec_path) }
+          @ui.rspec_result(result)
+          if result.passed?
+            @ui.already_passing(target.spec_path)
+            return Result.new(target: target, spec_path: spec_path, plan: nil, run: result)
+          end
+        end
+
+        attempts = 0
+        max = [SpecAi.configuration.max_repair_attempts.to_i, 1].max
+        plan = nil
+
+        while result.repairable? && attempts < max
+          attempts += 1
+          spec_contents = @sandbox.read(target.spec_path)
+          begin
+            plan = @ui.spin_repairing(attempts, max) do
+              Crews::RepairCrew.new(snapshot, result, spec_contents, previous_plan: plan, sandbox: @sandbox).plan
+            end
+            plan = plan.ground(snapshot) || plan
+          rescue InvalidPlan
+            @ui.skip_repair("The repair model did not return a valid test plan. The spec was left as-is with the failures above.")
+            break
+          end
+          spec_path = Generators::RspecGenerator.new(plan, snapshot, force: true, sandbox: @sandbox).write
+          @ui.writing(relative(spec_path))
+          result = @ui.spin_running { runner.run(spec_path) }
+          @ui.rspec_result(result)
+        end
+
+        @ui.completed(result.passed?, result: result)
+        Result.new(target: target, spec_path: spec_path, plan: plan, run: result, repair_attempts: attempts)
+      end
+
+      private
+
+      def relative(path)
+        path.to_s.sub(%r{\A#{Regexp.escape(@sandbox.root)}/?}, "")
+      end
+    end
+  end
+end