rubocop-rspec-guide 0.2.1 → 0.4.0

data/benchmark/quick_comparison.rb

@@ -0,0 +1,58 @@
+require "benchmark/ips"
+require_relative "../lib/rubocop-rspec-guide"
+
+SAMPLE = <<~RUBY
+  describe 'Example' do
+    context 'case A' do
+      let(:value) { 42 }
+      before { setup }
+      it 'works' do
+        expect(true).to be true
+      end
+    end
+    context 'case B' do
+      let(:value) { 42 }
+      before { setup }
+      it 'works' do
+        expect(true).to be true
+      end
+    end
+  end
+RUBY
+
+source = RuboCop::ProcessedSource.new(SAMPLE, RUBY_VERSION.to_f)
+config = RuboCop::Config.new({
+  "RSpec" => {
+    "Language" => {
+      "ExampleGroups" => {"Regular" => %w[describe context], "Skipped" => [], "Focused" => []},
+      "Examples" => {"Regular" => %w[it], "Focused" => [], "Skipped" => [], "Pending" => []},
+      "Helpers" => %w[let let!],
+      "Hooks" => %w[before after],
+      "Subjects" => %w[subject]
+    }
+  }
+})
+
+RuboCop::RSpec::Language.config = config['RSpec']['Language']
+
+puts "Quick Performance Check (Optimized Version)"
+puts "=" * 60
+
+Benchmark.ips do |x|
+  x.config(time: 2, warmup: 1)
+  
+  [
+    RuboCop::Cop::RSpecGuide::HappyPathFirst,
+    RuboCop::Cop::RSpecGuide::DuplicateLetValues,
+    RuboCop::Cop::RSpecGuide::DuplicateBeforeHooks,
+    RuboCop::Cop::RSpecGuide::InvariantExamples
+  ].each do |cop_class|
+    x.report(cop_class.badge.to_s) do
+      cop = cop_class.new(config)
+      commissioner = RuboCop::Cop::Commissioner.new([cop], [], raise_error: false)
+      commissioner.investigate(source)
+    end
+  end
+  
+  x.compare!
+end

data/benchmark/quick_invariant_bench.rb

@@ -0,0 +1,52 @@
+require "benchmark/ips"
+require_relative "../lib/rubocop-rspec-guide"
+
+SAMPLE = <<~RUBY
+  describe 'Validator' do
+    context 'with valid data' do
+      it 'responds to valid?' do
+        expect(subject).to respond_to(:valid?)
+      end
+    end
+    context 'with invalid data' do
+      it 'responds to valid?' do
+        expect(subject).to respond_to(:valid?)
+      end
+    end
+    context 'with edge case' do
+      it 'responds to valid?' do
+        expect(subject).to respond_to(:valid?)
+      end
+    end
+  end
+RUBY
+
+source = RuboCop::ProcessedSource.new(SAMPLE, RUBY_VERSION.to_f)
+config = RuboCop::Config.new({
+  "RSpec" => {
+    "Language" => {
+      "ExampleGroups" => {"Regular" => %w[describe context], "Skipped" => [], "Focused" => []},
+      "Examples" => {"Regular" => %w[it], "Focused" => [], "Skipped" => [], "Pending" => []},
+      "Helpers" => %w[let],
+      "Hooks" => %w[before],
+      "Subjects" => %w[subject]
+    }
+  },
+  "RSpecGuide/InvariantExamples" => {"MinLeafContexts" => 3}
+})
+
+RuboCop::RSpec::Language.config = config['RSpec']['Language']
+
+puts "Benchmarking InvariantExamples (optimized with local matcher)"
+puts "Expected baseline: ~1504 i/s, Previous (slow): ~854 i/s"
+puts ""
+
+Benchmark.ips do |x|
+  x.config(time: 2, warmup: 1)
+  
+  x.report("InvariantExamples") do
+    cop = RuboCop::Cop::RSpecGuide::InvariantExamples.new(config)
+    commissioner = RuboCop::Cop::Commissioner.new([cop], [], raise_error: false)
+    commissioner.investigate(source)
+  end
+end

data/benchmark/rspec_base_integration.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "rubocop"
+require_relative "../lib/rubocop-rspec-guide"
+
+# Create a sample RSpec file to analyze
+SAMPLE_CODE = <<~RUBY
+  describe 'UserService' do
+    context 'when user is admin' do
+      let(:user) { create(:user, :admin) }
+      let(:service) { UserService.new(user) }
+      
+      before { setup_admin_permissions }
+      
+      it 'has admin access' do
+        expect(service.admin?).to be true
+      end
+      
+      it 'can modify settings' do
+        expect(service.can_modify_settings?).to be true
+      end
+    end
+    
+    context 'when user is regular' do
+      let(:user) { create(:user) }
+      let(:service) { UserService.new(user) }
+      
+      before { setup_admin_permissions }
+      
+      it 'does not have admin access' do
+        expect(service.admin?).to be false
+      end
+      
+      it 'cannot modify settings' do
+        expect(service.can_modify_settings?).to be false
+      end
+    end
+  end
+RUBY
+
+# Configure RuboCop
+config = RuboCop::ConfigStore.new
+config_hash = {
+  "AllCops" => { "TargetRubyVersion" => 3.0 },
+  "RSpecGuide/MinimumBehavioralCoverage" => { "Enabled" => true },
+  "RSpecGuide/HappyPathFirst" => { "Enabled" => true },
+  "RSpecGuide/ContextSetup" => { "Enabled" => true },
+  "RSpecGuide/DuplicateLetValues" => { "Enabled" => true },
+  "RSpecGuide/DuplicateBeforeHooks" => { "Enabled" => true },
+  "RSpecGuide/InvariantExamples" => { "Enabled" => true }
+}
+
+puts "=" * 80
+puts "RuboCop::Cop::RSpec::Base Integration Benchmark"
+puts "=" * 80
+puts "\nSample code size: #{SAMPLE_CODE.lines.count} lines"
+puts "Cops enabled: 6 RSpec cops"
+puts "\n"
+
+# Run benchmark
+Benchmark.ips do |x|
+  x.config(time: 10, warmup: 3)
+  
+  x.report("Process sample RSpec file") do
+    runner = RuboCop::Runner.new(
+      { format: "quiet" },
+      RuboCop::ConfigStore.new
+    )
+    
+    # Create a temporary file
+    require "tempfile"
+    file = Tempfile.new(["benchmark_spec", ".rb"])
+    begin
+      file.write(SAMPLE_CODE)
+      file.flush
+      runner.run([file.path])
+    ensure
+      file.close
+      file.unlink
+    end
+  end
+  
+  x.compare!
+end

data/benchmark/save_baseline.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This script runs benchmarks and saves them as a baseline for future comparison
+require_relative "benchmark_helper"
+
+version = ENV["VERSION"] || "unknown"
+output_file = "benchmark/baseline_v#{version}.txt"
+
+puts "Saving baseline benchmark for version #{version}"
+puts "Output file: #{output_file}"
+puts ""
+
+# Run cops_benchmark and save output
+system("ruby benchmark/cops_benchmark.rb > #{output_file} 2>&1")
+
+puts ""
+puts "Baseline saved to #{output_file}"

data/benchmark/scalability_benchmark.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+# Benchmark cops with different file sizes
+puts "=" * 80
+puts "RuboCop RSpec Guide - Scalability Benchmark"
+puts "Testing how cops perform with different file sizes"
+puts "=" * 80
+puts ""
+
+# Configure benchmark timing based on environment
+if ENV["FULL_BENCHMARK"]
+  WARMUP_TIME = 2
+  MEASUREMENT_TIME = 5
+  puts "Mode: FULL (accurate measurements)"
+else
+  WARMUP_TIME = 1
+  MEASUREMENT_TIME = 2
+  puts "Mode: QUICK (fast feedback)"
+end
+puts ""
+
+# Test with increasing number of contexts
+Benchmark.ips do |x|
+  x.config(time: MEASUREMENT_TIME, warmup: WARMUP_TIME)
+
+  [5, 10, 20, 50].each do |contexts_count|
+    source = BenchmarkHelper.generate_context_code(
+      contexts_count: contexts_count,
+      examples_per_context: 3
+    )
+
+    x.report("MinimumBehavioralCoverage - #{contexts_count} contexts") do
+      BenchmarkHelper.run_cop(
+        RuboCop::Cop::RSpecGuide::MinimumBehavioralCoverage,
+        source
+      )
+    end
+  end
+
+  x.compare!
+end
+
+puts "\n"
+
+# Test with increasing number of examples
+Benchmark.ips do |x|
+  x.config(time: MEASUREMENT_TIME, warmup: WARMUP_TIME)
+
+  [10, 25, 50, 100].each do |examples_count|
+    source = BenchmarkHelper.generate_rspec_code(examples_count: examples_count)
+
+    x.report("ContextSetup - #{examples_count} examples") do
+      BenchmarkHelper.run_cop(
+        RuboCop::Cop::RSpecGuide::ContextSetup,
+        source
+      )
+    end
+  end
+
+  x.compare!
+end
+
+puts "\n"
+
+# Test DuplicateLetValues with nested contexts
+Benchmark.ips do |x|
+  x.config(time: MEASUREMENT_TIME, warmup: WARMUP_TIME)
+
+  [3, 5, 10, 15].each do |nesting_level|
+    contexts = (1..nesting_level).map do |i|
+      indent = "  " * i
+      <<~RUBY
+        #{indent}context "level #{i}" do
+        #{indent}  let(:value) { #{i} }
+        #{indent}
+        #{indent}  it "works" do
+        #{indent}    expect(value).to eq(#{i})
+        #{indent}  end
+      RUBY
+    end
+
+    source = <<~RUBY
+      RSpec.describe MyClass do
+      #{contexts.join("\n")}
+      #{"  end\n" * nesting_level}
+      end
+    RUBY
+
+    x.report("DuplicateLetValues - #{nesting_level} nesting levels") do
+      BenchmarkHelper.run_cop(
+        RuboCop::Cop::RSpecGuide::DuplicateLetValues,
+        source
+      )
+    end
+  end
+
+  x.compare!
+end
+
+puts "\n"
+
+# Test InvariantExamples with many duplicates
+Benchmark.ips do |x|
+  x.config(time: MEASUREMENT_TIME, warmup: WARMUP_TIME)
+
+  [2, 5, 10, 15].each do |duplicates_count|
+    contexts = (1..duplicates_count).map do |i|
+      <<~RUBY
+        context "scenario #{i}" do
+          it "validates input" do
+            expect(subject).to respond_to(:valid?)
+          end
+
+          it "has specific behavior" do
+            expect(subject.call(#{i})).to eq(#{i})
+          end
+        end
+      RUBY
+    end
+
+    source = <<~RUBY
+      RSpec.describe MyClass do
+        #{contexts.join("\n")}
+      end
+    RUBY
+
+    x.report("InvariantExamples - #{duplicates_count} duplicates") do
+      BenchmarkHelper.run_cop(
+        RuboCop::Cop::RSpecGuide::InvariantExamples,
+        source
+      )
+    end
+  end
+
+  x.compare!
+end
+
+puts "\n"
+
+# Memory usage test
+require "objspace"
+
+puts "=" * 80
+puts "Memory Usage Analysis"
+puts "=" * 80
+puts ""
+
+large_source = BenchmarkHelper.generate_context_code(
+  contexts_count: 50,
+  examples_per_context: 10
+)
+
+cops = [
+  RuboCop::Cop::RSpecGuide::MinimumBehavioralCoverage,
+  RuboCop::Cop::RSpecGuide::HappyPathFirst,
+  RuboCop::Cop::RSpecGuide::ContextSetup,
+  RuboCop::Cop::RSpecGuide::DuplicateLetValues,
+  RuboCop::Cop::RSpecGuide::DuplicateBeforeHooks,
+  RuboCop::Cop::RSpecGuide::InvariantExamples,
+  RuboCop::Cop::FactoryBotGuide::DynamicAttributeEvaluation
+]
+
+cops.each do |cop_class|
+  GC.start
+  before = ObjectSpace.memsize_of_all
+
+  BenchmarkHelper.run_cop(cop_class, large_source)
+
+  after = ObjectSpace.memsize_of_all
+  memory_used = (after - before) / 1024.0 / 1024.0
+
+  puts "#{cop_class.cop_name}: #{"%.2f" % memory_used} MB"
+end
+
+puts "\n"
+puts "=" * 80
+puts "Scalability benchmark completed!"
+puts "=" * 80

data/config/default.yml

@@ -1,38 +1,79 @@
 ---
+# RSpec Language configuration for rubocop-rspec integration
+# This enables RuboCop::Cop::RSpec::Base matchers to work properly
+RSpec:
+  Enabled: true
+  Language:
+    inherit_mode:
+      merge:
+        - Expectations
+        - Helpers
+        - Hooks
+        - Subjects
+    Helpers:
+      - let
+      - let!
+      - let_it_be
+      - let_it_be!
+
+RSpecGuide/MinimumBehavioralCoverage:
+  Description: "Require at least 2 behavioral variations in describe block (2+ contexts OR it-blocks + contexts)"
+  Enabled: true
+  VersionAdded: "0.3.0"
+  StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
+
 RSpecGuide/CharacteristicsAndContexts:
-  Description: "Require at least 2 contexts in describe block (happy path + edge cases)"
+  Description: "[DEPRECATED] Use RSpecGuide/MinimumBehavioralCoverage instead"
   Enabled: true
+  VersionAdded: "0.1.0"
+  VersionChanged: "0.3.0"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 RSpecGuide/DuplicateLetValues:
   Description: "Detect duplicate let values in sibling contexts (ERROR if in all, WARNING if partial)"
   Enabled: true
   WarnOnPartialDuplicates: true
+  VersionAdded: "0.1.0"
+  VersionChanged: "0.2.2"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 RSpecGuide/DuplicateBeforeHooks:
   Description: "Detect duplicate before hooks in sibling contexts (ERROR if in all, WARNING if partial)"
   Enabled: true
   WarnOnPartialDuplicates: true
+  VersionAdded: "0.1.0"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 RSpecGuide/InvariantExamples:
   Description: "Invariant examples should be in leaf contexts or extracted to shared_examples"
   Enabled: true
   MinLeafContexts: 3
+  VersionAdded: "0.1.0"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 RSpecGuide/HappyPathFirst:
   Description: "Corner cases should not be first context (happy path first)"
   Enabled: true
+  VersionAdded: "0.1.0"
+  VersionChanged: "0.2.1"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 RSpecGuide/ContextSetup:
   Description: "Context must have setup (let/before) to distinguish it from parent. Subject should be at describe level."
   Enabled: true
+  VersionAdded: "0.1.0"
+  VersionChanged: "0.2.0"
+  StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
+
+FactoryBotGuide/DynamicAttributeEvaluation:
+  Description: "Wrap method calls in blocks for dynamic evaluation (Time.now, SecureRandom, etc.)"
+  Enabled: true
+  VersionAdded: "0.3.0"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"
 
 FactoryBotGuide/DynamicAttributesForTimeAndRandom:
-  Description: "Wrap Time.now, SecureRandom and method calls in blocks for dynamic evaluation"
+  Description: "[DEPRECATED] Use FactoryBotGuide/DynamicAttributeEvaluation instead"
   Enabled: true
+  VersionAdded: "0.1.0"
+  VersionChanged: "0.3.0"
   StyleGuideUrl: "https://github.com/AlexeyMatskevich/rspec-guide"

data/config/obsoletion.yml

@@ -0,0 +1,6 @@
+# Cop obsoletion configuration for rubocop-rspec-guide
+# This file defines renamed, removed, and deprecated cops
+
+renamed:
+  RSpecGuide/CharacteristicsAndContexts: RSpecGuide/MinimumBehavioralCoverage
+  FactoryBotGuide/DynamicAttributesForTimeAndRandom: FactoryBotGuide/DynamicAttributeEvaluation

data/lib/rubocop/cop/factory_bot_guide/dynamic_attribute_evaluation.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBotGuide
+      # Checks that method calls in FactoryBot attribute definitions
+      # are wrapped in blocks for dynamic evaluation.
+      #
+      # Without blocks, method calls are evaluated once at factory definition time,
+      # not at factory instantiation time. This causes all factory instances to share
+      # the same value, leading to subtle bugs and test pollution.
+      #
+      # This is particularly problematic for:
+      # - Time-related methods (Time.now, Date.today, 1.day.from_now, etc.)
+      # - Random values (SecureRandom.hex, SecureRandom.uuid, etc.)
+      # - Object constructors (Array.new, Hash.new, etc.)
+      # - Any method calls that should return different values per instance
+      #
+      # @safety
+      #   This cop is safe to run automatically. It detects all method calls
+      #   in factory attributes, not just Time/Random methods.
+      #
+      # @example Time-related methods
+      #   # bad - all users get the same timestamp
+      #   factory :user do
+      #     created_at Time.now
+      #     updated_at DateTime.now
+      #     birth_date Date.today
+      #     expires_at 1.day.from_now
+      #   end
+      #
+      #   # good - each user gets a fresh timestamp
+      #   factory :user do
+      #     created_at { Time.now }
+      #     updated_at { DateTime.now }
+      #     birth_date { Date.today }
+      #     expires_at { 1.day.from_now }
+      #   end
+      #
+      # @example Random values
+      #   # bad - all users share the same token
+      #   factory :user do
+      #     token SecureRandom.hex
+      #     uuid SecureRandom.uuid
+      #   end
+      #
+      #   # good - each user gets a unique token
+      #   factory :user do
+      #     token { SecureRandom.hex }
+      #     uuid { SecureRandom.uuid }
+      #   end
+      #
+      # @example Object constructors
+      #   # bad - all users share the same array/hash instance!
+      #   factory :user do
+      #     tags Array.new
+      #     metadata Hash.new
+      #   end
+      #
+      #   # This causes test pollution:
+      #   user1 = create(:user)
+      #   user1.tags << 'admin'
+      #   user2 = create(:user)
+      #   user2.tags # => ['admin'] - unexpected!
+      #
+      #   # good - each user gets a new array/hash
+      #   factory :user do
+      #     tags { Array.new }
+      #     metadata { Hash.new }
+      #   end
+      #
+      # @example Static values (no block needed)
+      #   # good - static values don't need blocks
+      #   factory :user do
+      #     name "John Doe"
+      #     age 30
+      #     active true
+      #   end
+      #
+      # @example Complex expressions
+      #   # bad - method chains evaluated once
+      #   factory :user do
+      #     full_name current_user.profile.display_name
+      #   end
+      #
+      #   # good - method chains evaluated per instance
+      #   factory :user do
+      #     full_name { current_user.profile.display_name }
+      #   end
+      #
+      class DynamicAttributeEvaluation < Base
+        extend AutoCorrector
+
+        MSG = "Use block syntax for attribute `%<attribute>s` because `%<method>s` " \
+              "is evaluated once at factory definition time. " \
+              "Wrap in block: `%<attribute>s { %<value>s }`"
+
+        TIME_CLASSES = %w[Time Date DateTime].freeze
+        RANDOM_CLASSES = %w[SecureRandom].freeze
+
+        # @!method factory_block?(node)
+        def_node_matcher :factory_block?, <<~PATTERN
+          (block
+            (send {nil? (const {nil? cbase} :FactoryBot)} :factory ...)
+            ...)
+        PATTERN
+
+        # @!method attribute_assignment?(node)
+        def_node_matcher :attribute_assignment?, <<~PATTERN
+          (send nil? $_ $_value)
+        PATTERN
+
+        def on_block(node)
+          return unless factory_block?(node)
+
+          # Check all attribute assignments within the factory
+          node.each_descendant(:send) do |send_node|
+            check_attribute(send_node)
+          end
+        end
+
+        private
+
+        def check_attribute(node)
+          attribute_assignment?(node) do |attribute_name, value|
+            # Skip if value is already a block
+            next if value.block_type?
+
+            # Check if the value is a method call that needs dynamic evaluation
+            next unless requires_dynamic_evaluation?(value)
+
+            add_offense(
+              node,
+              message: format(
+                MSG,
+                attribute: attribute_name,
+                method: method_description(value),
+                value: value.source
+              )
+            ) do |corrector|
+              # Wrap the value in a block: value -> { value }
+              corrector.replace(value, "{ #{value.source} }")
+            end
+          end
+        end
+
+        def requires_dynamic_evaluation?(node)
+          # Only method calls need dynamic evaluation
+          # Static values (strings, symbols, numbers, etc.) are fine as-is
+          return false unless node.send_type?
+
+          # Time.now, Date.today, DateTime.now, etc.
+          return true if time_method?(node)
+
+          # SecureRandom.hex, SecureRandom.uuid, etc.
+          return true if random_method?(node)
+
+          # Any other method calls (e.g., 1.day.ago, Array.new, etc.)
+          # should be wrapped in blocks for dynamic evaluation
+          true
+        end
+
+        def time_method?(node)
+          return false unless node.receiver
+
+          receiver_name = if node.receiver.const_type?
+            node.receiver.const_name
+          end
+
+          TIME_CLASSES.include?(receiver_name)
+        end
+
+        def random_method?(node)
+          return false unless node.receiver
+
+          receiver_name = if node.receiver.const_type?
+            node.receiver.const_name
+          end
+
+          RANDOM_CLASSES.include?(receiver_name)
+        end
+
+        def method_description(node)
+          if node.receiver
+            "#{node.receiver.source}.#{node.method_name}"
+          else
+            node.method_name.to_s
+          end
+        end
+      end
+    end
+  end
+end