crspec 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 649f2c29f7f22f52d1291691f9c96c2c9718ab907c38e8ea27604fab5ec9ef8f
-  data.tar.gz: cfaac3973542770dc81f08c921bb29b054ed64f3dae0913ca75b175d42438242
+  metadata.gz: e70183d3b574744a0de1061ba25f99d495bdbaa4d9940cb76f76d37124701328
+  data.tar.gz: 02f551a7420e923ae7fd5f6357ee6c55256600adac922f6adeab7b3e811cae65
 SHA512:
-  metadata.gz: 85dc17da65b7d4bb59766cb7a00220f9009fec3b4e869969d3dde17fbafe7c8f63b190b083d2fbd243f3e6b3e02470f0e3076a9142b38b5d5e65ddb7ad595894
-  data.tar.gz: '0257282967b6ed5ca718bd01cf7329a920f8fca18266d44a59e196453bbd8db2d0bdaf52e646b9553cf86eed375c2f00c7e33139435d36876ae43bb4ddbd689a'
+  metadata.gz: b9abb32f9cbb3411ce1de2ab806395e5629c42802f83b1cc6f346f164d87c6c487ceea69a64c6650f2a2f2267436eedf06c30b64ba4313c4b757f9bb803bf901
+  data.tar.gz: b29fba9882c81d8bae86250693e764ed49c17cba74d180e05536e522bc6bf5d9f0faf293340937b39d1a7bf88a4b65a9fe7e617d635749f144548ad7598fe49b

data/README.md

@@ -8,9 +8,10 @@
 
 - **Fiber Storage Context Isolation**: Solves legacy thread-local (`Thread.current`) state leakage by routing all execution metadata and `let` memoization through inherited Fiber storage (`Fiber[:crspec_execution_context]`).
 - **Fiber-Aware Mocking (`crspec-mock`)**: Prevents mock registry corruption across parallel tests using prepended method interceptors bound to `Fiber[:crspec_mock_space]`.
-- **Rails Connection Leasing & Parallel Testing (`crspec-rails`)**: Leases database connections per example fiber (`ActiveRecord::Base.lease_connection`), handles savepoint transaction strategies (`SAVEPOINT ex_root`), and integrates with Rails parallel worker suites (`Crspec::Rails::Parallel`).
+- **Rails Integration & ActiveSupport Reuse (`crspec-rails`)**: Direct integration with `ActiveSupport::Testing::Assertions`, `ActiveSupport::Testing::TimeHelpers`, and `ActiveSupport::Testing::FileFixtures`. Leases database connections per example fiber (`ActiveRecord::Base.lease_connection`), handles savepoint transaction strategies (`SAVEPOINT ex_root`), and integrates with Rails parallel worker suites (`Crspec::Rails::Parallel`).
+- **Rails Request Specs**: Expressive HTTP request verb helpers (`get`, `post`, `put`, `patch`, `delete`), response status inspection (`response.status`), headers, and `json_response` parsing.
 - **Prism-Based AST Transpiler (`crspec-transpiler`)**: Automated migration tool using `ruby/prism` C-parser to convert existing RSpec codebases to Crspec syntax and flag thread-unsafe constructs like `before(:all)`.
-- **Concurrent Execution Kernel**: Multi-threaded worker pool integrated with non-blocking fiber schedulers (`Async::Scheduler`).
+- **Concurrent Execution Kernel**: Multi-threaded worker pool integrated with real-time progress dot formatting and non-blocking fiber schedulers (`Async::Scheduler`).
 
 ---
 
@@ -30,12 +31,30 @@ mise exec -- bundle install
 
 ---
 
+## Spec Helpers & Generator
+
+Initialize standard `spec_helper.rb` (and `rails_helper.rb` if run within a Rails project):
+
+```bash
+mise exec -- crspec --init
+```
+
+Spec files include helpers explicitly via standard `require` statements:
+
+```ruby
+require "spec_helper"
+# or
+require "rails_helper"
+```
+
+---
+
 ## Writing Specs
 
 `crspec` provides a familiar RSpec-style DSL for structuring example groups and expectations:
 
 ```ruby
-require "crspec"
+require "spec_helper"
 
 Crspec.describe User, type: :model do
   let(:valid_attributes) { { name: "Jane Doe", email: "jane@example.com" } }
@@ -45,6 +64,12 @@ Crspec.describe User, type: :model do
     expect(user.valid?).to be(true)
   end
 
+  it "changes user count when created" do
+    expect {
+      User.create!(valid_attributes)
+    }.to change(User, :count).by(1)
+  end
+
   context "when email is omitted" do
     let(:valid_attributes) { { name: "Jane Doe", email: nil } }
 
@@ -62,6 +87,7 @@ end
 - `include(*items)`
 - `raise_error(ExceptionClass, "message")`
 - `respond_to(*methods)`
+- `change(receiver, :method).by(amount)` / `change { ... }.by(amount)` / `.from(val).to(val)`
 
 ### Advanced: Execution Context & Extensions
 Regular spec authors do not need to interact with `execution_context` at all—`crspec` automatically isolates `let` memoization, database connections, and stubs invisibly per test.
@@ -90,7 +116,7 @@ Crspec.describe PaymentGateway do
 
   it "stubs credit card processing concurrently" do
     allow(stripe_client).to receive(:create).with(amount: 5000).and_return(status: "succeeded")
-    
+
     result = stripe_client.create(amount: 5000)
     expect(result[:status]).to eq("succeeded")
   end
@@ -99,15 +125,37 @@ end
 
 ---
 
-## Rails Concurrency & Parallel Testing (`crspec-rails`)
+## Rails Concurrency & Request Specs (`crspec-rails`)
 
 ### Database Isolation & Connection Leasing
-Wrap examples in connection leasing and transaction savepoints:
+`rails_helper.rb` automatically configures database-independent transaction isolation using your application's `config/database.yml`:
 
 ```ruby
-Crspec.describe User, type: :model do
-  around do |example|
-    Crspec::Rails::DatabaseIsolation.wrap_example(example)
+Crspec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.include(Crspec::Rails::RequestHelpers)
+
+  config.around(:each) do |example|
+    if defined?(ActiveRecord::Base) && config.use_transactional_fixtures
+      Crspec::Rails::DatabaseIsolation.wrap_example(example)
+    else
+      example.execute!
+    end
+  end
+end
+```
+
+### Request Specs
+Perform full REST API controller testing with built-in request helpers:
+
+```ruby
+Crspec.describe "Books API", type: :request do
+  it "creates a book via POST" do
+    post "/books", params: { name: "Refactoring", author: "Martin Fowler" }
+
+    expect(response.status).to eq(201)
+    expect(json_response[:name]).to eq("Refactoring")
   end
 end
 ```
@@ -118,7 +166,6 @@ Configure worker counts and setup/teardown hooks:
 ```ruby
 Crspec::Rails::Parallel.parallelize(workers: 4) do
   parallelize_setup do |worker_number|
-    # Prepare worker database, seed data, etc.
     puts "Worker #{worker_number} starting (TEST_ENV_NUMBER=#{ENV['TEST_ENV_NUMBER']})"
   end
 
@@ -128,13 +175,6 @@ Crspec::Rails::Parallel.parallelize(workers: 4) do
 end
 ```
 
-### Multi-Fiber Integration Server
-Boot an embedded multi-threaded/multi-fiber Puma server for system/browser specs:
-
-```ruby
-Crspec::Rails::SystemServer.start_concurrent_server!(Rails.application, 9887)
-```
-
 ---
 
 ## Migrating from RSpec (`crspec-transpile`)
@@ -151,6 +191,16 @@ mise exec -- crspec-transpile --write spec/
 
 ---
 
+## Sample Rails Bookstore App
+
+Explore the working sample Rails application in [`samples/book_store`](file:///Users/tachyons/code/crspec/samples/book_store):
+
+```bash
+mise exec -- ./exe/crspec samples/book_store/spec/
+```
+
+---
+
 ## Running Specs
 
 Execute your test suite concurrently using the `crspec` executable:

data/lib/crspec/cli.rb

@@ -2,6 +2,7 @@
 
 require "optparse"
 require_relative "../crspec"
+require_relative "generators/init"
 
 module Crspec
   class CLI
@@ -11,14 +12,30 @@ module Crspec
 
     def initialize(args)
       @args = args
-      @concurrency = Etc.nprocessors
+      @concurrency = Crspec.configuration.concurrency
       @paths = []
+      @requires = []
+      @init_mode = false
     end
 
     def run
       parse_options
+
+      if @init_mode
+        created = Generators::Init.generate
+        if created.empty?
+          puts "No helper files were created (already exists or not a Rails project)."
+        else
+          created.each { |f| puts "  create #{f}" }
+        end
+        return true
+      end
+
+      load_requires
       load_specs
-      runner = Runner.new(concurrency: @concurrency)
+
+      concurrency = @concurrency || Crspec.configuration.concurrency
+      runner = Runner.new(concurrency: concurrency)
       groups = Crspec.world.example_groups
 
       if groups.empty?
@@ -26,7 +43,7 @@ module Crspec
         return true
       end
 
-      puts "Running Crspec suite with concurrency #{@concurrency}..."
+      puts "Running Crspec suite with concurrency #{concurrency}..."
       runner.run(groups)
 
       puts "\nFinished in #{runner.total_duration.round(4)} seconds"
@@ -54,6 +71,14 @@ module Crspec
           @concurrency = n
         end
 
+        opts.on("-r", "--require PATH", String, "Require a file before running specs") do |path|
+          @requires << path
+        end
+
+        opts.on("--init", "Initialize spec_helper.rb (and rails_helper.rb if Rails project)") do
+          @init_mode = true
+        end
+
         opts.on("-h", "--help", "Show help") do
           puts opts
           exit 0
@@ -64,6 +89,12 @@ module Crspec
       @paths = ["spec"] if @paths.empty?
     end
 
+    def load_requires
+      @requires.each do |req|
+        require req
+      end
+    end
+
     def load_specs
       files = []
       @paths.each do |p|

data/lib/crspec/configuration.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Crspec
+  class Configuration
+    attr_accessor :concurrency, :use_transactional_fixtures, :formatter
+    attr_reader :before_hooks, :after_hooks, :around_hooks, :included_modules
+
+    def initialize
+      @concurrency = Etc.nprocessors
+      @use_transactional_fixtures = true
+      @formatter = nil
+      @before_hooks = []
+      @after_hooks = []
+      @around_hooks = []
+      @included_modules = []
+      @infer_spec_type = false
+    end
+
+    def before(_scope = :each, &block)
+      @before_hooks << block
+    end
+
+    def after(_scope = :each, &block)
+      @after_hooks.unshift(block)
+    end
+
+    def around(_scope = :each, &block)
+      @around_hooks << block
+    end
+
+    def include(mod)
+      @included_modules << mod
+    end
+
+    def infer_spec_type_from_file_location!
+      @infer_spec_type = true
+    end
+
+    def infer_spec_type?
+      !!@infer_spec_type
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration if block_given?
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/crspec/example_group.rb

@@ -3,6 +3,7 @@
 require_relative "expectations"
 require_relative "example"
 require_relative "mock/double"
+require_relative "configuration"
 
 module Crspec
   class ExampleGroup
@@ -21,6 +22,7 @@ module Crspec
       @after_hooks = []
       @let_blocks = {}
       @eager_lets = []
+      @included_modules = []
     end
 
     def self.define(description, metadata = {}, parent = nil, &block)
@@ -43,6 +45,10 @@ module Crspec
     end
     alias specify it
 
+    def include(mod)
+      @included_modules << mod
+    end
+
     def let(name, &block)
       @let_blocks[name.to_sym] = block
     end
@@ -71,6 +77,8 @@ module Crspec
 
     def ancestor_hooks(type)
       hooks = []
+      hooks.concat(Crspec.configuration.before_hooks) if type == :before
+
       curr = self
       ancestors = []
       while curr
@@ -82,6 +90,9 @@ module Crspec
         list = type == :before ? grp.before_hooks : grp.after_hooks
         hooks.concat(list)
       end
+
+      hooks.concat(Crspec.configuration.after_hooks) if type == :after
+
       hooks
     end
 
@@ -109,11 +120,31 @@ module Crspec
       eager
     end
 
+    def ancestor_included_modules
+      mods = []
+      curr = self
+      ancestors = []
+      while curr
+        ancestors.unshift(curr)
+        curr = curr.parent
+      end
+      ancestors.each do |grp|
+        mods.concat(grp.instance_variable_get(:@included_modules) || [])
+      end
+      mods
+    end
+
     def create_instance(example)
+      modules_to_include = (Crspec.configuration.included_modules + ancestor_included_modules).uniq
+
       klass = Class.new do
         include Expectations
         include Mock::DSL
 
+        modules_to_include.each do |mod|
+          include mod
+        end
+
         attr_reader :__crspec_example__
 
         def initialize(example)

data/lib/crspec/execution_context.rb

@@ -37,7 +37,7 @@ module Crspec
       @monitor.synchronize do
         return @memoized_values[key] if @memoized_values.key?(key)
 
-        @memoized_values[key] = block.call
+        @memoized_values[key] = yield
       end
     end
 

data/lib/crspec/generators/init.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Crspec
+  module Generators
+    class Init
+      SPEC_HELPER_CONTENT = <<~RUBY
+        # frozen_string_literal: true
+
+        require "crspec"
+        require "etc"
+
+        Crspec.configure do |config|
+          config.concurrency = Etc.nprocessors
+
+          config.before(:each) do
+            # Setup hooks executed before every spec example
+          end
+
+          config.after(:each) do
+            # Teardown hooks executed after every spec example
+          end
+        end
+      RUBY
+
+      RAILS_HELPER_CONTENT = <<~RUBY
+        # frozen_string_literal: true
+
+        require_relative "spec_helper"
+        ENV["RAILS_ENV"] ||= "test"
+        require File.expand_path("../config/environment", __dir__)
+
+        # Prevent database truncation if environment is production
+        abort("The Rails environment is running in production mode!") if defined?(Rails) && Rails.env.production?
+
+        require "crspec"
+
+        # Including support files for tests
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.glob("spec/support/**/*.rb").each { |f| require f }
+        end
+
+        # Checks for pending migrations and applies them before tests are run.
+        begin
+          ActiveRecord::Migration.maintain_test_schema! if defined?(ActiveRecord::Migration)
+        rescue ActiveRecord::PendingMigrationError => e
+          abort e.to_s
+        end
+
+        Crspec.configure do |config|
+          config.use_transactional_fixtures = true
+          config.infer_spec_type_from_file_location!
+          config.include(Crspec::Rails::RequestHelpers)
+
+          config.around(:each) do |example|
+            if defined?(ActiveRecord::Base) && config.use_transactional_fixtures
+              Crspec::Rails::DatabaseIsolation.wrap_example(example)
+            else
+              example.execute!
+            end
+          end
+        end
+      RUBY
+
+      def self.rails_project?(root_dir = Dir.pwd)
+        File.exist?(File.join(root_dir, "bin/rails")) ||
+          File.exist?(File.join(root_dir, "config/environment.rb")) ||
+          File.exist?(File.join(root_dir, "config/application.rb"))
+      end
+
+      def self.generate(target_dir = "spec", root_dir = Dir.pwd)
+        FileUtils.mkdir_p(target_dir)
+
+        spec_helper_path = File.join(target_dir, "spec_helper.rb")
+        rails_helper_path = File.join(target_dir, "rails_helper.rb")
+
+        created = []
+
+        unless File.exist?(spec_helper_path)
+          File.write(spec_helper_path, SPEC_HELPER_CONTENT)
+          created << spec_helper_path
+        end
+
+        if rails_project?(root_dir) && !File.exist?(rails_helper_path)
+          File.write(rails_helper_path, RAILS_HELPER_CONTENT)
+          created << rails_helper_path
+        end
+
+        created
+      end
+    end
+  end
+end

data/lib/crspec/matchers.rb

@@ -168,6 +168,57 @@ module Crspec
       end
     end
 
+    class ChangeMatcher < BaseMatcher
+      def initialize(receiver = nil, message = nil, &block)
+        super()
+        @receiver = receiver
+        @message = message
+        @block = block || -> { receiver.send(message) }
+        @expected_by = nil
+        @expected_from = nil
+        @expected_to = nil
+      end
+
+      def by(amount)
+        @expected_by = amount
+        self
+      end
+
+      def from(val)
+        @expected_from = val
+        self
+      end
+
+      def to(val)
+        @expected_to = val
+        self
+      end
+
+      def matches?(proc_to_run)
+        @before_val = @block.call
+        proc_to_run.call
+        @after_val = @block.call
+
+        if @expected_by
+          (@after_val - @before_val) == @expected_by
+        elsif !@expected_from.nil? && !@expected_to.nil?
+          @before_val == @expected_from && @after_val == @expected_to
+        elsif !@expected_to.nil?
+          @after_val == @expected_to
+        else
+          @before_val != @after_val
+        end
+      end
+
+      def failure_message
+        if @expected_by
+          "Expected result to change by #{@expected_by}, but changed by #{@after_val - @before_val} (from #{@before_val.inspect} to #{@after_val.inspect})"
+        else
+          "Expected result to change, but remained #{@before_val.inspect}"
+        end
+      end
+    end
+
     def eq(expected)
       EqMatcher.new(expected)
     end
@@ -199,5 +250,9 @@ module Crspec
     def respond_to(*methods)
       RespondToMatcher.new(*methods)
     end
+
+    def change(receiver = nil, message = nil, &block)
+      ChangeMatcher.new(receiver, message, &block)
+    end
   end
 end

data/lib/crspec/mock/double.rb

@@ -270,7 +270,14 @@ module Crspec
       end
 
       def instance_double(target_class, name = nil, stubs = {})
-        Double.new(name || target_class.name, stubs)
+        double_name = if target_class.is_a?(String) || target_class.is_a?(Symbol)
+                        target_class.to_s
+                      elsif target_class.respond_to?(:name)
+                        target_class.name
+                      else
+                        target_class.to_s
+                      end
+        Double.new(name || double_name, stubs)
       end
 
       def allow(target)

data/lib/crspec/rails/database_isolation.rb

@@ -2,22 +2,13 @@
 
 module Crspec
   module Rails
-    module DatabaseIsolation
+    class 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
+        if defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+          ActiveRecord::Base.connection_pool.with_connection do |conn|
+            conn.transaction(requires_new: true) do
+              example.execute!
+              raise ActiveRecord::Rollback
             end
           end
         else

data/lib/crspec/rails/parallel.rb

@@ -22,7 +22,7 @@ module Crspec
           @setup_blocks ||= []
           @teardown_blocks ||= []
 
-          return unless block_given?
+          return unless block
 
           instance_eval(&block)
         end

data/lib/crspec/rails/request_helpers.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "json"
+require "stringio"
+
+module Crspec
+  module Rails
+    module RequestHelpers
+      if defined?(ActiveSupport::Testing::Assertions)
+        include ActiveSupport::Testing::Assertions
+      end
+
+      if defined?(ActiveSupport::Testing::TimeHelpers)
+        include ActiveSupport::Testing::TimeHelpers
+      end
+
+      if defined?(ActiveSupport::Testing::FileFixtures)
+        include ActiveSupport::Testing::FileFixtures
+      end
+
+      ResponseStruct = Struct.new(:status, :body, :headers)
+
+      def response
+        execution_context[:last_response]
+      end
+
+      def json_response
+        return nil unless response&.body
+        JSON.parse(response.body, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def process_request(method, path, params = {}, headers = {})
+        body_string = params.is_a?(String) ? params : params.to_json
+        env = {
+          "REQUEST_METHOD" => method.to_s.upcase,
+          "PATH_INFO" => path,
+          "rack.input" => StringIO.new(body_string),
+          "CONTENT_TYPE" => headers["CONTENT_TYPE"] || "application/json",
+          "HTTP_ACCEPT" => headers["HTTP_ACCEPT"] || "application/json",
+          "CONTENT_LENGTH" => body_string.bytesize.to_s
+        }
+
+        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_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
+          else
+            response_body = params.to_json
+          end
+        ensure
+          if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection_handler)
+            ActiveRecord::Base.connection_handler.clear_active_connections!
+          end
+        end
+
+        res = ResponseStruct.new(status, response_body, response_headers)
+        execution_context[:last_response] = res
+        res
+      end
+
+      def get(path, params: {}, headers: {})
+        process_request(:get, path, params, headers)
+      end
+
+      def post(path, params: {}, headers: {})
+        process_request(:post, path, params, headers)
+      end
+
+      def put(path, params: {}, headers: {})
+        process_request(:put, path, params, headers)
+      end
+
+      def patch(path, params: {}, headers: {})
+        process_request(:patch, path, params, headers)
+      end
+
+      def delete(path, params: {}, headers: {})
+        process_request(:delete, path, params, headers)
+      end
+    end
+  end
+end

data/lib/crspec/transpiler/cli.rb

@@ -25,7 +25,7 @@ module Crspec
         when :write
           write_paths(@paths)
         else
-          puts "Usage: crspec-transpile [--analyze|--write] <files or directories>"
+          Rails.logger.debug "Usage: crspec-transpile [--analyze|--write] <files or directories>"
         end
       end
 
@@ -75,14 +75,14 @@ module Crspec
           rewriter.transpile
           next if rewriter.warnings.empty?
 
-          puts "File: #{file}"
+          Rails.logger.debug { "File: #{file}" }
           rewriter.warnings.each do |w|
-            puts "  #{w}"
+            Rails.logger.debug { "  #{w}" }
             total_warnings += 1
           end
         end
 
-        puts "Analysis complete. Total warnings found: #{total_warnings}"
+        Rails.logger.debug { "Analysis complete. Total warnings found: #{total_warnings}" }
       end
 
       def write_paths(paths)
@@ -97,11 +97,11 @@ module Crspec
           next unless new_code != content
 
           File.write(file, new_code)
-          puts "Transpiled: #{file}"
+          Rails.logger.debug { "Transpiled: #{file}" }
           count += 1
         end
 
-        puts "Transpilation complete. Updated #{count} file(s)."
+        Rails.logger.debug { "Transpilation complete. Updated #{count} file(s)." }
       end
     end
   end

data/lib/crspec/version.rb

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

data/lib/crspec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "crspec/version"
+require_relative "crspec/configuration"
 require_relative "crspec/execution_context"
 require_relative "crspec/matchers"
 require_relative "crspec/expectations"
@@ -15,8 +16,10 @@ require_relative "crspec/dsl"
 require_relative "crspec/rails/database_isolation"
 require_relative "crspec/rails/system_server"
 require_relative "crspec/rails/parallel"
+require_relative "crspec/rails/request_helpers"
 require_relative "crspec/transpiler/rewriter"
 require_relative "crspec/transpiler/cli"
+require_relative "crspec/generators/init"
 
 module Crspec
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crspec
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Aboobacker MK
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-29 00:00:00.000000000 Z
+date: 2026-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -38,36 +38,31 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- demo.rb
 - exe/crspec
 - exe/crspec-transpile
 - lib/crspec.rb
 - lib/crspec/cli.rb
+- lib/crspec/configuration.rb
 - lib/crspec/dsl.rb
 - lib/crspec/example.rb
 - lib/crspec/example_group.rb
 - lib/crspec/execution_context.rb
 - lib/crspec/expectations.rb
 - lib/crspec/formatters/progress_formatter.rb
+- lib/crspec/generators/init.rb
 - lib/crspec/matchers.rb
 - lib/crspec/mock/double.rb
 - lib/crspec/mock/interceptor.rb
 - lib/crspec/mock/space.rb
 - lib/crspec/rails/database_isolation.rb
 - lib/crspec/rails/parallel.rb
+- lib/crspec/rails/request_helpers.rb
 - lib/crspec/rails/system_server.rb
 - lib/crspec/runner.rb
 - lib/crspec/transpiler/cli.rb
 - lib/crspec/transpiler/rewriter.rb
 - lib/crspec/version.rb
-- samples/user_spec.rb
 - sig/crspec.rbs
-- test/crspec/execution_context_test.rb
-- test/crspec/mock_test.rb
-- test/crspec/rails_test.rb
-- test/crspec/runner_test.rb
-- test/crspec/transpiler_test.rb
-- test/test_helper.rb
 homepage: https://github.com/crspec/crspec
 licenses:
 - MIT

data/demo.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/inline"
-
-gemfile do
-  source "https://rubygems.org"
-  gem "crspec", path: __dir__
-  gem "prism"
-end
-
-require "crspec"
-
-puts "================================================================="
-puts "  Crspec Single-File Inline Demo & Feature Verification          "
-puts "================================================================="
-
-# Reset global state for clean standalone run
-Crspec.reset!
-
-# Domain Models
-class User
-  attr_accessor :name, :email
-
-  def initialize(name:, email:)
-    @name = name
-    @email = email
-  end
-
-  def valid?
-    return false if name.nil? || email.nil?
-
-    email.include?("@")
-  end
-end
-
-class PaymentProcessor
-  def charge(amount)
-    "real_charge_#{amount}"
-  end
-end
-
-# 1. Core DSL, Context Isolation, Lazy Let Memoization, Matchers
-Crspec.describe User, type: :model do
-  let(:valid_attributes) { { name: "Jane Doe", email: "jane@example.com" } }
-  subject(:user) { User.new(**valid_attributes) }
-
-  before do
-    # Per-example setup hook
-  end
-
-  it "validates primary attributes concurrently" do
-    expect(user.valid?).to be(true)
-    expect(user.name).to eq("Jane Doe")
-    expect(user.email).to include("example.com")
-  end
-
-  context "when email is invalid" do
-    let(:valid_attributes) { { name: "Jane Doe", email: nil } }
-
-    it "flags validation errors" do
-      expect(user.valid?).to eq(false)
-    end
-  end
-
-  context "when error is expected" do
-    it "catches raised exceptions" do
-      expect { raise ArgumentError, "Invalid user input" }.to raise_error(ArgumentError, "Invalid user input")
-    end
-  end
-end
-
-# 2. Fiber-Aware Mocking Engine (crspec-mock)
-Crspec.describe PaymentProcessor do
-  let(:processor) { PaymentProcessor.new }
-
-  it "supports fiber-isolated method stubs" do
-    allow(processor).to receive(:charge).with(5000).and_return("succeeded")
-    expect(processor.charge(5000)).to eq("succeeded")
-  end
-
-  it "supports test doubles and method expectations" do
-    gateway_double = double("StripeGateway", process: "ok")
-    expect(gateway_double.process).to eq("ok")
-  end
-end
-
-# 3. Rails Parallel Worker Integration (crspec-rails)
-Crspec::Rails::Parallel.parallelize(workers: 4) do
-  parallelize_setup do |worker_num|
-    # Per-worker setup hook (e.g. database setup for worker_num)
-  end
-
-  parallelize_teardown do |worker_num|
-    # Per-worker teardown hook
-  end
-end
-
-# 4. Prism AST Transpiler Verification (crspec-transpiler)
-rspec_sample_code = <<~RUBY
-  RSpec.describe "Legacy Suite" do
-    it "runs" do
-      expect(1).to eq(1)
-    end
-  end
-RUBY
-
-transpiled = Crspec::Transpiler::Rewriter.new(rspec_sample_code).transpile
-puts "[Prism Transpiler Check] RSpec -> Crspec: #{transpiled.include?("Crspec.describe") ? "PASSED" : "FAILED"}"
-
-# 5. Concurrent Multi-Threaded Execution Kernel
-puts "\n[Executing Specs Concurrently Across 4 Worker Threads]..."
-runner = Crspec::Runner.new(concurrency: 4)
-runner.run(Crspec.world.example_groups)
-
-puts "\n---------------- Execution Summary ----------------"
-puts "Total Duration : #{runner.total_duration.round(4)}s"
-puts "Passed Examples: #{runner.passed_examples.size}"
-puts "Failed Examples: #{runner.failed_examples.size}"
-puts "---------------------------------------------------"
-
-if runner.success?
-  puts "\nSUCCESS: All specs executed concurrently across 4 worker threads and passed cleanly!"
-else
-  puts "\nFAILURE: Some specs failed."
-  exit 1
-end

data/samples/user_spec.rb

@@ -1,31 +0,0 @@
-# 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/test/crspec/execution_context_test.rb

@@ -1,61 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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

data/test/crspec/rails_test.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "minitest/mock"
-
-class RailsTest < Minitest::Test
-  def setup
-    Crspec::Rails::Parallel.reset!
-    Crspec.reset!
-  end
-
-  def teardown
-    Crspec::Rails::Parallel.reset!
-  end
-
-  def test_database_isolation_wrapper
-    mock_example = Minitest::Mock.new
-    mock_example.expect(:execute!, true)
-
-    Crspec::Rails::DatabaseIsolation.wrap_example(mock_example)
-    assert mock_example.verify
-  end
-
-  def test_system_server_start
-    Crspec::Rails::SystemServer.reset!
-    refute Crspec::Rails::SystemServer.running?
-
-    Crspec::Rails::SystemServer.start_concurrent_server!(nil, 9887)
-    assert Crspec::Rails::SystemServer.running?
-  end
-
-  def test_rails_parallel_test_setup_and_teardown_hooks
-    setup_called = []
-    teardown_called = []
-
-    Crspec::Rails::Parallel.parallelize(workers: 2) do
-      parallelize_setup do |worker_num|
-        setup_called << worker_num
-      end
-
-      parallelize_teardown do |worker_num|
-        teardown_called << worker_num
-      end
-    end
-
-    assert Crspec::Rails::Parallel.enabled?
-    assert_equal 2, Crspec::Rails::Parallel.worker_count
-
-    group = Crspec.describe "Parallel Test Group" do
-      it "runs example" do
-        expect(1).to eq(1)
-      end
-    end
-
-    runner = Crspec::Runner.new(concurrency: 2)
-    runner.run([group])
-
-    assert runner.success?
-    assert_equal [1, 2], setup_called.sort
-    assert_equal [1, 2], teardown_called.sort
-  end
-end

data/test/crspec/runner_test.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class RunnerTest < Minitest::Test
-  def setup
-    Crspec.reset!
-  end
-
-  def test_concurrent_runner_execution
-    group = Crspec.describe "User Model" do
-      let(:name) { "Alice" }
-
-      it "validates name" do
-        expect(name).to eq("Alice")
-      end
-
-      it "calculates async property" do
-        expect(1 + 1).to eq(2)
-      end
-    end
-
-    formatter = Crspec::Formatters::NullFormatter.new
-    runner = Crspec::Runner.new(concurrency: 2, formatter: formatter)
-    runner.run([group])
-
-    assert runner.success?
-    assert_equal 2, runner.passed_examples.size
-    assert_equal 0, runner.failed_examples.size
-  end
-
-  def test_failing_example_recorded
-    group = Crspec.describe "Failing Suite" do
-      it "fails expectation" do
-        expect(1).to eq(2)
-      end
-    end
-
-    formatter = Crspec::Formatters::NullFormatter.new
-    runner = Crspec::Runner.new(concurrency: 1, formatter: formatter)
-    runner.run([group])
-
-    refute runner.success?
-    assert_equal 1, runner.failed_examples.size
-    assert_equal "Expected 2, got 1", runner.failed_examples.first.error.message
-  end
-
-  def test_progress_formatter_output
-    out = StringIO.new
-    formatter = Crspec::Formatters::ProgressFormatter.new(out, color: false)
-
-    group = Crspec.describe "Formatter Suite" do
-      it "passes" do
-        expect(1).to eq(1)
-      end
-
-      it "fails" do
-        expect(1).to eq(2)
-      end
-    end
-
-    runner = Crspec::Runner.new(concurrency: 1, formatter: formatter)
-    runner.run([group])
-
-    assert_includes out.string, "."
-    assert_includes out.string, "F"
-  end
-end

data/test/crspec/transpiler_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class TranspilerTest < Minitest::Test
-  def test_prism_ast_rewriting_rspec_to_crspec
-    source = <<~RUBY
-      RSpec.describe User, type: :model do
-        let(:valid_attributes) { { name: "Jane" } }
-        it "validates attributes" do
-          expect(1).to eq(1)
-        end
-      end
-    RUBY
-
-    rewriter = Crspec::Transpiler::Rewriter.new(source)
-    transformed = rewriter.transpile
-
-    assert_includes transformed, "Crspec.describe User"
-    refute_includes transformed, "RSpec.describe"
-  end
-
-  def test_detects_thread_unsafe_before_all
-    source = <<~RUBY
-      Crspec.describe Account do
-        before(:all) do
-          @account = Account.create!
-        end
-        it "tests something" do
-          expect(1).to eq(1)
-        end
-      end
-    RUBY
-
-    rewriter = Crspec::Transpiler::Rewriter.new(source)
-    rewriter.transpile
-
-    refute_empty rewriter.warnings
-    assert_includes rewriter.warnings.first, "before(:all) mutates global state"
-  end
-end

data/test/test_helper.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "crspec"
-
-require "minitest/autorun"