rails_proof 1.0.0

data/lib/rails_proof/review_store.rb

@@ -0,0 +1,241 @@
+require "digest"
+require "json"
+require "pathname"
+require "securerandom"
+require "time"
+require "rails_proof/ai_test_identity"
+
+module RailsProof
+  class ReviewStore
+    attr_reader :root
+
+    def initialize(root:)
+      @root = Pathname.new(root)
+    end
+
+    def save(
+      concern:,
+      test_output:,
+      test_file_path:,
+      test_class_name:,
+      target_path: nil
+    )
+      review_directory.mkpath
+
+      timestamp = Time.now.utc.iso8601
+      fingerprint = target_fingerprint(target_path)
+
+      existing_path = find_existing_review(
+        concern: concern,
+        target_path: target_path,
+        test_file_path: test_file_path,
+        target_fingerprint: fingerprint
+      )
+
+      if existing_path
+        update_existing_review(
+          path: existing_path,
+          concern: concern,
+          test_output: test_output,
+          timestamp: timestamp
+        )
+
+        return existing_path
+      end
+
+      path = review_directory.join(
+        review_filename(
+          test_class_name: test_class_name,
+          name: concern_name(concern)
+        )
+      )
+
+      path.write(
+        JSON.pretty_generate(
+          review_record(
+            concern: concern,
+            test_output: test_output,
+            test_file_path: test_file_path,
+            test_class_name: test_class_name,
+            target_path: target_path,
+            target_fingerprint: fingerprint,
+            timestamp: timestamp
+          )
+        ) + "\n"
+      )
+
+      path
+    end
+
+    def outstanding_findings(
+      target_path:,
+      test_file_path:
+    )
+      fingerprint = target_fingerprint(target_path)
+
+      return [] unless fingerprint
+
+      review_paths.filter_map do |path|
+        record = read_record(path)
+
+        next unless record
+        next unless record["status"] == "needs_review"
+        next unless record["target_path"] == target_path
+        next unless record["test_file_path"] == test_file_path
+        next unless record["target_fingerprint"] == fingerprint
+
+        record
+      end
+    end
+
+    private
+
+    def review_directory
+      root.join(".rails_proof/review")
+    end
+
+    def review_paths
+      return [] unless review_directory.directory?
+
+      review_directory.glob("*.json")
+    end
+
+    def review_filename(test_class_name:, name:)
+      timestamp = Time.now.utc.strftime("%Y%m%dT%H%M%S")
+      slug = slugify("#{test_class_name}-#{name}")
+      token = SecureRandom.hex(4)
+
+      "#{timestamp}-#{slug}-#{token}.json"
+    end
+
+    def slugify(value)
+      value
+        .to_s
+        .downcase
+        .gsub(/[^a-z0-9]+/, "-")
+        .gsub(/\A-+|-+\z/, "")
+        .slice(0, 80)
+    end
+
+    def review_record(
+      concern:,
+      test_output:,
+      test_file_path:,
+      test_class_name:,
+      target_path:,
+      target_fingerprint:,
+      timestamp:
+    )
+      {
+        version: 3,
+        status: "needs_review",
+        created_at: timestamp,
+        last_seen_at: timestamp,
+        occurrences: 1,
+        target_path: target_path,
+        target_fingerprint: target_fingerprint,
+        test_file_path: test_file_path,
+        test_class_name: test_class_name,
+        kind: concern_kind(concern),
+        name: concern_name(concern),
+        reason: concern_reason(concern),
+        test_code: concern_test_code(concern),
+        test_fingerprint:
+          RailsProof::AiTestIdentity.test_fingerprint(
+            concern_test_code(concern)
+          ),
+        test_output: test_output
+      }
+    end
+
+    def update_existing_review(
+      path:,
+      concern:,
+      test_output:,
+      timestamp:
+    )
+      record = read_record(path)
+
+      return unless record
+
+      record["last_seen_at"] = timestamp
+      record["occurrences"] =
+        record.fetch("occurrences", 1).to_i + 1
+      record["kind"] = concern_kind(concern)
+      record["name"] = concern_name(concern)
+      record["reason"] = concern_reason(concern)
+      record["test_code"] = concern_test_code(concern)
+      record["test_fingerprint"] =
+        RailsProof::AiTestIdentity.test_fingerprint(
+          concern_test_code(concern)
+        )
+      record["test_output"] = test_output
+
+      path.write(
+        JSON.pretty_generate(record) + "\n"
+      )
+    end
+
+    def find_existing_review(
+      concern:,
+      target_path:,
+      test_file_path:,
+      target_fingerprint:
+    )
+      return nil unless target_fingerprint
+
+      review_paths.find do |path|
+        record = read_record(path)
+
+        next false unless record
+        next false unless record["status"] == "needs_review"
+        next false unless record["target_path"] == target_path
+        next false unless record["test_file_path"] == test_file_path
+        next false unless(
+          record["target_fingerprint"] == target_fingerprint
+        )
+
+        RailsProof::AiTestIdentity.same?(
+          first_name: concern_name(concern),
+          first_test_code: concern_test_code(concern),
+          second_name: record["name"],
+          second_test_code: record["test_code"]
+        )
+      end
+    end
+
+    def concern_name(concern)
+      concern[:name] || concern["name"]
+    end
+
+    def concern_reason(concern)
+      concern[:reason] || concern["reason"]
+    end
+
+    def concern_test_code(concern)
+      concern[:test_code] || concern["test_code"]
+    end
+
+    def target_fingerprint(target_path)
+      return nil if target_path.blank?
+
+      path = root.join(target_path)
+
+      return nil unless path.file?
+
+      Digest::SHA256.hexdigest(path.read)
+    end
+
+    def concern_kind(concern)
+      kind = concern[:kind] || concern["kind"]
+
+      kind&.to_s
+    end
+
+    def read_record(path)
+      JSON.parse(path.read)
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/rails_proof/target_discovery.rb

@@ -0,0 +1,145 @@
+require "pathname"
+require "active_support/core_ext/string/inflections"
+
+module RailsProof
+  class TargetDiscovery
+    Target = Struct.new(
+      :type,
+      :path,
+      :class_name,
+      keyword_init: true
+    )
+
+    SUPPORTED_DIRECTORIES = {
+      "app/models" => :model,
+      "app/controllers" => :controller
+    }.freeze
+
+    attr_reader :root, :scope
+
+    def initialize(root:, scope: nil)
+      @root = Pathname.new(root)
+      @scope = scope
+    end
+
+    def targets
+      @targets ||= if normalized_scope
+        discover_scope(normalized_scope)
+      else
+        discover_all
+      end
+    end
+
+    private
+
+    def normalized_scope
+      return @normalized_scope if defined?(@normalized_scope)
+
+      value = scope.to_s.strip
+
+      @normalized_scope = if value.empty?
+        nil
+      else
+        normalize_path(value)
+      end
+    end
+
+    def normalize_path(path)
+      pathname = Pathname.new(path)
+
+      if pathname.absolute?
+        raise ArgumentError, "RailsProof scope must be relative to the Rails application"
+      end
+
+      normalized = pathname.cleanpath.to_s.delete_prefix("./")
+
+      if normalized == ".." || normalized.start_with?("../")
+        raise ArgumentError, "RailsProof scope must stay inside the Rails application"
+      end
+
+      normalized
+    end
+
+    def discover_scope(path)
+      absolute_path = root.join(path)
+
+      if absolute_path.file?
+        [target_for_file(path)]
+      elsif absolute_path.directory?
+        discover_directory(path)
+      else
+        raise ArgumentError, "RailsProof target not found: #{path}"
+      end
+    end
+
+    def discover_all
+      SUPPORTED_DIRECTORIES.keys.flat_map do |directory|
+        next [] unless root.join(directory).directory?
+
+        discover_directory(directory)
+      end
+    end
+
+    def discover_directory(directory)
+      type = type_for_path(directory)
+
+      unless type
+        raise ArgumentError, "Unsupported RailsProof target: #{directory}"
+      end
+
+      pattern = root.join(directory, "**", "*.rb").to_s
+
+      Dir.glob(pattern).sort.filter_map do |absolute_path|
+        relative_path = Pathname.new(absolute_path)
+          .relative_path_from(root)
+          .to_s
+
+        next if ignored_path?(relative_path)
+
+        target_for_file(relative_path)
+      end
+    end
+
+    def target_for_file(path)
+      type = type_for_path(path)
+
+      unless type && path.end_with?(".rb")
+        raise ArgumentError, "Unsupported RailsProof target: #{path}"
+      end
+
+      if ignored_path?(path)
+        raise ArgumentError, "RailsProof does not inspect base or concern files: #{path}"
+      end
+
+      Target.new(
+        type: type,
+        path: path,
+        class_name: class_name_for(path, type)
+      )
+    end
+
+    def type_for_path(path)
+      SUPPORTED_DIRECTORIES.each do |directory, type|
+        return type if path == directory || path.start_with?("#{directory}/")
+      end
+
+      nil
+    end
+
+    def ignored_path?(path)
+      path == "app/models/application_record.rb" ||
+        path.start_with?("app/models/concerns/") ||
+        path == "app/controllers/application_controller.rb" ||
+        path.start_with?("app/controllers/concerns/")
+    end
+
+    def class_name_for(path, type)
+      prefix = type == :model ? "app/models/" : "app/controllers/"
+
+      path
+        .delete_prefix(prefix)
+        .delete_suffix(".rb")
+        .camelize
+    end
+  end
+end

data/lib/rails_proof/test_coverage_plan.rb

@@ -0,0 +1,84 @@
+module RailsProof
+  class TestCoveragePlan
+    attr_reader :model_test_plan, :test_inspector
+
+    def initialize(model_test_plan, test_inspector)
+      @model_test_plan = model_test_plan
+      @test_inspector = test_inspector
+    end
+
+    def covered_concerns
+      @covered_concerns ||= model_test_plan.concerns.select do |concern|
+        covered?(concern)
+      end
+    end
+
+    def missing_concerns
+      @missing_concerns ||= model_test_plan.concerns.reject do |concern|
+        covered?(concern)
+      end
+    end
+
+    def covered_count
+      covered_concerns.count
+    end
+
+    def missing_count
+      missing_concerns.count
+    end
+
+    private
+
+    def covered?(concern)
+      test_names.any? do |test_name|
+        matches_concern?(test_name, concern)
+      end
+    end
+
+    def test_names
+      @test_names ||= test_inspector.test_cases.map do |test_case|
+        normalize(test_case[:name])
+      end
+    end
+
+    def matches_concern?(test_name, concern)
+      case concern[:type]
+      when :association
+        association_covered?(test_name, concern)
+      when :validation
+        validation_covered?(test_name, concern)
+      else
+        false
+      end
+    end
+
+    def association_covered?(test_name, concern)
+      macro = normalize(concern[:macro].to_s)
+      name = normalize(concern[:name].to_s)
+
+      test_name.include?(macro) &&
+        test_name.include?(name)
+    end
+
+    def validation_covered?(test_name, concern)
+      attribute = normalize(concern[:attribute].to_s)
+
+      test_name.include?(attribute) &&
+        (
+          test_name.include?("presence") ||
+          test_name.include?("present") ||
+          test_name.include?("required") ||
+          test_name.include?("requires")
+        )
+    end
+
+    def normalize(value)
+      value
+        .downcase
+        .tr("_", " ")
+        .gsub(/[^a-z0-9\s]/, " ")
+        .split
+        .join(" ")
+    end
+  end
+end

data/lib/rails_proof/test_inspector.rb

@@ -0,0 +1,54 @@
+module RailsProof
+  class TestInspector
+    attr_reader :source
+
+    def initialize(source)
+      @source = source
+    end
+
+    def test_cases
+      @test_cases ||= rails_style_tests + method_style_tests
+    end
+
+    def count
+      test_cases.count
+    end
+
+    def empty?
+      test_cases.empty?
+    end
+
+    private
+
+    def rails_style_tests
+      source.each_line.filter_map do |line|
+        match = line.match(
+          /^\s*test\s*(?:\(\s*)?(["'])(.+?)\1\s*\)?\s+do\b/
+        )
+
+        next unless match
+
+        {
+          style: :rails,
+          name: match[2]
+        }
+      end
+    end
+
+    def method_style_tests
+      source.each_line.filter_map do |line|
+        match = line.match(/^\s*def\s+(test_[a-zA-Z0-9_!?]+)/)
+
+        next unless match
+
+        method_name = match[1]
+
+        {
+          style: :method,
+          name: method_name.delete_prefix("test_").tr("_", " "),
+          method_name: method_name
+        }
+      end
+    end
+  end
+end

data/lib/rails_proof/test_runner.rb

@@ -0,0 +1,136 @@
+require "open3"
+require "pathname"
+
+module RailsProof
+  class TestRunner
+    class Error < StandardError; end
+
+    Result = Struct.new(
+      :passed,
+      :output,
+      :command,
+      keyword_init: true
+    ) do
+      def passed?
+        passed
+      end
+    end
+
+    attr_reader :root, :test_file_path
+
+    def initialize(root:, test_file_path:)
+      @root = Pathname.new(root).expand_path
+      @test_file_path = Pathname.new(test_file_path)
+    end
+
+    def run
+      stdout, stderr, status = Open3.capture3(
+        { "RAILS_ENV" => "test" },
+        *command,
+        chdir: working_directory.to_s
+      )
+
+      output = [stdout, stderr].reject(&:empty?).join
+
+      raise_unavailable_test_api!(output)
+
+      Result.new(
+        passed: status.success?,
+        output: output,
+        command: command
+      )
+    end
+
+    def command
+      @command ||= resolve_runner.fetch(:command)
+    end
+
+    def working_directory
+      @working_directory ||= resolve_runner.fetch(:working_directory)
+    end
+
+    private
+
+    def raise_unavailable_test_api!(output)
+      message =
+        unavailable_test_api_message(output)
+
+      return unless message
+
+      raise Error, message
+    end
+
+    def unavailable_test_api_message(output)
+      if output.match?(
+        /NoMethodError: undefined method ['`]stub['`]/
+      )
+        return "candidate uses .stub, but .stub is unavailable in this test environment"
+      end
+
+      if output.match?(
+        /NameError: uninitialized constant Minitest::Mock/
+      )
+        return "candidate uses Minitest::Mock, but Minitest::Mock is unavailable in this test environment"
+      end
+
+      nil
+    end
+
+    def resolve_runner
+      @resolve_runner ||= begin
+        normal_rails_runner || ancestor_test_runner || raise_runner_error
+      end
+    end
+
+    def normal_rails_runner
+      rails = root.join("bin/rails")
+      test_helper = root.join("test/test_helper.rb")
+
+      return unless rails.file? && test_helper.file?
+
+      {
+        working_directory: root,
+        command: [
+          rails.to_s,
+          "test",
+          test_file_path.to_s
+        ]
+      }
+    end
+
+    def ancestor_test_runner
+      current = root
+
+      loop do
+        runner = current.join("bin/test")
+        test_helper = current.join("test/test_helper.rb")
+
+        if runner.file? && test_helper.file?
+          absolute_test_path = root.join(test_file_path).expand_path
+          relative_test_path =
+            absolute_test_path.relative_path_from(current).to_s
+
+          return {
+            working_directory: current,
+            command: [
+              runner.to_s,
+              relative_test_path
+            ]
+          }
+        end
+
+        parent = current.parent
+        break if parent == current
+
+        current = parent
+      end
+
+      nil
+    end
+
+    def raise_runner_error
+      raise Error,
+        "RailsProof could not find a Rails test runner for #{root}"
+    end
+  end
+end