accord 0.1.0

data/spec/interface_body_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'accord/interface_body'
+
+module Accord
+  describe InterfaceBody do
+    let(:interface) { stub }
+    let(:bases) { [] }
+    let(:members) { stub }
+    let(:invariants) { stub }
+    let(:sig_info) { stub(:param => nil, :block => nil, :splat => nil) }
+
+    subject { InterfaceBody.new(interface, bases, members, invariants) }
+
+    before do
+      stub_const("Accord::SignatureInfo", stub)
+      stub_const("Accord::InterfaceMethod", stub)
+      Accord::SignatureInfo.stub(:new).and_return(sig_info)
+    end
+
+    describe "#extends" do
+      let(:base1) { stub }
+      let(:base2) { stub }
+
+      it "adds up interfaces" do
+        subject.extends(base1)
+        expect(bases).to include(base1)
+      end
+
+      it "doesn't add a already added base" do
+        subject.extends(base1)
+        subject.extends(base1)
+        expect(bases.size).to eq 1
+      end
+
+      it "prepends the added bases" do
+        subject.extends(base1)
+        subject.extends(base2)
+
+        expect(bases.shift).to be base2
+        expect(bases.shift).to be base1
+      end
+    end
+
+    describe "#responds_to" do
+      let(:method) { stub }
+
+      before do
+        members.stub(:add)
+        InterfaceMethod.stub(:new).with(interface, :method, sig_info).
+          and_return(method)
+      end
+
+      it "adds up methods" do
+        members.should_receive(:add).with(:method, method)
+        subject.responds_to(:method)
+      end
+
+      context "using :params option" do
+        context "to add a regular argument" do
+          it "creates a param in the signature info" do
+            sig_info.should_receive(:param).with(:foo)
+            subject.responds_to(:method, params: :foo)
+          end
+        end
+
+        context "to add a splat argument" do
+          it "creates a splat in the signature info" do
+            sig_info.should_receive(:splat).with(:foo)
+            subject.responds_to(:method, params: :"*foo")
+          end
+        end
+
+        context "to add a block argument" do
+          it "creates a block argument in the signature info" do
+            sig_info.should_receive(:block).with(:foo)
+            subject.responds_to(:method, params: :"&foo")
+          end
+        end
+      end
+
+      context "using block" do
+        context "to add a regular argument" do
+          it "creates a param in the signature info" do
+            sig_info.should_receive(:param).with(:foo)
+            subject.responds_to(:method) { param :foo }
+          end
+        end
+
+        context "to add a splat argument" do
+          it "creates a splat in the signature info" do
+            sig_info.should_receive(:splat).with(:foo)
+            subject.responds_to(:method) { splat :foo }
+          end
+        end
+
+        context "to add a block argument" do
+          it "creates a block argument in the signature info" do
+            sig_info.should_receive(:block).with(:foo)
+            subject.responds_to(:method) { block :foo }
+          end
+        end
+      end
+    end
+
+    describe "#invariant" do
+      it "adds up invariants" do
+        block = Proc.new { }
+        invariants.should_receive(:add).with(:invariant, &block)
+        subject.invariant(:invariant, &block)
+      end
+    end
+
+    describe "#interface" do
+      it "exposes the interface object" do
+        expect(subject.interface).to be interface
+      end
+    end
+
+    describe "#tags" do
+      let(:tags) { stub }
+
+      it "expose interface tags" do
+        interface.stub(:tags).and_return(tags)
+        expect(subject.tags).to be tags
+      end
+    end
+
+    describe ".run" do
+      subject { InterfaceBody }
+      let(:root_interface) { stub }
+
+      before do
+        stub_const('Accord::Interface', root_interface)
+        interface.stub(:bases=)
+        interface.stub(:members)
+        interface.stub(:invariants)
+      end
+
+      it "adds the root interface if bases is left empty" do
+        interface.should_receive(:bases=).with([root_interface])
+        subject.run(interface) { }
+      end
+
+      it "doesn't add root interface if bases has at least one interface" do
+        stub_const('Accord::TestInterface', stub)
+        interface.should_receive(:bases=).with([Accord::TestInterface])
+        subject.run(interface) { extends Accord::TestInterface }
+      end
+
+      it "runs the block in an instance" do
+        instance = nil
+        subject.run(interface) { instance = self }
+        expect(instance).to be_a InterfaceBody
+      end
+    end
+  end
+end

data/spec/interface_members_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'accord/interface_members'
+
+module Accord
+  describe InterfaceMembers do
+    let(:interface) { stub }
+    let(:member)    { stub }
+
+    subject { InterfaceMembers.new(interface) }
+
+    it "doesn't have any member added by default" do
+      expect(subject[:m]).to be_nil
+    end
+
+    describe "#add" do
+      it "adds the member" do
+        subject.add(:m, member)
+        expect(subject[:m]).to be member
+      end
+    end
+
+    describe "#names" do
+      it "return added names as symbols" do
+        subject.add(:m, member)
+        expect(subject.names).to eq [:m]
+      end
+    end
+
+    describe "#added?" do
+      it "returns true if the method was added" do
+        subject.add(:m, member)
+        expect(subject).to be_added(:m)
+      end
+
+      it "returns false if the method was not added" do
+        expect(subject).to_not be_added(:m)
+      end
+    end
+
+    describe "#each" do
+      it "iterates over all members" do
+        names = []
+        members = []
+
+        m, n = stub, stub
+
+        subject.add(:m, m)
+        subject.add(:n, n)
+
+        subject.each { |name, member| names << name; members << member }
+
+        expect(names).to eq [:m, :n]
+        expect(members).to eq [m, n]
+      end
+    end
+  end
+end

data/spec/interface_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'accord/interface'
+
+module Accord
+  describe InterfaceClass do
+    before { Accord.clear_adapter_hooks }
+
+    specify "interfaces are just a kind of specification" do
+      expect(InterfaceClass.new(:I)).to be_a(Specification)
+    end
+
+    it "returns self as its single interface" do
+      interface = InterfaceClass.new(:I)
+      expect(interface.interfaces).to eq [interface]
+    end
+
+    it "returns ancestor specs in #ancestors" do
+      spec = Specification.new
+      interface = InterfaceClass.new(:I, [spec])
+
+      expect(interface.ancestors).to eq [interface, spec]
+    end
+
+    it "returns only ancestor interfaces in #iro" do
+      spec = Specification.new
+      interface = InterfaceClass.new(:I, [spec])
+
+      expect(interface.iro).to eq [interface]
+    end
+
+    describe "#provided_by?" do
+      let(:object)    { stub }
+      let(:interface) { InterfaceClass.new(:I) }
+
+      let(:provided_by_declaration) { stub(:extends? => false) }
+      let(:declarations_module)     { stub }
+
+      before do
+        stub_const('Accord::Declarations', declarations_module)
+        declarations_module.stub(:provided_by).with(object).
+          and_return(provided_by_declaration)
+      end
+
+      it "returns false if the object is not told to provide the interface" do
+        expect(interface).to_not be_provided_by(object)
+      end
+
+      it "returns true if the object is told to provide the interface" do
+        provided_by_declaration.stub(:extends?).with(interface).
+          and_return(true)
+        expect(interface).to be_provided_by(object)
+      end
+    end
+
+    describe "#implemented_by?" do
+      let(:factory)   { stub }
+      let(:interface) { InterfaceClass.new(:I) }
+
+      let(:implemented_by_declaration) { stub(:extends? => false) }
+      let(:declarations_module)        { stub }
+
+      before do
+        stub_const('Accord::Declarations', declarations_module)
+        declarations_module.stub(:implemented_by).with(factory).
+          and_return(implemented_by_declaration)
+      end
+
+      it "returns false if the factory is not told to implement the interface" do
+        expect(interface).to_not be_implemented_by(factory)
+      end
+
+      it "returns true if the factory is told to implement the interface" do
+        implemented_by_declaration.stub(:extends?).with(interface).
+          and_return(true)
+        expect(interface).to be_implemented_by(factory)
+      end
+    end
+
+    describe "#adapt" do
+      let(:interface) { InterfaceClass.new(:I) }
+      let(:object)    { stub }
+      let(:adapter)   { stub }
+      let(:hook_miss) { Proc.new { |iface, *obs| nil } }
+      let(:hook_hit)  { Proc.new { |iface, *obs| adapter } }
+
+      it "returns nil if no hook is installed" do
+        expect(interface.adapt(object)).to be_nil
+      end
+
+      it "returns nil if all hooks fail" do
+        Accord.install_adapter_hook(hook_miss)
+        Accord.install_adapter_hook(hook_miss)
+        Accord.install_adapter_hook(hook_miss)
+
+        expect(interface.adapt(object)).to be_nil
+      end
+
+      it "returns the result of the first hook which succeeds" do
+        hook_hit2 = Proc.new { |iface, *obs| 'other adapter' }
+
+        Accord.install_adapter_hook(hook_miss)
+        Accord.install_adapter_hook(hook_hit)
+        Accord.install_adapter_hook(hook_miss)
+        Accord.install_adapter_hook(hook_hit2)
+        Accord.install_adapter_hook(hook_miss)
+
+        expect(interface.adapt(object)).to be adapter
+      end
+
+      context "when the hook actually cares about what is being adapted" do
+        let(:hook_hit) { stub }
+
+        before do
+          hook_hit.stub(:call).with(interface, object, object).
+            and_return(adapter)
+          Accord.install_adapter_hook(hook_hit)
+        end
+
+        subject { interface.adapt(object, object) }
+        it      { should be adapter }
+      end
+    end
+
+    describe "#adapt!" do
+      let(:interface) { InterfaceClass.new(:I) }
+      let(:object)    { stub }
+      let(:adapter)   { stub }
+      let(:hook_miss) { Proc.new { |iface, *obs| nil } }
+      let(:hook_hit)  { Proc.new { |iface, *obs| adapter } }
+
+      it "raises TypeError if there's no hook installed" do
+        expect { interface.adapt!(object) }.to raise_error(TypeError)
+      end
+
+      it "raises TypeError if no hook provided a suitable adapter" do
+        Accord.install_adapter_hook(Proc.new { |iface, *obs| nil })
+
+        expect { interface.adapt!(object) }.to raise_error(TypeError)
+      end
+
+      it "returns the adapter if one hook succeeded" do
+        Accord.install_adapter_hook(Proc.new { |iface, *obs| adapter })
+        expect(interface.adapt!(object)).to be adapter
+      end
+    end
+  end
+end

data/spec/nested_key_hash_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'accord/nested_key_hash'
+
+module Accord
+  describe NestedKeyHash do
+    subject { NestedKeyHash.new }
+
+    let(:k1) { 'key 1' }
+    let(:k2) { 'key 2' }
+    let(:k3) { 'key 3' }
+
+    let(:key) { [k1, k2, k3] }
+
+    specify "empty hash returns nil" do
+      expect(subject[key]).to be_nil
+    end
+
+    it "adds a value using a composed key" do
+      value = stub
+      subject[key] = value
+      expect(subject[key]).to be value
+    end
+
+    specify "different keys store different values" do
+      value1 = stub
+      value2 = stub
+      subject[[k1, k2, k3]] = value1
+      subject[[k3, k2, k1]] = value2
+
+      expect(subject[[k1, k2, k3]]).to be value1
+      expect(subject[[k3, k2, k1]]).to be value2
+    end
+
+    it "overwrites a value when using the same key" do
+      old_value = stub
+      new_value = stub
+      subject[key] = old_value
+      subject[key] = new_value
+      expect(subject[key]).to be new_value
+    end
+
+    specify "keys not prefixing other already in use returns nil" do
+      subject[key] = 'a value'
+      expect(subject[[k2, k1, k3]]).to be_nil
+    end
+
+    specify "prefix keys returns hash containing the remaining keys nested" do
+      value = stub
+      subject[key] = value
+      expect(subject[[k1]]).to eq({ k2 => { k3 => value } })
+    end
+
+    it "deletes a key" do
+      subject[key] = 'a value'
+      subject.delete(key)
+      expect(subject[key]).to be_nil
+    end
+
+    specify "deleting returns the deleted value" do
+      value = stub
+      subject[key] = value
+      result = subject.delete(key)
+      expect(result).to be value
+    end
+
+    specify "deleting a key removes intermediate empty hashes" do
+      subject[key] = 'a value'
+      subject.delete(key)
+      expect(subject[[k1]]).to be_nil
+      expect(subject[[k1, k2]]).to be_nil
+    end
+
+    specify "deleting a key keeps intermediate non-empty hashes" do
+      value, another_value, k4, k5 = stub, stub, 'key 4', 'key 5'
+      subject[[k1, k2, k3, k4]] = value
+      subject[[k1, k2, k4, k5]] = another_value
+      subject.delete([k1, k2, k3, k4])
+
+      expect(subject[[k1, k2, k4, k5]]).to be another_value
+    end
+
+    describe "key lookup with expansion" do
+
+      let(:k11) { stub }
+      let(:k12) { stub }
+      let(:k13) { stub }
+      let(:k21) { stub }
+      let(:k22) { stub }
+      let(:k23) { stub }
+
+      let(:expansions) do
+        {
+          k1 => [k11, k12, k13],
+          k2 => [k21, k22, k23]
+        }
+      end
+
+      describe "#detect_expansion" do
+        it "hits the value with valid expansion" do
+          subject[[k11, k22]] = 'value'
+          result = subject.detect_expansion([k1, k2]) do |k|
+            expansions[k]
+          end
+          expect(result).to eq 'value'
+        end
+
+        it "misses the value with invalid expansion" do
+          subject[[k11, k12]] = 'value'
+          result = subject.detect_expansion([k1, k2]) do |k|
+            expansions[k]
+          end
+          expect(result).to be_nil
+        end
+      end
+
+      describe "#select_expansions" do
+        it "hits the values matching some valid expansion" do
+          subject[[k11, k22]] = 'value'
+          subject[[k12, k21]] = 'other value'
+
+          result = subject.select_expansions([k1, k2]) do |k|
+            expansions[k]
+          end
+          expect(result).to eq ['value', 'other value']
+        end
+
+        it "misses if no valid expansion is found" do
+          subject[[k11, k12]] = 'value'
+          subject[[k11, k13]] = 'other value'
+
+          result = subject.select_expansions([k1, k2]) do |k|
+            expansions[k]
+          end
+
+          expect(result).to be_empty
+        end
+      end
+    end
+  end
+end