let_each 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 649eafd9476ae0aeffe70f65df3351c3d2c4744f1a844039966cec1d155ac26a
+  data.tar.gz: 5a8cc3329f8b40133f36baaa2463a790938cbcfd8e1945c05a8f4a8848aa96bc
+SHA512:
+  metadata.gz: '0184e7882ccb883e2e3e79e6661a9e3dced08549ebcb72c50de9f0fb4f8d3e63ebb194be376ae5d21150c459455dd39f43906288ea3e50917c8ad8c6bcfb0994'
+  data.tar.gz: bb6ed3372685424c08f478baf9d94d7aeab508a0af694507576ee7c897092674b824892d4dd79b69a1706e828ea942c8ea6c303e2e91c54c39ac5edb33c90bfb

data/LICENSE.txt

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) [2026] [Andrew Logsdon]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+![Tests](https://github.com/Alogsdon/rspec-let-each/actions/workflows/test.yml/badge.svg)
+# LetEach
+(rspec-let-each)
+
+`let_each` is an ergonomic RSpec helper that spawns context blocks with corresponding `let`s for each value in an array
+
+a common dilemma I found when writing specs was
+enumerating all edge cases is DRY and gives good coverage
+but it requires too much block nesting/boiler plate.
+Also, contexts written like this are not compatible with `let`s,
+without some hackery.
+
+e.g.
+```ruby
+[foo,bar].each do |x_local|
+  context "with x=#{x_local}" do
+    let(:x) { x_local }
+
+    it_behaves_like 'an example'
+  end
+end
+```
+
+alternatively, let + sample is succint
+but it gives flakey coverage
+e.g.
+```ruby
+let(:x) { [foo, bar].sample }
+
+it_behaves_like 'an example'
+```
+
+with this helper, we should be able to have the best of both worlds
+ - same coverage as first example
+ - compatible with `let` variables
+ - same succintness as second example
+```ruby
+let_each(:x, 2) { [foo, bar] }
+
+it_behaves_like 'an example'
+```
+
+Using the `let_each` by itself can lead to some awkward patterns when zipping expectations into the examples.
+That's why I added a chainable method `with`, intended for the corresponding expectations, or possibly actions.
+(The length of all chained `with`s is assumed to be the same as the parent `let_each`)
+now we might write
+```ruby
+subject { test_method(x) }
+
+let_each(:x, 2) { [foo, bar] }
+  .with(:expected_x) { [foo_expect, bar_expect] }
+
+it { is_expected.to eq(expected_x) }
+```
+it can be continually chained, in case we need variables in tripples or quads too, why not.
+
+## Installation
+
+Add this line to your application's `Gemfile` typically inside the `:test` group:
+
+```ruby
+group :test do
+  gem 'let_each'
+end
+```
+
+## Setup
+
+`let_each` is configured to automatically mix into RSpec's example groups when loaded.
+In some projects, the `lib` folder is automatically loaded. If not, just add a require for `let_each` in your test setup.
+```ruby
+# spec/spec_helper.rb
+require 'let_each'
+```
+You can immediately start using let_each inside your describe or context blocks.
+
+
+### Verifying Installation
+You can verify that the helper is loaded correctly by running a simple test:
+
+```ruby
+RSpec.describe "LetEach Integration" do
+  let_each(:val) { [1, 2] }
+  
+  it "works" do
+    expect([1, 2]).to include(val)
+  end
+end
+```
+
+## Compatibility
+
+`let_each` is tested against and supports:
+- **Ruby:** 2.7, 3.0, 3.1, 3.2, 3.3, 3.4
+- **RSpec:** 3.0 and newer
+
+## License
+MIT

data/lib/let_each/extension.rb

@@ -0,0 +1,116 @@
+module LetEach
+  module Extension
+    # Usage:
+    # lazy signature
+    # let_each(:x, 2) { [let_foo, let_bar] }
+    #   .with(:y) { [foo_expected, bar_expected] }
+    #
+    # eager signature
+    # let_each(:y, [eager_foo, eager_bar])
+    #
+    # the lazy_array_block plays nice with other `let`s, but contexts are eagerly evaluated
+    # so we need to provide a "length" to know how many contexts to spawn
+    # then the array values can still be lazily evaluated
+    # alternatively, just pass an eager array if you don't need the laziness on the values
+    #
+    # There is possibly some overhead to using this in its present state. It could be optimized more but this is just my POC for the feature.
+    # Careful not to exponentially spawn contexts, every call to this helper will multiply the number of examples
+    # In a future feature we may allow for automatically limiting the number of contexts, then trending towards `let(:x) { [foo, bar].sample }`
+    # AFAIK, this works in nested contexts, and with shared_examples/contexts,
+    # but I'd suggest pushing the usage as close to the actual examples as possible, so you don't enumerate too much
+    #
+    # I've added a chainable `with` method to allow for parallely assigned lets
+    # this can be also be chained multiple times
+    def let_each(name, length_or_array, &lazy_array_block)
+      if lazy_array_block
+        raise 'must specify the length when providing a lazy array block' unless length_or_array.is_a?(Integer)
+        length = length_or_array
+      else
+        raise 'must provide an array when not providing a lazy array block' unless length_or_array.respond_to?(:length)
+        array = length_or_array
+        length = array.length
+        lazy_array_block = -> { array }
+      end
+
+      array_proc_key = :"_#{name}_array_proc"
+      # I just didn't handle this case. doing so is a bit tricky with the approach I used
+      # we'd need to replay the `it` overrides with the changed value removed
+      raise "let_each already used for key: #{name}" if instance_methods.include?(array_proc_key)
+      # `it` was already used in this context but we didn't get a chance to override it yet
+      if defined?(@context_leafs)
+        raise 'let_each used after an example. either nest in a new context or arrange `let_each` above examples'
+      end
+
+      # behavior is also unexpected if we `let` with this same name, but I'm not going out of my way to guard against that
+
+      let(array_proc_key, &lazy_array_block) # memoize the array proc result
+      # `super` would only work the first time we call let_each per context. so we'll just closure it every time
+      old_it = method(:it).unbind
+      chainable = LetEachWithChainable.new(self, length)
+      define_singleton_method(:it) do |*args, &block|
+        if defined?(@context_leafs)
+          # we make a lot of contexts with this helper
+          # this is an improvement to reuse them when possible
+          # (when `it` is used multiple times in the same context)
+          # should be able to do something similar with `context` but I'm not worried about it right now
+          # new context = caches are dumped anyway, so there's probably not much to gain
+          @context_leafs.each do |leaf|
+            old_it.bind_call(leaf, *args, &block)
+          end
+        else
+          # first time we're calling `it` in this context
+          # instance variable will be inaccessible from within these context blocks
+          # so we assign the local variable too
+          @context_leafs = context_leafs = []
+          length.times do |i|
+            context "when #{name}[#{i}]" do
+              let(name) { send(array_proc_key)[i] }
+              chainable.each do |proc|
+                instance_exec(i, &proc)
+              end
+
+              old_it.bind_call(self, *args, &block)
+              context_leafs << self
+            end
+          end
+        end
+      end
+      chainable
+    end
+
+    class LetEachWithChainable
+      attr_accessor :withs, :example_group
+
+      def initialize(example_group, length)
+        @example_group = example_group
+        @length = length
+        @withs = []
+      end
+
+      def each(&block)
+        withs.each(&block)
+      end
+
+      def with(name, array = nil, &lazy_array_block)
+        if lazy_array_block
+          # length is assumed to be the same as the base let_each
+          raise 'dont need to provide a second argument when providing a lazy array block' if array
+        else
+          lazy_array_block = -> { array }
+        end
+        array_proc_key = :"_#{name}_array_proc"
+        # can memoize the proc right away
+        example_group.let(array_proc_key, &lazy_array_block)
+        # we can't unload the main `let` until we're in the context
+        # so just store the proc
+        withs << lambda do |index|
+          # self is the only variable not closured here
+          # we'll instance_exec this on the context
+          let(name) { send(array_proc_key)[index] }
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/let_each/version.rb

@@ -0,0 +1,3 @@
+module LetEach
+  VERSION = '0.1.0'
+end

data/lib/let_each.rb

@@ -0,0 +1,8 @@
+
+if defined?(RSpec)
+  require 'let_each/version'
+  require 'let_each/extension'
+  RSpec.configure do |config|
+    config.extend LetEach::Extension
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: let_each
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Logsdon
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/let_each.rb
+- lib/let_each/extension.rb
+- lib/let_each/version.rb
+homepage: https://github.com/Alogsdon/rspec-let-each
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: Ergonomic context spawning for RSpec
+test_files: []