memoized 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 926d7d513652375d0d0978b5eaff47a4ffacdd0a5f545ea6d3defc9c4a998fef
-  data.tar.gz: bccf0beaf3128e6ef3a4ac81b0cbebfe0622ebb0371fffe23e5eac92c39a3e05
+  metadata.gz: fb2cf278843df2c67e80b301e9eda488f5d1a1fa897601963982f6e39f5780a7
+  data.tar.gz: 364c3036a777f8e7492240c23577a12ba154c22e6011a308e19ccd64d77b0f6e
 SHA512:
-  metadata.gz: 718c91571de072ec727b30994ea61731a53b9ddaa7bc28cc2ca3cdb44bf7f7de7a1c7421953e859f6a785587831fda4575292e7c87f26cec9fcf3361d8b180e8
-  data.tar.gz: e9fa3a012d0ccf3a4df5d65e93198bea4f09de92873a3389c8573bda46779ee2cd78cd6b3410c6a424cd552b7f1eb1575aff0d9323caba1f435b3fbc6b923348
+  metadata.gz: 851942011f26ecaf7b90303d3fbd6a63462b649a7b5311b03417a56f51d83d69b83f722a90d719782aeb21d38e3685c962e14231afe8c98c9223ccb3b998df72
+  data.tar.gz: 3e4c2ab30a1ef2d18f4a9afd2f67ba7edc812f136d70364585b9fb1484dbe5211287d058970a5c58ba15adba9d9f7d2a7057d35a4fef6db24cc54b5fe4d8f1d2

data/.ruby-version

@@ -1 +1 @@
-3.4.1
+4.0.1

data/CHANGELOG.md

@@ -13,6 +13,14 @@ This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html
 
 -
 
+## 1.1.3 - 2026-03-10
+
+### Compatible changes
+
+- Add tests for Ruby 4.0
+- Introduce `required_ruby_version` in gemspec so people on legacy Ruby versions don't receive future upgrades
+- Drop tests and support for Ruby < 3
+
 ## 1.1.2 - 2025-01-22
 
 ### Compatible changes

data/Gemfile

@@ -5,5 +5,5 @@ gemspec
 gem 'rake', '~> 13.0.6'
 gem 'rspec', '~> 3.12.0'
 gem 'timecop', '~> 0.8.0'
-gem 'prop_check', '~> 0.18.1'
+gem 'prop_check', '~> 1.0.0'
 gem 'gemika'

data/Gemfile.lock

@@ -1,16 +1,14 @@
 PATH
   remote: .
   specs:
-    memoized (1.1.2)
+    memoized (1.1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    amazing_print (1.4.0)
     diff-lcs (1.5.0)
-    gemika (0.8.2)
-    prop_check (0.18.1)
-      amazing_print (~> 1.2)
+    gemika (2.0.0)
+    prop_check (1.0.2)
     rake (13.0.6)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -33,7 +31,7 @@ PLATFORMS
 DEPENDENCIES
   gemika
   memoized!
-  prop_check (~> 0.18.1)
+  prop_check (~> 1.0.0)
   rake (~> 13.0.6)
   rspec (~> 3.12.0)
   timecop (~> 0.8.0)

data/README.md

@@ -138,13 +138,13 @@ To run tests locally for development you have multiple options:
 
 2. Run tests against all Ruby versions:
    - Install all Ruby versions mentioned in `.github/workflows/test.yml`
-   - run `bin/matrix` (only supports `rbenv` for switching Ruby versions currently)
+   - run `dev/matrix` (only supports `rbenv` for switching Ruby versions currently)
 
 Hints:
 - At the time of writing this, we only have a single Gemfile. If that isn't the case any longer,
-  check the gemika README for more detailed development instructions.
+  check the [gemika](github.com/makandra/gemika) README for more detailed development instructions.
 - We recommend to have sufficiently new versions of bundler (> 2.3.0) and rubygems (> 3.3.0) installed for each Ruby version.
-- The script `bin/matrix` will warn you, if that is not the case. For all other methods you need to ensure that yourself.
+- The script `dev/matrix` will warn you, if that is not the case. For all other methods you need to ensure that yourself.
 
 ## License
 

data/lib/memoized/version.rb

@@ -1,3 +1,3 @@
 module Memoized
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
 end

data/memoized.gemspec

@@ -8,6 +8,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/makandra/memoized"
   s.summary     = "Memoized caches the results of your method calls"
   s.description = s.summary
+  s.license = 'MIT'
   s.metadata    = {
     'source_code_uri' => s.homepage,
     'bug_tracker_uri' => 'https://github.com/makandra/memoized/issues',
@@ -15,10 +16,11 @@ Gem::Specification.new do |s|
     'rubygems_mfa_required' => 'true',
   }
 
-  s.files         = `git ls-files`.split("\n").reject { |path| File.lstat(path).symlink? }
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n").reject { |path| File.lstat(path).symlink? }
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n").select { |f| !File.symlink?(f) && !f.match(%r{^(spec|dev|media|.github)/}) }
   s.require_paths = ["lib"]
 
-  s.license = 'MIT'
+  s.bindir = 'exe'
+  s.executables = []
+
+  s.required_ruby_version = '>= 3.0.0'
 end

metadata

@@ -1,22 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: memoized
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Barun Singh
 - Henning Koch
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2025-01-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Memoized caches the results of your method calls
-executables:
-- matrix
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
@@ -26,14 +24,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/matrix
 - lib/memoized.rb
 - lib/memoized/parameters.rb
 - lib/memoized/version.rb
 - memoized.gemspec
-- spec/memoized_spec.rb
-- spec/properties_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/makandra/memoized
 licenses:
 - MIT
@@ -49,14 +43,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Memoized caches the results of your method calls
 test_files: []

data/.github/workflows/test.yml

@@ -1,40 +0,0 @@
----
-name: Tests
-'on':
-  push:
-    branches:
-    - master
-  pull_request:
-    branches:
-    - master
-jobs:
-  test:
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - ruby: 2.5.3
-          gemfile: Gemfile
-        - ruby: 2.6.7
-          gemfile: Gemfile
-        - ruby: 2.7.3
-          gemfile: Gemfile
-        - ruby: 3.2.0
-          gemfile: Gemfile
-        - ruby: 3.4.1
-          gemfile: Gemfile
-    env:
-      BUNDLE_GEMFILE: "${{ matrix.gemfile }}"
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: "${{ matrix.ruby }}"
-    - name: Bundle
-      run: |
-        gem install bundler:2.3.1
-        bundle install --no-deployment
-    - name: Run tests
-      run: bundle exec rspec

data/bin/matrix

@@ -1,65 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# utility for comparing version strings
-# https://stackoverflow.com/questions/4023830/how-to-compare-two-strings-in-dot-separated-version-format-in-bash
-function version { echo "$@" | awk -F. '{ printf("%d%03d%03d%03d\n", $1,$2,$3,$4); }'; }
-
-# store current Ruby version and restore it on exit
-original_ruby_version=$(cat .ruby-version)
-trap "rbenv local $original_ruby_version" EXIT
-
-# determine employed Ruby versions (awk command == "strip whitespace", sed command == "delete_prefix")
-readarray -t versions < <(grep ruby: .github/workflows/test.yml | awk '{$1=$1};1' | sed 's/- ruby: //' | sort | uniq)
-echo "Detected Ruby versions:"
-for version in "${versions[@]}"
-do
-  echo "- $version"
-done
-echo ""
-
-for version in "${versions[@]}"
-do
-  # switch Ruby version
-  rbenv local "$version"
-
-  # determine actual versions
-  ruby_version=$(ruby -v)
-  rubygems_version=$(gem -v)
-  bundler_version=$(bundler -v | sed 's/Bundler version //')
-
-  # debug output
-  echo "====================="
-  echo "Target Ruby version: $version"
-  echo ""
-  echo "Ruby: $ruby_version"
-  echo "rubygems: $rubygems_version"
-  echo "Bundler: $bundler_version"
-  echo "====================="
-  echo ""
-
-  # version checks (minimum versions to make 'BUNDLED WITH' in Gemfile.lock work correctly)
-  if [ $(version $rubygems_version) -lt $(version "3.3.0") ]; then
-    echo "Please ensure that your rubygems version is > 3.3.0 for Ruby $ruby_version!"
-    echo "Install newest version:"
-    echo "gem update --system"
-    echo "Install specific version:"
-    echo "gem update --system <version>"
-    exit 1
-  fi
-
-  if [ $(version $bundler_version) -lt $(version "2.3.0") ]; then
-    echo "Please ensure that your Bundler version is > 2.3.0 for Ruby $ruby_version!"
-    echo "Install newest version:"
-    echo "gem install bundler"
-    echo "Install specific version:"
-    echo "gem install bundler:<version>"
-    exit 1
-  fi
-
-  # bundle and run specs
-  rake matrix:install
-  rake matrix:spec
-done
-
-exit 0

data/spec/memoized_spec.rb

@@ -1,371 +0,0 @@
-class MemoizedSpecClass
-  include Memoized
-  def no_params() Date.today; end
-  def with_params?(ndays, an_array) Date.today + ndays + an_array.length; end
-  def returning_nil!() Date.today; nil; end
-  def all_param_types(req, opt = 3, *rest, keyreq:, key: 11, **keyrest)
-    Date.today + (req * opt * rest.inject(&:*) * keyreq * key * keyrest.values.inject(&:*))
-  end
-  def only_kwargs(**keyrest)
-    Date.today + keyrest.values.inject(&:*)
-  end
-  memoize :no_params, :with_params?, :returning_nil!, :all_param_types, :only_kwargs
-end
-class Beepbop < MemoizedSpecClass; end
-
-
-describe Memoized do
-  let(:today) { Date.today }
-
-  describe '.memoize' do
-    let(:object) { MemoizedSpecClass.new }
-    let(:tomorrow) { Date.today + 1 }
-
-    context "for a method with no params" do
-      it "stores memoized value" do
-        Timecop.freeze(today)
-        expect(object.no_params).to eq(today)
-        Timecop.freeze(tomorrow)
-        expect(object.no_params).to eq(today)
-      end
-    end
-
-    context "for a method with params (and ending in ?)" do
-      it "stores memoized value" do
-        Timecop.freeze(today)
-        expect(object.with_params?(1, [1,2])).to eq(today + 3)
-        Timecop.freeze(tomorrow)
-        expect(object.with_params?(1, [1,2])).to eq(today + 3)
-      end
-      it "does not confuse one set of inputs for another" do
-        Timecop.freeze(today)
-        expect(object.with_params?(1, [1,2])).to eq(today + 3)
-        expect(object.with_params?(2, [1,2])).to eq(today + 4)
-        Timecop.freeze(tomorrow)
-        expect(object.with_params?(1, [1,2])).to eq(today + 3)
-        expect(object.with_params?(1, [2,2])).to eq(today + 4)
-      end
-    end
-
-    context "for a method that returns nil (and ends in !)" do
-      it "stores the memoized value" do
-        object.returning_nil!
-        allow(Date).to receive(:today).and_raise(ArgumentError)
-        expect(object.returning_nil!).to be_nil
-      end
-    end
-
-    context "for a method with all param types" do
-      it "stores memoized value" do
-        Timecop.freeze(today)
-        expect(object.all_param_types(2, 3, 5, 5, keyreq: 7, key: 11, **{ first: 13, second: 13 })).to eq(today + 1951950)
-        Timecop.freeze(tomorrow)
-        expect(object.all_param_types(2, 3, 5, 5, keyreq: 7, key: 11, **{ first: 13, second: 13 })).to eq(today + 1951950)
-      end
-      it "does not confuse one set of inputs for another" do
-        Timecop.freeze(today)
-        expect(object.all_param_types(2, 3, 5, 5, keyreq: 7, key: 11, **{ first: 13, second: 13 })).to eq(today + 1951950)
-        expect(object.all_param_types(2, 9, 5, keyreq: 7, key: 121, **{ first: 13 })).to eq(today + 990990)
-        Timecop.freeze(tomorrow)
-        expect(object.all_param_types(2, 3, 5, 5, keyreq: 7, key: 11, **{ first: 13, second: 13 })).to eq(today + 1951950)
-        expect(object.all_param_types(2, 9, 5, keyreq: 7, key: 121, **{ first: 13 })).to eq(today + 990990)
-      end
-    end
-
-    context "for a method with only keyword rest arguments" do
-      it "stores memoized value" do
-        Timecop.freeze(today)
-        expect(object.only_kwargs(**{ first: 2, second: 3 })).to eq(today + 6)
-        Timecop.freeze(tomorrow)
-        expect(object.only_kwargs(**{ first: 2, second: 3 })).to eq(today + 6)
-      end
-      it "does not confuse one set of inputs for another" do
-        Timecop.freeze(today)
-        expect(object.only_kwargs(**{ first: 2, second: 3 })).to eq(today + 6)
-        expect(object.only_kwargs(**{ first: 7 })).to eq(today + 7)
-        Timecop.freeze(tomorrow)
-        expect(object.only_kwargs(**{ first: 2, second: 3 })).to eq(today + 6)
-        expect(object.only_kwargs(**{ first: 7 })).to eq(today + 7)
-      end
-    end
-
-    context "for subclasses" do
-      let(:object) { Beepbop.new }
-      it "still memoizes things" do
-        Timecop.freeze(today)
-        expect(object.no_params).to eq(today)
-        Timecop.freeze(tomorrow)
-        expect(object.no_params).to eq(today)
-      end
-    end
-
-    context 'for private methods' do
-      class Beirut < MemoizedSpecClass
-        def foo() bar; end
-        private
-        def bar() Date.today; end
-        memoize :bar
-      end
-      let(:object) { Beirut.new }
-
-      it "respects the privacy of the memoized method" do
-        expect(Beirut.private_method_defined?(:bar)).to be_truthy
-        expect(Beirut.private_method_defined?(:_unmemoized_bar)).to be_truthy
-      end
-
-      it "memoizes things" do
-        Timecop.freeze(today)
-        expect(object.foo).to eq(today)
-        Timecop.freeze(today + 1)
-        expect(object.foo).to eq(today)
-      end
-    end
-
-    context 'for protected methods' do
-      class Wonka < MemoizedSpecClass
-        def foo() bar; end
-        protected
-        def bar() Date.today; end
-        memoize :bar
-      end
-      let(:object) { Wonka.new }
-
-      it "respects the privacy of the memoized method" do
-        expect(Wonka.protected_method_defined?(:bar)).to be_truthy
-        expect(Wonka.protected_method_defined?(:_unmemoized_bar)).to be_truthy
-      end
-
-      it "memoizes things" do
-        Timecop.freeze(today)
-        expect(object.foo).to eq(today)
-        Timecop.freeze(today + 1)
-        expect(object.foo).to eq(today)
-      end
-    end
-
-    context 'for methods with an arity of 0' do
-      class Arity0 < MemoizedSpecClass
-        def foo()
-        end
-
-        memoize :foo
-      end
-
-      it 'creates a memoized method with an arity of 0' do
-        expect(Arity0.instance_method(:foo).arity).to eq(0)
-      end
-    end
-
-    context 'for methods with an arity of 2' do
-      class Arity2 < MemoizedSpecClass
-        def foo(a, b)
-        end
-
-        memoize :foo
-      end
-
-      it 'creates a memoized method with an arity of 2' do
-        expect(Arity2.instance_method(:foo).arity).to eq(2)
-      end
-    end
-
-    context 'for methods with splat args' do
-      class AritySplat < MemoizedSpecClass
-        def foo(*args)
-        end
-
-        memoize :foo
-      end
-
-      it 'creates a memoized method with an arity of -1' do
-        expect(AritySplat.instance_method(:foo).arity).to eq(-1)
-      end
-    end
-
-    context 'for methods with a required and an optional arg' do
-      class ArityRequiredAndOptional < MemoizedSpecClass
-        def foo(a, b = 'default')
-          return [a, b]
-        end
-
-        memoize :foo
-      end
-
-      it 'creates a memoized method with a arity of -2' do
-        expect(ArityRequiredAndOptional.instance_method(:foo).arity).to eq(-2)
-      end
-
-      it "preserves the optional arg's default value" do
-        instance = ArityRequiredAndOptional.new
-        expect(instance.foo('foo')).to eq ['foo', 'default']
-      end
-    end
-
-    context 'for methods with a required arg and splat args' do
-      class ArityArgAndOptional < MemoizedSpecClass
-        def foo(a, *args)
-          return [a, args]
-        end
-
-        memoize :foo
-      end
-
-      it 'creates a memoized method with a arity of -2' do
-        expect(ArityArgAndOptional.instance_method(:foo).arity).to eq(-2)
-      end
-
-      it "passes the splat args to the memoized method" do
-        instance = ArityArgAndOptional.new
-        expect(instance.foo('foo', 'bar', 'baz')).to eq ['foo', ['bar', 'baz']]
-      end
-    end
-
-    context 'for methods with all types of args' do
-      class AllArgTypes < MemoizedSpecClass
-        def foo(required, optional = 3, *rest, req_keyword:, opt_keyword: 11, **keyrest)
-          return [required, optional, rest, req_keyword, opt_keyword, keyrest]
-        end
-
-        memoize :foo
-      end
-
-      it 'the memoized method has the same arity as the original method' do
-        expect(AllArgTypes.instance_method(:_unmemoized_foo).arity).to eq(-3)
-        expect(AllArgTypes.instance_method(:foo).arity).to eq(-3)
-      end
-
-      it 'the memoized method has the same parameters as the original method' do
-        expect(AllArgTypes.instance_method(:_unmemoized_foo).parameters)
-          .to eq([
-            [:req, :required],
-            [:opt, :optional],
-            [:rest, :rest],
-            [:keyreq, :req_keyword],
-            [:key, :opt_keyword],
-            [:keyrest, :keyrest]
-          ])
-        expect(AllArgTypes.instance_method(:foo).parameters)
-          .to eq([
-            [:req, :required],
-            [:opt, :optional],
-            [:rest, :rest],
-            [:keyreq, :req_keyword],
-            [:key, :opt_keyword],
-            [:keyrest, :keyrest]
-          ])
-      end
-
-      it "passes all args to the original method correctly" do
-        instance = AllArgTypes.new
-        expect(instance.foo(2, 333, 5, 5, req_keyword: 7, opt_keyword: 1111, first: 13, second: 17))
-          .to eq [2, 333, [5, 5], 7, 1111, { first: 13, second: 17 }]
-      end
-
-      it "preserves the original method's default values" do
-        instance = AllArgTypes.new
-        expect(instance.foo(2, req_keyword: 7, third: 19))
-          .to eq [2, 3, [], 7, 11, { third: 19 }]
-      end
-    end
-
-  end
-
-
-  describe 'instance methods' do
-    class MemoizedSpecClass
-      def today() Date.today; end
-      def plus_ndays(ndays) Date.today + ndays; end
-      memoize :today, :plus_ndays
-    end
-
-    let(:object) { MemoizedSpecClass.new }
-    before do
-      Timecop.freeze(today)
-      expect(object.today).to eq(today)
-      expect(object.plus_ndays(1)).to eq(today + 1)
-      expect(object.plus_ndays(3)).to eq(today + 3)
-    end
-
-    describe '#unmemoize' do
-      context "for a method with no arguments" do
-        it "clears the memoized value so it can be rememoized" do
-          Timecop.freeze(today + 1)
-          expect(object.today).to eq(today)
-
-          object.unmemoize(:today)
-          expect(object.today).to eq(today + 1)
-
-          Timecop.freeze(today + 2)
-          expect(object.today).to eq(today + 1)
-        end
-      end
-
-      context "for a method with arguments" do
-        it "unmemoizes for all inupts" do
-          Timecop.freeze(today + 1)
-          expect(object.plus_ndays(1)).to eq(today + 1)
-          expect(object.plus_ndays(3)).to eq(today + 3)
-
-          object.unmemoize(:plus_ndays)
-          expect(object.plus_ndays(1)).to eq(today + 2)
-          expect(object.plus_ndays(3)).to eq(today + 4)
-
-          Timecop.freeze(today + 2)
-          expect(object.plus_ndays(1)).to eq(today + 2)
-          expect(object.plus_ndays(3)).to eq(today + 4)
-        end
-      end
-
-      it "only affects the method specified" do
-        Timecop.freeze(today + 1)
-        expect(object.today).to eq(today)
-
-        object.unmemoize(:plus_ndays)
-        expect(object.today).to eq(today)
-
-        object.unmemoize(:today)
-        expect(object.today).to eq(today + 1)
-      end
-
-      context "for subclasses" do
-        let(:object) { Beepbop.new }
-        it "clears the memoized value" do
-          Timecop.freeze(today + 1)
-          expect(object.today).to eq(today)
-
-          object.unmemoize(:today)
-          expect(object.today).to eq(today + 1)
-
-          Timecop.freeze(today + 2)
-          expect(object.today).to eq(today + 1)
-        end
-      end
-    end
-
-    describe '#unmemoize_all' do
-      shared_examples_for "unmemoizing methods" do
-        it "clears all memoized values" do
-          Timecop.freeze(today + 1)
-          expect(object.today).to eq(today)
-          expect(object.plus_ndays(1)).to eq(today + 1)
-          expect(object.plus_ndays(3)).to eq(today + 3)
-
-          object.unmemoize_all
-
-          expect(object.today).to eq(today + 1)
-          expect(object.plus_ndays(1)).to eq(today + 2)
-          expect(object.plus_ndays(3)).to eq(today + 4)
-        end
-      end
-
-      it_should_behave_like "unmemoizing methods"
-
-      context "for subclasses" do
-        let(:object) { Beepbop.new }
-        it_should_behave_like "unmemoizing methods"
-      end
-    end
-
-  end
-
-end

data/spec/properties_spec.rb

@@ -1,222 +0,0 @@
-unless RUBY_VERSION == '2.5.3'
-  describe "#memoize" do
-    include PropCheck
-    include PropCheck::Generators
-    include Memoized
-
-    before do
-      PropCheck::Property.configure do |config|
-        # CAUTION:
-        # 100 (default) takes 8 seconds
-        # 300 takes 11 minutes
-        config.n_runs = 100
-      end
-    end
-
-    it "does not change the method's arity" do
-      forall(
-        array(
-          tuple(
-            one_of(
-              constant(:req), constant(:opt), constant(:rest), constant(:keyreq), constant(:key), constant(:keyrest)
-            ),
-            simple_symbol.map do |sym|
-              "param_#{sym}".to_sym
-            end
-          )
-        )
-      ) do |parameters|
-        # params now have proper names (no :"", no Ruby keywords) due to the .map in the generator above
-        unique_names = parameters.uniq { |v| v[1] }
-        single_args_and_kwargs = unique_names.uniq do |v|
-          if [:rest, :keyrest].include?(v[0])
-            v[0]
-          else
-            v[1]
-          end
-        end
-
-        mp = Memoized::Parameters.new(single_args_and_kwargs)
-        puts mp.debug_info if ENV['DEBUG'] == 'true'
-
-        eval(<<-RUBY)
-        class MemoizedPropertyClass
-          include Memoized
-
-          def parameter_dummy(#{mp.signature})
-            42
-          end
-
-          @old_arity = new.method(:parameter_dummy).arity
-          memoize :parameter_dummy
-          @new_arity = new.method(:parameter_dummy).arity
-
-          # cleanup to get rid of warnings
-          remove_method :_unmemoized_parameter_dummy
-          remove_method :parameter_dummy
-        end
-        RUBY
-
-        expect(MemoizedPropertyClass.instance_variable_get(:@new_arity))
-          .to eq(MemoizedPropertyClass.instance_variable_get(:@old_arity))
-      end
-    end
-
-    it "does not change the method's parameters" do
-      forall(
-        array(
-          tuple(
-            one_of(
-              constant(:req), constant(:opt), constant(:rest), constant(:keyreq), constant(:key), constant(:keyrest)
-            ),
-            simple_symbol.map do |sym|
-              "param_#{sym}".to_sym
-            end
-          )
-        )
-      ) do |parameters|
-        # params now have proper names (no :"", no Ruby keywords) due to the .map in the generator above
-        unique_names = parameters.uniq { |v| v[1] }
-        single_args_and_kwargs = unique_names.uniq do |v|
-          if [:rest, :keyrest].include?(v[0])
-            v[0]
-          else
-            v[1]
-          end
-        end
-
-        mp = Memoized::Parameters.new(single_args_and_kwargs)
-        puts mp.debug_info if ENV['DEBUG'] == 'true'
-
-        eval(<<-RUBY)
-        class MemoizedPropertyClass
-          include Memoized
-
-          def parameter_dummy(#{mp.signature})
-            42
-          end
-
-          @old_parameters = new.method(:parameter_dummy).parameters
-          memoize :parameter_dummy
-          @new_parameters = new.method(:parameter_dummy).parameters
-
-          # cleanup to get rid of warnings
-          remove_method :_unmemoized_parameter_dummy
-          remove_method :parameter_dummy
-        end
-        RUBY
-
-        expect(MemoizedPropertyClass.instance_variable_get(:@new_parameters))
-          .to eq(MemoizedPropertyClass.instance_variable_get(:@old_parameters))
-      end
-    end
-
-    it "does not change the method's value" do
-      forall(
-        array(
-          tuple(
-            one_of(
-              constant(:req), constant(:opt), constant(:rest), constant(:keyreq), constant(:key), constant(:keyrest)
-            ),
-            simple_symbol.map do |sym|
-              "param_#{sym}".to_sym
-            end
-          )
-        )
-      ) do |parameters|
-        # params now have proper names (no :"", no Ruby keywords) due to the .map in the generator above
-        unique_names = parameters.uniq { |v| v[1] }
-        single_args_and_kwargs = unique_names.uniq do |v|
-          if [:rest, :keyrest].include?(v[0])
-            v[0]
-          else
-            v[1]
-          end
-        end
-
-        mp = Memoized::Parameters.new(single_args_and_kwargs)
-        puts mp.debug_info if ENV['DEBUG'] == 'true'
-
-        eval(<<-RUBY)
-        class MemoizedPropertyClass
-          include Memoized
-
-          def parameter_dummy(#{mp.signature})
-            #{mp.test_body}
-          end
-
-          @old_value = new.parameter_dummy(#{mp.test_arguments})
-          memoize :parameter_dummy
-          @new_value = new.parameter_dummy(#{mp.test_arguments})
-
-          # cleanup to get rid of warnings
-          remove_method :_unmemoized_parameter_dummy
-          remove_method :parameter_dummy
-        end
-        RUBY
-
-        expect(MemoizedPropertyClass.instance_variable_get(:@new_value))
-          .to eq(MemoizedPropertyClass.instance_variable_get(:@old_value))
-      end
-    end
-
-    it "computes the correct value" do
-      forall(array(choose(15), min: 6, max: 6)) do |parameter_multiplicities|
-
-        params = []
-
-        parameter_multiplicities[0].times.with_index do |counter|
-          params << [:req, "required_#{counter}".to_sym]
-        end
-
-        parameter_multiplicities[1].times.with_index do |counter|
-          params << [:opt, "optional_#{counter}".to_sym]
-        end
-
-        if parameter_multiplicities[2] != 0
-          params << [:rest, :args]
-        end
-
-        parameter_multiplicities[3].times.with_index do |counter|
-          params << [:keyreq, "required_kw_#{counter}".to_sym]
-        end
-
-        parameter_multiplicities[4].times.with_index do |counter|
-          params << [:key, "optional_kw_#{counter}".to_sym]
-        end
-
-        if parameter_multiplicities[5] != 0
-          params << [:keyrest, :kwargs]
-        end
-
-        mp = Memoized::Parameters.new(params, parameter_multiplicities[2], parameter_multiplicities[5])
-
-        puts mp.debug_info if ENV['DEBUG'] == 'true'
-
-        eval(<<-RUBY)
-        class MemoizedPropertyClass
-          include Memoized
-
-          def parameter_dummy(#{mp.signature})
-            #{mp.test_body}
-          end
-
-          memoize :parameter_dummy
-          @value = new.parameter_dummy(#{mp.test_arguments})
-
-          # cleanup to get rid of warnings
-          remove_method :_unmemoized_parameter_dummy
-          remove_method :parameter_dummy
-        end
-        RUBY
-
-        expected_result = [2, 3, 5, 7, 11, 13].zip(parameter_multiplicities).map do |base, exponent|
-          base ** exponent
-        end.inject(&:*)
-
-        expect(MemoizedPropertyClass.instance_variable_get(:@value))
-          .to eq(expected_result)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,88 +0,0 @@
-require 'date'
-require 'timecop'
-require 'memoized'
-if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('2.5.3')
-  require 'prop_check'
-end
-
-RSpec.configure do |config|
-  config.warnings = true
-  config.order = :random
-  Kernel.srand config.seed
-end
-
-module Memoized
-  class Parameters
-    attr_accessor :args_count, :kwargs_count
-
-    def test_body
-      params.map(&Parameters.method(:to_test_body)).join(" * ")
-    end
-
-    def self.to_test_body((param_type, param_name))
-      case param_type
-      when :req
-        "#{param_name}"
-      when :opt
-        "#{param_name}"
-      when :rest
-        "#{param_name}.inject(&:*)"
-      when :keyreq
-        "#{param_name}"
-      when :key
-        "#{param_name}"
-      when :keyrest
-        "#{param_name}.values.inject(&:*)"
-      else raise "unknown parameter type"
-      end
-    end
-
-    def test_arguments
-      params.map(&Parameters.new([], @args_count, @kwargs_count).method(:to_test_arguments)).join(", ")
-    end
-
-    def to_test_arguments((param_type, param_name))
-      case param_type
-      when :req
-        "2"
-      when :opt
-        "3"
-      when :rest
-        if @args_count.nil?
-          "5, 5, 5"
-        else
-          (["5"] * @args_count).join(', ')
-        end
-      when :keyreq
-        "#{param_name}: 7"
-      when :key
-        "#{param_name}: 11"
-      when :keyrest
-        if @kwargs_count.nil?
-          "**{ first: 13, second: 13 }"
-        else
-          kwargs_list = (1..@kwargs_count).map.with_index do |counter|
-            "kwarg_#{counter}: 13"
-          end
-          "**{ #{kwargs_list.join(', ')} }"
-        end
-      else raise "unknown parameter type"
-      end
-    end
-
-    def debug_info
-      "#{@req_params.size} - #{@opt_params.size} - #{@args_count || @rest_params.size} " \
-        "| #{@keyreq_params.size} - #{@key_params.size} - #{@kwargs_count || @keyrest_params.size}"
-    end
-  end
-end
-
-module ParametersTestExtension
-  def initialize(parameters = [], args_count = nil, kwargs_count = nil)
-    super(parameters)
-    @args_count = args_count
-    @kwargs_count = kwargs_count
-  end
-end
-
-Memoized::Parameters.prepend(ParametersTestExtension)