memoist 0.2.0 → 0.9.0

data/README.md

@@ -24,7 +24,17 @@ Just extend with the Memoist module
 
 And person.social_security will only be calculated once.
 
-You can even do it with a method that takes arguments.
+Every memoized function (which initially was not accepting any arguments) has a ```(reload)``` 
+argument you can pass in to bypass and reset the memoization:
+
+    def some_method
+      Time.now
+    end
+    memoize :some_method
+
+Calling ```some_method``` will be memoized, but calling ```some_method(true)``` will rememoize each time.
+
+You can even memoize method that takes arguments.
 
 
     class Person
@@ -36,6 +46,23 @@ You can even do it with a method that takes arguments.
 
 This will only be calculated once per value of income.
 
+Reload
+------
+
+Each memoized function comes with a way to flush the existing value.
+
+    person.social_security       # returns the memoized value
+    person.social_security(true) # bypasses the memoized value and rememoizes it
+    
+This also works with a memoized method with arguments
+
+    person.taxes_due(100_000)       # returns the memoized value
+    person.taxes_due(100_000, true) # bypasses the memoized value and rememoizes it
+
+If you want to flush the entire memoization cache for an object
+
+    person.flush_cache
+
 Authors
 ===========
 
@@ -51,4 +78,9 @@ Everyone who contributed to it in the rails repository.
 * jeem
 * Jay Pignata
 * Damien Mathieu
-* José Valim                             
+* José Valim
+
+License
+=======
+
+Released under the [MIT License](http://www.opensource.org/licenses/MIT), just as Ruby on Rails is.

data/lib/memoist.rb

@@ -1,27 +1,43 @@
-# require 'active_support/core_ext/kernel/singleton_class'
 require 'memoist/core_ext/singleton_class'
 
 module Memoist
 
-  def self.memoized_ivar_for(symbol)
-    "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
+  def self.memoized_ivar_for(method_name, identifier=nil)
+    ["@#{memoized_prefix(identifier)}", escape_punctuation(method_name.to_s)].join("_")
   end
 
-  module InstanceMethods
-    def self.included(base)
-      base.class_eval do
-        unless base.method_defined?(:freeze_without_memoizable)
-          alias_method :freeze_without_memoizable, :freeze
-          alias_method :freeze, :freeze_with_memoizable
-        end
-      end
+  def self.unmemoized_method_for(method_name, identifier=nil)
+    [unmemoized_prefix(identifier), method_name].join("_").to_sym
+  end
+
+  def self.memoized_prefix(identifier=nil)
+    ["_memoized", identifier].compact.join("_")
+  end
+
+  def self.unmemoized_prefix(identifier=nil)
+    ["_unmemoized", identifier].compact.join("_")
+  end
+
+  def self.escape_punctuation(string)
+    string.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')
+  end
+
+  def self.memoist_eval(klass, *args, &block)
+    if klass.respond_to?(:class_eval)
+      klass.class_eval(*args, &block)
+    else
+      klass.singleton_class.class_eval(*args, &block)
     end
+  end
 
-    def freeze_with_memoizable
-      memoize_all unless frozen?
-      freeze_without_memoizable
+  def self.extract_reload!(method, args)
+    if args.length == method.arity + 1 && (args.last == true || args.last == :reload)
+      reload = args.pop
     end
+    reload
+  end
 
+  module InstanceMethods
     def memoize_all
       prime_cache
     end
@@ -30,85 +46,152 @@ module Memoist
       flush_cache
     end
 
-    def prime_cache(*syms)
-      if syms.empty?
-        syms = methods.collect do |m|
-          m[12..-1] if m.to_s.start_with?("_unmemoized_")
+    def prime_cache(*method_names)
+      if method_names.empty?
+        prefix = Memoist.unmemoized_prefix+"_"
+        method_names = methods.collect do |method_name|
+          if method_name.to_s.start_with?(prefix)
+            method_name[prefix.length..-1]
+          end
         end.compact
       end
 
-      syms.each do |sym|
-        m = method(:"_unmemoized_#{sym}") rescue next
-        if m.arity == 0
-          __send__(sym)
+      method_names.each do |method_name|
+        if method(Memoist.unmemoized_method_for(method_name)).arity == 0
+          __send__(method_name)
         else
-          ivar = Memoist.memoized_ivar_for(sym)
+          ivar = Memoist.memoized_ivar_for(method_name)
           instance_variable_set(ivar, {})
         end
       end
     end
 
-    def flush_cache(*syms)
-      if syms.empty?
-        syms = (methods + private_methods + protected_methods).collect do |m|
-          m[12..-1] if m.to_s.start_with?("_unmemoized_")
+    def flush_cache(*method_names)
+      if method_names.empty?
+        prefix = Memoist.unmemoized_prefix+"_"
+        method_names = (methods + private_methods + protected_methods).collect do |method_name|
+          if method_name.to_s.start_with?(prefix)
+            method_name[prefix.length..-1]
+          end
         end.compact
       end
 
-      syms.each do |sym|
-        ivar = Memoist.memoized_ivar_for(sym)
+      method_names.each do |method_name|
+        ivar = Memoist.memoized_ivar_for(method_name)
         instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
       end
     end
   end
 
-  def memoize(*symbols)
-    symbols.each do |symbol|
-      original_method = :"_unmemoized_#{symbol}"
-      memoized_ivar = Memoist.memoized_ivar_for(symbol)
-
-      class_eval <<-EOS, __FILE__, __LINE__ + 1
-        include InstanceMethods                                                  # include InstanceMethods
-                                                                                 #
-        if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
-          raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
-        end                                                                      # end
-        alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
-                                                                                 #
-        if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0
-          def #{symbol}(reload = false)                                          #   def mime_type(reload = false)
-            if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?
-              #{memoized_ivar} = [#{original_method}]                            #       @_memoized_mime_type = [_unmemoized_mime_type]
-            end                                                                  #     end
-            #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]
-          end                                                                    #   end
-        else                                                                     # else
-          def #{symbol}(*args)                                                   #   def mime_type(*args)
-            #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?
-            args_length = method(:#{original_method}).arity                      #     args_length = method(:_unmemoized_mime_type).arity
-            if args.length == args_length + 1 &&                                 #     if args.length == args_length + 1 &&
-              (args.last == true || args.last == :reload)                        #       (args.last == true || args.last == :reload)
-              reload = args.pop                                                  #       reload = args.pop
-            end                                                                  #     end
-                                                                                 #
-            if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type
-              if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)
-                #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]
-              elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type
-                #{memoized_ivar}[args] = #{original_method}(*args)               #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args)
-              end                                                                #       end
-            else                                                                 #     else
-              #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)
-            end                                                                  #     end
-          end                                                                    #   end
-        end                                                                      # end
-                                                                                 #
-        if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
-          private #{symbol.inspect}                                              #   private :mime_type
-        elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
-          protected #{symbol.inspect}                                            #   protected :mime_type
-        end                                                                      # end
-      EOS
+  def memoize(*method_names)
+    if method_names.last.is_a?(Hash)
+      identifier = method_names.pop[:identifier]
+    end
+
+    method_names.each do |method_name|
+      unmemoized_method = Memoist.unmemoized_method_for(method_name, identifier)
+      memoized_ivar = Memoist.memoized_ivar_for(method_name, identifier)
+
+      Memoist.memoist_eval(self) do
+        include InstanceMethods
+
+        if method_defined?(unmemoized_method)
+          raise "Already memoized #{method_name}"
+        end
+        alias_method unmemoized_method, method_name
+
+        if instance_method(method_name).arity == 0
+
+          # define a method like this;
+
+          # def mime_type(reload=true)
+          #   skip_cache = reload || !memoized?(:abc)
+          #   set_cache = skip_cache && !frozen?
+          #
+          #   if skip_cache
+          #     value = _unmemoized_mime_type
+          #   else
+          #     value = @_memoized_mime_type[0]
+          #   end
+          #
+          #   if set_cache
+          #     @_memoized_mime_type = [value]
+          #   end
+          #
+          #   value
+          # end
+
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(reload = false)
+              skip_cache = reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}
+              else
+                value = #{memoized_ivar}[0]
+              end
+
+              if set_cache
+                #{memoized_ivar} = [value]
+              end
+
+              value
+            end
+          EOS
+        else
+
+          # define a method like this;
+
+          # def mime_type(*args)
+          #   reload = Memoist.extract_reload!(method(:_unmemoized_mime_type), args)
+          #
+          #   skip_cache = reload || !memoized_with_args?(:mime_type, args)
+          #   set_cache = skip_cache && !frozen
+          #
+          #   if skip_cache
+          #     value = _unmemoized_mime_type(*args)
+          #   else
+          #     value = @_memoized_mime_type[args]
+          #   end
+          #
+          #   if set_cache
+          #     @_memoized_mime_type ||= {}
+          #     @_memoized_mime_type[args] = value
+          #   end
+          #
+          #   value
+          # end
+
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(*args)
+              reload = Memoist.extract_reload!(method(#{unmemoized_method.inspect}), args)
+
+              skip_cache = reload || !(defined?(#{memoized_ivar}) && #{memoized_ivar} && #{memoized_ivar}.has_key?(args))
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}(*args)
+              else
+                value = #{memoized_ivar}[args]
+              end
+
+              if set_cache
+                #{memoized_ivar} ||= {}
+                #{memoized_ivar}[args] = value
+              end
+
+              value
+            end
+          EOS
+        end
+
+        if private_method_defined?(unmemoized_method)
+          private method_name
+        elsif protected_method_defined?(unmemoized_method)
+          protected method_name
+        end
+      end
     end
   end
 end

data/lib/memoist/core_ext/singleton_class.rb

@@ -5,9 +5,4 @@ module Kernel
       self
     end
   end unless respond_to?(:singleton_class) # exists in 1.9.2
-
-  # class_eval on an object acts like singleton_class.class_eval.
-  def class_eval(*args, &block)
-    singleton_class.class_eval(*args, &block)
-  end
-end
+end

data/test/memoist_test.rb

@@ -2,25 +2,58 @@ require 'test_helper'
 require 'memoist'
 
 class MemoistTest < Test::Unit::TestCase
+
+  class CallCounter
+
+    def initialize
+      @calls = {}
+    end
+
+    def call(method_name)
+      @calls[method_name] ||= 0
+      @calls[method_name] += 1
+    end
+
+    def count(method_name)
+      @calls[method_name] ||= 0
+    end
+
+  end
+
   class Person
     extend Memoist
 
-    attr_reader :name_calls, :age_calls, :is_developer_calls, :name_query_calls
-
     def initialize
-      @name_calls = 0
-      @age_calls = 0
-      @is_developer_calls = 0
-      @name_query_calls = 0
+      @counter = CallCounter.new
+    end
+
+    def name_calls
+      @counter.count(:name)
+    end
+
+    def student_name_calls
+      @counter.count(:student_name)
+    end
+
+    def name_query_calls
+      @counter.count(:name?)
+    end
+
+    def is_developer_calls
+      @counter.count(:is_developer?)
+    end
+
+    def age_calls
+      @counter.count(:age)
     end
 
     def name
-      @name_calls += 1
+      @counter.call(:name)
       "Josh"
     end
 
     def name?
-      @name_query_calls += 1
+      @counter.call(:name?)
       true
     end
     memoize :name?
@@ -31,7 +64,7 @@ class MemoistTest < Test::Unit::TestCase
     memoize :update
 
     def age
-      @age_calls += 1
+      @counter.call(:age)
       nil
     end
 
@@ -47,12 +80,20 @@ class MemoistTest < Test::Unit::TestCase
     private
 
     def is_developer?
-      @is_developer_calls += 1
+      @counter.call(:is_developer?)
       "Yes"
     end
     memoize :is_developer?
   end
 
+  class Student < Person
+    def name
+      @counter.call(:student_name)
+      "Student #{super}"
+    end
+    memoize :name, :identifier => :student
+  end
+
   class Company
     attr_reader :name_calls
     def initialize
@@ -259,6 +300,18 @@ class MemoistTest < Test::Unit::TestCase
     assert_raise(RuntimeError) { company.memoize :name }
   end
 
+  def test_double_memoization_with_identifier
+    assert_nothing_raised { Person.memoize :name, :identifier => :again }
+  end
+
+  def test_memoization_with_a_subclass
+    student = Student.new
+    student.name
+    student.name
+    assert_equal 1, student.student_name_calls
+    assert_equal 1, student.name_calls
+  end
+
   def test_protected_method_memoization
     person = Person.new
 

metadata

@@ -1,12 +1,17 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: memoist
-version: !ruby/object:Gem::Version
-  version: 0.2.0
+version: !ruby/object:Gem::Version 
+  hash: 59
   prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
-authors:
+authors: 
 - Joshua Peek
-- Tarmo Tänav
+- "Tarmo T\xC3\xA4nav"
 - Jeremy Kemper
 - Eugene Pimenov
 - Xavier Noria
@@ -15,14 +20,16 @@ authors:
 - jeem
 - Jay Pignata
 - Damien Mathieu
-- José Valim
+- "Jos\xC3\xA9 Valim"
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-15 00:00:00.000000000 Z
+
+date: 2013-03-20 00:00:00 Z
 dependencies: []
+
 description: 
-email:
+email: 
 - josh@joshpeek.com
 - tarmo@itech.ee
 - jeremy@bitsweat.net
@@ -35,10 +42,12 @@ email:
 - 42@dmathieu.com
 - jose.valim@gmail.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.md
-files:
+files: 
 - README.md
 - test/memoist_test.rb
 - test/test_helper.rb
@@ -46,28 +55,37 @@ files:
 - lib/memoist.rb
 homepage: https://github.com/matthewrudy/memoist
 licenses: []
+
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --main
 - README.md
-require_paths:
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: memoize methods invocation
 test_files: []
+