memoizable 0.1.0 → 0.2.0

data/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+Contributing
+------------
+
+* If you want your code merged into the mainline, please discuss the proposed changes with me before doing any work on it. This library is still in early development, and the direction it is going may not always be clear. Some features may not be appropriate yet, may need to be deferred until later when the foundation for them is laid, or may be more applicable in a plugin.
+* Fork the project.
+* Make your feature addition or bug fix.
+  * Follow this [style guide](https://github.com/dkubb/styleguide).
+* Add specs for it. This is important so I don't break it in a future version unintentionally. Tests must cover all branches within the code, and code must be fully covered.
+* Commit, do not mess with Rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Run "rake ci". This must pass and not show any regressions in the metrics for the code to be merged.
+* Send me a pull request. Bonus points for topic branches.

data/{LICENSE → LICENSE.md}

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Enrique Comba Riepenhausen
+Copyright (c) 2013 Dan Kubb, Erik Michaels-Ober
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,23 @@
+# memoizable
+
+Memoize method return values
+
+[![Gem Version](https://badge.fury.io/rb/memoizable.png)][gem]
+[![Build Status](https://secure.travis-ci.org/dkubb/memoizable.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/dkubb/memoizable.png)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/dkubb/memoizable.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/dkubb/memoizable/badge.png?branch=master)][coveralls]
+
+[gem]: https://rubygems.org/gems/memoizable
+[travis]: https://travis-ci.org/dkubb/memoizable
+[gemnasium]: https://gemnasium.com/dkubb/memoizable
+[codeclimate]: https://codeclimate.com/github/dkubb/memoizable
+[coveralls]: https://coveralls.io/r/dkubb/memoizable
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## Copyright
+
+Copyright © 2013 Dan Kubb, Erik Michaels-Ober. See LICENSE for details.

data/Rakefile

@@ -1,48 +1,8 @@
-require 'rubygems'
-require 'rake'
+require 'bundler'
+require 'rspec/core/rake_task'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "memoizable"
-    gem.summary = %Q{Memoize method calls}
-    gem.description = %Q{Memoizes calls to method to boost the performance of recursive calls}
-    gem.email = "ecomba@nexwerk.com"
-    gem.homepage = "http://github.com/ecomba/memoizable"
-    gem.authors = ["Enrique Comba Riepenhausen"]
-    gem.add_development_dependency "rspec"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
 
+task :test    => :spec
 task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "memoizable #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/lib/memoizable/instance_methods.rb

@@ -0,0 +1,47 @@
+module Memoizable
+
+  # Methods mixed in to memoizable instances
+  module InstanceMethods
+
+    # Freeze the object
+    #
+    # @example
+    #   object.freeze  # object is now frozen
+    #
+    # @return [Object]
+    #
+    # @api public
+    def freeze
+      memoized_method_cache  # initialize method cache
+      super
+    end
+
+    # Sets a memoized value for a method
+    #
+    # @example
+    #   object.memoize(hash: 12345)
+    #
+    # @param [Hash{Symbol => Object}] data
+    #   the data to memoize
+    #
+    # @return [self]
+    #
+    # @api public
+    def memoize(data)
+      memoized_method_cache.set(data)
+      self
+    end
+
+  private
+
+    # The memoized method results
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def memoized_method_cache
+      @_memoized_method_cache ||= Memory.new(self.class.freezer)
+    end
+
+  end # InstanceMethods
+end # Memoizable

data/lib/memoizable/memory.rb

@@ -0,0 +1,88 @@
+module Memoizable
+
+  # Storage for memoized methods
+  class Memory
+
+    def initialize(freezer)
+      @memory  = ThreadSafe::Cache.new
+      @freezer = freezer
+    end
+
+    # Get the value from memory
+    #
+    # @param [Symbol] name
+    #
+    # @return [Object]
+    #
+    # @api public
+    def [](name)
+      @memory.fetch(name) do
+        raise NameError, "No method #{name.inspect} was memoized"
+      end
+    end
+
+    # Store the value in memory
+    #
+    # @param [Symbol] name
+    # @param [Object] value
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def []=(name, value)
+      if @memory.key?(name)
+        raise ArgumentError, "The method #{name} is already memoized"
+      end
+      @memory[name] = freeze_value(value)
+    end
+
+    # Fetch the value from memory, or store it if it does not exist
+    #
+    # @param [Symbol] name
+    #
+    # @yieldreturn [Object]
+    #   the value to memoize
+    #
+    # @api public
+    def fetch(name)
+      @memory.fetch(name) { self[name] = yield }
+    end
+
+    # Set the memory
+    #
+    # @param [Hash]
+    #
+    # @return [Memory]
+    #
+    # @api public
+    def set(data)
+      data.each { |name, value| self[name] = value }
+      self
+    end
+
+    # Test if the name has a value in memory
+    #
+    # @param [Symbol] name
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def key?(name)
+      @memory.key?(name)
+    end
+
+  private
+
+    # Freeze the value
+    #
+    # @param [Object] value
+    #
+    # @return [Object]
+    #
+    # @api private
+    def freeze_value(value)
+      @freezer.call(value)
+    end
+
+  end # Memory
+end # Memoizable

data/lib/memoizable/method_builder.rb

@@ -0,0 +1,133 @@
+module Memoizable
+
+  # Build the memoized method
+  class MethodBuilder
+
+    # Raised when the method arity is invalid
+    class InvalidArityError < ArgumentError
+
+      # Initialize an invalid arity exception
+      #
+      # @param [Module] descendant
+      # @param [Symbol] method
+      # @param [Integer] arity
+      #
+      # @api private
+      def initialize(descendant, method, arity)
+        super("Cannot memoize #{descendant}##{method}, it's arity is #{arity}")
+      end
+
+    end # InvalidArityError
+
+    # The original method before memoization
+    #
+    # @return [UnboundMethod]
+    #
+    # @api public
+    attr_reader :original_method
+
+    # Initialize an object to build a memoized method
+    #
+    # @param [Module] descendant
+    # @param [Symbol] method_name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(descendant, method_name)
+      @descendant          = descendant
+      @method_name         = method_name
+      @original_visibility = visibility
+      @original_method     = @descendant.instance_method(@method_name)
+      assert_zero_arity
+    end
+
+    # Build a new memoized method
+    #
+    # @example
+    #   method_builder.call  # => creates new method
+    #
+    # @return [MethodBuilder]
+    #
+    # @api public
+    def call
+      remove_original_method
+      create_memoized_method
+      set_method_visibility
+      self
+    end
+
+  private
+
+    # Assert the method arity is zero
+    #
+    # @return [undefined]
+    #
+    # @raise [InvalidArityError]
+    #
+    # @api private
+    def assert_zero_arity
+      arity = @original_method.arity
+      if arity.nonzero?
+        raise InvalidArityError.new(@descendant, @method_name, arity)
+      end
+    end
+
+    # Remove the original method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def remove_original_method
+      descendant_exec(@method_name) { |name| undef_method(name) }
+    end
+
+    # Create a new memoized method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def create_memoized_method
+      descendant_exec(@method_name, @original_method) do |name, method|
+        define_method(name) do ||
+          memoized_method_cache.fetch(name, &method.bind(self))
+        end
+      end
+    end
+
+    # Set the memoized method visibility to match the original method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def set_method_visibility
+      descendant_exec(@method_name, @original_visibility) do |name, visibility|
+        send(visibility, name)
+      end
+    end
+
+    # Get the visibility of the original method
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def visibility
+      if    @descendant.private_method_defined?(@method_name)   then :private
+      elsif @descendant.protected_method_defined?(@method_name) then :protected
+      else                                                           :public
+      end
+    end
+
+    # Helper method to execute code within the descendant scope
+    #
+    # @param [Array] args
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def descendant_exec(*args, &block)
+      @descendant.instance_exec(*args, &block)
+    end
+
+  end # MethodBuilder
+end # Memoizable

data/lib/memoizable/module_methods.rb

@@ -0,0 +1,110 @@
+module Memoizable
+
+  # Methods mixed in to memoizable singleton classes
+  module ModuleMethods
+
+    # Return default deep freezer
+    #
+    # @return [#call]
+    #
+    # @api private
+    #
+    def freezer
+      Freezer
+    end
+
+    # Memoize a list of methods
+    #
+    # @example
+    #   memoize :hash
+    #
+    # @param [Array<Symbol>] methods
+    #   a list of methods to memoize
+    #
+    # @return [self]
+    #
+    # @api public
+    def memoize(*methods)
+      methods.each(&method(:memoize_method))
+      self
+    end
+
+    # Test if an instance method is memoized
+    #
+    # @example
+    #   class Foo
+    #     include Memoizable
+    #
+    #     def bar
+    #     end
+    #     memoize :bar
+    #   end
+    #
+    #   Foo.memoized?(:bar)  # true
+    #   Foo.memoized?(:baz)  # false
+    #
+    # @param [Symbol] name
+    #
+    # @return [Boolean]
+    #   true if method is memoized, false if not
+    #
+    # @api private
+    def memoized?(name)
+      memoized_methods.key?(name)
+    end
+
+    # Return unmemoized instance method
+    #
+    # @example
+    #
+    #   class Foo
+    #     include Memoizable
+    #
+    #     def bar
+    #     end
+    #     memoize :bar
+    #   end
+    #
+    #   Foo.unmemoized_instance_method(:bar)
+    #
+    # @param [Symbol] name
+    #
+    # @return [UnboundMethod]
+    #   the memoized method
+    #
+    # @raise [NameError]
+    #   raised if the method is unknown
+    #
+    # @api public
+    def unmemoized_instance_method(name)
+      memoized_methods[name].original_method
+    end
+
+  private
+
+    # Memoize the named method
+    #
+    # @param [Symbol] method_name
+    #   a method name to memoize
+    # @param [#call] freezer
+    #   a freezer for memoized values
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def memoize_method(method_name)
+      memoized_methods[method_name] = MethodBuilder.new(self, method_name).call
+    end
+
+    # Return method builder registry
+    #
+    # @return [Hash<Symbol, MethodBuilder>]
+    #
+    # @api private
+    #
+    def memoized_methods
+      @_memoized_methods ||= Memory.new(freezer)
+    end
+
+  end # ModuleMethods
+end # Memoizable

data/lib/memoizable/version.rb

@@ -0,0 +1,6 @@
+module Memoizable
+
+  # Gem version
+  VERSION = '0.2.0'.freeze
+
+end # Memoizable

data/lib/memoizable.rb

@@ -1,17 +1,30 @@
+require 'thread_safe'
+
+require 'memoizable/instance_methods'
+require 'memoizable/method_builder'
+require 'memoizable/module_methods'
+require 'memoizable/memory'
+require 'memoizable/version'
+
+# Allow methods to be memoized
 module Memoizable
-  CACHE = Hash.new
-  module ClassMethods
-    def memoize(name)
-      original = "__original__#{name}"
-      alias_method original, name
-      define_method(name) do |*args|
-        CACHE[self.to_s.unpack("a*")<<name.to_s.unpack("a*")<<args] ||= 
-          send(original, *args)
-      end
+
+  # Default freezer
+  Freezer = lambda { |object| object.freeze }.freeze
+
+  # Hook called when module is included
+  #
+  # @param [Module] descendant
+  #   the module or class including Memoizable
+  #
+  # @return [self]
+  #
+  # @api private
+  def self.included(descendant)
+    descendant.module_eval do
+      extend ModuleMethods
+      include InstanceMethods
     end
   end
-  
-  def self.included(receiver)
-    receiver.extend ClassMethods
-  end
-end
+
+end # Memoizable

data/memoizable.gemspec

@@ -1,56 +1,23 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/memoizable/version', __FILE__)
 
-Gem::Specification.new do |s|
-  s.name = %q{memoizable}
-  s.version = "0.1.0"
+Gem::Specification.new do |gem|
+  gem.name        = 'memoizable'
+  gem.version     = Memoizable::VERSION.dup
+  gem.authors     = ['Dan Kubb']
+  gem.email       = 'dan.kubb@gmail.com'
+  gem.description = 'Memoize method return values'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/dkubb/memoizable'
+  gem.license     = 'MIT'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Enrique Comba Riepenhausen"]
-  s.date = %q{2009-12-21}
-  s.description = %q{Memoizes calls to method to boost the performance of recursive calls}
-  s.email = %q{ecomba@nexwerk.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION.yml",
-     "lib/memoizable.rb",
-     "memoizable.gemspec",
-     "spec/fibonacci_sample_spec.rb",
-     "spec/memoizable_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/ecomba/memoizable}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Memoize method calls}
-  s.test_files = [
-    "spec/fibonacci_sample_spec.rb",
-     "spec/memoizable_spec.rb",
-     "spec/spec_helper.rb"
-  ]
+  gem.require_paths    = %w[lib]
+  gem.files            = %w[CONTRIBUTING.md LICENSE.md README.md Rakefile memoizable.gemspec]
+  gem.files           += Dir.glob('lib/**/*.rb')
+  gem.files           += Dir.glob('spec/**/*')
+  gem.test_files       = Dir.glob('spec/**/*')
+  gem.extra_rdoc_files = %w[LICENSE.md README.md CONTRIBUTING.md]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  gem.add_runtime_dependency('thread_safe', '~> 0.1.3')
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 0"])
-  end
+  gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end
-

data/spec/fixtures/classes.rb

@@ -0,0 +1,32 @@
+module MemoizableSpecs
+  class Object
+    include Memoizable
+
+    def required_arguments(foo)
+    end
+
+    def optional_arguments(foo = nil)
+    end
+
+    def test
+      'test'
+    end
+
+    def public_method
+      caller
+    end
+
+  protected
+
+    def protected_method
+      caller
+    end
+
+  private
+
+    def private_method
+      caller
+    end
+
+  end # class Object
+end # module MemoizableSpecs

data/spec/memoize_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+shared_examples_for 'memoizes method' do
+  it 'memoizes the instance method' do
+    subject
+    instance = object.new
+    expect(instance.send(method)).to be(instance.send(method))
+  end
+
+  it 'creates a method that returns a same value' do
+    subject
+    instance = object.new
+    expect(instance.send(method)).to be(instance.send(method))
+  end
+
+  it 'creates a method with an arity of 0' do
+    subject
+    expect(object.new.method(method).arity).to be_zero
+  end
+
+  context 'when the initializer calls the memoized method' do
+    before do
+      method = self.method
+      object.send(:define_method, :initialize) { send(method) }
+    end
+
+    it 'allows the memoized method to be called within the initializer' do
+      subject
+      expect { object.new }.to_not raise_error
+    end
+  end
+end
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end
+
+describe Memoizable::ModuleMethods, '#memoize' do
+  subject { object.memoize(method) }
+
+  let(:object) do
+    stub_const 'TestClass', Class.new(MemoizableSpecs::Object) {
+      def some_state
+        Object.new
+      end
+    }
+  end
+
+  context 'on method with required arguments' do
+    let(:method) { :required_arguments }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(
+        Memoizable::MethodBuilder::InvalidArityError,
+        "Cannot memoize TestClass#required_arguments, it's arity is 1"
+      )
+    end
+  end
+
+  context 'on method with optional arguments' do
+    let(:method) { :optional_arguments }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(
+        Memoizable::MethodBuilder::InvalidArityError,
+        "Cannot memoize TestClass#optional_arguments, it's arity is -1"
+      )
+    end
+  end
+
+  context 'memoized method that returns generated values' do
+    let(:method) { :some_state }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      expect(object.new.send(method)).to be_frozen
+    end
+  end
+
+  context 'public method' do
+    let(:method) { :public_method }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a public method' do
+      should be_public_method_defined(method)
+    end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      expect(object.new.send(method)).to be_frozen
+    end
+  end
+
+  context 'protected method' do
+    let(:method) { :protected_method }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a protected method' do
+      should be_protected_method_defined(method)
+    end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      expect(object.new.send(method)).to be_frozen
+    end
+  end
+
+  context 'private method' do
+    let(:method) { :private_method }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a private method' do
+      should be_private_method_defined(method)
+    end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      expect(object.new.send(method)).to be_frozen
+    end
+  end
+end

data/spec/memoized_predicate_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Memoizable::ModuleMethods, '#memoized?' do
+  let(:object) do
+    Class.new do
+      include Memoizable
+      def foo
+      end
+      memoize :foo
+    end
+  end
+
+  subject { object.memoized?(name) }
+
+  context 'with memoized method' do
+    let(:name) { :foo }
+
+    it { should be(true) }
+  end
+
+  context 'with non memoized method' do
+    let(:name) { :bar }
+
+    it { should be(false) }
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,25 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  command_name 'spec'
+
+  add_filter 'config'
+  add_filter 'spec'
+  add_filter 'vendor'
+
+  minimum_coverage 89.8
+end
+
 require 'memoizable'
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
 
-Spec::Runner.configure do |config|
-  
+RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
 end

metadata

@@ -1,77 +1,106 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: memoizable
-version: !ruby/object:Gem::Version 
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
-- Enrique Comba Riepenhausen
+authors:
+- Dan Kubb
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-12-21 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-description: Memoizes calls to method to boost the performance of recursive calls
-email: ecomba@nexwerk.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+description: Memoize method return values
+email: dan.kubb@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
-files: 
-- .document
-- .gitignore
-- LICENSE
-- README.rdoc
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+- CONTRIBUTING.md
+files:
+- CONTRIBUTING.md
+- LICENSE.md
+- README.md
 - Rakefile
-- VERSION.yml
-- lib/memoizable.rb
 - memoizable.gemspec
-- spec/fibonacci_sample_spec.rb
-- spec/memoizable_spec.rb
+- lib/memoizable/instance_methods.rb
+- lib/memoizable/memory.rb
+- lib/memoizable/method_builder.rb
+- lib/memoizable/module_methods.rb
+- lib/memoizable/version.rb
+- lib/memoizable.rb
+- spec/fixtures/classes.rb
+- spec/memoize_spec.rb
+- spec/memoized_predicate_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
-homepage: http://github.com/ecomba/memoizable
-licenses: []
-
+homepage: https://github.com/dkubb/memoizable
+licenses:
+- MIT
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+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.3.5
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Memoize method calls
-test_files: 
-- spec/fibonacci_sample_spec.rb
-- spec/memoizable_spec.rb
+summary: Memoize method return values
+test_files:
+- spec/fixtures/classes.rb
+- spec/memoize_spec.rb
+- spec/memoized_predicate_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,5 +0,0 @@
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg

data/README.rdoc

@@ -1,64 +0,0 @@
-= Memoizable
-
-== Introduction
-
-When doing recursion sometimes we are faced with the problem of performance
-versus the beauty of the code we are implementing, specially when, due to 
-the recursive nature of the method we have written we seem to be computing
-over and over the same.
-
-The concept of memoization comes from the idea of capturing a certain
-method call and saving it's result to an internal cache, so that, if this
-particular method (with the same parameters) is called, it will return the
-previously computed result.
-
-I was inspired in writing this little module after reading an article
-on James Edward Grey II'2 blog (http://blog.grayproductions.net/articles/caching_and_memoization)
-
-== Example
-
-Imagine we want to compute the Fibonacci sequence:
-
-  class Fibonacci
-    def fib(num)
-      return num if num < 2
-      fib(num -1) + fib(num - 2)
-    end
-  end
-
-As you can see immediately is that this will result in poor performance the
-higher the number in the sequence we request as the algorithm will compute
-over and over same method calls.
-
-You could add some cache functionallity into your method and class, although
-you would add new behaviour that the class and method shouldn't really have
-as they should be dealing exclusively with the logic they are supposed to 
-execute; in this case the computation of the Fibonacci sequence.
-
-Here is how the class would look like when we Memonize it:
-
-  class Fibonacci
-    include Memoizable
-
-    def fib(num)
-      return num if num < 2
-      fib(num -1) + fib(num - 2)
-    end
-  
-    memoize :fib
-  end
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2009 Enrique Comba Riepenhausen. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +0,0 @@
---- 
-:major: 0
-:minor: 1
-:patch: 0

data/spec/fibonacci_sample_spec.rb

@@ -1,26 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require 'benchmark'
-
-describe "Fibonacci" do
-  class Fibonacci
-    def fib(number)
-      return number if number < 2
-      fib(number -1) + fib(number - 2)
-    end
-  end
-  
-  context "context" do
-    it "should run faster" do
-      fibo = Fibonacci.new
-      bm = Benchmark.measure { fibo.fib(30) }
-      class Fibonacci; include Memoizable; memoize :fib; end;
-      fibo2 = Fibonacci.new
-      bm2 = Benchmark.measure { fibo2.fib(30) }
-      
-      # This test is flakey, I know... How to test the real speed? 
-      bm.to_a[5].should > bm2.to_a[5]
-      bm2.to_a[5].should < 0.01
-    end
-  end
-end

data/spec/memoizable_spec.rb

@@ -1,61 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Memoizable" do
-  before(:all) do
-    class Foo; def a; return "blaah" end; end;
-  end
-  
-  context "Module structure" do
-    it "should have a ClassMethods module" do
-      Memoizable::ClassMethods.class.should be(Module)
-    end
-    
-    it "should contain a memonize method" do
-      Memoizable::ClassMethods.public_method_defined?(:memoize).should be_true
-    end
-    
-    context ": Cache" do
-      it "should be present" do
-        Memoizable::CACHE.should_not be_nil
-      end
-      
-      it "should be a hash" do
-        Memoizable::CACHE.should be_instance_of(Hash)
-      end
-    end
-  end
-  
-  context "Class Inclusion" do
-    it "should extend a given class with the memoize method" do
-      class Foo; include Memoizable; end;
-      Foo.respond_to?(:memoize).should be_true
-    end
-    
-    it "should alias the original method" do
-      Foo.memoize :a
-      foo = Foo.new
-      foo.respond_to?("__original__a").should be_true
-    end
-    
-    it "should modify the method" do
-      method_a = Foo.instance_method(:a)
-      Foo.memoize :a
-      method_a.should_not == Foo.instance_method(:a)
-    end
-  end
-  
-  context "Method calls" do  
-    it "should return the same values" do
-      foo = Foo.new
-      first_return = foo.a
-      Foo.memoize :a
-      first_return.should == foo.a
-    end
-    
-    it "should put the method call into the cache" do
-      Foo.memoize :a
-      foo = Foo.new
-      Memoizable::CACHE.size.should > 0
-    end
-  end
-end