memoization 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in memoization.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Burke Libbey
+
+MIT License
+
+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,29 @@
+# Memoization
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'memoization'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memoization
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/memoization.rb

@@ -0,0 +1,108 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/deprecation'
+
+module Memoization
+  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_chain :freeze, :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 = Memoization.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 = Memoization.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 = Memoization.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/memoization/version.rb

@@ -0,0 +1,3 @@
+module Memoization
+  VERSION = "0.0.1"
+end

data/memoization.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/memoization/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Burke Libbey"]
+  gem.email         = ["burke@burkelibbey.org"]
+  gem.description   = %q{Forward-port of ActiveSupport::Memoizable for 3.2 and beyond.}
+  gem.summary       = %q{Forward-port of ActiveSupport::Memoizable for 3.2 and beyond. Because it's actually useful.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "memoization"
+  gem.require_paths = ["lib"]
+  gem.version       = Memoization::VERSION
+end

data/test/abstract_unit.rb

@@ -0,0 +1,64 @@
+ORIG_ARGV = ARGV.dup
+
+begin
+  old, $VERBOSE = $VERBOSE, nil
+  # require File.expand_path('../../../load_paths', __FILE__)
+ensure
+  $VERBOSE = old
+end
+
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
+
+require 'active_support/core_ext/kernel/reporting'
+
+require 'active_support/core_ext/string/encoding'
+if "ruby".encoding_aware?
+  # These are the normal settings that will be set up by Railties
+  # TODO: Have these tests support other combinations of these values
+  silence_warnings do
+    Encoding.default_internal = "UTF-8"
+    Encoding.default_external = "UTF-8"
+  end
+end
+
+require 'test/unit'
+# require 'empty_bool'
+
+silence_warnings { require 'mocha' }
+
+ENV['NO_RELOAD'] = '1'
+require 'active_support'
+
+# Include shims until we get off 1.8.6
+require 'active_support/ruby/shim' if RUBY_VERSION < '1.8.7'
+
+def uses_memcached(test_name)
+  require 'memcache'
+  begin
+    MemCache.new('localhost:11211').stats
+    yield
+  rescue MemCache::MemCacheError
+    $stderr.puts "Skipping #{test_name} tests. Start memcached and try again."
+  end
+end
+
+def with_kcode(code)
+  if RUBY_VERSION < '1.9'
+    begin
+      old_kcode, $KCODE = $KCODE, code
+      yield
+    ensure
+      $KCODE = old_kcode
+    end
+  else
+    yield
+  end
+end
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+if RUBY_VERSION < '1.9'
+  $KCODE = 'UTF8'
+end

data/test/memoization_test.rb

@@ -0,0 +1,279 @@
+require './lib/memoization'
+require './test/abstract_unit'
+
+class MemoizationTest < ActiveSupport::TestCase
+  class Person
+    extend Memoization
+
+    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 Memoization
+
+    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 Memoization
+    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 Memoization
+      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 Memoization
+    assert_raise(RuntimeError) { person.memoize :name }
+
+    company = Company.new
+    company.extend Memoization
+    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

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: memoization
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-30 00:00:00.000000000 Z
+dependencies: []
+description: Forward-port of ActiveSupport::Memoizable for 3.2 and beyond.
+email:
+- burke@burkelibbey.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/memoization.rb
+- lib/memoization/version.rb
+- memoization.gemspec
+- test/abstract_unit.rb
+- test/memoization_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+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.11
+signing_key: 
+specification_version: 3
+summary: Forward-port of ActiveSupport::Memoizable for 3.2 and beyond. Because it's
+  actually useful.
+test_files:
+- test/abstract_unit.rb
+- test/memoization_test.rb