memoist 0.1.0

data/README.md

@@ -0,0 +1,54 @@
+Memoist
+=============
+
+Memoist is an extraction of ActiveSupport::Memoizable.
+
+Since June 2011 ActiveSupport::Memoizable has been deprecated.
+But I love it,
+and so I plan to keep it alive.
+
+Usage
+-----
+
+Just extend with the Memoist module
+
+    require 'memoist'
+    class Person
+      extend Memoist
+      
+      def social_security
+        decrypt_social_security
+      end
+      memoize :social_security
+    end
+
+And person.social_security will only be calculated once.
+
+You can even do it with a method that takes arguments.
+
+
+    class Person
+      def taxes_due(income)
+        income * 0.40
+      end
+      memoize :taxes_due
+    end
+
+This will only be calculated once per value of income.
+
+Authors
+===========
+
+Everyone who contributed to it in the rails repository.
+
+* Joshua Peek
+* Tarmo Tänav
+* Jeremy Kemper
+* Eugene Pimenov
+* Xavier Noria
+* Niels Ganser
+* Carl Lerche & Yehuda Katz
+* jeem
+* Jay Pignata
+* Damien Mathieu
+* José Valim                             

data/lib/memoist.rb

@@ -0,0 +1,109 @@
+# 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
+  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
+    end
+
+    def freeze_with_memoizable
+      memoize_all unless frozen?
+      freeze_without_memoizable
+    end
+
+    def memoize_all
+      prime_cache ".*"
+    end
+
+    def unmemoize_all
+      flush_cache ".*"
+    end
+
+    def prime_cache(*syms)
+      syms.each do |sym|
+        methods.each do |m|
+          if m.to_s =~ /^_unmemoized_(#{sym})/
+            if method(m).arity == 0
+              __send__($1)
+            else
+              ivar = Memoist.memoized_ivar_for($1)
+              instance_variable_set(ivar, {})
+            end
+          end
+        end
+      end
+    end
+
+    def flush_cache(*syms)
+      syms.each do |sym|
+        (methods + private_methods + protected_methods).each do |m|
+          if m.to_s =~ /^_unmemoized_(#{sym.to_s.gsub(/\?\Z/, '\?')})/
+            ivar = Memoist.memoized_ivar_for($1)
+            instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
+          end
+        end
+      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
+    end
+  end
+end

data/lib/memoist/core_ext/singleton_class.rb

@@ -0,0 +1,13 @@
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      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

data/test/memoist_test.rb

@@ -0,0 +1,279 @@
+require 'test_helper'
+require 'memoist'
+
+class MemoistTest < Test::Unit::TestCase
+  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
+    end
+
+    def name
+      @name_calls += 1
+      "Josh"
+    end
+
+    def name?
+      @name_query_calls += 1
+      true
+    end
+    memoize :name?
+
+    def update(name)
+      "Joshua"
+    end
+    memoize :update
+
+    def age
+      @age_calls += 1
+      nil
+    end
+
+    memoize :name, :age
+
+    protected
+
+    def memoize_protected_test
+      'protected'
+    end
+    memoize :memoize_protected_test
+
+    private
+
+    def is_developer?
+      @is_developer_calls += 1
+      "Yes"
+    end
+    memoize :is_developer?
+  end
+
+  class Company
+    attr_reader :name_calls
+    def initialize
+      @name_calls = 0
+    end
+
+    def name
+      @name_calls += 1
+      "37signals"
+    end
+  end
+
+  module Rates
+    extend Memoist
+
+    attr_reader :sales_tax_calls
+    def sales_tax(price)
+      @sales_tax_calls ||= 0
+      @sales_tax_calls += 1
+      price * 0.1025
+    end
+    memoize :sales_tax
+  end
+
+  class Calculator
+    extend Memoist
+    include Rates
+
+    attr_reader :fib_calls
+    def initialize
+      @fib_calls = 0
+    end
+
+    def fib(n)
+      @fib_calls += 1
+
+      if n == 0 || n == 1
+        n
+      else
+        fib(n - 1) + fib(n - 2)
+      end
+    end
+    memoize :fib
+
+    def add_or_subtract(i, j, add)
+      if add
+        i + j
+      else
+        i - j
+      end
+    end
+    memoize :add_or_subtract
+
+    def counter
+      @count ||= 0
+      @count += 1
+    end
+    memoize :counter
+  end
+
+  def setup
+    @person = Person.new
+    @calculator = Calculator.new
+  end
+
+  def test_memoization
+    assert_equal "Josh", @person.name
+    assert_equal 1, @person.name_calls
+
+    3.times { assert_equal "Josh", @person.name }
+    assert_equal 1, @person.name_calls
+  end
+
+  def test_memoization_with_punctuation
+    assert_equal true, @person.name?
+
+    assert_nothing_raised(NameError) do
+      @person.memoize_all
+      @person.unmemoize_all
+    end
+  end
+
+  def test_memoization_flush_with_punctuation
+    assert_equal true, @person.name?
+    @person.flush_cache(:name?)
+    3.times { assert_equal true, @person.name? }
+    assert_equal 2, @person.name_query_calls
+  end
+
+  def test_memoization_with_nil_value
+    assert_equal nil, @person.age
+    assert_equal 1, @person.age_calls
+
+    3.times { assert_equal nil, @person.age }
+    assert_equal 1, @person.age_calls
+  end
+
+  def test_reloadable
+    assert_equal 1, @calculator.counter
+    assert_equal 2, @calculator.counter(:reload)
+    assert_equal 2, @calculator.counter
+    assert_equal 3, @calculator.counter(true)
+    assert_equal 3, @calculator.counter
+  end
+
+  def test_flush_cache
+    assert_equal 1, @calculator.counter
+
+    assert @calculator.instance_variable_get(:@_memoized_counter).any?
+    @calculator.flush_cache(:counter)
+    assert @calculator.instance_variable_get(:@_memoized_counter).empty?
+
+    assert_equal 2, @calculator.counter
+  end
+
+  def test_unmemoize_all
+    assert_equal 1, @calculator.counter
+
+    assert @calculator.instance_variable_get(:@_memoized_counter).any?
+    @calculator.unmemoize_all
+    assert @calculator.instance_variable_get(:@_memoized_counter).empty?
+
+    assert_equal 2, @calculator.counter
+  end
+
+  def test_memoize_all
+    @calculator.memoize_all
+    assert @calculator.instance_variable_defined?(:@_memoized_counter)
+  end
+
+  def test_memoization_cache_is_different_for_each_instance
+    assert_equal 1, @calculator.counter
+    assert_equal 2, @calculator.counter(:reload)
+    assert_equal 1, Calculator.new.counter
+  end
+
+  def test_memoized_is_not_affected_by_freeze
+    @person.freeze
+    assert_equal "Josh", @person.name
+    assert_equal "Joshua", @person.update("Joshua")
+  end
+
+  def test_memoization_with_args
+    assert_equal 55, @calculator.fib(10)
+    assert_equal 11, @calculator.fib_calls
+  end
+
+  def test_reloadable_with_args
+    assert_equal 55, @calculator.fib(10)
+    assert_equal 11, @calculator.fib_calls
+    assert_equal 55, @calculator.fib(10, :reload)
+    assert_equal 12, @calculator.fib_calls
+    assert_equal 55, @calculator.fib(10, true)
+    assert_equal 13, @calculator.fib_calls
+  end
+
+  def test_memoization_with_boolean_arg
+    assert_equal 4, @calculator.add_or_subtract(2, 2, true)
+    assert_equal 2, @calculator.add_or_subtract(4, 2, false)
+  end
+
+  def test_object_memoization
+    [Company.new, Company.new, Company.new].each do |company|
+      company.extend Memoist
+      company.memoize :name
+
+      assert_equal "37signals", company.name
+      assert_equal 1, company.name_calls
+      assert_equal "37signals", company.name
+      assert_equal 1, company.name_calls
+    end
+  end
+
+  def test_memoized_module_methods
+    assert_equal 1.025, @calculator.sales_tax(10)
+    assert_equal 1, @calculator.sales_tax_calls
+    assert_equal 1.025, @calculator.sales_tax(10)
+    assert_equal 1, @calculator.sales_tax_calls
+    assert_equal 2.5625, @calculator.sales_tax(25)
+    assert_equal 2, @calculator.sales_tax_calls
+  end
+
+  def test_object_memoized_module_methods
+    company = Company.new
+    company.extend(Rates)
+
+    assert_equal 1.025, company.sales_tax(10)
+    assert_equal 1, company.sales_tax_calls
+    assert_equal 1.025, company.sales_tax(10)
+    assert_equal 1, company.sales_tax_calls
+    assert_equal 2.5625, company.sales_tax(25)
+    assert_equal 2, company.sales_tax_calls
+  end
+
+  def test_double_memoization
+    assert_raise(RuntimeError) { Person.memoize :name }
+    person = Person.new
+    person.extend Memoist
+    assert_raise(RuntimeError) { person.memoize :name }
+
+    company = Company.new
+    company.extend Memoist
+    company.memoize :name
+    assert_raise(RuntimeError) { company.memoize :name }
+  end
+
+  def test_protected_method_memoization
+    person = Person.new
+
+    assert_raise(NoMethodError) { person.memoize_protected_test }
+    assert_equal "protected", person.send(:memoize_protected_test)
+  end
+
+  def test_private_method_memoization
+    person = Person.new
+
+    assert_raise(NoMethodError) { person.is_developer? }
+    assert_equal "Yes", person.send(:is_developer?)
+    assert_equal 1, person.is_developer_calls
+    assert_equal "Yes", person.send(:is_developer?)
+    assert_equal 1, person.is_developer_calls
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'test/unit'
+
+$:.unshift File.expand_path(File.dirname(__FILE__)+"/../lib")

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: memoist
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Peek
+- Tarmo Tänav
+- Jeremy Kemper
+- Eugene Pimenov
+- Xavier Noria
+- Niels Ganser
+- Carl Lerche & Yehuda Katz
+- jeem
+- Jay Pignata
+- Damien Mathieu
+- José Valim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-24 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- josh@joshpeek.com
+- tarmo@itech.ee
+- jeremy@bitsweat.net
+- libc@mac.com
+- fxn@hashref.com
+- niels@herimedia.co
+- wycats@gmail.com
+- jeem@hughesorama.com
+- john.pignata@gmail.com
+- 42@dmathieu.com
+- jose.valim@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- test/memoist_test.rb
+- test/test_helper.rb
+- lib/memoist/core_ext/singleton_class.rb
+- lib/memoist.rb
+homepage: https://github.com/matthewrudy/memoist
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: memoize methods invocation
+test_files: []