rails_proof 1.0.0

data/lib/rails_proof/ai_test_executor.rb

@@ -0,0 +1,263 @@
+require "pathname"
+require "rails_proof/ai_test_validator"
+require "rails_proof/ai_test_writer"
+require "rails_proof/ai_concern_filter"
+require "rails_proof/test_runner"
+require "rails_proof/review_store"
+
+module RailsProof
+  class AiTestExecutor
+    Result = Struct.new(
+      :concern,
+      :status,
+      :errors,
+      :test_output,
+      :review_path,
+      :skip_reason,
+      keyword_init: true
+    ) do
+      def kept?
+        status == :kept
+      end
+
+      def rejected?
+        status == :rejected
+      end
+
+      def needs_review?
+        status == :needs_review
+      end
+
+      def skipped?
+        status == :skipped
+      end
+    end
+
+    attr_reader :root,
+      :target_path,
+      :test_file_path,
+      :test_class_name,
+      :superclass,
+      :concerns,
+      :runner_class,
+      :review_store
+
+    def initialize(
+      root:,
+      test_file_path:,
+      test_class_name:,
+      superclass:,
+      concerns:,
+      target_path: nil,
+      runner_class: RailsProof::TestRunner,
+      review_store: nil
+    )
+      @root = Pathname.new(root)
+      @target_path = target_path
+      @test_file_path = test_file_path
+      @test_class_name = test_class_name
+      @superclass = superclass
+      @concerns = concerns
+      @runner_class = runner_class
+      @review_store = review_store ||
+        RailsProof::ReviewStore.new(root: @root)
+    end
+
+    def execute
+      filter = RailsProof::AiConcernFilter.new(
+        concerns: concerns,
+        existing_tests: existing_test_source,
+        review_findings: outstanding_review_findings
+      )
+
+      results = filter.concerns.map do |concern|
+        execute_concern(concern)
+      end
+
+      results.concat(
+        filter.skipped.map do |skipped|
+          skipped_result(skipped)
+        end
+      )
+
+      results
+    end
+
+    private
+
+    def execute_concern(concern)
+      test_code = concern[:test_code] || concern["test_code"]
+      validation = RailsProof::AiTestValidator.new(test_code).validate
+
+      unless validation.valid?
+        return Result.new(
+          concern: concern,
+          status: :rejected,
+          errors: validation.errors,
+          test_output: nil,
+          review_path: nil,
+          skip_reason: nil
+        )
+      end
+
+      previous_state = capture_file_state
+
+      write_candidate(concern)
+
+      test_result = runner.run
+
+      if test_result.passed?
+        Result.new(
+          concern: concern,
+          status: :kept,
+          errors: [],
+          test_output: test_result.output,
+          review_path: nil,
+          skip_reason: nil
+        )
+      else
+        restore_file_state(previous_state)
+
+        review_path, persistence_error =
+          persist_review(
+            concern: concern,
+            test_output: test_result.output
+          )
+
+        errors = ["candidate test failed against application"]
+        errors << persistence_error if persistence_error
+
+        Result.new(
+          concern: concern,
+          status: :needs_review,
+          errors: errors,
+          test_output: test_result.output,
+          review_path: review_path,
+          skip_reason: nil
+        )
+      end
+    rescue StandardError => error
+      restore_file_state(previous_state) if defined?(previous_state)
+
+      Result.new(
+        concern: concern,
+        status: :rejected,
+        errors: [error.message],
+        test_output: nil,
+        review_path: nil,
+        skip_reason: nil
+      )
+    end
+
+    def skipped_result(skipped)
+      Result.new(
+        concern: skipped.concern,
+        status: :skipped,
+        errors: [],
+        test_output: nil,
+        review_path: nil,
+        skip_reason: skipped.reason
+      )
+    end
+
+    def existing_test_source
+      return "" unless absolute_test_file_path.file?
+
+      absolute_test_file_path.read
+    end
+
+    def outstanding_review_findings
+      return [] unless target_path
+      return [] unless review_store.respond_to?(:outstanding_findings)
+
+      review_store.outstanding_findings(
+        target_path: target_path,
+        test_file_path: test_file_path
+      )
+    end
+
+    def absolute_test_file_path
+      @absolute_test_file_path ||=
+        root.join(test_file_path)
+    end
+
+    def capture_file_state
+      if absolute_test_file_path.file?
+        {
+          existed: true,
+          content: absolute_test_file_path.read
+        }
+      else
+        {
+          existed: false,
+          content: nil
+        }
+      end
+    end
+
+    def restore_file_state(state)
+      return unless state
+
+      if state[:existed]
+        absolute_test_file_path.write(state[:content])
+      elsif absolute_test_file_path.exist?
+        absolute_test_file_path.delete
+      end
+    end
+
+    def write_candidate(concern)
+      writer = RailsProof::AiTestWriter.new(
+        test_class_name: test_class_name,
+        superclass: superclass,
+        concerns: [concern]
+      )
+
+      if absolute_test_file_path.file?
+        insert_into_existing_file(writer.render)
+      else
+        absolute_test_file_path.dirname.mkpath
+        absolute_test_file_path.write(writer.render_test_file)
+      end
+    end
+
+    def insert_into_existing_file(rendered_test)
+      source = absolute_test_file_path.read
+
+      unless source.match?(/^end\s*\z/)
+        raise ArgumentError,
+          "RailsProof could not find the end of #{test_file_path}"
+      end
+
+      updated = source.sub(
+        /^end\s*\z/,
+        "\n#{rendered_test}\nend"
+      )
+
+      absolute_test_file_path.write(updated)
+    end
+
+    def persist_review(concern:, test_output:)
+      path = review_store.save(
+        concern: concern,
+        test_output: test_output,
+        target_path: target_path,
+        test_file_path: test_file_path,
+        test_class_name: test_class_name
+      )
+
+      [path, nil]
+    rescue StandardError => error
+      [
+        nil,
+        "RailsProof could not persist review: #{error.message}"
+      ]
+    end
+
+    def runner
+      runner_class.new(
+        root: root,
+        test_file_path: test_file_path
+      )
+    end
+  end
+end

data/lib/rails_proof/ai_test_identity.rb

@@ -0,0 +1,261 @@
+require "digest"
+require "set"
+require "rails_proof/test_inspector"
+
+module RailsProof
+  class AiTestIdentity
+    class << self
+      def name_keys(name:, test_code:)
+        names = [name]
+
+        if test_code.is_a?(String)
+          inspector = RailsProof::TestInspector.new(test_code)
+
+          names.concat(
+            inspector.test_cases.map do |test_case|
+              test_case[:name]
+            end
+          )
+        end
+
+        names
+          .filter_map { |value| normalize_name(value) }
+          .uniq
+      end
+
+      def test_fingerprint(test_code)
+        canonical = canonical_test_code(test_code)
+
+        return nil unless canonical
+
+        Digest::SHA256.hexdigest(canonical)
+      end
+
+      def assertion_keys(test_code)
+        return [] unless test_code.is_a?(String)
+        return [] if test_code.strip.empty?
+
+        test_code.each_line.filter_map do |line|
+          assertion = normalize_assertion(line)
+
+          next unless assertion
+          next if trivial_assertion?(assertion)
+
+          assertion
+        end.uniq
+      end
+
+      def behavior_keys(test_code)
+        return [] unless test_code.is_a?(String)
+        return [] if test_code.strip.empty?
+
+        context = []
+        keys = []
+
+        test_code.each_line do |line|
+          normalized = normalize_code_line(line)
+
+          next if normalized.empty?
+          next if normalized.start_with?("#")
+          next if test_declaration?(normalized)
+          next if normalized == "end"
+
+          assertion = normalize_assertion(normalized)
+
+          if assertion
+            unless trivial_assertion?(assertion)
+              keys << behavior_key(
+                context: context,
+                assertion: assertion
+              )
+            end
+
+            next
+          end
+
+          context << normalized
+        end
+
+        keys.uniq
+      end
+
+      def same?(
+        first_name:,
+        first_test_code:,
+        second_name:,
+        second_test_code:
+      )
+        return true if same_name?(
+          first_name: first_name,
+          first_test_code: first_test_code,
+          second_name: second_name,
+          second_test_code: second_test_code
+        )
+
+        same_meaningful_behavior?(
+          first_test_code: first_test_code,
+          second_test_code: second_test_code
+        )
+      end
+
+      def same_candidate?(
+        first_name:,
+        first_test_code:,
+        second_name:,
+        second_test_code:
+      )
+        return true if same?(
+          first_name: first_name,
+          first_test_code: first_test_code,
+          second_name: second_name,
+          second_test_code: second_test_code
+        )
+
+        same_test_body?(
+          first_test_code,
+          second_test_code
+        )
+      end
+
+      def normalize_name(value)
+        normalized = value
+          .to_s
+          .downcase
+          .gsub(/[^a-z0-9]+/, " ")
+          .strip
+          .squeeze(" ")
+
+        normalized.empty? ? nil : normalized
+      end
+
+      private
+
+      def same_name?(
+        first_name:,
+        first_test_code:,
+        second_name:,
+        second_test_code:
+      )
+        first_names = name_keys(
+          name: first_name,
+          test_code: first_test_code
+        )
+
+        second_names = name_keys(
+          name: second_name,
+          test_code: second_test_code
+        )
+
+        (first_names & second_names).any?
+      end
+
+      def same_meaningful_behavior?(
+        first_test_code:,
+        second_test_code:
+      )
+        first_behaviors = behavior_keys(first_test_code)
+        second_behaviors = behavior_keys(second_test_code)
+
+        return false if first_behaviors.empty?
+        return false if second_behaviors.empty?
+
+        first_set = first_behaviors.to_set
+        second_set = second_behaviors.to_set
+
+        first_set.subset?(second_set) ||
+          second_set.subset?(first_set)
+      end
+
+      def same_test_body?(first_test_code, second_test_code)
+        first_fingerprint = test_fingerprint(first_test_code)
+        second_fingerprint = test_fingerprint(second_test_code)
+
+        return false unless first_fingerprint
+        return false unless second_fingerprint
+
+        first_fingerprint == second_fingerprint
+      end
+
+      def canonical_test_code(test_code)
+        return nil unless test_code.is_a?(String)
+        return nil if test_code.strip.empty?
+
+        source = test_code.dup
+
+        source.sub!(
+          /^\s*test\s*(?:\(\s*)?(["']).+?\1\s*\)?\s+do\b/,
+          "test do"
+        )
+
+        source
+          .each_line
+          .map(&:strip)
+          .reject(&:empty?)
+          .join(" ")
+          .gsub(/\s+/, " ")
+          .strip
+      end
+
+      def normalize_code_line(line)
+        line
+          .strip
+          .gsub(/\s+/, " ")
+      end
+
+      def test_declaration?(line)
+        line.match?(
+          /\Atest\s*(?:\(\s*)?(["']).+?\1\s*\)?\s+do\b/
+        ) ||
+          line.match?(/\Adef\s+test_[a-zA-Z0-9_!?]+/)
+      end
+
+      def normalize_assertion(line)
+        normalized = line
+          .strip
+          .gsub(/\s+/, " ")
+
+        return nil unless assertion_line?(normalized)
+
+        normalized = normalized.sub(
+          /\Arefute_/,
+          "assert_not_"
+        )
+
+        normalized = normalized.sub(
+          /\Arefute\b/,
+          "assert_not"
+        )
+
+        normalized
+      end
+
+      def assertion_line?(line)
+        line.match?(
+          /\A(?:assert|assert_not|refute)(?:_[a-zA-Z0-9_!?]+)?(?:\s|\()/
+        )
+      end
+
+      def trivial_assertion?(assertion)
+        normalized = assertion
+          .delete("()")
+          .strip
+          .gsub(/\s+/, " ")
+
+        [
+          "assert true",
+          "assert false",
+          "assert_not true",
+          "assert_not false"
+        ].include?(normalized)
+      end
+
+      def behavior_key(context:, assertion:)
+        normalized_context = context
+          .map { |line| normalize_code_line(line) }
+          .join(" | ")
+
+        "#{normalized_context} => #{assertion}"
+      end
+    end
+  end
+end

data/lib/rails_proof/ai_test_planner.rb

@@ -0,0 +1,118 @@
+module RailsProof
+  class AiTestPlanner
+    class InvalidResponse < StandardError; end
+
+    VALID_KINDS = %i[
+      coverage
+      contract_check
+    ].freeze
+
+    attr_reader :target_type,
+      :class_name,
+      :source,
+      :existing_tests,
+      :deterministic_concerns,
+      :client
+
+    def initialize(
+      target_type:,
+      class_name:,
+      source:,
+      existing_tests:,
+      deterministic_concerns:,
+      client:
+    )
+      @target_type = target_type
+      @class_name = class_name
+      @source = source
+      @existing_tests = existing_tests
+      @deterministic_concerns = deterministic_concerns
+      @client = client
+    end
+
+    def concerns
+      @concerns ||= suggestions.map do |suggestion|
+        normalize_suggestion(suggestion)
+      end
+    end
+
+    def context
+      {
+        target_type: target_type,
+        class_name: class_name,
+        source: source,
+        existing_tests: existing_tests,
+        deterministic_concerns: deterministic_concerns
+      }
+    end
+
+    private
+
+    def suggestions
+      response = client.suggest_tests(context: context)
+
+      unless response.is_a?(Array)
+        raise InvalidResponse,
+          "AI client must return an array of test suggestions"
+      end
+
+      response
+    end
+
+    def normalize_suggestion(suggestion)
+      unless suggestion.respond_to?(:[])
+        raise InvalidResponse,
+          "AI test suggestion must be a hash-like object"
+      end
+
+      kind = normalize_kind(
+        suggestion[:kind] || suggestion["kind"]
+      )
+
+      name = suggestion[:name] || suggestion["name"]
+      reason = suggestion[:reason] || suggestion["reason"]
+      test_code = suggestion[:test_code] || suggestion["test_code"]
+
+      unless name.is_a?(String) && name.strip.present?
+        raise InvalidResponse,
+          "AI test suggestion must include a name"
+      end
+
+      unless reason.is_a?(String) && reason.strip.present?
+        raise InvalidResponse,
+          "AI test suggestion must include a reason"
+      end
+
+      if !test_code.nil? &&
+          (!test_code.is_a?(String) || test_code.strip.blank?)
+        raise InvalidResponse,
+          "AI test suggestion test_code must be a nonblank string"
+      end
+
+      concern = {
+        type: :ai,
+        kind: kind,
+        name: name.strip,
+        reason: reason.strip,
+        description: name.strip
+      }
+
+      concern[:test_code] = test_code.strip if test_code.present?
+
+      concern
+    end
+
+    def normalize_kind(value)
+      return :coverage if value.nil?
+
+      kind = value.to_s.strip.to_sym
+
+      unless VALID_KINDS.include?(kind)
+        raise InvalidResponse,
+          "AI test suggestion kind must be coverage or contract_check"
+      end
+
+      kind
+    end
+  end
+end

data/lib/rails_proof/ai_test_validator.rb

@@ -0,0 +1,65 @@
+require "ripper"
+
+module RailsProof
+  class AiTestValidator
+    Result = Struct.new(
+      :valid,
+      :errors,
+      keyword_init: true
+    ) do
+      def valid?
+        valid
+      end
+    end
+
+    attr_reader :test_code
+
+    def initialize(test_code)
+      @test_code = test_code
+    end
+
+    def validate
+      errors = []
+
+      errors << "test code must be a nonblank string" unless nonblank?
+      return Result.new(valid: false, errors: errors) unless errors.empty?
+
+      errors << "test code is not valid Ruby" unless valid_ruby?
+      errors << "test code must contain exactly one test declaration" unless one_test?
+      errors << "test code must not contain a class declaration" if class_declaration?
+      errors << "test code must not contain a require statement" if require_statement?
+      errors << "test code must not contain Markdown code fences" if markdown_fence?
+
+      Result.new(
+        valid: errors.empty?,
+        errors: errors
+      )
+    end
+
+    private
+
+    def nonblank?
+      test_code.is_a?(String) && !test_code.strip.empty?
+    end
+
+    def valid_ruby?
+      !Ripper.sexp(test_code).nil?
+    end
+
+    def one_test?
+      test_code.scan(/^\s*test\s*(?:\(\s*)?["']/).count == 1
+    end
+
+    def class_declaration?
+      test_code.match?(/^\s*class\s+/)
+    end
+
+    def require_statement?
+      test_code.match?(/^\s*require(?:_relative)?\s+/)
+    end
+
+    def markdown_fence?
+      test_code.include?("```")
+    end
+  end
+end