crspec 0.1.2 → 0.1.3

data/lib/crspec/rails/request_helpers.rb

@@ -18,7 +18,25 @@ module Crspec
         include ActiveSupport::Testing::FileFixtures
       end
 
-      ResponseStruct = Struct.new(:status, :body, :headers)
+      # Lightweight response wrapper that mimics the small subset of the
+      # Rails test response API that the specs rely on (status, body,
+      # headers, media_type, parsed_body, etc.).
+      ResponseStruct = Struct.new(:status, :body, :headers) do
+        def media_type
+          content_type_header = headers["Content-Type"] || headers["content-type"]
+          return nil unless content_type_header
+
+          # Strip any charset or parameters, e.g. "application/json; charset=utf-8"
+          content_type_header.split(";").first&.strip
+        end
+
+        def parsed_body
+          return nil unless body
+          JSON.parse(body)
+        rescue JSON::ParserError
+          nil
+        end
+      end
 
       def response
         execution_context[:last_response]
@@ -32,34 +50,72 @@ module Crspec
       end
 
       def process_request(method, path, params = {}, headers = {})
-        body_string = params.is_a?(String) ? params : params.to_json
+        # Emulate Rails integration test semantics:
+        # - For GET/DELETE, params are typically carried in the query string
+        # - For POST/PUT/PATCH with JSON, params are in the request body
+        # - `format: :json` should affect the requested path / Accept header
+
+        params = params.dup if params.is_a?(Hash)
+
+        requested_format = nil
+        if params.is_a?(Hash) && params.key?(:format)
+          requested_format = params.delete(:format)&.to_s
+        end
+
+        path_with_format = path.dup
+        if requested_format && !path_with_format.end_with?(".#{requested_format}")
+          path_with_format = "#{path_with_format}.#{requested_format}"
+        end
+
+        query_string = nil
+        body_string = ""
+
+        if params.is_a?(Hash) && !params.empty?
+          if %i[get delete].include?(method.to_sym)
+            # Attach params as query string for idempotent verbs
+            query_string = URI.encode_www_form(params)
+          else
+            # Default to JSON body for non-GET verbs when params are present
+            body_string = params.to_json
+            headers = headers.merge("CONTENT_TYPE" => "application/json") unless headers["CONTENT_TYPE"]
+          end
+        elsif params.is_a?(String)
+          body_string = params
+        end
+
         env = {
           "REQUEST_METHOD" => method.to_s.upcase,
-          "PATH_INFO" => path,
+          "PATH_INFO" => path_with_format,
+          "QUERY_STRING" => query_string.to_s,
           "rack.input" => StringIO.new(body_string),
-          "CONTENT_TYPE" => headers["CONTENT_TYPE"] || "application/json",
-          "HTTP_ACCEPT" => headers["HTTP_ACCEPT"] || "application/json",
+          "CONTENT_TYPE" => headers["CONTENT_TYPE"],
+          "HTTP_ACCEPT" => headers["HTTP_ACCEPT"] || (requested_format == "json" ? "application/json" : nil),
           "CONTENT_LENGTH" => body_string.bytesize.to_s
-        }
+        }.compact
 
         headers.each do |k, v|
           env["HTTP_#{k.to_s.upcase.tr('-', '_')}"] = v unless k.to_s.start_with?("HTTP_")
         end
 
         status = 200
-        response_headers = { "Content-Type" => "application/json" }
+        response_headers = { "Content-Type" => "text/plain" }
         response_body = ""
 
         begin
           if defined?(::Rails) && ::Rails.application && ::Rails.application.routes.routes.any?
-            begin
-              status, response_headers, body_obj = ::Rails.application.call(env)
-              response_body = body_obj.respond_to?(:body) ? body_obj.body : body_obj.join
-            rescue StandardError
-              response_body = params.to_json
-            end
+            status, response_headers, body_obj = ::Rails.application.call(env)
+            response_body = body_obj.respond_to?(:body) ? body_obj.body : body_obj.join
           else
-            response_body = params.to_json
+            # No Rails app mounted; behave like a very small echo server.
+            if (env["HTTP_ACCEPT"] || "").to_s.include?("json") ||
+               (env["CONTENT_TYPE"] || "").to_s.include?("json") ||
+               requested_format == "json"
+              response_headers["Content-Type"] = "application/json"
+              response_body = params.is_a?(String) ? params : params.to_json
+            else
+              response_headers["Content-Type"] = "text/plain"
+              response_body = params.to_s
+            end
           end
         ensure
           if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection_handler)

data/lib/crspec/rails/system_server.rb

@@ -5,7 +5,14 @@ require "etc"
 module Crspec
   module Rails
     class SystemServer
+      # The effective port is offset by TEST_ENV_NUMBER so concurrent
+      # --processes children never collide on the same listener.
+      def self.effective_port(port)
+        port + ENV.fetch("TEST_ENV_NUMBER", "").to_i
+      end
+
       def self.start_concurrent_server!(app = nil, port = 9887)
+        port = effective_port(port)
         @server_mutex ||= Mutex.new
         @server_mutex.synchronize do
           return if @running

data/lib/crspec/rails/warden_shim.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+begin
+  if defined?(Rails) && Rails.env.test? && defined?(Warden::Manager)
+    # Ensure there is always a failure app in test so that requests which
+    # hit Warden::Manager#call_failure_app do not raise "No Failure App
+    # provided" but instead respond with a simple 401/403 style response.
+    Rails.application.config.middleware.insert_after Rack::Head, Warden::Manager do |config|
+      config.failure_app ||= lambda do |_env|
+        [401, { "Content-Type" => "text/plain" }, ["Unauthorized"]]
+      end
+    end unless Rails.application.config.middleware.any? { |m| m.klass == Warden::Manager }
+  end
+rescue StandardError
+  # If the app doesn't use Warden/Devise in a conventional fashion we
+  # silently skip installing the shim.
+end

data/lib/crspec/runner.rb

@@ -1,51 +1,89 @@
 # frozen_string_literal: true
 
 require "etc"
+begin
+  require "async"
+  require "async/semaphore"
+rescue LoadError
+  # Fiber tier unavailable; threads-only execution.
+end
 require_relative "execution_context"
 require_relative "formatters/progress_formatter"
+require_relative "status_persistence"
 
 module Crspec
   class Runner
-    attr_reader :concurrency, :passed_examples, :failed_examples, :total_duration, :formatter
+    attr_reader :concurrency, :fibers, :passed_examples, :failed_examples, :pending_examples, :total_duration, :formatter, :seed
 
-    def initialize(concurrency: Etc.nprocessors, formatter: nil)
+    def initialize(concurrency: Etc.nprocessors, fibers: 1, formatter: nil, fail_fast: false,
+                   seed: nil, only_failures: false, persistence_path: nil,
+                   tags: nil, locations: nil)
       @concurrency = concurrency
+      @fibers = fibers && fibers > 1 && defined?(Async) ? fibers : 1
       @formatter = formatter || Formatters::ProgressFormatter.new
       @queue = Thread::Queue.new
       @passed_examples = []
       @failed_examples = []
-      @mutex = Mutex.new
+      @pending_examples = []
       @total_duration = 0
+      @fail_fast = fail_fast == true ? 1 : fail_fast
+      @failure_count = 0
+      @failure_mutex = Mutex.new
+      @seed = seed
+      @only_failures = only_failures
+      @tags = tags
+      @locations = locations
+      @persistence = StatusPersistence.new(
+        persistence_path || Crspec.configuration.example_status_persistence_file_path
+      )
     end
 
     def run(example_groups)
+      Rails::AssetsShim.install! if defined?(Rails::AssetsShim)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @formatter.start
-      example_groups.each { |group| enqueue_examples(group) }
+      example_groups.each(&:finalize!)
+
+      examples = []
+      example_groups.each { |group| collect_examples(group, examples) }
+      examples = filter_examples(examples)
+      previous_statuses = @persistence.load
+      examples = order_examples(examples, previous_statuses)
+      examples.each { |example| @queue.push(example) }
+      @queue.close
 
       workers = Array.new(@concurrency) do |worker_idx|
         Thread.new do
           worker_number = worker_idx + 1
+          results = { passed: [], failed: [], pending: [] }
+          Thread.current[:crspec_results] = results
           Rails::Parallel.setup_worker(worker_number) if defined?(Rails::Parallel) && Rails::Parallel.enabled?
 
-          Fiber.set_scheduler(Async::Scheduler.new) if defined?(Async::Scheduler)
-          until @queue.empty?
-            example = begin
-              @queue.pop(true)
-            rescue StandardError
-              nil
+          if @fibers > 1
+            run_worker_fibers(results)
+          else
+            while (example = @queue.pop)
+              execute_example(example, results)
             end
-            break unless example
-
-            execute_example(example)
           end
         ensure
+          Rails::DatabaseIsolation.finish_worker if defined?(Rails::DatabaseIsolation)
           Rails::Parallel.teardown_worker(worker_number) if defined?(Rails::Parallel) && Rails::Parallel.enabled?
         end
       end
 
-      workers.each(&:join)
+      workers.each do |worker|
+        worker.join
+        results = worker[:crspec_results]
+        next unless results
+
+        @passed_examples.concat(results[:passed])
+        @failed_examples.concat(results[:failed])
+        @pending_examples.concat(results[:pending])
+      end
       @total_duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      Mock::Interceptor.cleanup! if defined?(Mock::Interceptor)
+      @persistence.save(@passed_examples + @failed_examples)
       @formatter.finish
       self
     end
@@ -56,12 +94,85 @@ module Crspec
 
     private
 
-    def enqueue_examples(group)
-      group.examples.each { |example| @queue.push(example) }
-      group.children.each { |child| enqueue_examples(child) }
+    # Each worker thread runs up to @fibers concurrent example-fibers via
+    # the Async reactor. IO-bound examples overlap within a thread. Fiber
+    # Storage isolation (ExecutionContext, Mock::Space, DB leases) makes
+    # this safe: each example fiber gets its own context, mock space and
+    # leased DB connection.
+    def run_worker_fibers(results)
+      Sync do |top|
+        semaphore = Async::Semaphore.new(@fibers, parent: top)
+        while (example = @queue.pop)
+          semaphore.async do
+            execute_example(example, results)
+          ensure
+            Rails::DatabaseIsolation.finish_worker if defined?(Rails::DatabaseIsolation)
+          end
+        end
+      end
+    end
+
+    def collect_examples(group, acc)
+      acc.concat(group.examples)
+      group.children.each { |child| collect_examples(child, acc) }
+    end
+
+    # Focus (fit/fdescribe/:focus) narrows to focused examples when any
+    # exist; --tag filters on metadata; line-number filters (spec.rb:42)
+    # select the example whose definition is closest above the line.
+    def filter_examples(examples)
+      examples = examples.select(&:focused?) if examples.any?(&:focused?)
+
+      if @tags && !@tags.empty?
+        examples = examples.select do |ex|
+          meta = ex.example_group.ancestor_metadata.merge(ex.metadata || {})
+          @tags.all? do |key, value|
+            value == true ? !!meta[key] : meta[key] == value
+          end
+        end
+      end
+
+      if @locations && !@locations.empty?
+        examples = examples.select do |ex|
+          @locations.any? do |file, line|
+            next false unless ex.file_path && File.expand_path(ex.file_path) == File.expand_path(file)
+            next true if line.nil?
+
+            candidates = examples.select { |e| e.file_path && File.expand_path(e.file_path) == File.expand_path(file) }
+            best = candidates.select { |e| e.line_number && e.line_number <= line }.max_by(&:line_number)
+            best ? ex.equal?(best) : false
+          end
+        end
+      end
+
+      examples
+    end
+
+    # Slowest-first (using persisted timings) shrinks the critical path of
+    # the parallel run; unknown examples go first (assumed potentially slow).
+    # --seed applies random ordering before the timing sort is skipped.
+    def order_examples(examples, previous_statuses)
+      if @only_failures
+        examples = examples.select do |ex|
+          entry = previous_statuses[ex.persistence_key]
+          entry.nil? || entry["status"] == "failed"
+        end
+      end
+
+      if @seed
+        rng = Random.new(@seed)
+        examples.shuffle(random: rng)
+      elsif previous_statuses.empty?
+        examples
+      else
+        examples.sort_by do |ex|
+          entry = previous_statuses[ex.persistence_key]
+          -(entry ? entry["run_time"].to_f : Float::INFINITY)
+        end
+      end
     end
 
-    def execute_example(example)
+    def execute_example(example, results)
       ExecutionContext.isolate(example.id, example.metadata) do |_context|
         example.execute!
       ensure
@@ -76,20 +187,23 @@ module Crspec
           end
         end
 
-        record_result(example)
+        record_result(example, results)
       end
     end
 
-    def record_result(example)
-      @mutex.synchronize do
-        if example.status == :passed
-          @passed_examples << example
-          @formatter.example_passed(example)
-        elsif example.status == :pending
-          @formatter.example_pending(example)
-        else
-          @failed_examples << example
-          @formatter.example_failed(example)
+    def record_result(example, results)
+      if example.status == :passed
+        results[:passed] << example
+        @formatter.example_passed(example)
+      elsif example.status == :pending
+        results[:pending] << example
+        @formatter.example_pending(example)
+      else
+        results[:failed] << example
+        @formatter.example_failed(example)
+        if @fail_fast
+          failures = @failure_mutex.synchronize { @failure_count += 1 }
+          @queue.clear if failures >= @fail_fast
         end
       end
     end

data/lib/crspec/shared_examples.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Crspec
+  # Registry of shared example groups / contexts. Registration happens at
+  # load time (single-threaded); lookups at group-definition time. Blocks
+  # are re-evaluated in the including group, so no state is shared between
+  # examples — parallel-safe by construction.
+  module SharedRegistry
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def register(name, block)
+        registry[name.to_s] = block
+      end
+
+      def fetch(name)
+        registry[name.to_s] or raise ArgumentError,
+                                     "Could not find shared examples or context #{name.inspect}"
+      end
+
+      def reset!
+        @registry = {}
+      end
+    end
+  end
+
+  def self.shared_examples(name, &block)
+    SharedRegistry.register(name, block)
+  end
+
+  def self.shared_context(name, &block)
+    SharedRegistry.register(name, block)
+  end
+
+  class << self
+    alias shared_examples_for shared_examples
+  end
+
+  module SharedDSL
+    def shared_examples(name, &block)
+      Crspec::SharedRegistry.register(name, block)
+    end
+    alias shared_examples_for shared_examples
+    alias shared_context shared_examples
+
+    def include_context(name, *args)
+      block = Crspec::SharedRegistry.fetch(name)
+      if args.empty?
+        instance_eval(&block)
+      else
+        instance_exec(*args, &block)
+      end
+    end
+    alias include_examples include_context
+
+    def it_behaves_like(name, *args)
+      block = Crspec::SharedRegistry.fetch(name)
+      child = describe("behaves like #{name}") {}
+      if args.empty?
+        child.instance_eval(&block)
+      else
+        child.instance_exec(*args, &block)
+      end
+      child
+    end
+    alias it_should_behave_like it_behaves_like
+  end
+end

data/lib/crspec/status_persistence.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Crspec
+  # Persists per-example status and timing between runs. Backs
+  # slowest-first scheduling and --only-failures. Keyed by the example's
+  # stable identity (group description chain + example description).
+  class StatusPersistence
+    def initialize(path)
+      @path = path
+    end
+
+    def load
+      return {} unless @path && File.exist?(@path)
+
+      JSON.parse(File.read(@path))
+    rescue JSON::ParserError, Errno::ENOENT
+      {}
+    end
+
+    def save(examples)
+      return unless @path
+
+      previous = load
+      examples.each do |example|
+        next if example.status == :pending
+
+        previous[example.persistence_key] = {
+          "status" => example.status.to_s,
+          "run_time" => example.execution_time.round(6)
+        }
+      end
+
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      tmp_path = File.join(dir, ".crspec-status-#{Process.pid}-#{rand(1_000_000)}")
+      File.write(tmp_path, JSON.pretty_generate(previous))
+      File.rename(tmp_path, @path)
+    rescue SystemCallError
+      File.delete(tmp_path) if tmp_path && File.exist?(tmp_path)
+      nil
+    end
+  end
+end

data/lib/crspec/transpiler/cli.rb

@@ -15,6 +15,8 @@ module Crspec
         @args = args
         @mode = :help
         @paths = []
+        @diff = false
+        @backup = true
       end
 
       def run
@@ -24,8 +26,11 @@ module Crspec
           analyze_paths(@paths)
         when :write
           write_paths(@paths)
+        when :report
+          report_paths(@paths)
         else
-          Rails.logger.debug "Usage: crspec-transpile [--analyze|--write] <files or directories>"
+          puts "Usage: crspec-transpile [--analyze|--write|--report] [--diff] [--no-backup] <files or directories>"
+          true
         end
       end
 
@@ -43,6 +48,18 @@ module Crspec
             @mode = :write
           end
 
+          opts.on("--report", "Print a per-file migration report with safety scores") do
+            @mode = :report
+          end
+
+          opts.on("--diff", "Dry run: print unified diffs instead of writing") do
+            @diff = true
+          end
+
+          opts.on("--no-backup", "Do not write .bak backups when transpiling") do
+            @backup = false
+          end
+
           opts.on("-h", "--help", "Show help") do
             @mode = :help
           end
@@ -52,37 +69,46 @@ module Crspec
         @paths = leftovers.empty? ? ["spec"] : leftovers
       end
 
+      # Only *_spec.rb plus known helper files are candidates. The old
+      # fallback glob (**/*.rb when no spec files matched) could rewrite an
+      # entire application tree; it is gone.
       def find_files(paths)
         files = []
         paths.each do |p|
           if File.directory?(p)
             files.concat(Dir.glob(File.join(p, "**", "*_spec.rb")))
-            files.concat(Dir.glob(File.join(p, "**", "*.rb"))) if files.empty?
+            files.concat(Dir.glob(File.join(p, "**", "{spec,rails}_helper.rb")))
           elsif File.file?(p)
             files << p
+          else
+            warn "warning: path not found: #{p}"
           end
         end
         files.uniq
       end
 
+      def log(msg = nil)
+        msg = yield if block_given?
+        puts msg
+      end
+
       def analyze_paths(paths)
         files = find_files(paths)
-        total_warnings = 0
+        total = 0
 
         files.each do |file|
-          content = File.read(file)
-          rewriter = Rewriter.new(content)
-          rewriter.transpile
-          next if rewriter.warnings.empty?
+          rewriter = transpiled(file)
+          next if rewriter.lints.empty?
 
-          Rails.logger.debug { "File: #{file}" }
-          rewriter.warnings.each do |w|
-            Rails.logger.debug { "  #{w}" }
-            total_warnings += 1
+          log { "File: #{file}" }
+          rewriter.lints.each do |lint|
+            log { format("  line %-4d %-8s [%s] %s", lint.line, lint.severity, lint.code, lint.message) }
+            total += 1
           end
         end
 
-        Rails.logger.debug { "Analysis complete. Total warnings found: #{total_warnings}" }
+        log { "Analysis complete. Total findings: #{total}" }
+        true
       end
 
       def write_paths(paths)
@@ -96,12 +122,77 @@ module Crspec
 
           next unless new_code != content
 
-          File.write(file, new_code)
-          Rails.logger.debug { "Transpiled: #{file}" }
+          if @diff
+            print_diff(file, content, new_code)
+          else
+            File.write("#{file}.bak", content) if @backup
+            File.write(file, new_code)
+            log { "Transpiled: #{file}#{@backup ? " (backup: #{file}.bak)" : ""}" }
+          end
           count += 1
         end
 
-        Rails.logger.debug { "Transpilation complete. Updated #{count} file(s)." }
+        log { @diff ? "Dry run complete. #{count} file(s) would change." : "Transpilation complete. Updated #{count} file(s)." }
+        true
+      end
+
+      # Per-file concurrency-safety score plus the constructs that need
+      # manual work, enabling incremental migration.
+      def report_paths(paths)
+        files = find_files(paths)
+        rows = files.map do |file|
+          rewriter = transpiled(file)
+          manual = rewriter.lints.reject { |l| l.severity == :info }
+          [file, rewriter.safety_score, rewriter.lints.size, manual]
+        end
+
+        log { format("%-60s %7s %9s", "File", "Score", "Findings") }
+        log { "-" * 78 }
+        rows.sort_by { |_, score, _, _| score }.each do |file, score, findings, manual|
+          log { format("%-60s %6d%% %9d", file, score, findings) }
+          manual.each do |lint|
+            log { format("    line %-4d %-8s [%s] %s", lint.line, lint.severity, lint.code, lint.message) }
+          end
+        end
+
+        avg = rows.empty? ? 100 : rows.sum { |_, s, _, _| s } / rows.size
+        manual_total = rows.sum { |_, _, _, m| m.size }
+        log { "-" * 78 }
+        log { "#{rows.size} file(s), average safety score #{avg}%, #{manual_total} construct(s) need manual work." }
+        true
+      end
+
+      def transpiled(file)
+        rewriter = Rewriter.new(File.read(file))
+        rewriter.transpile
+        rewriter
+      end
+
+      def print_diff(file, old_code, new_code)
+        log { "--- #{file}" }
+        log { "+++ #{file} (transpiled)" }
+        old_lines = old_code.lines
+        new_lines = new_code.lines
+        max = [old_lines.size, new_lines.size].max
+        offset = 0
+        old_lines.each_with_index do |line, i|
+          new_line = new_lines[i + offset]
+          next if line == new_line
+
+          if new_lines[i + offset + 1] == line
+            log { "+#{new_lines[i + offset]}" }
+            offset += 1
+            redo_line = new_lines[i + offset]
+            log { " #{redo_line}" } if redo_line == line
+          else
+            log { "-#{line}" }
+            log { "+#{new_line}" } if new_line
+          end
+        end
+        (old_lines.size + offset...new_lines.size).each do |i|
+          log { "+#{new_lines[i]}" }
+        end
+        max.zero? && nil
       end
     end
   end