memoized 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38881d8fc70ecdbf1920e7bbb40d684403d88c4225e53d7a3e426f97ef5f41ac
-  data.tar.gz: 750f0290f9258b48bcabdf993e0c0a11f9919643b2a944efa5046cdd930d05a8
+  metadata.gz: fb2cf278843df2c67e80b301e9eda488f5d1a1fa897601963982f6e39f5780a7
+  data.tar.gz: 364c3036a777f8e7492240c23577a12ba154c22e6011a308e19ccd64d77b0f6e
 SHA512:
-  metadata.gz: 35dd34457b8c984200f9fe3eefc72539cf6dcf4661d6ade672197a9c0760439fb27d7b577400eb9416db66fb2f69fc8b6302f78f36f6dbb25d79350f5b7ca521
-  data.tar.gz: 94360c1c038704a77d06258aa76971bdcb875064cbec5a26b090f5764c50eecccddb01c42ecd67b3a15b3c577768a2740160163111900543582ab4677577d994
+  metadata.gz: 851942011f26ecaf7b90303d3fbd6a63462b649a7b5311b03417a56f51d83d69b83f722a90d719782aeb21d38e3685c962e14231afe8c98c9223ccb3b998df72
+  data.tar.gz: 3e4c2ab30a1ef2d18f4a9afd2f67ba7edc812f136d70364585b9fb1484dbe5211287d058970a5c58ba15adba9d9f7d2a7057d35a4fef6db24cc54b5fe4d8f1d2

data/.ruby-version

@@ -1 +1 @@
-2.6.7
+4.0.1

data/CHANGELOG.md

@@ -13,6 +13,22 @@ 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
+
+- Add Ruby 3.4 support
+- Provide dev script `bin/matrix` and adjust REAMDE
+- Move development dependencies out of the gemspec
+
 ## 1.1.1 - 2022-06-22
 
 ### Breaking changes

data/Gemfile

@@ -1,3 +1,9 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'rake', '~> 13.0.6'
+gem 'rspec', '~> 3.12.0'
+gem 'timecop', '~> 0.8.0'
+gem 'prop_check', '~> 1.0.0'
+gem 'gemika'

data/Gemfile.lock

@@ -1,30 +1,28 @@
 PATH
   remote: .
   specs:
-    memoized (1.1.1)
+    memoized (1.1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    amazing_print (1.4.0)
-    diff-lcs (1.3)
-    gemika (0.7.1)
-    prop_check (0.14.1)
-      amazing_print (~> 1.2)
-    rake (10.4.2)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
+    diff-lcs (1.5.0)
+    gemika (2.0.0)
+    prop_check (1.0.2)
+    rake (13.0.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
     timecop (0.8.1)
 
 PLATFORMS
@@ -33,10 +31,10 @@ PLATFORMS
 DEPENDENCIES
   gemika
   memoized!
-  prop_check (~> 0.14.1)
-  rake (~> 10.4.2)
-  rspec (~> 3.5.0)
+  prop_check (~> 1.0.0)
+  rake (~> 13.0.6)
+  rspec (~> 3.12.0)
   timecop (~> 0.8.0)
 
 BUNDLED WITH
-   2.2.21
+   2.3.1

data/README.md

@@ -120,20 +120,31 @@ calculate value ...
 
 ## Development
 
-There are tests in `spec`. We only accept PRs with tests. To run tests:
+Development
+-----------
 
-- Install Ruby 2.6.1
-- Install development dependencies using `bundle install`
-- Run tests using `bundle exec rake current_rspec`
+I'm very eager to keep this gem leightweight and on topic. If you're unsure whether a change would make
+it into the gem, [talk to me beforehand](mailto:henning.koch@makandra.de).
 
-We recommend to test large changes against multiple versions of Ruby. Supported combinations are configured in `.github/workflows/test.yml`. We provide some rake tasks to help with this:
+There are tests in `spec`. We only accept PRs with tests. If you create a PR, the tests will automatically run on
+GitHub actions on each push. We will only merge pull requests after a green GitHub actions run.
 
-- Install development dependencies using `bundle exec rake matrix:install`
-- Run tests using `bundle exec rake matrix:spec`
+To run tests locally for development you have multiple options:
 
-Note that we have configured GitHub Actions to automatically run tests in all supported Ruby versions and dependency sets after each push. We will only merge pull requests after a green GitHub Actions run.
+1. Run tests against a specific Ruby version:
+   - Install and switch to the Ruby version
+   - Install development dependencies using `bundle install`
+   - Run tests using `bundle exec rspec`
 
-I'm very eager to keep this gem leightweight and on topic. If you're unsure whether a change would make it into the gem, [talk to me beforehand](mailto:henning.koch@makandra.de).
+2. Run tests against all Ruby versions:
+   - Install all Ruby versions mentioned in `.github/workflows/test.yml`
+   - 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](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 `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.1'
+  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,16 +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.add_development_dependency('rake', '~> 10.4.2')
-  s.add_development_dependency('rspec', '~> 3.5.0')
-  s.add_development_dependency('timecop', '~> 0.8.0')
-  s.add_development_dependency('prop_check', '~> 0.14.1')
-  s.add_development_dependency('gemika')
+  s.required_ruby_version = '>= 3.0.0'
 end

metadata

@@ -1,93 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: memoized
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Barun Singh
 - Henning Koch
-autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2022-06-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.4.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.4.2
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.5.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.5.0
-- !ruby/object:Gem::Dependency
-  name: timecop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-- !ruby/object:Gem::Dependency
-  name: prop_check
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.14.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.14.1
-- !ruby/object:Gem::Dependency
-  name: gemika
-  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'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Memoized caches the results of your method calls
-email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
@@ -101,9 +28,6 @@ files:
 - 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
@@ -112,7 +36,6 @@ metadata:
   bug_tracker_uri: https://github.com/makandra/memoized/issues
   changelog_uri: https://github.com/makandra/memoized/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -120,15 +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.0.3.1
-signing_key: 
+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,38 +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.0.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.2.21
-        bundle install --no-deployment
-    - name: Run tests
-      run: bundle exec rspec

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)