memoized 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ab7a8649195530ae1e3ace893313e3731c1dcf3af93f6ebeaebad4a715efa65
-  data.tar.gz: 543fd2584dbf7a34fd45c23394888cf8935a8f93f93be9a293b684e1054c3eed
+  metadata.gz: 38881d8fc70ecdbf1920e7bbb40d684403d88c4225e53d7a3e426f97ef5f41ac
+  data.tar.gz: 750f0290f9258b48bcabdf993e0c0a11f9919643b2a944efa5046cdd930d05a8
 SHA512:
-  metadata.gz: 13673e0131ff6560848e8dcac44ea746db4c18602b3fa68d3072dbefeaca95bf93ea1bbd4159ce49c8be30cd7361e616237c1ef61d19bc6e2d72efaba6a5d9fe
-  data.tar.gz: 99f27fd8d150aaf3283d29cd159f16ed31beb13c6a293338709f15397c562294caf55a971b7764847895919aaf46c1a87ea77c123f2680691b1765b361b129b8
+  metadata.gz: 35dd34457b8c984200f9fe3eefc72539cf6dcf4661d6ade672197a9c0760439fb27d7b577400eb9416db66fb2f69fc8b6302f78f36f6dbb25d79350f5b7ca521
+  data.tar.gz: 94360c1c038704a77d06258aa76971bdcb875064cbec5a26b090f5764c50eecccddb01c42ecd67b3a15b3c577768a2740160163111900543582ab4677577d994

data/.github/workflows/test.yml

@@ -0,0 +1,38 @@
+---
+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/.ruby-version

@@ -1 +1 @@
-2.6.1
+2.6.7

data/CHANGELOG.md

@@ -13,6 +13,32 @@ This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html
 
 -
 
+## 1.1.1 - 2022-06-22
+
+### Breaking changes
+
+- (The `.parameters` of a memoized method are no longer renamed to `arg1` ... `argn` and instead retain their original names)
+
+### Compatible changes
+
+- Methods with keyword arguments can now be properly memoized
+- In addition to a methods `.arity`, memoized now also preserves its `.parameters`
+
+## 1.1.0 - 2022-03-16
+
+### Breaking changes
+
+- Remove no longer supported ruby versions (2.3.8, 2.4.5)
+
+### Compatible changes
+
+- Activate rubygems MFA
+
+## 1.0.2 - 2019-05-22
+
+### Compatible changes
+
+- Preserve arity of methods with optional arguments
 
 ## 1.0.1 - 2019-02-27
 

data/Gemfile

@@ -1,2 +1,3 @@
 source 'https://rubygems.org'
+
 gemspec

data/Gemfile.lock

@@ -1,12 +1,16 @@
 PATH
   remote: .
   specs:
-    memoized (1.0.0)
+    memoized (1.1.1)
 
 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)
@@ -27,10 +31,12 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  gemika
   memoized!
+  prop_check (~> 0.14.1)
   rake (~> 10.4.2)
   rspec (~> 3.5.0)
   timecop (~> 0.8.0)
 
 BUNDLED WITH
-   1.17.2
+   2.2.21

data/README.md

@@ -1,6 +1,4 @@
-[![Build Status](https://travis-ci.org/makandra/memoized.svg?branch=master)](https://travis-ci.org/makandra/memoized)
-
-# Memoized
+# Memoized [![Tests](https://github.com/makandra/memoized/workflows/Tests/badge.svg)](https://github.com/makandra/memoized/actions)
 
 Memoized will memoize the results of your methods. It acts much like
 `ActiveSupport::Memoizable` without all of that freezing business. The API for
@@ -14,7 +12,7 @@ $ gem install memoized
 
 ## Usage
 
-To define a memoized instance method, use `memoized def``:
+To define a memoized instance method, use `memoize def`:
 
 ```ruby
 class A
@@ -78,6 +76,64 @@ instance.goodbye        # the goodbye method is now memoized
 instance.unmemoize_all  # neither hello nor goodbye are memoized anymore
 ```
 
+## Limitations
+
+When you are using Memoized with default arguments or default keyword arguments, there are some edge cased you have to
+keep in mind.
+
+When you memoize a method with (keyword) arguments that have an expression as default value, you should be aware
+that the expression is evaluated only once.
+
+```ruby
+memoize def print_time(time = Time.now)
+  time
+end
+
+print_time
+=> 2021-07-23 14:23:18 +0200
+
+sleep(1.minute)
+print_time
+=> 2021-07-23 14:23:18 +0200
+```
+
+When you memoize a method with (keyword) arguments that have default values, you should be aware that Memoized
+differentiates between a method call without arguments and the default values.
+
+```ruby
+def true_or_false(default = true)
+  puts 'calculate value ...'
+  default
+end
+
+true_or_false
+calculate value ...
+=> true
+
+true_or_false
+=> true
+
+true_or_false(true)
+calculate value ...
+=> true
+```
+
+## Development
+
+There are tests in `spec`. We only accept PRs with tests. To run tests:
+
+- Install Ruby 2.6.1
+- Install development dependencies using `bundle install`
+- Run tests using `bundle exec rake current_rspec`
+
+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:
+
+- Install development dependencies using `bundle exec rake matrix:install`
+- Run tests using `bundle exec rake matrix:spec`
+
+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.
+
+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).
 
 ## License
 

data/Rakefile

@@ -1,2 +1,10 @@
 require 'rake'
 require 'bundler/gem_tasks'
+
+begin
+  require 'gemika/tasks'
+rescue LoadError
+  puts 'Run `gem install gemika` for additional tasks'
+end
+
+task :default => 'matrix:spec'

data/lib/memoized/parameters.rb

@@ -0,0 +1,98 @@
+module Memoized
+  class Parameters
+    UNIQUE = 42.freeze
+
+    attr_accessor :req_params, :opt_params, :rest_params, :keyreq_params, :key_params, :keyrest_params
+
+    def initialize(parameters = [])
+      # This constructor does not check, whether the parameters were ordered correctly
+      # with respect to the Ruby language specification. However, all outputs will be sorted correctly.
+      @req_params = []
+      @opt_params = []
+      @rest_params = []
+      @keyreq_params = []
+      @key_params = []
+      @keyrest_params = []
+
+      parameters.each do |(param_type, param_name)|
+        case param_type
+        when :req
+          @req_params << [param_type, param_name]
+        when :opt
+          @opt_params << [param_type, param_name]
+        when :rest
+          @rest_params << [param_type, param_name]
+        when :keyreq
+          @keyreq_params << [param_type, param_name]
+        when :key
+          @key_params << [param_type, param_name]
+        when :keyrest
+          @keyrest_params << [param_type, param_name]
+        when :block
+          raise Memoized::CannotMemoize, 'Cannot memoize a method that takes a block!'
+        else
+          raise Memoized::CannotMemoize, 'Unknown parameter type!'
+        end
+      end
+
+      if @rest_params.size > 1 || @keyrest_params.size > 1
+        raise Memoized::CannotMemoize "Multiple rest or keyrest parameters, invalid signature!"
+      end
+    end
+
+    def params
+      @req_params + @opt_params + @rest_params + @keyreq_params + @key_params + @keyrest_params
+    end
+
+    def signature
+      params.map(&Parameters.method(:to_signature)).join(', ')
+    end
+
+    def self.to_signature((param_type, param_name))
+      case param_type
+      when :req
+        "#{param_name}"
+      when :opt
+        "#{param_name} = Memoized::Parameters::UNIQUE"
+      when :rest
+        "*#{param_name}"
+      when :keyreq
+        "#{param_name}:"
+      when :key
+        "#{param_name}: Memoized::Parameters::UNIQUE"
+      when :keyrest
+        "**#{param_name}"
+      else raise "unknown parameter type"
+      end
+    end
+
+    def cache_key
+      <<-STRING
+        all_args = []
+        all_kwargs = {}
+
+        #{params.map(&Parameters.method(:to_cache_key)).join("\n")}
+        
+        cache_key = [all_args, all_kwargs]
+      STRING
+    end
+
+    def self.to_cache_key((param_type, param_name))
+      case param_type
+      when :req
+        "all_args.push(#{param_name})"
+      when :opt
+        "all_args.push(#{param_name}) unless #{param_name}.equal?(Memoized::Parameters::UNIQUE)"
+      when :rest
+        "all_args.push(*#{param_name})"
+      when :keyreq
+        "all_kwargs[:#{param_name}] = #{param_name}"
+      when :key
+        "all_kwargs[:#{param_name}] = #{param_name} unless #{param_name}.equal?(Memoized::Parameters::UNIQUE)"
+      when :keyrest
+        "all_kwargs.merge!(#{param_name})"
+      else raise "unknown parameter type"
+      end
+    end
+  end
+end

data/lib/memoized/version.rb

@@ -1,3 +1,3 @@
 module Memoized
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

data/lib/memoized.rb

@@ -1,4 +1,8 @@
+require 'memoized/parameters'
+
 module Memoized
+  class CannotMemoize < ::StandardError; end
+
   def self.included(base)
     base.extend ClassMethods
     base.send :include, InstanceMethods
@@ -20,45 +24,27 @@ module Memoized
 
         alias_method unmemoized_method, method_name
 
-        arity = instance_method(unmemoized_method).arity
-
-        case arity
-        when 0
-          module_eval(<<-RUBY)
-            def #{method_name}()
-              #{memoized_ivar_name} ||= [#{unmemoized_method}()]
-              #{memoized_ivar_name}.first
-            end
-          RUBY
-
-        when -1
-          module_eval(<<-RUBY)
-            def #{method_name}(*args)
-              #{memoized_ivar_name} ||= {}
-              if #{memoized_ivar_name}.has_key?(args)
-                #{memoized_ivar_name}[args]
-              else
-                #{memoized_ivar_name}[args] = #{unmemoized_method}(*args)
-              end
-            end
-          RUBY
+        parameters = Parameters.new(instance_method(unmemoized_method).parameters)
 
-        else
-          arg_names = (0..(arity - 1)).map { |i| "arg#{i}" }
-          args_ruby = arg_names.join(', ')
+        module_eval(<<-RUBY)
+          def #{method_name}(#{parameters.signature})
+            #{parameters.cache_key}
 
-          module_eval(<<-RUBY)
-            def #{method_name}(#{args_ruby})
-              args = [#{args_ruby}]
-              #{memoized_ivar_name} ||= {}
-              if #{memoized_ivar_name}.has_key?(args)
-                #{memoized_ivar_name}[args]
-              else
-                #{memoized_ivar_name}[args] = #{unmemoized_method}(#{args_ruby})
+            #{memoized_ivar_name} ||= {}
+            
+            if #{memoized_ivar_name}.key?(cache_key)
+              #{memoized_ivar_name}[cache_key]
+            else
+              live_result = if all_kwargs.empty?
+                #{unmemoized_method}(*all_args)
+              else  
+                #{unmemoized_method}(*all_args, **all_kwargs)
               end
+              #{memoized_ivar_name}[cache_key] = live_result
+              live_result
             end
-          RUBY
-        end
+          end
+        RUBY
 
         if self.private_method_defined?(unmemoized_method)
           private method_name

data/memoized.gemspec

@@ -8,6 +8,12 @@ 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.metadata    = {
+    'source_code_uri' => s.homepage,
+    'bug_tracker_uri' => 'https://github.com/makandra/memoized/issues',
+    'changelog_uri' => 'https://github.com/makandra/memoized/blob/master/CHANGELOG.md',
+    '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? }
@@ -19,4 +25,6 @@ Gem::Specification.new do |s|
   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')
 end

data/spec/memoized_spec.rb

@@ -3,7 +3,13 @@ class MemoizedSpecClass
   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
-  memoize :no_params, :with_params?, :returning_nil!
+  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
 
@@ -49,6 +55,40 @@ describe Memoized do
       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
@@ -114,7 +154,6 @@ describe Memoized do
       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
@@ -128,7 +167,6 @@ describe Memoized do
       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
@@ -142,7 +180,92 @@ describe Memoized do
       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

data/spec/properties_spec.rb

@@ -0,0 +1,222 @@
+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,9 +1,88 @@
 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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memoized
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Barun Singh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2022-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,16 +53,44 @@ dependencies:
     - - "~>"
       - !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'
 description: Memoized caches the results of your method calls
 email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -70,14 +98,20 @@ files:
 - README.md
 - Rakefile
 - 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
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/makandra/memoized
+  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:
@@ -93,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Memoized caches the results of your method calls

data/.travis.yml

@@ -1,26 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.1.8
-  - 2.3.8
-  - 2.4.5
-  - 2.5.3
-  - 2.6.1
-
-gemfile:
-  - Gemfile
-
-script: bundle exec rspec spec
-
-sudo: false
-
-cache: bundler
-
-notifications:
-  email:
-    - fail@makandra.de
-
-install:
-  # Replace default Travis CI bundler script with a version that doesn't
-  # explode when lockfile doesn't match recently bumped version
-  - bundle install --no-deployment --jobs=3 --retry=3 --path=${BUNDLE_PATH:-vendor/bundle}