memoizable 0.2.0 → 0.3.0

data/README.md

@@ -1,4 +1,4 @@
-# memoizable
+# Memoizable
 
 Memoize method return values
 
@@ -18,6 +18,61 @@ Memoize method return values
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
+## Rationale
+
+Memoization is an optimization that saves the return value of a method so it
+doesn't need to be re-computed every time that method is called. For example,
+perhaps you've written a method like this:
+
+```ruby
+class Planet
+  # This is the equation for the area of a sphere. If it's true for a
+  # particular instance of a planet, then that planet is spherical.
+  def spherical?
+    4 * Math::PI * radius ** 2 == area
+  end
+end
+```
+
+This code will re-compute whether a particular planet is spherical every time
+the method is called. If the method is called more than once, it may be more
+efficient to save the computed value in an instance variable, like so:
+
+```ruby
+class Planet
+  def spherical?
+    @spherical ||= 4 * Math::PI * radius ** 2 == area
+  end
+end
+```
+
+One problem with this approach is that, if the return value is `false`, the
+value will still be computed each time the method is called. It also becomes
+unweildy for methods that grow to be longer than one line.
+
+These problems can be solved by mixing-in the `Memoizable` module and memoizing
+the method.
+
+```ruby
+require 'memoizable'
+
+class Planet
+  include Memoizable
+  def spherical?
+    4 * Math::PI * radius ** 2 == area
+  end
+  memoize :spherical?
+end
+```
+
+## Warning
+
+The example above assumes that the radius and area of a planet will not change
+over time. This seems like a reasonable assumption but such an assumption is
+not safe in every domain. If it was possible for one of the attributes to
+change between method calls, memoizing that value could produce the wrong
+result. Please keep this in mind when considering which methods to memoize.
+
 ## Copyright
 
 Copyright © 2013 Dan Kubb, Erik Michaels-Ober. See LICENSE for details.

data/Rakefile

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'bundler'
 require 'rspec/core/rake_task'
 

data/lib/memoizable.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'thread_safe'
 
 require 'memoizable/instance_methods'
@@ -8,6 +10,7 @@ require 'memoizable/version'
 
 # Allow methods to be memoized
 module Memoizable
+  include InstanceMethods
 
   # Default freezer
   Freezer = lambda { |object| object.freeze }.freeze
@@ -21,10 +24,9 @@ module Memoizable
   #
   # @api private
   def self.included(descendant)
-    descendant.module_eval do
-      extend ModuleMethods
-      include InstanceMethods
-    end
+    super
+    descendant.extend(ModuleMethods)
   end
+  private_class_method :included
 
 end # Memoizable

data/lib/memoizable/instance_methods.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Memoizable
 
   # Methods mixed in to memoizable instances
@@ -40,7 +42,7 @@ module Memoizable
     #
     # @api private
     def memoized_method_cache
-      @_memoized_method_cache ||= Memory.new(self.class.freezer)
+      @_memoized_method_cache ||= Memory.new
     end
 
   end # InstanceMethods

data/lib/memoizable/memory.rb

@@ -1,11 +1,18 @@
+# encoding: utf-8
+
 module Memoizable
 
   # Storage for memoized methods
   class Memory
 
-    def initialize(freezer)
-      @memory  = ThreadSafe::Cache.new
-      @freezer = freezer
+    # Initialize the memory storage for memoized methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize
+      @memory = ThreadSafe::Cache.new
+      freeze
     end
 
     # Get the value from memory
@@ -17,7 +24,7 @@ module Memoizable
     # @api public
     def [](name)
       @memory.fetch(name) do
-        raise NameError, "No method #{name.inspect} was memoized"
+        fail NameError, "No method #{name} is memoized"
       end
     end
 
@@ -30,10 +37,12 @@ module Memoizable
     #
     # @api public
     def []=(name, value)
-      if @memory.key?(name)
-        raise ArgumentError, "The method #{name} is already memoized"
+      memoized = true
+      @memory.compute_if_absent(name) do
+        memoized = false
+        value
       end
-      @memory[name] = freeze_value(value)
+      fail ArgumentError, "The method #{name} is already memoized" if memoized
     end
 
     # Fetch the value from memory, or store it if it does not exist
@@ -44,8 +53,8 @@ module Memoizable
     #   the value to memoize
     #
     # @api public
-    def fetch(name)
-      @memory.fetch(name) { self[name] = yield }
+    def fetch(name, &block)
+      @memory.compute_if_absent(name, &block)
     end
 
     # Set the memory
@@ -71,18 +80,5 @@ module Memoizable
       @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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Memoizable
 
   # Build the memoized method
@@ -14,11 +16,26 @@ module Memoizable
       #
       # @api private
       def initialize(descendant, method, arity)
-        super("Cannot memoize #{descendant}##{method}, it's arity is #{arity}")
+        super("Cannot memoize #{descendant}##{method}, its arity is #{arity}")
       end
 
     end # InvalidArityError
 
+    # Raised when a block is passed to a memoized method
+    class BlockNotAllowedError < ArgumentError
+
+      # Initialize a block not allowed exception
+      #
+      # @param [Module] descendant
+      # @param [Symbol] method
+      #
+      # @api private
+      def initialize(descendant, method)
+        super("Cannot pass a block to #{descendant}##{method}, it is memoized")
+      end
+
+    end # BlockNotAllowedError
+
     # The original method before memoization
     #
     # @return [UnboundMethod]
@@ -30,16 +47,18 @@ module Memoizable
     #
     # @param [Module] descendant
     # @param [Symbol] method_name
+    # @param [#call] freezer
     #
     # @return [undefined]
     #
     # @api private
-    def initialize(descendant, method_name)
+    def initialize(descendant, method_name, freezer)
       @descendant          = descendant
       @method_name         = method_name
+      @freezer             = freezer
       @original_visibility = visibility
       @original_method     = @descendant.instance_method(@method_name)
-      assert_zero_arity
+      assert_arity(@original_method.arity)
     end
 
     # Build a new memoized method
@@ -61,15 +80,16 @@ module Memoizable
 
     # Assert the method arity is zero
     #
+    # @param [Integer] arity
+    #
     # @return [undefined]
     #
     # @raise [InvalidArityError]
     #
     # @api private
-    def assert_zero_arity
-      arity = @original_method.arity
+    def assert_arity(arity)
       if arity.nonzero?
-        raise InvalidArityError.new(@descendant, @method_name, arity)
+        fail InvalidArityError.new(@descendant, @method_name, arity)
       end
     end
 
@@ -88,9 +108,12 @@ module Memoizable
     #
     # @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))
+      descendant_exec(@method_name, @original_method, @freezer) do |name, method, freezer|
+        define_method(name) do |&block|
+          fail BlockNotAllowedError.new(self.class, name) if block
+          memoized_method_cache.fetch(name) do
+            freezer.call(method.bind(self).call)
+          end
         end
       end
     end
@@ -101,9 +124,7 @@ module Memoizable
     #
     # @api private
     def set_method_visibility
-      descendant_exec(@method_name, @original_visibility) do |name, visibility|
-        send(visibility, name)
-      end
+      @descendant.send(@original_visibility, @method_name)
     end
 
     # Get the visibility of the original method

data/lib/memoizable/module_methods.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Memoizable
 
   # Methods mixed in to memoizable singleton classes
@@ -8,7 +10,6 @@ module Memoizable
     # @return [#call]
     #
     # @api private
-    #
     def freezer
       Freezer
     end
@@ -82,18 +83,33 @@ module Memoizable
 
   private
 
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module including ModuleMethods
+    #
+    # @return [self]
+    #
+    # @api private
+    def included(descendant)
+      super
+      descendant.module_eval { include Memoizable }
+    end
+
     # 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
+      memoized_methods[method_name] = MethodBuilder.new(
+        self,
+        method_name,
+        freezer
+      ).call
     end
 
     # Return method builder registry
@@ -101,9 +117,8 @@ module Memoizable
     # @return [Hash<Symbol, MethodBuilder>]
     #
     # @api private
-    #
     def memoized_methods
-      @_memoized_methods ||= Memory.new(freezer)
+      @_memoized_methods ||= Memory.new
     end
 
   end # ModuleMethods

data/lib/memoizable/version.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 module Memoizable
 
   # Gem version
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'.freeze
 
 end # Memoizable

data/memoizable.gemspec

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require File.expand_path('../lib/memoizable/version', __FILE__)
 
 Gem::Specification.new do |gem|
@@ -12,10 +14,9 @@ Gem::Specification.new do |gem|
 
   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]
+  gem.files           += Dir.glob('{lib,spec}/**/*.rb')
+  gem.test_files       = Dir.glob('spec/{unit,integration}/**/*.rb')
+  gem.extra_rdoc_files = Dir.glob('**/*.md')
 
   gem.add_runtime_dependency('thread_safe', '~> 0.1.3')
 

data/spec/shared/call_super_shared_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+shared_examples 'it calls super' do |method|
+  around do |example|
+    # Restore original method after each example
+    original = "original_#{method}"
+    superclass.class_eval do
+      alias_method original, method
+      example.call
+      undef_method method
+      alias_method method, original
+    end
+  end
+
+  it "delegates to the superclass ##{method} method" do
+    # This is the most succinct approach I could think of to test whether the
+    # superclass method is called. All of the built-in rspec helpers did not
+    # seem to work for this.
+    called = false
+    superclass.class_eval { define_method(method) { |_| called = true } }
+    expect { subject }.to change { called }.from(false).to(true)
+  end
+end

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'simplecov'
 require 'coveralls'
 
@@ -12,12 +14,17 @@ SimpleCov.start do
   add_filter 'spec'
   add_filter 'vendor'
 
-  minimum_coverage 89.8
+  minimum_coverage 100
 end
 
 require 'memoizable'
 require 'rspec'
 
+# Require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
+  require file.chomp('.rb')
+end
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expect_with|
     expect_with.syntax = :expect

data/spec/unit/memoizable/class_methods/included_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Memoizable, '.included' do
+  subject { object.class_eval { include Memoizable } }
+
+  let(:object)     { Class.new }
+  let(:superclass) { Module    }
+
+  it_behaves_like 'it calls super', :included
+
+  it 'extends the descendant with module methods' do
+    subject
+    extended_modules = class << object; included_modules end
+    expect(extended_modules).to include(Memoizable::ModuleMethods)
+  end
+end

data/spec/{fixtures → unit/memoizable/fixtures}/classes.rb

@@ -1,4 +1,6 @@
-module MemoizableSpecs
+# encoding: utf-8
+
+module Fixture
   class Object
     include Memoizable
 
@@ -12,6 +14,13 @@ module MemoizableSpecs
       'test'
     end
 
+    def zero_arity
+      caller
+    end
+
+    def one_arity(arg)
+    end
+
     def public_method
       caller
     end
@@ -29,4 +38,4 @@ module MemoizableSpecs
     end
 
   end # class Object
-end # module MemoizableSpecs
+end # module Fixture

data/spec/unit/memoizable/instance_methods/freeze_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe Memoizable::InstanceMethods, '#freeze' do
+  subject { object.freeze }
+
+  let(:described_class) { Class.new(Fixture::Object) }
+
+  before do
+    described_class.memoize(:test)
+  end
+
+  let(:object) { described_class.allocate }
+
+  it_should_behave_like 'a command method'
+
+  it 'freezes the object' do
+    expect { subject }.to change(object, :frozen?).from(false).to(true)
+  end
+
+  it 'allows methods not yet called to be memoized' do
+    subject
+    expect(object.test).to be(object.test)
+  end
+end

data/spec/unit/memoizable/instance_methods/memoize_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe Memoizable::InstanceMethods, '#memoize' do
+  subject { object.memoize(method => value) }
+
+  let(:described_class) { Class.new(Fixture::Object) }
+  let(:object)          { described_class.new        }
+  let(:method)          { :test                      }
+
+  before do
+    described_class.memoize(method)
+  end
+
+  context 'when the method is not memoized' do
+    let(:value) { String.new }
+
+    it 'sets the memoized value for the method to the value' do
+      subject
+      expect(object.send(method)).to be(value)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'when the method is already memoized' do
+    let(:value)    { double }
+    let(:original) { nil    }
+
+    before do
+      object.memoize(method => original)
+    end
+
+    it 'raises an exception' do
+      expect { subject }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/memoizable/method_builder/call_spec.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe Memoizable::MethodBuilder, '#call' do
+  subject { object.call }
+
+  let(:object)   { described_class.new(descendant, method_name, freezer) }
+  let(:freezer)  { lambda { |object| object.freeze }                     }
+  let(:instance) { descendant.new                                        }
+
+  let(:descendant) do
+    Class.new do
+      include Memoizable
+
+      def public_method
+        __method__.to_s
+      end
+
+      def protected_method
+        __method__.to_s
+      end
+      protected :protected_method
+
+      def private_method
+        __method__.to_s
+      end
+      private :private_method
+    end
+  end
+
+  shared_examples_for 'Memoizable::MethodBuilder#call' do
+    it_should_behave_like 'a command method'
+
+    it 'creates a method that is memoized' do
+      subject
+      expect(instance.send(method_name)).to be(instance.send(method_name))
+    end
+
+    it 'creates a method that returns the expected value' do
+      subject
+      expect(instance.send(method_name)).to eql(method_name.to_s)
+    end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      expect(descendant.new.send(method_name)).to be_frozen
+    end
+
+    it 'creates a method that does not accept a block' do
+      subject
+      expect { descendant.new.send(method_name) {} }.to raise_error(
+        described_class::BlockNotAllowedError,
+        "Cannot pass a block to #{descendant}##{method_name}, it is memoized"
+      )
+    end
+  end
+
+  context 'public method' do
+    let(:method_name) { :public_method }
+
+    it_should_behave_like 'Memoizable::MethodBuilder#call'
+
+    it 'creates a public memoized method' do
+      subject
+      expect(descendant).to be_public_method_defined(method_name)
+    end
+  end
+
+  context 'protected method' do
+    let(:method_name) { :protected_method }
+
+    it_should_behave_like 'Memoizable::MethodBuilder#call'
+
+    it 'creates a protected memoized method' do
+      subject
+      expect(descendant).to be_protected_method_defined(method_name)
+    end
+
+  end
+
+  context 'private method' do
+    let(:method_name) { :private_method }
+
+    it_should_behave_like 'Memoizable::MethodBuilder#call'
+
+    it 'creates a private memoized method' do
+      subject
+      expect(descendant).to be_private_method_defined(method_name)
+    end
+  end
+end

data/spec/unit/memoizable/method_builder/class_methods/new_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../../fixtures/classes', __FILE__)
+
+describe Memoizable::MethodBuilder, '.new' do
+  subject { described_class.new(descendant, method_name, freezer) }
+
+  let(:descendant) { Fixture::Object                   }
+  let(:freezer)    { lambda { |object| object.freeze } }
+
+  context 'with a zero arity method' do
+    let(:method_name) { :zero_arity }
+
+    it { should be_instance_of(described_class) }
+
+    it 'sets the original method' do
+      # original method is not memoized
+      method = subject.original_method.bind(descendant.new)
+      expect(method.call).to_not be(method.call)
+    end
+  end
+
+  context 'with a one arity method' do
+    let(:method_name) { :one_arity }
+
+    it 'raises an exception' do
+      expect { subject }.to raise_error(
+        described_class::InvalidArityError,
+        'Cannot memoize Fixture::Object#one_arity, its arity is 1'
+      )
+    end
+  end
+end

data/spec/unit/memoizable/method_builder/original_method_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Memoizable::MethodBuilder, '#original_method' do
+  subject { object.original_method }
+
+  let(:object)      { described_class.new(descendant, method_name, freezer) }
+  let(:method_name) { :foo                                                  }
+  let(:freezer)     { lambda { |object| object.freeze }                     }
+
+  let(:descendant) do
+    Class.new do
+      def initialize
+        @foo = 0
+      end
+
+      def foo
+        @foo += 1
+      end
+    end
+  end
+
+  it { should be_instance_of(UnboundMethod) }
+
+  it 'returns the original method' do
+    # original method is not memoized
+    method = subject.bind(descendant.new)
+    expect(method.call).to_not be(method.call)
+  end
+end

data/spec/unit/memoizable/module_methods/included_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Memoizable::ModuleMethods, '#included' do
+  subject { descendant.instance_exec(object) { |mod| include mod } }
+
+  let(:object)     { Module.new.extend(described_class) }
+  let(:descendant) { Class.new                          }
+  let(:superclass) { Module                             }
+
+  before do
+    # Prevent Module.included from being called through inheritance
+    Memoizable.stub(:included)
+  end
+
+  it_behaves_like 'it calls super', :included
+
+  it 'includes Memoizable into the descendant' do
+    subject
+    expect(descendant.included_modules).to include(Memoizable)
+  end
+end

data/spec/{memoize_spec.rb → unit/memoizable/module_methods/memoize_spec.rb}

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../../fixtures/classes', __FILE__)
 
 shared_examples_for 'memoizes method' do
   it 'memoizes the instance method' do
@@ -8,13 +10,7 @@ shared_examples_for 'memoizes method' do
     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
+  it 'creates a zero arity method', :unless => RUBY_VERSION == '1.8.7' do
     subject
     expect(object.new.method(method).arity).to be_zero
   end
@@ -32,17 +28,11 @@ shared_examples_for 'memoizes method' do
   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) {
+    stub_const 'TestClass', Class.new(Fixture::Object) {
       def some_state
         Object.new
       end
@@ -55,7 +45,7 @@ describe Memoizable::ModuleMethods, '#memoize' do
     it 'should raise error' do
       expect { subject }.to raise_error(
         Memoizable::MethodBuilder::InvalidArityError,
-        "Cannot memoize TestClass#required_arguments, it's arity is 1"
+        'Cannot memoize TestClass#required_arguments, its arity is 1'
       )
     end
   end
@@ -66,7 +56,7 @@ describe Memoizable::ModuleMethods, '#memoize' do
     it 'should raise error' do
       expect { subject }.to raise_error(
         Memoizable::MethodBuilder::InvalidArityError,
-        "Cannot memoize TestClass#optional_arguments, it's arity is -1"
+        'Cannot memoize TestClass#optional_arguments, its arity is -1'
       )
     end
   end

data/spec/{memoized_predicate_spec.rb → unit/memoizable/module_methods/memoized_predicate_spec.rb}

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Memoizable::ModuleMethods, '#memoized?' do

data/spec/unit/memoizable/module_methods/unmemoized_instance_method_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Memoizable::ModuleMethods, '#unmemoized_instance_method' do
+  subject { object.unmemoized_instance_method(name) }
+
+  let(:object) do
+    Class.new do
+      include Memoizable
+
+      def initialize
+        @foo = 0
+      end
+
+      def foo
+        @foo += 1
+      end
+
+      memoize :foo
+    end
+  end
+
+  context 'when the method was memoized' do
+    let(:name) { :foo }
+
+    it { should be_instance_of(UnboundMethod) }
+
+    it 'returns the original method' do
+      # original method is not memoized
+      method = subject.bind(object.new)
+      expect(method.call).to_not be(method.call)
+    end
+  end
+
+  context 'when the method was not memoized' do
+    let(:name) { :bar }
+
+    it 'raises an exception' do
+      expect { subject }.to raise_error(NameError, 'No method bar is memoized')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memoizable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-18 00:00:00.000000000 Z
+date: 2013-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thread_safe
@@ -54,9 +54,9 @@ email: dan.kubb@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CONTRIBUTING.md
 - LICENSE.md
 - README.md
-- CONTRIBUTING.md
 files:
 - CONTRIBUTING.md
 - LICENSE.md
@@ -69,10 +69,20 @@ files:
 - 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/shared/call_super_shared_spec.rb
+- spec/shared/command_method_behavior.rb
 - spec/spec_helper.rb
+- spec/unit/memoizable/class_methods/included_spec.rb
+- spec/unit/memoizable/fixtures/classes.rb
+- spec/unit/memoizable/instance_methods/freeze_spec.rb
+- spec/unit/memoizable/instance_methods/memoize_spec.rb
+- spec/unit/memoizable/method_builder/call_spec.rb
+- spec/unit/memoizable/method_builder/class_methods/new_spec.rb
+- spec/unit/memoizable/method_builder/original_method_spec.rb
+- spec/unit/memoizable/module_methods/included_spec.rb
+- spec/unit/memoizable/module_methods/memoize_spec.rb
+- spec/unit/memoizable/module_methods/memoized_predicate_spec.rb
+- spec/unit/memoizable/module_methods/unmemoized_instance_method_spec.rb
 homepage: https://github.com/dkubb/memoizable
 licenses:
 - MIT
@@ -99,8 +109,15 @@ signing_key:
 specification_version: 3
 summary: Memoize method return values
 test_files:
-- spec/fixtures/classes.rb
-- spec/memoize_spec.rb
-- spec/memoized_predicate_spec.rb
-- spec/spec_helper.rb
+- spec/unit/memoizable/class_methods/included_spec.rb
+- spec/unit/memoizable/fixtures/classes.rb
+- spec/unit/memoizable/instance_methods/freeze_spec.rb
+- spec/unit/memoizable/instance_methods/memoize_spec.rb
+- spec/unit/memoizable/method_builder/call_spec.rb
+- spec/unit/memoizable/method_builder/class_methods/new_spec.rb
+- spec/unit/memoizable/method_builder/original_method_spec.rb
+- spec/unit/memoizable/module_methods/included_spec.rb
+- spec/unit/memoizable/module_methods/memoize_spec.rb
+- spec/unit/memoizable/module_methods/memoized_predicate_spec.rb
+- spec/unit/memoizable/module_methods/unmemoized_instance_method_spec.rb
 has_rdoc: