accord 0.1.0

data/spec/integration/adapter_for_class_declaration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Adapter for class declaration" do
+  let(:ip1)      { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+  let(:registry) { Accord::AdapterRegistry.new }
+
+  context "given a class claiming to implement an interface" do
+    let(:cls) { Class.new }
+    before { Accord::Declarations.implements(cls, ip1) }
+
+    context "and a registration using the class declaration" do
+      let(:declaration) { Accord::Declarations.implemented_by(cls) }
+
+      before { registry.register([declaration], ip1, '') { 'value' } }
+
+      it "returns that when the claimed interface is used for lookup" do
+        expect(registry.lookup([declaration], ip1).call).to eq 'value'
+      end
+    end
+  end
+end

data/spec/integration/adapter_hook_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'accord'
+
+module Accord
+  describe "Adapter hook" do
+    before do
+      Accord.install_default_adapter_hook
+    end
+
+    after do
+      Accord.clear_adapter_hooks
+      Accord.clear_default_adapter_hook
+    end
+
+    let(:itarget)  { InterfaceClass.new(:itarget, [Interface]) }
+    let(:registry) { Accord.default_adapter_registry }
+
+    it "makes interfaces adapt using the default adapter hook" do
+      ir = InterfaceClass.new(:ir, [Interface])
+      registry.register([ir], itarget) { 'adapted' }
+
+      obj = Object.new
+      Accord::Declarations.also_provides(obj, ir)
+
+      expect(itarget.adapt(obj)).to eq 'adapted'
+    end
+
+    it "also enables multi adaptation from interfaces" do
+      ir1 = InterfaceClass.new(:ir1, [Interface])
+      ir2 = InterfaceClass.new(:ir2, [Interface])
+      registry.register([ir1, ir2], itarget) { 'adapted' }
+
+      obj1 = Object.new
+      obj2 = Object.new
+      Declarations.also_provides(obj1, ir1)
+      Declarations.also_provides(obj2, ir2)
+
+      expect(itarget.adapt(obj1, obj2)).to eq 'adapted'
+    end
+  end
+end

data/spec/integration/default_adapters_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Default adapters" do
+  let(:registry) { Accord::AdapterRegistry.new }
+  let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+  let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+
+  before do
+    stub_const('IP1', ip1)
+    stub_const('IR1', ir1)
+  end
+
+  context "single" do
+    before do
+      registry.register([nil], IP1, '') { 1 }
+    end
+
+    context "for interfaces we don't have specific adapters for" do
+      let(:iq) { Accord::InterfaceClass.new(:iq, [Accord::Interface]) }
+
+      it "finds the default adapter" do
+        expect(registry.lookup([iq], IP1, '').call).to eq 1
+      end
+    end
+
+    context "when a specific adapter is also registered" do
+      let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+
+      before do
+        registry.register([ir1], IP1, '') { 2 }
+      end
+
+      it "overrides the default" do
+        expect(registry.lookup([ir1], IP1, '').call).to eq 2
+      end
+    end
+  end
+
+  context "multi" do
+    before do
+      registry.register([nil, IR1], IP1, '') { 1 }
+    end
+
+    context "for interfaces we don't have specific adapters for" do
+      let(:iq) { Accord::InterfaceClass.new(:iq, [Accord::Interface]) }
+
+      it "finds the default adapter" do
+        expect(registry.lookup([iq, IR1], IP1, '').call).to eq 1
+      end
+    end
+
+    context "when a specific adapter is also registered" do
+      let(:ir2) { Accord::InterfaceClass.new(:ir2, [Accord::Interface]) }
+
+      before do
+        registry.register([ir2, IR1], IP1, '') { 2 }
+      end
+
+      it "overrides the default" do
+        expect(registry.lookup([ir2, IR1], IP1, '').call).to eq 2
+      end
+    end
+  end
+
+  context "null" do
+    let(:ip2) { Accord::InterfaceClass.new(:ip2, [ip1]) }
+
+    before do
+      registry.register([], ip2, '') { 'null adapter' }
+    end
+
+    it "also can adapt no specification" do
+      expect(registry.lookup([], ip2, '').call).to eq 'null adapter'
+    end
+
+    it "will take into consideration any extending interface" do
+      expect(registry.lookup([], IP1, '').call).to eq 'null adapter'
+    end
+  end
+end

data/spec/integration/hash_adapters_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Hash adapters" do
+  let(:ip)       { Accord::InterfaceClass.new(:ip, [Accord::Interface]) }
+  let(:registry) { Accord::AdapterRegistry.new }
+
+  context "given a hash" do
+    let(:hash) { Hash.new }
+
+    context "and a registration for it using no required interfaces" do
+      before { registry.register([], ip, '') { hash } }
+
+      it "returns that when the lookup is made without required interfaces "\
+         "for the right provided interface" do
+        expect(registry.lookup([], ip).call).to be hash
+      end
+    end
+  end
+end

data/spec/integration/interface_declaration_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Accord::Interface method" do
+  let(:mod) { Module.new }
+  let(:not_constant) do
+    Accord::Interface(:NotConstant) do
+      responds_to :method
+    end
+  end
+
+  before do
+    stub_const('TestModule', mod)
+
+    Accord::Interface(TestModule, :Base) do
+      responds_to :method1
+
+      invariant :invariant do |ob, errors|
+        ob.base_invariant_ran
+        errors << :base if ob.set_error
+        :ignore_return
+      end
+
+      tags[:tag] = :base
+      interface[:method1].tags[:tag] = :value
+    end
+
+    Accord::Interface(TestModule, :Extension) do
+      extends TestModule::Base
+
+      responds_to :method2, params: [{ param: :default }]
+
+      invariant :invariant do |ob, errors|
+        ob.extension_invariant_ran
+        errors << :extension if ob.set_error
+        :ignore_return
+      end
+
+      invariant :exclusive do |ob, errors|
+        ob.exclusive_invariant_ran
+        errors << :extension if ob.set_error
+        :ignore_return
+      end
+    end
+
+    Accord::Interface(TestModule, :OtherExtension) do
+      extends TestModule::Base
+
+      responds_to :method1 do
+        param :argument
+      end
+
+      responds_to :method2, params: { param: :default }
+      responds_to :method3, params: :argument
+    end
+  end
+
+  it "can be declared without a block" do
+    Accord::Interface(TestModule, :Marker)
+    expect(TestModule::Marker).to be_a(Accord::InterfaceClass)
+  end
+
+  describe "not constant" do
+    it "has a simpler name" do
+      expect(not_constant.name).to eq 'NotConstant'
+    end
+  end
+
+  describe "Base" do
+    it "has a name" do
+      expect(TestModule::Base.name).to eq 'TestModule::Base'
+    end
+
+    it "has :method1" do
+      expect(TestModule::Base).to be_defined(:method1)
+      expect(TestModule::Base).to be_owns(:method1)
+    end
+
+    specify "base's method can be obtained by calling #[]" do
+      expect(TestModule::Base[:method1].interface).to be TestModule::Base
+    end
+
+    it " has no method :method2" do
+      expect(TestModule::Base).to_not be_defined(:method2)
+      expect(TestModule::Base).to_not be_owns(:method2)
+    end
+
+    it "has a single method" do
+      expect(TestModule::Base.member_names).to eq [:method1]
+      expect(TestModule::Base.own_member_names).to eq [:method1]
+    end
+
+    it "iterates only over :method1" do
+      names = []
+      members = []
+
+      TestModule::Base.each do |name, member|
+        names << name
+        members << member
+      end
+
+      expect(names).to eq [:method1]
+      expect(members.map(&:interface)).to eq [TestModule::Base]
+    end
+
+    specify ":method1 doesn't require a parameter" do
+      expect(TestModule::Base[:method1].signature_info.arguments).to be_empty
+    end
+
+    it "has a tagged value" do
+      expect(TestModule::Base.tags[:tag]).to eq :base
+    end
+
+    it "can have tags on methods" do
+      expect(TestModule::Base[:method1].tags[:tag]).to eq :value
+    end
+
+    describe "invariants" do
+      let(:ob) { stub(base_invariant_ran: nil, set_error: false) }
+
+      it "runs only one invariant" do
+        ob.should_receive(:base_invariant_ran)
+        TestModule::Base.assert_invariants?(ob)
+      end
+
+      it "returns true if no error is set" do
+        result = TestModule::Base.assert_invariants?(ob)
+        expect(result).to be_true
+      end
+
+      it "returns false if an error is set" do
+        ob.stub(set_error: true)
+        result = TestModule::Base.assert_invariants?(ob)
+        expect(result).to be_false
+      end
+
+      it "collects errors" do
+        ob.stub(set_error: true)
+        errors = []
+        TestModule::Base.assert_invariants?(ob, errors)
+        expect(errors).to eq [:base]
+      end
+
+      describe "with exception" do
+        it "raise error if invariant set error" do
+          ob.stub(set_error: true)
+          expect {
+            TestModule::Base.assert_invariants(ob)
+          }.to raise_error(Accord::Invalid)
+        end
+
+        it "collects errors before raising" do
+          ob.stub(set_error: true)
+          errors = []
+          TestModule::Base.assert_invariants(ob, errors) rescue nil
+
+          expect(errors).to eq [:base]
+        end
+      end
+    end
+  end
+
+  describe "Extension" do
+    it "has :method1" do
+      expect(TestModule::Extension.member_names).to include(:method1)
+      expect(TestModule::Extension).to be_defined(:method1)
+    end
+
+    it "doesn't owns :method1" do
+      expect(TestModule::Extension).to_not be_owns(:method1)
+    end
+
+    it "has :method2" do
+      expect(TestModule::Extension.member_names).to include(:method1)
+      expect(TestModule::Extension).to be_defined(:method2)
+    end
+
+    it "owns :method2" do
+      expect(TestModule::Extension).to be_owns(:method2)
+    end
+
+    it "has :method1 and :method2 defined in this order" do
+      expect(TestModule::Extension.member_names).to eq [:method1, :method2]
+    end
+
+    it "has :method2 defined in itself" do
+      expect(TestModule::Extension.own_member_names).to eq [:method2]
+    end
+
+    specify ":method2 requires a parameter with a default value" do
+      expect(TestModule::Extension[:method2].signature_info.arguments).to(
+        eq([{ name: :param, default: :default }])
+      )
+    end
+
+    specify "tags are not inherited" do
+      expect(TestModule::Extension.tags[:tag]).to be_nil
+    end
+
+    specify "tags on methods are inherited if the method is inherited" do
+      expect(TestModule::Extension[:method1].tags[:tag]).to eq :value
+    end
+
+    describe "invariants" do
+      let(:ob) do
+        stub(
+          set_error: false,
+          base_invariant_ran: nil,
+          extension_invariant_ran: nil,
+          exclusive_invariant_ran: nil,
+        )
+      end
+
+      it "runs invariants from base" do
+        ob.should_receive(:base_invariant_ran)
+        TestModule::Extension.assert_invariants?(ob)
+      end
+
+      it "runs invariants with the same name as the ones from base" do
+        ob.should_receive(:extension_invariant_ran)
+        TestModule::Extension.assert_invariants?(ob)
+      end
+
+      it "runs invariants included only in extension" do
+        ob.should_receive(:exclusive_invariant_ran)
+        TestModule::Extension.assert_invariants?(ob)
+      end
+    end
+  end
+
+  describe "OtherExtension" do
+    it "overrides :method1 to require an argument" do
+      expect(TestModule::OtherExtension[:method1].signature_info.arguments).to(
+        eq([{ name: :argument }])
+      )
+    end
+
+    it "keeps the original method as it was" do
+      expect(TestModule::Base[:method1].signature_info.arguments).to be_empty
+    end
+
+    specify "tags on methods are not inherited if the method is overridden" do
+      expect(TestModule::OtherExtension[:method1].tags[:tag]).to be_nil
+    end
+
+    specify ":method2 has an optional parameter" do
+      expect(TestModule::OtherExtension[:method2].signature_info.arguments).to(
+        eq([{ name: :param, default: :default }])
+      )
+    end
+
+    specify ":method3 has a single required parameter" do
+      expect(TestModule::OtherExtension[:method3].signature_info.arguments).to(
+        eq([{ name: :argument }])
+      )
+    end
+  end
+end

data/spec/integration/multi_adapters_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Multi adapters" do
+  let(:ip)  { Accord::InterfaceClass.new(:ip, [Accord::Interface]) }
+  let(:ir1) { Accord::InterfaceClass.new(:ir1, [Accord::Interface]) }
+  let(:ir2) { Accord::InterfaceClass.new(:ir2, [Accord::Interface]) }
+
+  let(:registry) { Accord::AdapterRegistry.new }
+
+  before do
+    stub_const('IR1', ir1)
+    stub_const('IR2', ir2)
+  end
+
+  context "given a factory requiring more than one parameter" do
+    let(:factory) { Proc.new { |o1, o2| 'factory result' } }
+
+    context "and a registered adapter for those discriminators" do
+      before do
+        registry.register([ir1, ir2], ip, '') { 'adapter' }
+      end
+
+      context "when a query is made for objects providing those "\
+              "required interfaces" do
+        let(:cls1) { Class.new { Accord::Declarations.implements(self, IR1) } }
+        let(:cls2) { Class.new { Accord::Declarations.implements(self, IR2) } }
+
+        let(:r1) { cls1.new }
+        let(:r2) { cls2.new }
+
+        subject { registry.get([r1, r2], ip, '') }
+
+        it { should eq 'adapter' }
+      end
+
+      context "when a query is made for objects providing those "\
+              "required interfaces with the wrong name" do
+        let(:cls1) { Class.new { Accord::Declarations.implements(self, IR1) } }
+        let(:cls2) { Class.new { Accord::Declarations.implements(self, IR2) } }
+
+        let(:r1) { cls1.new }
+        let(:r2) { cls2.new }
+
+        subject { registry.get([r1, r2], ip, 'not unamed') }
+
+        it { should be_nil }
+      end
+    end
+
+    context "and a named registered adapter for those discriminators" do
+      before do
+        registry.register([ir1, ir2], ip, 'bob') { 'adapter' }
+      end
+
+      context "when a query is made for objects providing those "\
+              "required interfaces with the right name" do
+        let(:cls1) { Class.new { Accord::Declarations.implements(self, IR1) } }
+        let(:cls2) { Class.new { Accord::Declarations.implements(self, IR2) } }
+
+        let(:r1) { cls1.new }
+        let(:r2) { cls2.new }
+
+        subject { registry.get([r1, r2], ip, 'bob') }
+
+        it { should eq 'adapter' }
+      end
+
+      context "when a query is made for objects providing those "\
+              "required interfaces with the wrong name (unamed)" do
+        let(:cls1) { Class.new { Accord::Declarations.implements(self, IR1) } }
+        let(:cls2) { Class.new { Accord::Declarations.implements(self, IR2) } }
+
+        let(:r1) { cls1.new }
+        let(:r2) { cls2.new }
+
+        subject { registry.get([r1, r2], ip, '') }
+
+        it { should be_nil }
+      end
+    end
+  end
+end