crspec 0.1.0

data/lib/crspec/execution_context.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "monitor"
+
+module Crspec
+  class ExecutionContext
+    STORAGE_KEY = :crspec_execution_context
+
+    attr_reader :example_id, :metadata, :parent
+
+    def self.current
+      Fiber[STORAGE_KEY] ||= new(SecureRandom.uuid)
+    end
+
+    def self.isolate(example_id, metadata = {})
+      parent_context = Fiber[STORAGE_KEY]
+      new_context = new(example_id, metadata, parent_context)
+
+      # Fiber storage inheritance preserves context while isolating mutations
+      Fiber.new(storage: { STORAGE_KEY => new_context }) do
+        yield new_context
+      end.resume
+    end
+
+    def initialize(example_id, metadata = {}, parent = nil)
+      @example_id = example_id
+      @metadata = metadata.freeze
+      @parent = parent
+      @memoized_values = {}
+      @monitor = Monitor.new
+    end
+
+    def fetch_memoized(key, &block)
+      return @memoized_values[key] if @memoized_values.key?(key)
+
+      @monitor.synchronize do
+        return @memoized_values[key] if @memoized_values.key?(key)
+
+        @memoized_values[key] = block.call
+      end
+    end
+
+    def [](key)
+      @monitor.synchronize do
+        @memoized_values[key]
+      end
+    end
+
+    def []=(key, value)
+      @monitor.synchronize do
+        @memoized_values[key] = value
+      end
+    end
+
+    def reset!
+      @monitor.synchronize do
+        @memoized_values.clear
+      end
+    end
+  end
+end

data/lib/crspec/expectations.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "matchers"
+
+module Crspec
+  class ExpectationNotMetError < StandardError; end
+
+  class ExpectationTarget
+    def initialize(actual)
+      @actual = actual
+    end
+
+    def to(matcher = nil, &block)
+      matcher ||= block
+      return matcher.setup_expect(@actual) if matcher.respond_to?(:setup_expect)
+
+      raise ExpectationNotMetError, matcher.failure_message unless matcher.matches?(@actual)
+
+      true
+    end
+
+    def not_to(matcher = nil, &block)
+      matcher ||= block
+      if matcher.matches?(@actual)
+        msg = matcher.respond_to?(:failure_message_when_negated) ? matcher.failure_message_when_negated : "Expected matcher not to match"
+        raise ExpectationNotMetError, msg
+      end
+      true
+    end
+
+    alias to_not not_to
+  end
+
+  module Expectations
+    include Matchers
+
+    UNDEFINED = Object.new.freeze
+
+    def expect(value = UNDEFINED, &block)
+      actual = value.equal?(UNDEFINED) ? block : value
+      ExpectationTarget.new(actual)
+    end
+  end
+end

data/lib/crspec/formatters/progress_formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Crspec
+  module Formatters
+    class ProgressFormatter
+      def initialize(output = $stdout, color: output.respond_to?(:tty?) && output.tty?)
+        @output = output
+        @color = color
+        @mutex = Mutex.new
+      end
+
+      def example_passed(_example)
+        @mutex.synchronize do
+          @output.print @color ? "\e[32m.\e[0m" : "."
+          @output.flush
+        end
+      end
+
+      def example_failed(_example)
+        @mutex.synchronize do
+          @output.print @color ? "\e[31mF\e[0m" : "F"
+          @output.flush
+        end
+      end
+
+      def example_pending(_example)
+        @mutex.synchronize do
+          @output.print @color ? "\e[33m*\e[0m" : "*"
+          @output.flush
+        end
+      end
+
+      def start; end
+
+      def finish
+        @mutex.synchronize do
+          @output.puts
+        end
+      end
+    end
+
+    class NullFormatter
+      def example_passed(_example); end
+      def example_failed(_example); end
+      def example_pending(_example); end
+      def start; end
+      def finish; end
+    end
+  end
+end

data/lib/crspec/matchers.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Crspec
+  module Matchers
+    class BaseMatcher
+      attr_reader :actual, :expected
+
+      def initialize(expected = nil)
+        @expected = expected
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to match #{@expected.inspect}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@actual.inspect} not to match #{@expected.inspect}"
+      end
+    end
+
+    class EqMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        @actual == @expected
+      end
+
+      def failure_message
+        "Expected #{@expected.inspect}, got #{@actual.inspect}"
+      end
+
+      def failure_message_when_negated
+        "Expected value not to equal #{@expected.inspect}"
+      end
+    end
+
+    class BeMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        if @expected.nil? && !instance_variable_defined?(:@expected)
+          true
+        elsif @expected.equal?(true) || @expected.equal?(false)
+          @actual == @expected
+        else
+          @actual.equal?(@expected)
+        end
+      end
+
+      def failure_message
+        "Expected #{@expected.inspect} (object_id: #{@expected.object_id}), got #{@actual.inspect} (object_id: #{@actual.object_id})"
+      end
+    end
+
+    class BeNilMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        @actual.nil?
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to be nil"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@actual.inspect} not to be nil"
+      end
+    end
+
+    class BeTruthyMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        !!@actual
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to be truthy"
+      end
+    end
+
+    class BeFalsyMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        !@actual
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to be falsy"
+      end
+    end
+
+    class IncludeMatcher < BaseMatcher
+      def matches?(actual)
+        @actual = actual
+        if @expected.is_a?(Array)
+          @expected.all? { |e| @actual.include?(e) }
+        else
+          @actual.include?(@expected)
+        end
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to include #{@expected.inspect}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@actual.inspect} not to include #{@expected.inspect}"
+      end
+    end
+
+    class RaiseErrorMatcher < BaseMatcher
+      def initialize(expected_exception = StandardError, expected_message = nil)
+        super(expected_exception)
+        @expected_exception = expected_exception
+        @expected_message = expected_message
+        @actual_exception = nil
+      end
+
+      def matches?(block)
+        raise ArgumentError, "raise_error matcher requires a block" unless block.respond_to?(:call)
+
+        begin
+          block.call
+          false
+        rescue Exception => e
+          @actual_exception = e
+          matches_exception?(e)
+        end
+      end
+
+      def failure_message
+        if @actual_exception
+          "Expected #{@expected_exception}#{@expected_message ? " with message #{@expected_message.inspect}" : ""}, but got #{@actual_exception.class}: #{@actual_exception.message.inspect}"
+        else
+          "Expected #{@expected_exception} to be raised, but nothing was raised"
+        end
+      end
+
+      def failure_message_when_negated
+        "Expected no exception, but #{@actual_exception.class} was raised"
+      end
+
+      private
+
+      def matches_exception?(e)
+        return false unless e.is_a?(@expected_exception)
+        return true unless @expected_message
+
+        if @expected_message.is_a?(Regexp)
+          @expected_message.match?(e.message)
+        else
+          e.message.include?(@expected_message.to_s)
+        end
+      end
+    end
+
+    class RespondToMatcher < BaseMatcher
+      def initialize(*methods)
+        super(methods)
+        @methods = methods
+      end
+
+      def matches?(actual)
+        @actual = actual
+        @methods.all? { |m| @actual.respond_to?(m) }
+      end
+
+      def failure_message
+        "Expected #{@actual.inspect} to respond to #{@methods.map(&:inspect).join(", ")}"
+      end
+    end
+
+    def eq(expected)
+      EqMatcher.new(expected)
+    end
+
+    def be(expected = nil)
+      BeMatcher.new(expected)
+    end
+
+    def be_nil
+      BeNilMatcher.new
+    end
+
+    def be_truthy
+      BeTruthyMatcher.new
+    end
+
+    def be_falsy
+      BeFalsyMatcher.new
+    end
+
+    def include(*expected)
+      IncludeMatcher.new(expected.size == 1 ? expected.first : expected)
+    end
+
+    def raise_error(expected_exception = StandardError, message = nil)
+      RaiseErrorMatcher.new(expected_exception, message)
+    end
+
+    def respond_to(*methods)
+      RespondToMatcher.new(*methods)
+    end
+  end
+end

data/lib/crspec/mock/double.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require_relative "space"
+
+module Crspec
+  module Mock
+    class MockError < StandardError; end
+
+    class Double
+      attr_reader :name
+
+      def initialize(name = nil, stubs = {})
+        @name = name || "Double"
+        Space.current.register_double(self)
+        stubs.each do |method_name, return_value|
+          Space.current.register_stub(self, method_name, proc { return_value })
+        end
+      end
+
+      def verify_expectations!
+        # Verified via Space
+      end
+
+      def inspect
+        "#<Double #{@name.inspect}>"
+      end
+    end
+
+    class StubChain
+      attr_reader :target, :method_name
+
+      def initialize(target, method_name)
+        @target = target
+        @method_name = method_name.to_sym
+        @expected_args = nil
+        @return_proc = proc {}
+        register_default_stub
+      end
+
+      def with(*args)
+        @expected_args = args
+        update_stub
+        self
+      end
+
+      def and_return(*values)
+        if values.size == 1
+          val = values.first
+          @return_proc = proc { val }
+        else
+          idx = 0
+          @return_proc = proc do
+            res = values[idx] || values.last
+            idx += 1
+            res
+          end
+        end
+        update_stub
+        self
+      end
+
+      def and_raise(exception = StandardError, message = nil)
+        @return_proc = proc do
+          err = exception.is_a?(Class) ? exception.new(message) : exception
+          raise err
+        end
+        update_stub
+        self
+      end
+
+      def and_yield(*yield_args)
+        old_proc = @return_proc
+        @return_proc = proc do |*args, &block|
+          block&.call(*yield_args)
+          old_proc.call(*args)
+        end
+        update_stub
+        self
+      end
+
+      private
+
+      def register_default_stub
+        update_stub
+      end
+
+      def update_stub
+        target = @target
+        method_name = @method_name
+        expected_args = @expected_args
+        return_proc = @return_proc
+
+        implementation = proc do |*args, **kwargs, &block|
+          if expected_args && args != expected_args
+            raise MockError, "Expected #{method_name} with #{expected_args.inspect}, got #{args.inspect}"
+          end
+
+          return_proc.call(*args, **kwargs, &block)
+        end
+
+        Space.current.register_stub(target, method_name, implementation)
+      end
+    end
+
+    class ExpectationChain < StubChain
+      def initialize(target, method_name)
+        @call_count = 0
+        @expected_count = 1
+        @count_constraint = :exact
+        super(target, method_name)
+        Space.current.register_expectation(self)
+      end
+
+      def once
+        @expected_count = 1
+        @count_constraint = :exact
+        self
+      end
+
+      def twice
+        @expected_count = 2
+        @count_constraint = :exact
+        self
+      end
+
+      def exactly(n)
+        @expected_count = n
+        @count_constraint = :exact
+        self
+      end
+
+      def at_least(n)
+        @expected_count = n
+        @count_constraint = :at_least
+        self
+      end
+
+      def verify_expectations!
+        valid = case @count_constraint
+                when :exact then @call_count == @expected_count
+                when :at_least then @call_count >= @expected_count
+                end
+
+        return if valid
+
+        raise MockError,
+              "Expected #{@target.inspect} to receive #{@method_name.inspect} #{@count_constraint} #{@expected_count} times, but received it #{@call_count} times"
+      end
+
+      private
+
+      def update_stub
+        target = @target
+        method_name = @method_name
+        expected_args = @expected_args
+        return_proc = @return_proc
+
+        implementation = proc do |*args, **kwargs, &block|
+          @call_count += 1
+          if expected_args && args != expected_args
+            raise MockError, "Expected #{method_name} with #{expected_args.inspect}, got #{args.inspect}"
+          end
+
+          return_proc.call(*args, **kwargs, &block)
+        end
+
+        Space.current.register_stub(target, method_name, implementation)
+      end
+    end
+
+    class ReceiveMatcher
+      attr_reader :method_name
+
+      def initialize(method_name)
+        @method_name = method_name.to_sym
+        @expected_args = nil
+        @return_values = nil
+        @raise_exception = nil
+        @yield_args = nil
+        @expected_count = 1
+        @count_constraint = :exact
+      end
+
+      def with(*args)
+        @expected_args = args
+        self
+      end
+
+      def and_return(*values)
+        @return_values = values
+        self
+      end
+
+      def and_raise(exception = StandardError, message = nil)
+        @raise_exception = exception
+        @raise_message = message
+        self
+      end
+
+      def and_yield(*args)
+        @yield_args = args
+        self
+      end
+
+      def once
+        @expected_count = 1
+        @count_constraint = :exact
+        self
+      end
+
+      def twice
+        @expected_count = 2
+        @count_constraint = :exact
+        self
+      end
+
+      def exactly(n)
+        @expected_count = n
+        @count_constraint = :exact
+        self
+      end
+
+      def at_least(n)
+        @expected_count = n
+        @count_constraint = :at_least
+        self
+      end
+
+      def setup_allow(target)
+        chain = StubChain.new(target, @method_name)
+        apply_chain_options(chain)
+        chain
+      end
+
+      def setup_expect(target)
+        chain = ExpectationChain.new(target, @method_name)
+        chain.instance_variable_set(:@expected_count, @expected_count)
+        chain.instance_variable_set(:@count_constraint, @count_constraint)
+        apply_chain_options(chain)
+        chain
+      end
+
+      private
+
+      def apply_chain_options(chain)
+        chain.with(*@expected_args) if @expected_args
+        chain.and_return(*@return_values) if @return_values
+        chain.and_raise(@raise_exception, @raise_message) if @raise_exception
+        chain.and_yield(*@yield_args) if @yield_args
+      end
+    end
+
+    class AllowTarget
+      def initialize(target)
+        @target = target
+      end
+
+      def to(matcher)
+        if matcher.respond_to?(:setup_allow)
+          matcher.setup_allow(@target)
+        else
+          matcher.call(@target)
+        end
+      end
+    end
+
+    module DSL
+      def double(name = nil, stubs = {})
+        Double.new(name, stubs)
+      end
+
+      def instance_double(target_class, name = nil, stubs = {})
+        Double.new(name || target_class.name, stubs)
+      end
+
+      def allow(target)
+        AllowTarget.new(target)
+      end
+
+      def receive(method_name)
+        ReceiveMatcher.new(method_name)
+      end
+    end
+  end
+end

data/lib/crspec/mock/interceptor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Crspec
+  module Mock
+    module Interceptor
+      def method_missing(method_name, *args, **kwargs, &block)
+        space = Fiber[Space::STORAGE_KEY]
+        if space && (stub = space.fetch_stub(self, method_name))
+          stub.call(*args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        space = Fiber[Space::STORAGE_KEY]
+        space&.fetch_stub(self, method_name) || super
+      end
+
+      def self.add_intercept_method(method_name)
+        method_sym = method_name.to_sym
+        return if instance_methods(false).include?(method_sym) || private_instance_methods(false).include?(method_sym)
+
+        define_method(method_sym) do |*args, **kwargs, &block|
+          space = Fiber[Space::STORAGE_KEY]
+          if space && (stub = space.fetch_stub(self, method_sym))
+            stub.call(*args, **kwargs, &block)
+          else
+            super(*args, **kwargs, &block)
+          end
+        end
+      end
+    end
+  end
+end