forget-me-not 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWI4NDI2YmQ5NTc1NjMyOGM5Y2UyZjk1NmFhYTcwODQyNWYzMzQ0Mw==
+  data.tar.gz: !binary |-
+    NTFmOTRhYTg3NjNjZjAwM2JmNzIyYmRkNmI3YzM5NjJlNWY1ZjI4NA==
+SHA512:
+  metadata.gz: !binary |-
+    MWJiNjdmODBmOTIwZGEzOThjNThjZDU2YjJlODk0M2RhN2Q2MjJkNjU5MjVj
+    YTZmYmU2ZDViYjg4MTc1Yzc0YjQ4M2ZmMjBjOTkxYzViZTAwZmQ4NzUzZTgw
+    OWQzMzRkODE0ZWMwN2VlNjIwNjk4NGJlYzAxMDY4NjE4ZjhhNjk=
+  data.tar.gz: !binary |-
+    M2MwOWE5MjFlN2U4ODRlN2VjMDg0MWQzYWZlODk0YmE2YmY5MmU5MjlhNmJj
+    MmJhNzk1N2RiMzM4YjMxNzY3MTlhYWI3MTYyM2FhYjViZTA4MTU5MDI4OWU0
+    ZGRiNWIxOTJkZWI5MmQxY2FjYzU3MzUwMTE3NDg4OGViM2NlYzA=

data/CHANGELOG.md

@@ -0,0 +1 @@
+## 0.0.1.0 - Pre Release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andy Davis
+
+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,151 @@
+# ForgetMeNot
+[![Build Status](https://secure.travis-ci.org/KoanHealth/forget-me-not.png?branch=master&.png)](http://travis-ci.org/KoanHealth/forget-me-not)
+[![Code Climate](https://codeclimate.com/github/KoanHealth/forget-me-not.png)](https://codeclimate.com/github/KoanHealth/forget-me-not)
+[![Coverage Status](https://coveralls.io/repos/KoanHealth/forget-me-not/badge.png?branch=master)](https://coveralls.io/r/KoanHealth/forget-me-not)
+
+Provides memoization and caching mixins
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'forget-me-not'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install forget-me-not
+
+## Background 
+
+Although the code is quite similar between the two mixins they solve very different problems.
+
+### Memoization
+Memoization is intended to allow a single object instance to remember the result of a method call.  If you have
+ever written something like:
+
+    def full_name
+      @full_name ||= "#{last_name}, #{first_name}"
+	end
+
+then you have done memoization.  The result is calculated the first time full_name is called.  Subsequent calls return
+the same value and do not incur the overhead of calculating the result.  Trivial in this case, but the work could be quite
+substantial.
+
+Memoization is scoped to an object.  If you ask two different User instances what the memoized full_name is, then
+you will get a different answer from each of them.
+
+### Caching
+
+Caching is similar, but broader in scope.  For us, the initial use case was a dashboard in one of our products that
+aggregated the numerical values of several hundred thousand medical claims.  Rather than performing this query every
+time we generated the dashboard, we cached the results of the query allowing us to display the web page in a snap.
+
+Our caching mixin is intended to be used with a cache like memcached that is available across your servers.  It includes
+convenience methods to allow cache warming.
+
+Caching is system wide.  If the same cached method for two separate instances is called, the actual method should only be
+called once.
+
+## Usage
+
+### Memoizable Mixin
+    class MyClass
+      include ForgetMeNot::Memoizable
+
+      def some_method
+        'result'
+      end
+
+      def some_other_method(with_an_arg)
+      	"result2-#{with_an_arg}"
+      end
+
+      memoize :some_method, :some_other_method
+    end
+
+Calls to both some_method and some_other_method are memoized.  Notice that some_other_method takes an argument, differing
+argument values will result in different results being memoized.
+
+By default, the memoization code stores results in a simple Hash based cache.  If you have other requirements, perhaps
+a thread-safe storage, then set the ForgetMeNot::Memoization.storage_builder property to a proc that will create a new
+instance of whatever storage you desire.
+
+### Cacheable Mixin
+The basics are unsurprising:
+
+    class MyClass
+      include ForgetMeNot::Cacheable
+
+      def some_method
+        'result'
+      end
+
+      cache :some_method
+    end
+
+Like memoization, arguments are fully supported and will result in distinct storage to the cache.
+
+To control warming the cache, implement the cache_warm method
+
+    class MyClass
+      include ForgetMeNot::Cacheable
+
+      def some_method
+        'result'
+      end
+
+      cache :some_method
+
+      # Warm the cache for this object
+      def self.cache_warm(*args)
+      	instance = new
+      	instance.some_method
+      end
+    end
+
+Then somewhere (a rake task perhaps), call Cacheable.warm.  Whatever args you pass to warm are passed to every class that
+included Cacheable.
+
+In addition to the arguments passed to the cached method, Cacheable allows instance properties to also be used as cache
+key members.
+
+    class MyClass
+      include ForgetMeNot::Cacheable
+
+      attr_reader :important_property
+      def initialize(important_property)
+      	@important_property = important_property
+      end
+
+      def some_method
+        'result'
+      end
+
+      cache :some_method, :include => :important_property
+    end
+
+By default, the cache will attempt to use the Rails cache.  If that isn't found, but ActiveSupport is available, a new
+instance of MemoryStore will be used.  Failing that, cache will raise an error.  This is intended to provide a reasonably
+sane default, but really, set the ForgetMeNot::Cacheable.cache.  Cacheable expects a cache shaped like an
+ActiveSupport::Cacheable::Store
+
+
+## Origins
+This is an extension of the ideas and approach found here:
+https://github.com/sferik/twitter/blob/master/lib/twitter/memoizable.rb.  You guys rock.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write tests for your code.
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+## Copyright
+(c) 2013 Koan Health. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+Bundler.setup
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/lib/forget-me-not/cacheable.rb

@@ -0,0 +1,140 @@
+module ForgetMeNot
+# Allows the cross-system caching of lengthy function calls
+  module Cacheable
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        Cacheable.cachers << base
+      end
+    end
+
+    module ClassMethods
+      def cache_results(*methods)
+        options = methods.last.is_a?(Hash) ? methods.pop : {}
+        methods.each { |m| cache_method(m, options) }
+      end
+
+      def cache_warm(*args)
+        # Classes can call the methods necessary to warm the cache
+      end
+
+      private
+      def cache_method(method_name, options)
+        method = instance_method(method_name)
+        visibility = method_visibility(method_name)
+        define_cache_method(method, options)
+        send(visibility, method_name)
+      end
+
+      def define_cache_method(method, options)
+        method_name = method.name.to_sym
+        key_prefix = "/cached_method_result/#{self.name}"
+        instance_key = get_instance_key_proc(options[:include]) if options.has_key?(:include)
+
+        undef_method(method_name)
+        define_method(method_name) do |*args|
+          cache_key = [
+            key_prefix,
+            (instance_key && instance_key.call(self)),
+            method_name,
+            args.hash
+          ].compact.join '/'
+
+          puts "key: #{cache_key}" if (defined?(Rails) && Rails.env.test?)
+
+          Cacheable.cache_fetch(cache_key) do
+            method.bind(self).call(*args)
+          end
+        end
+      end
+
+      def get_instance_key_proc(instance_key_methods)
+        instance_keys = Array.new(instance_key_methods).flatten
+        Proc.new do |instance|
+          instance_keys.map { |key| instance.send(key) }.hash
+        end
+      end
+
+      def method_visibility(method)
+        if private_method_defined?(method)
+          :private
+        elsif protected_method_defined?(method)
+          :protected
+        else
+          :public
+        end
+      end
+    end
+
+    def self.cache_fetch(key, &block)
+      cache.fetch(key, cache_options, &block)
+    end
+
+    def self.cache
+      @cache ||= default_cache
+    end
+
+    def self.cache=(value)
+      @cache = value
+    end
+
+    def self.cache_options
+      @cache_options ||= {expires_in: 12 * 60 * 60}
+      @cache_options.merge(Cacheable.cache_options_threaded)
+    end
+
+    def self.cache_options_threaded
+      Thread.current['cacheable-cache-options'] || {}
+    end
+
+    def self.cache_options_threaded=(options)
+      Thread.current['cacheable-cache-options'] = options
+    end
+
+    def self.cachers
+      @cachers ||= Set.new
+    end
+
+    def self.cachers_and_descendants
+      all_cachers = Set.new
+      Cacheable.cachers.each do |c|
+        all_cachers << c
+        all_cachers += c.descendants if c.is_a? Class
+      end
+      all_cachers
+    end
+
+    def self.warm(*args)
+      begin
+        Cacheable.cache_options_threaded = {force: true}
+        Cacheable.cachers_and_descendants.each { |cacher| cacher.cache_warm(*args) }
+      ensure
+        Cacheable.cache_options_threaded = nil
+      end
+    end
+
+    private
+    def self.default_cache
+      rails_cache ||
+      active_support_cache ||
+      raise(
+      <<-ERR_TEXT
+        When using Cacheable in a project that does not have a Rails or ActiveSupport Cache,
+        you must explicitly set the cache to an object shaped like ActiveSupport::Cache::Store
+        ERR_TEXT
+        )
+    end
+
+    def self.rails_cache
+      defined?(Rails) && Rails.cache
+    end
+
+    def self.active_support_cache
+      defined?(ActiveSupport) &&
+        defined?(ActiveSupport::Cache) &&
+        defined?(ActiveSupport::Cache::MemoryStore) &&
+        ActiveSupport::Cache::MemoryStore.new
+    end
+
+  end
+end

data/lib/forget-me-not/hash_cache.rb

@@ -0,0 +1,12 @@
+module ForgetMeNot
+  class HashCache
+    def fetch(key)
+      data[key] ||= yield
+    end
+
+    private
+    def data
+      @data ||= {}
+    end
+  end
+end

data/lib/forget-me-not/memoizable.rb

@@ -0,0 +1,74 @@
+module ForgetMeNot
+# Allows the memoization of method calls
+  module Memoizable
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def memoize(*methods)
+        options = methods.last.is_a?(Hash) ? methods.pop : {}
+        methods.each { |m| memoize_method(m, options) }
+      end
+
+      private
+      def memoize_method(method_name, options)
+        method = instance_method(method_name)
+        visibility = method_visibility(method_name)
+        define_memoized_method(method, options)
+        send(visibility, method_name)
+      end
+
+      def define_memoized_method(method, options)
+        method_name = method.name.to_sym
+        key_prefix = "/memoized_method_result/#{self.name}"
+
+        undef_method(method_name)
+        define_method(method_name) do |*args|
+          memoize_key = [
+            key_prefix,
+            method_name,
+            args.hash
+          ].compact.join '/'
+
+          puts "key: #{memoize_key}" if (defined?(Rails) && Rails.env.test?)
+
+          fetch_from_storage(memoize_key) do
+            method.bind(self).call(*args)
+          end
+        end
+      end
+
+      def method_visibility(method)
+        if private_method_defined?(method)
+          :private
+        elsif protected_method_defined?(method)
+          :protected
+        else
+          :public
+        end
+      end
+    end
+
+    def fetch_from_storage(key, &block)
+      storage.fetch(key, &block)
+    end
+
+    def storage
+      @storage ||= Memoizable.storage_builder.call
+    end
+
+    class << self
+      def storage_builder
+        @storage_builder ||= Proc.new {HashCache.new}
+      end
+
+      def storage_builder=(builder)
+        @storage_builder = builder
+      end
+    end
+
+  end
+end

data/lib/forget-me-not/version.rb

@@ -0,0 +1,3 @@
+module ForgetMeNot
+  VERSION = '0.1.0'
+end

data/lib/forget-me-not.rb

@@ -0,0 +1,5 @@
+require 'forget-me-not/version'
+
+require 'forget-me-not/cacheable'
+require 'forget-me-not/memoizable'
+require 'forget-me-not/hash_cache'

data/spec/cacheable_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+module ForgetMeNot
+  class TestClass
+    include Cacheable
+    include MethodCounter
+
+    def method1
+      record_call :method1
+      'method1'
+    end
+
+    def method2(arg)
+      record_call :method2
+      "method2(#{arg})"
+    end
+
+    def method3(org, month, visit_type)
+      record_call :method3
+      "method3(#{org}, #{month}, #{visit_type})"
+    end
+
+    def method4(array_arg)
+      record_call :method4
+      "method4([#{array_arg.join ','}])"
+    end
+
+    def method5(hash_arg)
+      record_call :method5
+      "method5({#{hash_arg.map { |k, v| "#{k}/#{v}" }.join '|' }})"
+    end
+
+    cache_results :method1, :method2, :method3, :method4, :method5
+  end
+
+
+  class TestClass2
+    include Cacheable
+    include MethodCounter
+
+    attr_reader :org, :month
+
+    def initialize(org, month)
+      @org = org
+      @month = month
+    end
+
+    def method1
+      record_call :method1
+      "[#{org},#{month}].method1"
+    end
+
+    cache_results :method1, include: [:org, :month]
+  end
+
+  class TestClass3 < TestClass2
+
+  end
+
+  describe Cacheable do
+    before do
+      Cacheable.cache = ActiveSupport::Cache::MemoryStore.new
+      TestClass.clear_calls
+      TestClass2.clear_calls
+    end
+
+
+    describe 'cache arity-0 calls' do
+      it 'should cache calls from the same instance' do
+        foo = TestClass.new
+        expect(foo.method1).to eq 'method1'
+        expect(foo.method1).to eq 'method1'
+
+        expect(TestClass.count(:method1)).to eq 1
+      end
+
+      it 'should cache calls from the different instances' do
+        foo = TestClass.new
+        bar = TestClass.new
+        expect(foo.method1).to eq 'method1'
+        expect(bar.method1).to eq 'method1'
+
+        expect(TestClass.count(:method1)).to eq 1
+      end
+
+      it 'cache should expire' do
+        foo = TestClass.new
+        expect(foo.method1).to eq 'method1'
+
+        Timecop.freeze(DateTime.now + 13.hours) do
+          expect(foo.method1).to eq 'method1'
+        end
+
+        expect(TestClass.count(:method1)).to eq 2
+      end
+    end
+
+    describe 'cache arity-1 calls' do
+      it 'should cache calls from the same instance, same argument' do
+        foo = TestClass.new
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+
+        expect(TestClass.count(:method2)).to eq 1
+      end
+
+      it 'should cache calls from the same instance, different arguments' do
+        foo = TestClass.new
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+
+        expect(TestClass.count(:method2)).to eq 2
+      end
+
+      it 'should distinguish calls with null and blank arguments' do
+        foo = TestClass.new
+        expect(foo.method2(nil)).to eq 'method2()'
+        expect(foo.method2(nil)).to eq 'method2()'
+        expect(foo.method2('')).to eq 'method2()'
+        expect(foo.method2('')).to eq 'method2()'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+
+        expect(TestClass.count(:method2)).to eq 3
+      end
+
+      it 'should distinguish calls with different elements in an array argument' do
+        foo = TestClass.new
+        expect(foo.method4([1, 2])).to eq 'method4([1,2])'
+        expect(foo.method4([1, 2])).to eq 'method4([1,2])'
+        expect(foo.method4([1, 3])).to eq 'method4([1,3])'
+        expect(foo.method4([1, 3])).to eq 'method4([1,3])'
+        expect(TestClass.count(:method4)).to eq 2
+      end
+
+      it 'should distinguish calls with different elements in a hash argument' do
+        foo = TestClass.new
+        expect(foo.method5(foo: 1, bar: 2)).to eq 'method5({foo/1|bar/2})'
+        expect(foo.method5(foo: 1, bar: 2)).to eq 'method5({foo/1|bar/2})'
+
+        expect(foo.method5(foo: 1, bar: 3)).to eq 'method5({foo/1|bar/3})'
+        expect(foo.method5(foo: 1, bar: 3)).to eq 'method5({foo/1|bar/3})'
+
+        expect(foo.method5(foo: 1, elvis: 2)).to eq 'method5({foo/1|elvis/2})'
+        expect(foo.method5(foo: 1, elvis: 2)).to eq 'method5({foo/1|elvis/2})'
+
+        expect(TestClass.count(:method5)).to eq 3
+      end
+
+    end
+
+    describe 'cache arity-3 calls' do
+      it 'should cache calls from the same instance, different arguments' do
+        foo = TestClass.new
+        expect(foo.method3('general', 201312, :emergency)).to eq 'method3(general, 201312, emergency)'
+        expect(foo.method3('general', 201312, :emergency)).to eq 'method3(general, 201312, emergency)'
+        expect(foo.method3('general', 201311, :emergency)).to eq 'method3(general, 201311, emergency)'
+        expect(foo.method3('general', 201311, :emergency)).to eq 'method3(general, 201311, emergency)'
+
+        expect(TestClass.count(:method3)).to eq 2
+      end
+    end
+
+    describe 'cache with instance args' do
+      it 'same instance parameters' do
+        foo = TestClass2.new('general', 201312)
+        bar = TestClass2.new('general', 201312)
+        expect(foo.method1).to eq '[general,201312].method1'
+        expect(bar.method1).to eq '[general,201312].method1'
+        expect(TestClass2.count(:method1)).to eq 1
+      end
+
+      it 'different instance parameters' do
+        foo = TestClass2.new('general', 201312)
+        bar = TestClass2.new('general', 201311)
+        expect(foo.method1).to eq '[general,201312].method1'
+        expect(bar.method1).to eq '[general,201311].method1'
+        expect(TestClass2.count(:method1)).to eq 2
+      end
+    end
+
+    describe 'cachers' do
+
+      it 'should track objects that include Cacheable' do
+        expected = [TestClass, TestClass2].to_set
+        expect(Cacheable.cachers & expected).to eq expected
+      end
+
+      it 'cachers_and_descendants should include descendants' do
+        expected = [TestClass, TestClass2, TestClass3].to_set
+        expect(Cacheable.cachers_and_descendants & expected).to eq expected
+      end
+
+    end
+  end
+end

data/spec/memoizable_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module ForgetMeNot
+  class MemoizeTestClass
+    include Memoizable
+    include MethodCounter
+
+    def method1
+      record_call :method1
+      'method1'
+    end
+
+    def method2(arg)
+      record_call :method2
+      "method2(#{arg})"
+    end
+
+    def method3(org, month, visit_type)
+      record_call :method3
+      "method3(#{org}, #{month}, #{visit_type})"
+    end
+
+    def method4(array_arg)
+      record_call :method4
+      "method4([#{array_arg.join ','}])"
+    end
+
+    def method5(hash_arg)
+      record_call :method5
+      "method5({#{hash_arg.map { |k, v| "#{k}/#{v}" }.join '|' }})"
+    end
+
+    memoize :method1, :method2, :method3, :method4, :method5
+  end
+
+  describe Memoizable do
+    before do
+      MemoizeTestClass.clear_calls
+      TestClass2.clear_calls
+    end
+
+
+    describe 'memoize arity-0 calls' do
+      it 'should memoize calls from the same instance' do
+        foo = MemoizeTestClass.new
+        expect(foo.method1).to eq 'method1'
+        expect(foo.method1).to eq 'method1'
+
+        expect(MemoizeTestClass.count(:method1)).to eq 1
+      end
+
+      it 'should memoize calls from the different instances separately' do
+        foo = MemoizeTestClass.new
+        bar = MemoizeTestClass.new
+        expect(foo.method1).to eq 'method1'
+        expect(bar.method1).to eq 'method1'
+
+        expect(MemoizeTestClass.count(:method1)).to eq 2
+      end
+
+    end
+
+    describe 'memoize arity-1 calls' do
+      it 'should memoize calls from the same instance, same argument' do
+        foo = MemoizeTestClass.new
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+
+        expect(MemoizeTestClass.count(:method2)).to eq 1
+      end
+
+      it 'should memoize calls from the same instance, different arguments' do
+        foo = MemoizeTestClass.new
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('foo')).to eq 'method2(foo)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+
+        expect(MemoizeTestClass.count(:method2)).to eq 2
+      end
+
+      it 'should distinguish calls with null and blank arguments' do
+        foo = MemoizeTestClass.new
+        expect(foo.method2(nil)).to eq 'method2()'
+        expect(foo.method2(nil)).to eq 'method2()'
+        expect(foo.method2('')).to eq 'method2()'
+        expect(foo.method2('')).to eq 'method2()'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+        expect(foo.method2('bar')).to eq 'method2(bar)'
+
+        expect(MemoizeTestClass.count(:method2)).to eq 3
+      end
+
+      it 'should distinguish calls with different elements in an array argument' do
+        foo = MemoizeTestClass.new
+        expect(foo.method4([1, 2])).to eq 'method4([1,2])'
+        expect(foo.method4([1, 2])).to eq 'method4([1,2])'
+        expect(foo.method4([1, 3])).to eq 'method4([1,3])'
+        expect(foo.method4([1, 3])).to eq 'method4([1,3])'
+        expect(MemoizeTestClass.count(:method4)).to eq 2
+      end
+
+      it 'should distinguish calls with different elements in a hash argument' do
+        foo = MemoizeTestClass.new
+        expect(foo.method5(foo: 1, bar: 2)).to eq 'method5({foo/1|bar/2})'
+        expect(foo.method5(foo: 1, bar: 2)).to eq 'method5({foo/1|bar/2})'
+
+        expect(foo.method5(foo: 1, bar: 3)).to eq 'method5({foo/1|bar/3})'
+        expect(foo.method5(foo: 1, bar: 3)).to eq 'method5({foo/1|bar/3})'
+
+        expect(foo.method5(foo: 1, elvis: 2)).to eq 'method5({foo/1|elvis/2})'
+        expect(foo.method5(foo: 1, elvis: 2)).to eq 'method5({foo/1|elvis/2})'
+
+        expect(MemoizeTestClass.count(:method5)).to eq 3
+      end
+
+    end
+
+    describe 'memoize arity-3 calls' do
+      it 'should memoize calls from the same instance, different arguments' do
+        foo = MemoizeTestClass.new
+        expect(foo.method3('general', 201312, :emergency)).to eq 'method3(general, 201312, emergency)'
+        expect(foo.method3('general', 201312, :emergency)).to eq 'method3(general, 201312, emergency)'
+        expect(foo.method3('general', 201311, :emergency)).to eq 'method3(general, 201311, emergency)'
+        expect(foo.method3('general', 201311, :emergency)).to eq 'method3(general, 201311, emergency)'
+
+        expect(MemoizeTestClass.count(:method3)).to eq 2
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+
+require 'active_support/all'
+require 'timecop'
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'forget-me-not'
+
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/support/method_counter.rb

@@ -0,0 +1,24 @@
+module MethodCounter
+  extend ActiveSupport::Concern
+  module ClassMethods
+    def clear_calls
+      calls.clear
+    end
+
+    def calls
+      @@calls ||= Hash.new(0)
+    end
+
+    def count(method_name)
+      calls[method_name]
+    end
+
+    def record_call(method_name)
+      calls[method_name] += 1
+    end
+  end
+
+  def record_call(method_name)
+    self.class.record_call(method_name)
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: forget-me-not
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Koan Health
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Caching and Memoization Mixins
+email:
+- development@koanhealth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/forget-me-not/cacheable.rb
+- lib/forget-me-not/hash_cache.rb
+- lib/forget-me-not/memoizable.rb
+- lib/forget-me-not/version.rb
+- lib/forget-me-not.rb
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- spec/cacheable_spec.rb
+- spec/memoizable_spec.rb
+- spec/spec_helper.rb
+- spec/support/method_counter.rb
+homepage: https://github.com/KoanHealth/forget-me-not
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Mixins that provide caching and memoization for Ruby classes
+test_files:
+- spec/cacheable_spec.rb
+- spec/memoizable_spec.rb
+- spec/spec_helper.rb
+- spec/support/method_counter.rb