memoizable 0.4.2 → 0.5.1

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

@@ -1,93 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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
-    allow(Memoizable).to receive(: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/unit/memoizable/module_methods/memoize_spec.rb

@@ -1,123 +0,0 @@
-# encoding: utf-8
-
-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 zero arity method', :unless => RUBY_VERSION == '1.8.7' 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
-
-describe Memoizable::ModuleMethods, '#memoize' do
-  subject { object.memoize(method) }
-
-  let(:object) do
-    stub_const 'TestClass', Class.new(Fixture::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, its 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, its 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/unit/memoizable/module_methods/memoized_predicate_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-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/unit/memoizable/module_methods/unmemoized_instance_method_spec.rb

@@ -1,43 +0,0 @@
-# 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