accord 0.1.0

data/spec/integration/named_adapters_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Named adapters" do
+  let(:registry) { Accord::AdapterRegistry.new }
+
+  context "single" do
+    let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+    let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+
+    before do
+      registry.register([ir1], ip1, '') { 1 }
+      registry.register([ir1], ip1, 'bob') { 2 }
+    end
+
+    subject do
+      registry.lookup_all([ir1], ip1).map { |name, fac| [name, fac.call] }
+    end
+
+    it { should eq [['', 1], ['bob', 2]] }
+  end
+
+  context "multi" do
+    let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+    let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+    let(:ir2) { Accord::InterfaceClass.new(:ir2, [Accord::Interface]) }
+
+    before do
+      registry.register([ir1, ir2], ip1, '') { 1 }
+      registry.register([ir1, ir2], ip1, 'bob') { 2 }
+    end
+
+    subject do
+      registry.lookup_all([ir1, ir2], ip1).map { |name, fac| [name, fac.call] }
+    end
+
+    it { should eq [['', 1], ['bob', 2]] }
+  end
+
+  context "null" do
+    let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+
+    before do
+      registry.register([], ip1, '') { 1 }
+      registry.register([], ip1, 'bob') { 2 }
+    end
+
+    subject do
+      registry.lookup_all([], ip1).map { |name, fac| [name, fac.call] }
+    end
+
+    it { should eq [['', 1], ['bob', 2]] }
+  end
+end

data/spec/integration/single_adapters_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Single adapters" do
+  let(:registry) { Accord::AdapterRegistry.new }
+  let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+  let(:ir2) { Accord::InterfaceClass.new(:ir2, [ir1]) }
+  let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+  let(:ip2) { Accord::InterfaceClass.new(:ip2, [ip1]) }
+  let(:ip3) { Accord::InterfaceClass.new(:ip3, [ip2]) }
+
+  before do
+    registry.register([ir1], ip2, '') { 12 }
+  end
+
+  specify "exact lookup" do
+    expect(registry.lookup([ir1], ip2, '').call).to eq 12
+  end
+
+  specify "lookup using an extension of a previously registered adapter" do
+    expect(registry.lookup([ir2], ip2, '').call).to eq 12
+  end
+
+  specify "lookup by class implementation" do
+    cls = Class.new
+    Accord::Declarations.implements(cls, ir2)
+    expect(registry.lookup([ir2], ip2, '').call).to eq 12
+  end
+
+  specify "lookup for interface whose registration's provided extends" do
+    expect(registry.lookup([ir2], ip1, '').call).to eq 12
+  end
+
+  specify "lookup for spec not extending registered one" do
+    expect(registry.lookup([Accord::Interface], ip1, '')).to be_nil
+  end
+
+  specify "lookup for spec not extending registered one, with default" do
+    expect(registry.lookup([Accord::Interface], ip1, '',
+                           default: lambda { 42 }).call).to eq 42
+  end
+
+  specify "lookup for interface not provided by any registration" do
+    expect(registry.lookup([ir1], ip3, '')).to be_nil
+  end
+
+  specify "lookup by name" do
+    expect(registry.lookup([ir1], ip1, 'bob')).to be_nil
+    registry.register([ir1], ip2, 'bob') { "Bob's 12" }
+    expect(registry.lookup([ir1], ip1, 'bob').call).to eq "Bob's 12"
+  end
+
+  specify "lookup omitting name" do
+    expect(registry.lookup([ir1], ip1).call).to eq 12
+  end
+
+  specify "lookup for adapter providing more appropriated spec" do
+    registry.register([ir1], ip1, '') { 11 }
+    expect(registry.lookup([ir1], ip1, '').call).to eq 11
+  end
+
+  specify "lookup for more specific adapter" do
+    registry.register([ir2], ip2, '') { 21 }
+    expect(registry.lookup([ir2], ip1, '').call).to eq 21
+  end
+
+  describe "detecting exactly matches" do
+    specify "getting less specific" do
+      registry.register([ir1], ip1, '') { 11 }
+      expect(registry.first(required: [ir1], provided: ip1).call).to eq 11
+    end
+
+    specify "getting more specific" do
+      expect(registry.first(required: [ir1], provided: ip2).call).to eq 12
+    end
+
+    specify "getting more specific with name" do
+      registry.register([ir1], ip2, 'bob') { "Bob's 12" }
+      expect(
+        registry.first(required: [ir1], provided: ip2, name: 'bob').call
+      ).to eq "Bob's 12"
+    end
+
+    specify "using more specific required interface" do
+      registry.register([ir2], ip2, '') { 21 }
+      expect(registry.first(required: [ir2], provided: ip2).call).to eq 21
+    end
+
+    specify "missing by trying to get a unregistered adapter" do
+      expect(registry.first(required: [ir2], provided: ip2)).to be_nil
+    end
+  end
+end

data/spec/integration/subscriptions_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Subscriptions" do
+  let(:registry) { Accord::SubscriptionRegistry.new }
+  let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+  let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+
+  context "single" do
+    context "registrations for same interface" do
+      before do
+        registry.subscribe([ir1], ip1) { 'sub1' }
+        registry.subscribe([ir1], ip1) { 'sub2' }
+      end
+
+      specify "are returned by order of definition" do
+        items = registry.lookup([ir1], ip1).map do |sub|
+          sub.call
+        end
+        expect(items).to eq ['sub1', 'sub2']
+      end
+
+      context "and also for all interfaces" do
+        before do
+          registry.subscribe([nil], ip1) { 'general' }
+        end
+
+        specify "are returned first" do
+          items = registry.lookup([ir1], ip1).map do |sub|
+            sub.call
+          end
+          expect(items).to eq ['general', 'sub1', 'sub2']
+        end
+      end
+    end
+  end
+
+  context "multi" do
+    let(:ir2) { Accord::InterfaceClass.new(:ir2, [Accord::Interface]) }
+
+    before do
+      registry.subscribe([ir1, ir2], ip1) { 'sub1' }
+      registry.subscribe([ir1, ir2], ip1) { 'sub2' }
+    end
+
+    specify "are returned by order of definition" do
+      items = registry.lookup([ir1, ir2], ip1).map do |sub|
+        sub.call
+      end
+      expect(items).to eq ['sub1', 'sub2']
+    end
+
+    context "with a registration for all interfaces as first discriminator" do
+      before do
+        registry.subscribe([nil, ir2], ip1) { 'general' }
+      end
+
+      it "returns that registration first" do
+        items = registry.lookup([ir1, ir2], ip1).map do |sub|
+          sub.call
+        end
+        expect(items).to eq ['general', 'sub1', 'sub2']
+      end
+    end
+  end
+
+  context "null" do
+    before do
+      registry.subscribe([], ip1) { 'sub1' }
+      registry.subscribe([], ip1) { 'sub2' }
+    end
+
+    specify "are returned by order of definition" do
+      items = registry.lookup([], ip1).map do |sub|
+        sub.call
+      end
+      expect(items).to eq ['sub1', 'sub2']
+    end
+  end
+
+  describe "unregistration" do
+    let(:subscriber1) { Proc.new { 'sub1' } }
+    let(:subscriber2) { Proc.new { 'sub2' } }
+
+    before do
+      registry.subscribe([ir1], ip1, &subscriber1)
+      registry.subscribe([ir1], ip1, &subscriber2)
+    end
+
+    subject { registry.lookup([ir1], ip1).map { |sub| sub.call } }
+
+    context "when a specific subscriber is specified" do
+      before do
+        registry.unsubscribe([ir1], ip1, subscriber1)
+      end
+
+      it "unregisters only it" do
+        expect(subject).to eq ['sub2']
+      end
+    end
+
+    context "when no subscriber is specified" do
+      before do
+        registry.unsubscribe([ir1], ip1)
+      end
+
+      it "unregisters all" do
+        expect(subject).to be_empty
+      end
+    end
+  end
+
+  describe "Subscription adapters" do
+    let(:cls) { Class.new { Accord::Declarations.implements(self, IR1) } }
+    let(:obj) { cls.new }
+
+    before { stub_const('IR1', ir1) }
+
+    context "single" do
+      let(:calls) { [] }
+      let(:s1)    { Proc.new { |o| calls << ['sub1', o]; ['sub1', o] } }
+      let(:s2)    { Proc.new { |o| calls << ['sub2', o]; ['sub2', o] } }
+
+      before do
+        registry.subscribe([ir1], ip1, &s1)
+        registry.subscribe([ir1], ip1, &s2)
+      end
+
+      specify "are get in the order they are subscribed" do
+        items = registry.get([obj], ip1)
+        expect(items).to eq [['sub1', obj], ['sub2', obj]]
+      end
+
+      specify "are called in the order they are subscribed" do
+        registry.call([obj], ip1)
+        expect(calls).to eq [['sub1', obj], ['sub2', obj]]
+      end
+
+      context "when a nil is returned by the subscriber" do
+        before do
+          registry.subscribe([ir1], ip1) { nil }
+        end
+
+        specify "#get doesn't return it" do
+          items = registry.get([obj], ip1)
+          expect(items).to eq [['sub1', obj], ['sub2', obj]]
+        end
+      end
+    end
+
+    context "multiple" do
+      let(:ir2)  { Accord::InterfaceClass.new(:ir2, [Accord::Interface]) }
+      let(:cls2) { Class.new { Accord::Declarations.implements(self, IR2) } }
+      let(:obj2) { cls2.new }
+
+      let(:calls) { [] }
+      let(:s1)    { Proc.new { |r1, r2| calls << [1, r1, r2]; [1, r1, r2] } }
+      let(:s2)    { Proc.new { |r1, r2| calls << [2, r1, r2]; [2, r1, r2] } }
+
+      before do
+        stub_const('IR2', ir2)
+        registry.subscribe([ir1, ir2], ip1, &s1)
+        registry.subscribe([ir1, ir2], ip1, &s2)
+      end
+
+      specify "are get in the order they are subscribed" do
+        items = registry.get([obj, obj2], ip1)
+        expect(items).to eq [[1, obj, obj2], [2, obj, obj2]]
+      end
+
+      specify "are called in the order they are subscribed" do
+        registry.call([obj, obj2], ip1)
+        expect(calls).to eq [[1, obj, obj2], [2, obj, obj2]]
+      end
+
+      context "when a nil is returned by the subscriber" do
+        before do
+          registry.subscribe([ir1, ir2], ip1) { nil }
+        end
+
+        specify "#get doesn't return it" do
+          items = registry.get([obj, obj2], ip1)
+          expect(items).to eq [[1, obj, obj2], [2, obj, obj2]]
+        end
+      end
+    end
+
+    context "null" do
+      let(:calls) { [] }
+
+      before do
+        registry.subscribe([], ip1) { |*args| calls << [1, args]; 1 }
+        registry.subscribe([], ip1) { |*args| calls << [2, args]; 2 }
+      end
+
+      specify "are get in the order they are subscribed" do
+        items = registry.get([], ip1)
+        expect(items).to eq [1, 2]
+      end
+
+      specify "are called in the order they are subscribed" do
+        registry.call([], ip1)
+        expect(calls).to eq [[1, []], [2, []]]
+      end
+
+      context "when a nil is returned by the subscriber" do
+        before do
+          registry.subscribe([], ip1) { nil }
+        end
+
+        specify "#get doesn't return it" do
+          items = registry.get([], ip1)
+          expect(items).to eq [1, 2]
+        end
+      end
+    end
+  end
+
+  describe "Handlers" do
+    let(:arguments) { [] }
+    let(:obj)       { Object.new }
+
+    before do
+      registry.subscribe([ir1], nil) { |*args| arguments.concat(args) }
+    end
+
+    context "when required objects are satisfied" do
+      before do
+        Accord::Declarations.also_provides(obj, ir1)
+      end
+
+      specify "are called in the order they are defined" do
+        registry.call([obj], nil)
+        expect(arguments).to eq [obj]
+      end
+    end
+
+    context "when required objects are not satisfied" do
+      specify "are not called" do
+        registry.call([obj], nil)
+        expect(arguments).to be_empty
+      end
+    end
+  end
+end

data/spec/integration/verification_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Verification" do
+  before do
+    stub_const('TestModule', Module.new)
+
+    Accord::Interface(TestModule, :B1) do
+      responds_to :method1
+    end
+
+    Accord::Interface(TestModule, :B2) do
+      responds_to :method2, params: :arg
+    end
+
+    Accord::Interface(TestModule, :B3) do
+      responds_to :method3, params: [ :arg1, :arg2 ]
+    end
+
+    Accord::Interface(TestModule, :B4) do
+      responds_to :method4, params: [ :arg1, { arg2: :default } ]
+    end
+
+    Accord::Interface(TestModule, :B5) do
+      responds_to :method5, params: [ :arg1, :"*arg2", :"&block" ]
+    end
+
+    Accord::Interface(TestModule, :I) do
+      extends TestModule::B1
+      extends TestModule::B2
+      extends TestModule::B3
+      extends TestModule::B4
+      extends TestModule::B5
+    end
+  end
+
+  describe "objects" do
+    let(:candidate) { Object.new }
+
+    context "when candidate not even provides the interface" do
+      it "raises DoesNotImplement" do
+        expect {
+          TestModule::I.verify_object(candidate)
+        }.to raise_error(Accord::DoesNotImplement)
+      end
+    end
+
+    context "when candidate at least provides the interface" do
+      before do
+        Accord::Declarations.also_provides(candidate, TestModule::I)
+      end
+
+      context "when candidate has none of the methods" do
+        it "raises BrokenImplementation" do
+          expect {
+            TestModule::I.verify_object(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when candidate is missing one of the methods" do
+        it "raises BrokenImplementation" do
+          def candidate.method1; end
+          def candidate.method2(a1, a2); end
+          def candidate.method3(a1, a2=:any); end
+          expect {
+            TestModule::I.verify_object(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when the candidate has all methods, but signatures don't "\
+              "match" do
+        it "raises BrokenImplementation" do
+          def candidate.method1; end
+          def candidate.method2(a1); end
+          def candidate.method3(a1, a2); end
+          def candidate.method4(a1, a2); end
+          def candidate.method5; end
+          expect {
+            TestModule::I.verify_object(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when all methods match signature" do
+        it "doesn't raise" do
+          def candidate.method1; end
+          def candidate.method2(a1); end
+          def candidate.method3(a1, a2); end
+          def candidate.method4(a1, a2=:any); end
+          def candidate.method5(a1, *a2, &block); end
+          expect {
+            TestModule::I.verify_object(candidate)
+          }.to_not raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when a method has a default as last argument" do
+        it "doesn't raise if it still can be called with that argument" do
+          def candidate.method1(a1=nil); end
+          def candidate.method2(a1, a2=nil); end
+          def candidate.method3(a1, a2=nil); end
+          def candidate.method4(a1, a2=:any); end
+          def candidate.method5(a1, *a2, &block); end
+          expect {
+            TestModule::I.verify_object(candidate)
+          }.to_not raise_error(Accord::BrokenImplementation)
+        end
+      end
+    end
+  end
+
+  describe "module" do
+    let(:candidate) { Module.new }
+
+    context "when candidate not even implements the interface" do
+      it "raises DoesNotImplement" do
+        expect {
+          TestModule::I.verify_module(candidate)
+        }.to raise_error(Accord::DoesNotImplement)
+      end
+    end
+
+    context "when candidate at least implements the interface" do
+      before do
+        Accord::Declarations.implements(candidate, TestModule::I)
+      end
+
+      context "when candidate has none of the methods" do
+        it "raises BrokenImplementation" do
+          expect {
+            TestModule::I.verify_module(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when candidate is missing one of the methods" do
+        it "raises BrokenImplementation" do
+          candidate.module_eval do
+            def method1; end
+            def method2(a1, a2); end
+            def method3(a1, a2=:any); end
+          end
+          expect {
+            TestModule::I.verify_module(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when the candidate has all methods, but signatures don't "\
+              "match" do
+        it "raises BrokenImplementation" do
+          candidate.module_eval do
+            def method1; end
+            def method2(a1); end
+            def method3(a1, a2); end
+            def method4(a1, a2); end
+            def method5; end
+          end
+          expect {
+            TestModule::I.verify_module(candidate)
+          }.to raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when all methods match signature" do
+        it "doesn't raise" do
+          candidate.module_eval do
+            def method1; end
+            def method2(a1); end
+            def method3(a1, a2); end
+            def method4(a1, a2=:any); end
+            def method5(a1, *a2, &block); end
+          end
+          expect {
+            TestModule::I.verify_module(candidate)
+          }.to_not raise_error(Accord::BrokenImplementation)
+        end
+      end
+
+      context "when a method has a default as last argument" do
+        it "doesn't raise if it still can be called with that argument" do
+          candidate.module_eval do
+            def method1(a1=nil); end
+            def method2(a1, a2=nil); end
+            def method3(a1, a2=nil); end
+            def method4(a1, a2=:any); end
+            def method5(a1, *a2, &block); end
+          end
+          expect {
+            TestModule::I.verify_module(candidate)
+          }.to_not raise_error(Accord::BrokenImplementation)
+        end
+      end
+    end
+  end
+
+  module Accord
+    describe "implementations" do
+      specify "interfaces should be implemented" do
+        Interfaces::Tags.verify_module(Tags)
+        Interfaces::SignatureInfo.verify_module(SignatureInfo)
+        Interfaces::Method.verify_module(InterfaceMethod)
+        Interfaces::Specification.verify_module(Specification)
+        Interfaces::Interface.verify_module(InterfaceClass)
+        Interfaces::Declaration.verify_module(Declarations::Declaration)
+        Interfaces::InterfaceDeclarations.verify_object(Declarations)
+        Interfaces::AdapterRegistry.verify_module(AdapterRegistry)
+        Interfaces::SubscriptionRegistry.verify_module(SubscriptionRegistry)
+        Interfaces::InterfaceBody.verify_module(InterfaceBody)
+      end
+    end
+  end
+end