memorb 0.1.0

data/spec/memorb/integrator_class_methods_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+describe ::Memorb::IntegratorClassMethods do
+  let(:integrator) { ::Class.new { extend ::Memorb } }
+  let(:integration) { ::Memorb::Integration[integrator] }
+  let(:instance) { integrator.new }
+
+  describe '::memorb' do
+    it 'returns the integration for the integrator' do
+      expect(integrator.memorb).to be(integration)
+    end
+  end
+  describe '::memorb!' do
+    it 'calls register with the same arguments' do
+      spy = double('spy', register: nil)
+      mod = Module.new
+      ::Memorb::RubyCompatibility.define_method(mod, :memorb) { spy }
+      integrator.singleton_class.prepend(mod)
+      block = Proc.new { nil }
+      expect(spy).to receive(:register).with(:a, &block)
+      integrator.memorb!(:a, &block)
+    end
+  end
+  describe '::inherited' do
+    it 'makes children of integrators get their own integration' do
+      child_integrator = ::Class.new(integrator)
+      integration = ::Memorb::Integration[child_integrator]
+      expect(integration).not_to be(nil)
+      expected_ancestry = [integration, child_integrator]
+      expect(child_integrator.ancestors).to start_with(*expected_ancestry)
+    end
+  end
+  describe '::method_added' do
+    let(:method_name) { :method_1 }
+
+    it 'retains upstream behavior' do
+      spy = double('spy', spy!: nil)
+      ::Memorb::RubyCompatibility
+        .define_method(integrator.singleton_class, :method_added) do |m|
+          spy.spy!(m)
+        end
+      expect(spy).to receive(:spy!).with(method_name)
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+    end
+    context 'when the method has been registered' do
+      it 'enables the method' do
+        integration.register(method_name)
+        expect(integration.enabled_methods).not_to include(method_name)
+        expect(integration.public_instance_methods).not_to include(method_name)
+        ::Memorb::RubyCompatibility
+          .define_method(integrator, method_name) { nil }
+        expect(integration.enabled_methods).to include(method_name)
+        expect(integration.public_instance_methods).to include(method_name)
+      end
+    end
+    context 'when automatic registration is enabled' do
+      it 'registers and enables new methods' do
+        integration.send(:_auto_registration).increment
+        ::Memorb::RubyCompatibility
+          .define_method(integrator, method_name) { nil }
+        expect(integration.registered_methods).to include(method_name)
+        expect(integration.enabled_methods).to include(method_name)
+        expect(integration.public_instance_methods).to include(method_name)
+      end
+    end
+  end
+  describe '::method_removed' do
+    let(:method_name) { :method_1 }
+    let(:method_id) { ::Memorb::MethodIdentifier.new(method_name) }
+
+    it 'retains upstream behavior' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      spy = double('spy', spy!: nil)
+      ::Memorb::RubyCompatibility
+        .define_method(integrator.singleton_class, :method_removed) do |m|
+          spy.spy!(m)
+        end
+      expect(spy).to receive(:spy!).with(method_name)
+      ::Memorb::RubyCompatibility.remove_method(integrator, method_name)
+    end
+    it 'removes the override for the method' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      integration.register(method_name)
+      expect(integration.enabled_methods).to include(method_name)
+      expect(integration.public_instance_methods).to include(method_name)
+      ::Memorb::RubyCompatibility.remove_method(integrator, method_name)
+      expect(integration.enabled_methods).not_to include(method_name)
+      expect(integration.public_instance_methods).not_to include(method_name)
+    end
+    it 'clears cached data for the method in all instances' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      integration.register(method_name)
+      instance.send(method_name)
+      store = instance.memorb.method_store.read(method_id)
+      expect(store.keys).not_to be_empty
+      ::Memorb::RubyCompatibility.remove_method(integrator, method_name)
+      expect(store.keys).to be_empty
+    end
+  end
+  describe '::method_undefined' do
+    let(:method_name) { :method_1 }
+    let(:method_id) { ::Memorb::MethodIdentifier.new(method_name) }
+
+    it 'retains upstream behavior' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      spy = double('spy', spy!: nil)
+      ::Memorb::RubyCompatibility
+        .define_method(integrator.singleton_class, :method_undefined) do |m|
+          spy.spy!(m)
+        end
+      expect(spy).to receive(:spy!).with(method_name)
+      ::Memorb::RubyCompatibility.undef_method(integrator, method_name)
+    end
+    it 'undefines the override for the method' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      integration.register(method_name)
+      ::Memorb::RubyCompatibility.undef_method(integrator, method_name)
+      instance = integrator.new
+      expect(integration.enabled_methods).not_to include(method_name)
+      expect(integration.public_instance_methods).not_to include(method_name)
+      expect {
+        instance.send(method_name)
+      }.to raise_error(::NoMethodError, /undefined method/)
+    end
+    it 'clears cached data for the method in all instances' do
+      ::Memorb::RubyCompatibility
+        .define_method(integrator, method_name) { nil }
+      integration.register(method_name)
+      instance.send(method_name)
+      store = instance.memorb.method_store.read(method_id)
+      expect(store.keys).not_to be_empty
+      ::Memorb::RubyCompatibility.undef_method(integrator, method_name)
+      expect(store.keys).to be_empty
+    end
+  end
+end

data/spec/memorb/key_value_store_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+describe ::Memorb::KeyValueStore do
+  let(:key) { :key }
+  let(:value) { 'value' }
+
+  describe '#write' do
+    it 'stores a value' do
+      subject.write(key, value)
+      data = subject.instance_variable_get(:@data)
+      expect(data).to include(key => value)
+    end
+    it 'returns the stored value' do
+      result = subject.write(key, value)
+      expect(result).to equal(value)
+    end
+  end
+  describe '#read' do
+    it 'retrieves a value for a given key' do
+      data = subject.instance_variable_get(:@data)
+      data[key] = value
+      result = subject.read(key)
+      expect(result).to equal(value)
+    end
+    context 'when a value has not been set' do
+      it 'returns nil' do
+        result = subject.read(key)
+        expect(result).to eq(nil)
+      end
+    end
+  end
+  describe '#has?' do
+    context 'when a value has not been set' do
+      it 'return false' do
+        result = subject.has?(:key)
+        expect(result).to eq(false)
+      end
+    end
+    context 'when a value has been set' do
+      it 'returns true' do
+        data = subject.instance_variable_get(:@data)
+        data[key] = value
+        result = subject.has?(:key)
+        expect(result).to be(true)
+      end
+    end
+  end
+  describe '#fetch' do
+    context 'when a value has not been set' do
+      it 'stores and returns the result of the block' do
+        result = subject.fetch(key) { value }
+        expect(result).to equal(value)
+        data = subject.instance_variable_get(:@data)
+        expect(data[key]).to equal(value)
+      end
+    end
+    context 'when a value has been set' do
+      it 'retrieves the value that was already set' do
+        data = subject.instance_variable_get(:@data)
+        data[key] = value
+        result = subject.fetch(key) { 'other' }
+        expect(result).to equal(value)
+      end
+    end
+  end
+  describe '#forget' do
+    it 'removes the entry for the given key' do
+      data = subject.instance_variable_get(:@data)
+      original = { :k1 => :v1, :k2 => :v2 }
+      addition = { :k3 => :v3 }
+      data.merge!(original).merge!(addition)
+      subject.forget(:k3)
+      expect(data).to eq(original)
+    end
+  end
+  describe '#reset!' do
+    it 'clears all data' do
+      data = subject.instance_variable_get(:@data)
+      data[key] = value
+      subject.reset!
+      expect(data).to be_empty
+    end
+  end
+  describe '#inspect' do
+    it 'displays the keys that it stores' do
+      [:symbol, 'string', 123, [:a, :b]].each { |k| subject.write(k, value) }
+      expectation = '#<Memorb::KeyValueStore keys=[:symbol, "string", 123, [:a, :b]]>'
+      expect(subject.inspect).to eq(expectation)
+    end
+  end
+end

data/spec/memorb/method_identifier_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+describe ::Memorb::MethodIdentifier do
+  let(:method_name) { :method_1 }
+  subject { described_class.new(method_name) }
+
+  describe '#hash' do
+    it 'does not equal the hash of the method name symbol' do
+      expect(subject.hash).not_to equal(method_name.hash)
+    end
+    context 'when given an other instance with the same method name' do
+      it 'shares its hash value with the other instance' do
+        subject_1 = described_class.new(method_name)
+        subject_2 = described_class.new(method_name)
+        expect(subject_1.hash).to equal(subject_2.hash)
+      end
+    end
+    context 'when given an other instance with a different method name' do
+      it 'does not share its hash value with the other instance' do
+        subject_1 = described_class.new(:method_1)
+        subject_2 = described_class.new(:method_2)
+        expect(subject_1.hash).not_to equal(subject_2.hash)
+      end
+    end
+  end
+  describe '#eql?' do
+    context 'when given an other instance with the same method name' do
+      it 'returns true' do
+        subject_1 = described_class.new(method_name)
+        subject_2 = described_class.new(method_name)
+        result = subject_1.eql?(subject_2)
+        expect(result).to be(true)
+      end
+    end
+    context 'when given an other instance with a different method name' do
+      it 'returns false' do
+        subject_1 = described_class.new(:method_1)
+        subject_2 = described_class.new(:method_2)
+        result = subject_1.eql?(subject_2)
+        expect(result).to be(false)
+      end
+    end
+  end
+  describe '#==' do
+    context 'when given an other instance with the same method name' do
+      it 'is considered equal to the other instance' do
+        subject_1 = described_class.new('method_1')
+        subject_2 = described_class.new('method_1')
+        expect(subject_1 == subject_2).to be(true)
+      end
+    end
+    context 'when given an other instance with a different method name' do
+      it 'is not considered equal to the other instance' do
+        subject_1 = described_class.new('method_1')
+        subject_2 = described_class.new('method_2')
+        expect(subject_1 == subject_2).to be(false)
+      end
+    end
+  end
+  describe '#to_s' do
+    it 'returns the originally provided method name as a string' do
+      expect(subject.to_s).to eq('method_1')
+    end
+  end
+  describe '#to_sym' do
+    it 'returns the originally provided method name as a symbol' do
+      expect(subject.to_sym).to be(:method_1)
+    end
+  end
+  context 'when used as a key in a hash' do
+    context 'accessing with different instances for the same method name' do
+      it 'shares the same key in the hash with the other instance' do
+        instance_1 = described_class.new(method_name)
+        instance_2 = described_class.new(method_name)
+        hash = { instance_1 => nil }
+        expect(hash).to have_key(instance_2)
+      end
+    end
+    it 'does not refer to the same key as the symbol of the method name' do
+      hash = { subject => nil }
+      expect(hash).not_to have_key(method_name)
+    end
+  end
+end

data/spec/memorb_spec.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+describe ::Memorb do
+  context 'when integrating improperly' do
+    let(:error) { ::Memorb::InvalidIntegrationError }
+    let(:error_message) { 'Memorb must be integrated using `extend`' }
+
+    context 'when included on a target' do
+      it 'raises an error' do
+        expect {
+          ::Class.new { include ::Memorb }
+        }.to raise_error(error, error_message)
+      end
+    end
+    context 'when prepended on a target' do
+      it 'raises an error' do
+        expect {
+          ::Class.new { prepend ::Memorb }
+        }.to raise_error(error, error_message)
+      end
+    end
+  end
+
+  describe 'integrators' do
+    shared_examples 'for ancestry verification' do
+      it 'has the correct ancestry' do
+        expect(integration).not_to be(nil)
+        ancestors = integrator.ancestors
+        expected_ancestry = [integration, integrator]
+        relevant_ancestors = ancestors.select { |a| expected_ancestry.include?(a) }
+        expect(relevant_ancestors).to match_array(expected_ancestry)
+      end
+    end
+
+    let(:integration) { ::Memorb::Integration[integrator] }
+    let(:instance) { integrator.new }
+
+    describe 'a basic integrator' do
+      let(:integrator) {
+        ::Class.new do
+          extend ::Memorb
+        end
+      }
+      include_examples 'for ancestry verification'
+    end
+
+    describe 'an integrator that includes Memorb more than once' do
+      let(:integrator) {
+        ::Class.new do
+          extend ::Memorb
+          extend ::Memorb
+        end
+      }
+      include_examples 'for ancestry verification'
+    end
+
+    describe 'a child of an integrator' do
+      let(:parent_integrator) {
+        ::Class.new do
+          extend ::Memorb
+        end
+      }
+      let(:integrator) {
+        ::Class.new(parent_integrator)
+      }
+      include_examples 'for ancestry verification'
+    end
+
+    describe 'a child of an integrator that includes Memorb again' do
+      let(:parent_integrator) {
+        ::Class.new do
+          extend ::Memorb
+        end
+      }
+      let(:integrator) {
+        ::Class.new(parent_integrator) do
+          extend ::Memorb
+        end
+      }
+      include_examples 'for ancestry verification'
+    end
+
+    describe 'an integrator that aliases a method after registration' do
+      let(:integrator) {
+        ::Class.new(::SpecHelper.basic_target_class) do
+          extend ::Memorb
+          memorb.register(:increment)
+          alias_method :other_increment, :increment
+        end
+      }
+
+      it 'implements caching for the aliased method' do
+        result_1 = instance.other_increment
+        result_2 = instance.other_increment
+        expect(result_1).to eq(result_2)
+      end
+    end
+
+    describe 'an integrator that aliases a method before registration' do
+      let(:integrator) {
+        ::Class.new(::SpecHelper.basic_target_class) do
+          extend ::Memorb
+          alias_method :other_increment, :increment
+          memorb.register(:increment)
+        end
+      }
+
+      it 'does not implement caching for the aliased method' do
+        result_1 = instance.other_increment
+        result_2 = instance.other_increment
+        expect(result_1).not_to eq(result_2)
+      end
+    end
+
+    describe 'an integrator that uses alias method chaining' do
+      let(:integrator) {
+        ::Class.new(::SpecHelper.basic_target_class) do
+          extend ::Memorb
+          memorb.register(:increment)
+          def new_increment; old_increment; end
+          alias_method :old_increment, :increment
+          alias_method :increment, :new_increment
+        end
+      }
+
+      it 'results in infinite recursion when the method is called' do
+        error = case ::RUBY_ENGINE
+        when 'jruby'
+          [java.lang.StackOverflowError]
+        else
+          [::SystemStackError, 'stack level too deep']
+        end
+        expect { instance.increment }.to raise_error(*error)
+      end
+    end
+
+    describe 'an integrator with a method that accepts a block' do
+      let(:integrator) {
+        ::Class.new(::SpecHelper.basic_target_class) do
+          extend ::Memorb
+          def with_block(&block); block ? block.call(self) : increment; end
+          memorb.register(:with_block)
+        end
+      }
+
+      it 'still gets the block as a parameter' do
+        result = instance.with_block { |x| x }
+        expect(result).to be(instance)
+      end
+
+      it 'considers calls with different blocks to have the same arguments' do
+        result_1 = instance.with_block { |x| x.increment }
+        result_2 = instance.with_block { |x| x.increment }
+        expect(result_1).to eq(result_2)
+      end
+
+      it 'considers calls with different proc-blocks to have the same arguments' do
+        proc_1 = ::Proc.new { |x| x.increment }
+        proc_2 = ::Proc.new { |x| x.increment }
+        result_1 = instance.with_block(&proc_1)
+        result_2 = instance.with_block(&proc_2)
+        expect(result_1).to eq(result_2)
+      end
+
+      it 'considers a call with a block to be the same as a call without one' do
+        result_1 = instance.with_block { |x| x.increment }
+        result_2 = instance.with_block
+        expect(result_1).to eq(result_2)
+      end
+    end
+
+    ::SpecHelper.for_testing_garbage_collection do
+      let(:integrator) {
+        ::Class.new(::SpecHelper.basic_target_class) do
+          extend ::Memorb
+          memorb.register(:noop)
+        end
+      }
+
+      describe 'a method argument for a memoized method' do
+        it 'allows the argument to be garbage collected' do
+          ref = ::WeakRef.new(Object.new)
+          instance.send(:noop, ref.__getobj__)
+          ::SpecHelper.force_garbage_collection
+          expect(ref.weakref_alive?).to be_falsey
+        end
+      end
+      describe 'a low-level cache fetch' do
+        it 'allows the cache key to be garbage collected' do
+          ref = ::WeakRef.new(Object.new)
+          instance.memorb.fetch(ref.__getobj__) { nil }
+          ::SpecHelper.force_garbage_collection
+          expect(ref.weakref_alive?).to be_falsey
+        end
+      end
+    end
+  end
+end