crspec 0.1.0

data/lib/crspec/mock/space.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "interceptor"
+
+module Crspec
+  module Mock
+    class Space
+      STORAGE_KEY = :crspec_mock_space
+
+      def self.current
+        Fiber[STORAGE_KEY] ||= new
+      end
+
+      def self.verify_and_reset!
+        space = Fiber[STORAGE_KEY]
+        return unless space
+
+        begin
+          space.verify!
+        ensure
+          space.reset!
+          Fiber[STORAGE_KEY] = nil
+        end
+      end
+
+      def initialize
+        @doubles = []
+        @stubs = Hash.new { |h, k| h[k] = {} }
+        @expectations = []
+        @mutex = Mutex.new
+      end
+
+      def register_stub(target, method_name, implementation)
+        method_sym = method_name.to_sym
+        ensure_interceptor_prepended(target, method_sym)
+        @mutex.synchronize do
+          @stubs[target.object_id][method_sym] = implementation
+        end
+      end
+
+      def fetch_stub(target, method_name)
+        @mutex.synchronize do
+          @stubs[target.object_id][method_name.to_sym]
+        end
+      end
+
+      def register_expectation(expectation)
+        @mutex.synchronize do
+          @expectations << expectation
+        end
+      end
+
+      def register_double(double_obj)
+        @mutex.synchronize do
+          @doubles << double_obj
+        end
+      end
+
+      def verify!
+        @expectations.each(&:verify_expectations!)
+        @doubles.each(&:verify_expectations!)
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @stubs.clear
+          @doubles.clear
+          @expectations.clear
+        end
+      end
+
+      private
+
+      def ensure_interceptor_prepended(target, method_name)
+        klass = target.singleton_class
+        klass.prepend(Interceptor) unless klass.include?(Interceptor)
+        Interceptor.add_intercept_method(method_name)
+      end
+    end
+  end
+end

data/lib/crspec/rails/database_isolation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Crspec
+  module Rails
+    module DatabaseIsolation
+      def self.wrap_example(example)
+        if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:lease_connection)
+          connection = ActiveRecord::Base.lease_connection
+          connection.begin_transaction(joinable: false)
+          savepoint_name = "ex_root"
+          connection.create_savepoint(savepoint_name) if connection.respond_to?(:create_savepoint)
+
+          begin
+            example.execute!
+          ensure
+            if connection.respond_to?(:transaction_open?) && connection.transaction_open?
+              connection.rollback_transaction
+            end
+            if ActiveRecord::Base.respond_to?(:connection_handler) && ActiveRecord::Base.connection_handler.respond_to?(:release_connection)
+              ActiveRecord::Base.connection_handler.release_connection
+            end
+          end
+        else
+          example.execute!
+        end
+      end
+    end
+  end
+end

data/lib/crspec/rails/parallel.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Crspec
+  module Rails
+    module Parallel
+      class << self
+        attr_accessor :worker_count, :setup_blocks, :teardown_blocks, :enabled
+
+        def parallelize(workers: :number_of_processors, &block)
+          count = case workers
+                  when :number_of_processors
+                    Etc.nprocessors
+                  when Integer
+                    workers
+                  else
+                    Etc.nprocessors
+                  end
+          @worker_count = count
+          @enabled = true
+          @setup_blocks ||= []
+          @teardown_blocks ||= []
+
+          return unless block_given?
+
+          instance_eval(&block)
+        end
+
+        def enabled?
+          !!@enabled
+        end
+
+        def parallelize_setup(&block)
+          @setup_blocks ||= []
+          @setup_blocks << block
+        end
+
+        def parallelize_teardown(&block)
+          @teardown_blocks ||= []
+          @teardown_blocks << block
+        end
+
+        def setup_worker(worker_number)
+          env_num = worker_number == 1 ? "" : worker_number.to_s
+          ENV["TEST_ENV_NUMBER"] = env_num
+          ENV["PARALLEL_WORKERS"] = (@worker_count || Etc.nprocessors).to_s
+
+          if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection_db_config)
+            setup_active_record_db(worker_number)
+          end
+
+          @setup_blocks&.each { |b| b.call(worker_number) }
+        end
+
+        def teardown_worker(worker_number)
+          @teardown_blocks&.each { |b| b.call(worker_number) }
+
+          return unless defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection_handler)
+
+          begin
+            ActiveRecord::Base.connection_handler.clear_all_connections!
+          rescue StandardError
+            nil
+          end
+        end
+
+        def reset!
+          @enabled = false
+          @worker_count = nil
+          @setup_blocks = []
+          @teardown_blocks = []
+        end
+
+        private
+
+        def setup_active_record_db(worker_number)
+          return if worker_number == 1
+
+          config = begin
+            ActiveRecord::Base.connection_db_config
+          rescue StandardError
+            nil
+          end
+          return unless config
+
+          db_name = "#{config.database}_#{worker_number}"
+          new_config = config.configuration_hash.merge(database: db_name)
+          begin
+            ActiveRecord::Base.establish_connection(new_config)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crspec/rails/system_server.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Crspec
+  module Rails
+    class SystemServer
+      def self.start_concurrent_server!(app = nil, port = 9887)
+        @server_mutex ||= Mutex.new
+        @server_mutex.synchronize do
+          return if @running
+
+          if defined?(Puma::Server)
+            rack_app = app || (defined?(::Rails) && ::Rails.respond_to?(:application) ? ::Rails.application : nil)
+            return unless rack_app
+
+            events = defined?(Puma::Events) ? Puma::Events.null : nil
+            server = Puma::Server.new(rack_app, events, { min_threads: 1, max_threads: Etc.nprocessors })
+            server.add_tcp_listener("127.0.0.1", port)
+            Thread.new { server.run }
+          end
+          @running = true
+        end
+      end
+
+      def self.running?
+        !!@running
+      end
+
+      def self.reset!
+        @running = false
+      end
+    end
+  end
+end

data/lib/crspec/runner.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "etc"
+require_relative "execution_context"
+require_relative "formatters/progress_formatter"
+
+module Crspec
+  class Runner
+    attr_reader :concurrency, :passed_examples, :failed_examples, :total_duration, :formatter
+
+    def initialize(concurrency: Etc.nprocessors, formatter: nil)
+      @concurrency = concurrency
+      @formatter = formatter || Formatters::ProgressFormatter.new
+      @queue = Thread::Queue.new
+      @passed_examples = []
+      @failed_examples = []
+      @mutex = Mutex.new
+      @total_duration = 0
+    end
+
+    def run(example_groups)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @formatter.start
+      example_groups.each { |group| enqueue_examples(group) }
+
+      workers = Array.new(@concurrency) do |worker_idx|
+        Thread.new do
+          worker_number = worker_idx + 1
+          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
+            end
+            break unless example
+
+            execute_example(example)
+          end
+        ensure
+          Rails::Parallel.teardown_worker(worker_number) if defined?(Rails::Parallel) && Rails::Parallel.enabled?
+        end
+      end
+
+      workers.each(&:join)
+      @total_duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      @formatter.finish
+      self
+    end
+
+    def success?
+      @failed_examples.empty?
+    end
+
+    private
+
+    def enqueue_examples(group)
+      group.examples.each { |example| @queue.push(example) }
+      group.children.each { |child| enqueue_examples(child) }
+    end
+
+    def execute_example(example)
+      ExecutionContext.isolate(example.id, example.metadata) do |_context|
+        example.execute!
+      ensure
+        if defined?(Mock::Space)
+          begin
+            Mock::Space.verify_and_reset!
+          rescue StandardError => e
+            if example.status == :passed
+              example.instance_variable_set(:@status, :failed)
+              example.instance_variable_set(:@error, e)
+            end
+          end
+        end
+
+        record_result(example)
+      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)
+        end
+      end
+    end
+  end
+end

data/lib/crspec/transpiler/cli.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "rewriter"
+require "optparse"
+require "fileutils"
+
+module Crspec
+  module Transpiler
+    class CLI
+      def self.run(args)
+        new(args).run
+      end
+
+      def initialize(args)
+        @args = args
+        @mode = :help
+        @paths = []
+      end
+
+      def run
+        parse_options
+        case @mode
+        when :analyze
+          analyze_paths(@paths)
+        when :write
+          write_paths(@paths)
+        else
+          puts "Usage: crspec-transpile [--analyze|--write] <files or directories>"
+        end
+      end
+
+      private
+
+      def parse_options
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: crspec-transpile [options] <path>"
+
+          opts.on("-a", "--analyze", "Analyze files for thread-unsafe patterns") do
+            @mode = :analyze
+          end
+
+          opts.on("-w", "--write", "Transpile RSpec files to Crspec in-place") do
+            @mode = :write
+          end
+
+          opts.on("-h", "--help", "Show help") do
+            @mode = :help
+          end
+        end
+
+        leftovers = parser.parse(@args)
+        @paths = leftovers.empty? ? ["spec"] : leftovers
+      end
+
+      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?
+          elsif File.file?(p)
+            files << p
+          end
+        end
+        files.uniq
+      end
+
+      def analyze_paths(paths)
+        files = find_files(paths)
+        total_warnings = 0
+
+        files.each do |file|
+          content = File.read(file)
+          rewriter = Rewriter.new(content)
+          rewriter.transpile
+          next if rewriter.warnings.empty?
+
+          puts "File: #{file}"
+          rewriter.warnings.each do |w|
+            puts "  #{w}"
+            total_warnings += 1
+          end
+        end
+
+        puts "Analysis complete. Total warnings found: #{total_warnings}"
+      end
+
+      def write_paths(paths)
+        files = find_files(paths)
+        count = 0
+
+        files.each do |file|
+          content = File.read(file)
+          rewriter = Rewriter.new(content)
+          new_code = rewriter.transpile
+
+          next unless new_code != content
+
+          File.write(file, new_code)
+          puts "Transpiled: #{file}"
+          count += 1
+        end
+
+        puts "Transpilation complete. Updated #{count} file(s)."
+      end
+    end
+  end
+end

data/lib/crspec/transpiler/rewriter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Crspec
+  module Transpiler
+    class Rewriter < Prism::Visitor
+      attr_reader :transformed_code, :warnings
+
+      def initialize(source_code)
+        super()
+        @source_code = source_code
+        @replacements = []
+        @warnings = []
+      end
+
+      def transpile
+        result = Prism.parse(@source_code)
+        result.value.accept(self)
+        apply_replacements
+      end
+
+      def visit_call_node(node)
+        # Convert RSpec.describe -> Crspec.describe
+        if node.receiver.is_a?(Prism::ConstantReadNode) &&
+           node.receiver.name == :RSpec &&
+           node.name == :describe
+          @replacements << {
+            start_offset: node.receiver.location.start_offset,
+            end_offset: node.receiver.location.end_offset,
+            text: "Crspec"
+          }
+        end
+
+        # Flag thread-unsafe before(:all) blocks
+        if node.name == :before && node.arguments
+          first_arg = node.arguments.arguments.first
+          if first_arg.is_a?(Prism::SymbolNode) && first_arg.value == "all"
+            @warnings << "Line #{node.location.start_line}: [Thread Safety Warning] before(:all) mutates global state across examples."
+          end
+        end
+
+        super
+      end
+
+      def visit_constant_read_node(node)
+        if node.name == :RSpec
+          @replacements << {
+            start_offset: node.location.start_offset,
+            end_offset: node.location.end_offset,
+            text: "Crspec"
+          }
+        end
+        super
+      end
+
+      private
+
+      def apply_replacements
+        buffer = @source_code.dup
+        # Sort replacements backwards so offsets remain valid during splicing
+        sorted = @replacements.uniq { |r| [r[:start_offset], r[:end_offset]] }.sort_by { |r| -r[:start_offset] }
+        sorted.each do |r|
+          buffer[r[:start_offset]...r[:end_offset]] = r[:text]
+        end
+        @transformed_code = buffer
+      end
+    end
+  end
+end

data/lib/crspec/version.rb

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

data/lib/crspec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "crspec/version"
+require_relative "crspec/execution_context"
+require_relative "crspec/matchers"
+require_relative "crspec/expectations"
+require_relative "crspec/example"
+require_relative "crspec/example_group"
+require_relative "crspec/mock/interceptor"
+require_relative "crspec/mock/space"
+require_relative "crspec/mock/double"
+require_relative "crspec/formatters/progress_formatter"
+require_relative "crspec/runner"
+require_relative "crspec/dsl"
+require_relative "crspec/rails/database_isolation"
+require_relative "crspec/rails/system_server"
+require_relative "crspec/rails/parallel"
+require_relative "crspec/transpiler/rewriter"
+require_relative "crspec/transpiler/cli"
+
+module Crspec
+  class Error < StandardError; end
+end

data/samples/user_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "crspec"
+require "active_model"
+
+class User
+  include ActiveModel::Model
+
+  attr_accessor :name, :email
+
+  validates :name, presence: true
+  validates :email, presence: true
+end
+
+Crspec.describe User, type: :model do
+  let(:valid_attributes) { { name: "Jane Doe", email: "jane@example.com" } }
+  subject(:user) { User.new(valid_attributes) }
+
+  it "validates primary attributes" do
+    expect(user.valid?).to be(true)
+  end
+
+  context "when email is omitted" do
+    let(:valid_attributes) { { name: "Jane Doe", email: nil } }
+
+    it "flags validation errors" do
+      expect(user.valid?).to be(false)
+      expect(user.errors[:email]).to include("can't be blank")
+    end
+  end
+end

data/sig/crspec.rbs

@@ -0,0 +1,4 @@
+module Crspec
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/crspec/execution_context_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ExecutionContextTest < Minitest::Test
+  def test_fiber_storage_isolation_and_inheritance
+    parent_ctx = nil
+    sub_fiber_ctx = nil
+
+    Crspec::ExecutionContext.isolate("ex-1", { type: :model }) do |ctx|
+      parent_ctx = ctx
+      assert_equal "ex-1", Crspec::ExecutionContext.current.example_id
+
+      # Sub-fiber created inside example inherits Fiber storage
+      Fiber.new do
+        sub_fiber_ctx = Crspec::ExecutionContext.current
+      end.resume
+    end
+
+    assert_equal parent_ctx.example_id, sub_fiber_ctx.example_id
+  end
+
+  def test_per_fiber_lazy_memoization
+    Crspec::ExecutionContext.isolate("ex-2") do
+      ctx = Crspec::ExecutionContext.current
+      count = 0
+      val1 = ctx.fetch_memoized(:user) do
+        count += 1
+        "Jane"
+      end
+      val2 = ctx.fetch_memoized(:user) do
+        count += 1
+        "Jane"
+      end
+
+      assert_equal "Jane", val1
+      assert_equal "Jane", val2
+      assert_equal 1, count
+    end
+  end
+
+  def test_thread_safety_memoization
+    Crspec::ExecutionContext.isolate("ex-3") do
+      ctx = Crspec::ExecutionContext.current
+      counter = 0
+      threads = Array.new(10) do
+        Thread.new do
+          ctx.fetch_memoized(:shared_calc) do
+            sleep 0.01
+            counter += 1
+            42
+          end
+        end
+      end
+
+      results = threads.map(&:value)
+      assert_equal Array.new(10, 42), results
+      assert_equal 1, counter
+    end
+  end
+end

data/test/crspec/mock_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class MockTest < Minitest::Test
+  class StripeClient
+    def charge(amount)
+      "real_charge_#{amount}"
+    end
+  end
+
+  def test_fiber_isolated_stubs
+    client = StripeClient.new
+    fiber1_result = nil
+    fiber2_result = nil
+
+    f1 = Fiber.new do
+      Crspec::Mock::Space.current.register_stub(client, :charge, proc { "stub_fiber_1" })
+      fiber1_result = client.charge(100)
+    end
+
+    f2 = Fiber.new do
+      Crspec::Mock::Space.current.register_stub(client, :charge, proc { "stub_fiber_2" })
+      fiber2_result = client.charge(200)
+    end
+
+    f1.resume
+    f2.resume
+
+    assert_equal "stub_fiber_1", fiber1_result
+    assert_equal "stub_fiber_2", fiber2_result
+    assert_equal "real_charge_500", client.charge(500)
+  end
+
+  def test_double_and_expectation_dsl
+    Crspec::ExecutionContext.isolate("mock-test") do
+      stubs_mock = Crspec::Mock::Double.new("Stripe", charge: "ok")
+      assert_equal "ok", stubs_mock.charge(50)
+    end
+  end
+
+  def test_allow_receive_with_and_return
+    group = Crspec.describe "PaymentGateway" do
+      it "stubs method" do
+        client = StripeClient.new
+        allow(client).to receive(:charge).with(5000).and_return("succeeded")
+        expect(client.charge(5000)).to eq("succeeded")
+      end
+    end
+
+    runner = Crspec::Runner.new(concurrency: 1)
+    runner.run([group])
+    assert runner.success?
+  end
+end