memoized 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30eefb403ce7300b9b943f9a6a946c56ac21fe619323ace0c06e63ca11198eab
+  data.tar.gz: 5e0e371e3bb72db04dec7fd23789a4c88f1acfffcf49c898529c5edcd60594a4
+SHA512:
+  metadata.gz: 7402174132f312c8e7f45389fd18fcae350aeffc006587c0d20921b4ead346ef794c90634e4c6c367891050edbc6d5c0982a4203e822dc9c3cda9b91dfd9ee76
+  data.tar.gz: 6a0676fcac1c743821fde6b3010d9d53a0792097775593fb41a7c912ca45ddb2ef68276cae9996aa96cc7ee92274c1c62e0e0af2442b02d4d69858442f90e99c

data/.gitignore

@@ -0,0 +1 @@
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.6.1

data/.travis.yml

@@ -0,0 +1,26 @@
+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}

data/CHANGELOG.txt

@@ -0,0 +1,4 @@
+== 1.0.1
+* Bump version to avoid conflict with old memoizer gem
+== 1.0.0
+* Initial release

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    memoized (1.0.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    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.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    timecop (0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  memoized!
+  rake (~> 10.4.2)
+  rspec (~> 3.5.0)
+  timecop (~> 0.8.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,90 @@
+[![Build Status](https://travis-ci.org/makandra/memoized.svg?branch=master)](https://travis-ci.org/makandra/memoized)
+
+# Memoized
+
+Memoized will memoize the results of your methods. It acts much like
+`ActiveSupport::Memoizable` without all of that freezing business. The API for
+unmemoizing is also a bit more explicit.
+
+## Install
+
+```
+$ gem install memoized
+```
+
+## Usage
+
+To define a memoized instance method, use `memoized def``:
+
+```ruby
+class A
+  include Memoized
+
+  memoize def hello
+    'hello!'
+  end
+end
+```
+
+You may also `memoize` one or more methods after they have been defined:
+
+```ruby
+class B
+  include Memoized
+
+  def hello
+    'hello!'
+  end
+
+  def goodbye
+    'goodbye :('
+  end
+
+  memoize :hello, :goodbye
+end
+```
+
+Memoizing class methods works the same way:
+
+```ruby
+class C
+  class << self
+    include Memoized
+
+    memoize def hello
+      'hello!'
+    end
+  end
+end
+```
+
+
+To unmemoize a specific method:
+
+```ruby
+instance = A.new
+instance.hello              # the hello method is now memoized
+instance.unmemoize(:hello)  # the hello method is no longer memoized
+instance.hello              # the hello method is run again and re-memoized
+```
+
+
+To unmemoize all methods for an instance:
+
+```ruby
+instance = B.new
+instance.hello          # the hello method is now memoized
+instance.goodbye        # the goodbye method is now memoized
+instance.unmemoize_all  # neither hello nor goodbye are memoized anymore
+```
+
+
+## License
+
+See [LICENSE.txt](https://github.com/makandra/memoized/blob/master/LICENSE.txt)
+
+
+## Credits
+
+- This gem is a fork of [Memoizer](https://github.com/wegowise/memoizer) by [Wegowise](https://www.wegowise.com/).
+- Changes in this fork by [makandra](https://makandra.com).

data/Rakefile

@@ -0,0 +1,2 @@
+require 'rake'
+require 'bundler/gem_tasks'

data/lib/memoized.rb

@@ -0,0 +1,85 @@
+module Memoized
+  def self.included(base)
+    base.extend ClassMethods
+    base.send :include, InstanceMethods
+  end
+
+  def self.safe_name(method_name)
+    method_name.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang').to_sym
+  end
+
+  def self.ivar_name(method_name)
+    :"@_memoized_#{self.safe_name(method_name)}"
+  end
+
+  module ClassMethods
+    def memoize(*method_names)
+      method_names.each do |method_name|
+        memoized_ivar_name = Memoized.ivar_name(method_name)
+        unmemoized_method = "_unmemoized_#{method_name}"
+
+        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
+
+        else
+          arg_names = (0..(arity - 1)).map { |i| "arg#{i}" }
+          args_ruby = arg_names.join(', ')
+
+          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})
+              end
+            end
+          RUBY
+        end
+
+        if self.private_method_defined?(unmemoized_method)
+          private method_name
+        elsif self.protected_method_defined?(unmemoized_method)
+          protected method_name
+        end
+      end
+    end
+  end
+
+  module InstanceMethods
+    def unmemoize(method_name)
+      self.instance_variable_set(Memoized.ivar_name(method_name), nil)
+    end
+
+    def unmemoize_all
+      (methods + private_methods + protected_methods).each do |method|
+        if method.to_s =~ /^_unmemoized_(.*)/
+          unmemoize($1)
+        end
+      end
+    end
+  end
+end

data/lib/memoized/version.rb

@@ -0,0 +1,3 @@
+module Memoized
+  VERSION = '1.0.0'
+end

data/memoized.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "memoized/version"
+
+Gem::Specification.new do |s|
+  s.name        = "memoized"
+  s.version     = Memoized::VERSION
+  s.authors     = ["Barun Singh", "Henning Koch"]
+  s.homepage    = "https://github.com/makandra/memoizer"
+  s.summary     = "Memoized caches the results of your method calls"
+  s.description = s.summary
+
+  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.require_paths = ["lib"]
+
+  s.license = 'MIT'
+
+  s.add_development_dependency('rake', '~> 10.4.2')
+  s.add_development_dependency('rspec', '~> 3.5.0')
+  s.add_development_dependency('timecop', '~> 0.8.0')
+end

data/spec/memoized_spec.rb

@@ -0,0 +1,248 @@
+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
+  memoize :no_params, :with_params?, :returning_nil!
+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 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
+
+  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/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'date'
+require 'timecop'
+require 'memoized'
+
+RSpec.configure do |config|
+  config.warnings = true
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: memoized
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Barun Singh
+- Henning Koch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-27 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
+description: Memoized caches the results of your method calls
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.txt
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/memoized.rb
+- lib/memoized/version.rb
+- memoized.gemspec
+- spec/memoized_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/makandra/memoizer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Memoized caches the results of your method calls
+test_files: []