accord 0.1.0

data/spec/declarations_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'accord/declarations'
+require 'accord/interface'
+
+module Accord
+  describe Declarations do
+    let(:i1)  { InterfaceClass.new(:I1, [Interface]) }
+    let(:cls) { Class.new }
+
+    describe "class declarations" do
+      let(:mod) { Module.new }
+
+      specify "are empty by default" do
+        expect(Declarations.implemented_by(cls).interfaces).to be_empty
+      end
+
+      describe "implemented" do
+        it "can be modified to implement a specific interface" do
+          Declarations.implements(cls, i1)
+          expect(Declarations.implemented_by(cls)).to be_extend(i1)
+        end
+
+        it "can inherit interfaces from superclasses" do
+          Declarations.implements(cls, i1)
+          subclass = Class.new(cls)
+          expect(Declarations.implemented_by(subclass)).to be_extend(i1)
+        end
+
+        it "can inherit interfaces from included modules" do
+          Declarations.implements(mod, i1)
+          cls.send(:include, mod)
+          expect(Declarations.implemented_by(cls)).to be_extend(i1)
+        end
+
+        it "makes the class to implement the interface" do
+          Declarations.implements(cls, i1)
+          expect(i1).to be_implemented_by(cls)
+        end
+
+        it "makes instance to provide the interface" do
+          Declarations.implements(cls, i1)
+          expect(i1).to be_provided_by(cls.new)
+        end
+      end
+
+      describe "implemented only" do
+        let(:i2) { InterfaceClass.new(:i2, [Interface]) }
+
+        before do
+          Declarations.implements(cls, i1)
+        end
+
+        it "can be modified to implement a specific interface only" do
+          Declarations.implements_only(cls, i2)
+          expect(Declarations.implemented_by(cls)).to be_extend(i2)
+          expect(Declarations.implemented_by(cls)).to_not be_extend(i1)
+        end
+      end
+    end
+
+    describe "proc declarations" do
+      let(:prc) { Proc.new {} }
+
+      specify "are empty by default" do
+        expect(Declarations.implemented_by(prc).interfaces).to be_empty
+      end
+
+      describe "implemented" do
+        it "can be modified to implement a specific interface" do
+          Declarations.implements(prc, i1)
+          expect(Declarations.implemented_by(prc)).to be_extend(i1)
+        end
+      end
+
+      describe "implemented only" do
+        let(:i2) { InterfaceClass.new(:i2, [Interface]) }
+
+        before do
+          Declarations.implements(prc, i1)
+        end
+
+        it "can be modified to implement a specific interface only" do
+          Declarations.implements_only(prc, i2)
+          expect(Declarations.implemented_by(prc)).to be_extend(i2)
+          expect(Declarations.implemented_by(prc)).to_not be_extend(i1)
+        end
+      end
+    end
+
+    describe "object declarations" do
+      let(:i2)  { InterfaceClass.new(:i2, [Interface]) }
+      let(:obj) { cls.new }
+
+      specify "are empty by default" do
+        expect(Declarations.provided_by(obj).interfaces).to be_empty
+      end
+
+      describe ".also_provides" do
+        it "makes the object to provide an interface" do
+          Declarations.also_provides(obj, i1)
+          expect(i1).to be_provided_by(obj)
+        end
+
+        it "adds interfaces to the object" do
+          Declarations.also_provides(obj, i1)
+          Declarations.also_provides(obj, i2)
+          expect(i2).to be_provided_by(obj)
+        end
+      end
+
+      describe ".directly_provides" do
+        it "makes an object to provide only the given interfaces" do
+          Declarations.also_provides(obj, i2)
+          Declarations.directly_provides(obj, i1)
+          expect(i1).to be_provided_by(obj)
+          expect(i2).to_not be_provided_by(obj)
+        end
+
+        it "doesn't affect interfaces provided from the object's class" do
+          Declarations.implements(cls, i1)
+          Declarations.directly_provides(obj, i2)
+          expect(i1).to be_provided_by(obj)
+          expect(i2).to be_provided_by(obj)
+        end
+      end
+
+      describe ".no_longer_provides" do
+        it "makes the object to not provide a specific interface" do
+          Declarations.also_provides(obj, i1)
+          Declarations.also_provides(obj, i2)
+          Declarations.no_longer_provides(obj, i1)
+          expect(i1).to_not be_provided_by(obj)
+          expect(i2).to be_provided_by(obj)
+        end
+
+        it "doesn't affect interfaces provided from the object's class" do
+          Declarations.implements(cls, i1)
+          Declarations.no_longer_provides(obj, i1)
+          expect(i1).to be_provided_by(obj)
+        end
+      end
+    end
+  end
+end

data/spec/extendor_container_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'accord/extendor_container'
+
+module Accord
+  describe ExtendorContainer do
+    let(:extendor) { stub }
+    let(:i1)       { stub }
+    let(:i2)       { stub }
+    let(:provided) { stub }
+
+    let(:extendor_class) do
+      Class.new do
+        attr_reader :current
+        def initialize
+          @current = []
+        end
+        def add(interface)
+          current << interface
+        end
+        def delete(interface)
+          current.delete(interface)
+        end
+        def empty?
+          current.empty?
+        end
+      end
+    end
+
+    subject { ExtendorContainer.new }
+
+    before do
+      provided.stub(:iro => [provided, i1, i2])
+      stub_const('Accord::Extendor', extendor_class)
+    end
+
+    it "starts clean" do
+      expect(subject.get(provided).current).to be_empty
+    end
+
+    it "reports when a given interface is not set" do
+      expect(subject.has?(provided)).to be_false
+    end
+
+    it "adds an interface for each extendor of its resolution order" do
+      subject.add(provided)
+      expect(subject.get(provided).current).to include(provided)
+      expect(subject.get(i1).current).to include(provided)
+      expect(subject.get(i2).current).to include(provided)
+    end
+
+    it "reports when a given interface is set" do
+      subject.add(provided)
+      expect(subject.has?(provided)).to be_true
+      expect(subject.has?(i1)).to be_true
+      expect(subject.has?(i2)).to be_true
+    end
+
+    it "accumulates interfaces while adding" do
+      other = stub
+      other.stub(:iro => [other, i1, i2])
+
+      subject.add(provided)
+      subject.add(other)
+
+      expect(subject.get(provided).current).to eq [provided]
+      expect(subject.get(other).current).to eq [other]
+
+      expect(subject.get(i1).current).to include(provided)
+      expect(subject.get(i1).current).to include(other)
+
+      expect(subject.get(i2).current).to include(provided)
+      expect(subject.get(i2).current).to include(other)
+    end
+
+    it "deletes interfaces" do
+      other = stub
+      other.stub(:iro => [other, i1, i2])
+
+      subject.add(provided)
+      subject.add(other)
+      subject.delete(provided)
+
+      expect(subject.get(provided).current).to eq []
+      expect(subject.get(other).current).to eq [other]
+
+      expect(subject.get(i1).current).to_not include(provided)
+      expect(subject.get(i1).current).to include(other)
+
+      expect(subject.get(i2).current).to_not include(provided)
+      expect(subject.get(i2).current).to include(other)
+    end
+
+    it "reports when an interface has been deleted" do
+      subject.add(provided)
+      subject.delete(provided)
+      expect(subject.has?(provided)).to be_false
+      expect(subject.has?(i1)).to be_false
+      expect(subject.has?(i2)).to be_false
+    end
+  end
+end

data/spec/extendor_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+require 'accord/extendor'
+
+module Accord
+  describe Extendor do
+    subject { Extendor.new }
+
+    it { should be_empty }
+    its(:current) { should be_empty }
+
+    specify "adding interface to extendor" do
+      interface = stub
+      subject.add(interface)
+      expect(subject.current).to eq [interface]
+    end
+
+    specify "adding interface makes it not empty" do
+      subject.add(stub)
+      expect(subject).to_not be_empty
+      expect(subject.current).to_not be_empty
+    end
+
+    specify "adds an interface only once" do
+      interface = stub
+      subject.add(interface)
+      subject.add(interface)
+      expect(subject.current).to eq [interface]
+    end
+
+    describe "adding in details" do
+      let(:interface1) { stub }
+      let(:interface2) { stub(:extends? => true) }
+      let(:extending)  { stub }
+
+      before do
+        subject.add(interface1)
+        subject.add(interface2)
+      end
+
+      context "when added interface extends some" do
+        before do
+          extending.stub(:extends?).with(interface1).and_return(true)
+          extending.stub(:extends?).with(interface2).and_return(false)
+          subject.add(extending)
+        end
+
+        it "adds it after the ones it extends" do
+          expect(subject.current).to eq [interface1, extending, interface2]
+        end
+      end
+
+      context "when added interface extends none" do
+        before do
+          extending.stub(:extends?).with(interface1).and_return(false)
+          extending.stub(:extends?).with(interface2).and_return(false)
+          subject.add(extending)
+        end
+
+        it "adds it in the beginning" do
+          expect(subject.current).to eq [extending, interface1, interface2]
+        end
+      end
+
+      context "when added interface extends all" do
+        before do
+          extending.stub(:extends?).with(interface1).and_return(true)
+          extending.stub(:extends?).with(interface2).and_return(true)
+          subject.add(extending)
+        end
+
+        it "adds it in the end" do
+          expect(subject.current).to eq [interface1, interface2, extending]
+        end
+      end
+    end
+
+    specify "modifying current doesn't alter state of extendor" do
+      subject.current << stub
+      expect(subject.current).to be_empty
+
+      interface = stub
+      subject.add(interface)
+      subject.current << stub
+      expect(subject.current.size).to eq 1
+
+      subject.current.delete(interface)
+      expect(subject.current.size).to eq 1
+    end
+
+    specify "deleting is done using #delete" do
+      interface = stub
+      subject.add(interface)
+      subject.delete(interface)
+      expect(subject).to be_empty
+    end
+
+    specify "deleting interface on empty extendor" do
+      subject.delete(stub)
+      expect(subject).to be_empty
+    end
+
+    specify "deleting doesn't break if deleting already deleted interface" do
+      interface1 = stub
+      interface2 = stub(:extends? => false)
+      subject.add(interface1)
+      subject.add(interface2)
+
+      subject.delete(interface1)
+      subject.delete(interface1)
+      subject.delete(interface1)
+
+      expect(subject.current).to eq [interface2]
+    end
+
+    describe "#compact_map" do
+      it "maps the current interfaces to the given block" do
+        interface1 = stub
+        interface2 = stub(:extends? => false)
+        subject.add(interface1)
+        subject.add(interface2)
+
+        result = subject.compact_map { |i| i.object_id }
+
+        expect(result).to include(interface1.object_id)
+        expect(result).to include(interface2.object_id)
+      end
+
+      it "discards nil entries when mapping" do
+        interface1 = stub
+        interface2 = stub(:extends? => false)
+        subject.add(interface1)
+        subject.add(interface2)
+
+        result = subject.compact_map { |i| i.equal?(interface1) ? nil : i }
+
+        expect(result).to_not include(interface1)
+        expect(result).to     include(interface2)
+      end
+
+      it "maps in the order they were left" do
+        interface1 = stub
+        interface2 = stub
+        interface3 = stub
+
+        interface2.stub(:extends?).with(interface1).and_return(false)
+        interface3.stub(:extends?).with(interface1).and_return(true)
+        interface3.stub(:extends?).with(interface2).and_return(false)
+
+        subject.add(interface1)
+        subject.add(interface2)
+        subject.add(interface3)
+
+        interfaces = subject.compact_map { |i| i }
+
+        expect(interfaces).to eq [interface1, interface3, interface2]
+      end
+    end
+
+    describe "#flat_map" do
+      it "maps the current interfaces to the given block" do
+        interface1 = stub
+        interface2 = stub(:extends? => false)
+        subject.add(interface1)
+        subject.add(interface2)
+
+        result = subject.flat_map { |i| i.object_id }
+
+        expect(result).to include(interface1.object_id)
+        expect(result).to include(interface2.object_id)
+      end
+
+      it "expands arrays returned by block" do
+        interface1 = stub
+        interface2 = stub(:extends? => false)
+        subject.add(interface1)
+        subject.add(interface2)
+
+        result = subject.flat_map { |i| [i] }
+
+        expect(result).to include(interface1)
+        expect(result).to include(interface2)
+      end
+
+      it "maps in the order they were left" do
+        interface1 = stub
+        interface2 = stub
+        interface3 = stub
+
+        interface2.stub(:extends?).with(interface1).and_return(false)
+        interface3.stub(:extends?).with(interface1).and_return(true)
+        interface3.stub(:extends?).with(interface2).and_return(false)
+
+        subject.add(interface1)
+        subject.add(interface2)
+        subject.add(interface3)
+
+        interfaces = subject.flat_map { |i| i }
+
+        expect(interfaces).to eq [interface1, interface3, interface2]
+      end
+    end
+  end
+end

data/spec/integration/adaptation_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'accord'
+
+describe "Adaptation" do
+  let(:registry) { Accord::AdapterRegistry.new }
+  let(:ip1) { Accord::InterfaceClass.new(:ip1, [Accord::Interface]) }
+
+  let(:yclass) { Class.new do
+    Accord::Declarations.implements(self, IP1)
+    attr_reader :context
+    def initialize(context)
+      @context = context
+    end
+  end }
+
+  before do
+    stub_const('IP1', ip1)
+  end
+
+  describe "getting an adapter" do
+    let(:ir)     { Accord::InterfaceClass.new(:ir, [Accord::Interface]) }
+    let(:xclass) { Class.new { Accord::Declarations.implements(self, IR) } }
+    let(:x)      { xclass.new }
+
+    before do
+      stub_const('IR', ir)
+    end
+
+    context "unamed" do
+      subject { registry.get([x], IP1) }
+
+      before do
+        registry.register([IR], IP1, '') { |o| yclass.new(o) }
+      end
+
+      it { should be_a(yclass) }
+      its(:context) { should be x }
+    end
+
+    context "named" do
+      let(:y2class) { Class.new(yclass) }
+      subject { registry.get([x], IP1, 'bob') }
+
+      before do
+        registry.register([IR], IP1, 'bob') { |o| y2class.new(o) }
+      end
+
+      it { should be_a(y2class) }
+      its(:context) { should be x }
+    end
+
+    describe "factory with embedded condition" do
+      let(:factory) { Proc.new { |o| o.name == 'object' ? 'adapter' : nil } }
+      let(:oclass) { Class.new do
+        Accord::Declarations.implements(self, IR)
+        attr_writer :name
+        def name
+          @name ||= 'object'
+        end
+      end }
+      let(:obj) { oclass.new }
+
+      before do
+        registry.register([IR], IP1, 'conditional', &factory)
+      end
+
+      context "when the adapter satisfies the condition" do
+        subject { registry.get([obj], IP1, 'conditional') }
+        it { should eq 'adapter' }
+      end
+
+      context "when the adapter doesn't satisfy the condition" do
+        subject { registry.get([obj], IP1, 'conditional') }
+        before { obj.name = 'other' }
+        it { should be_nil }
+
+        context "when a default value is provided" do
+          subject do
+            registry.get([obj], IP1, 'conditional', default: 'default')
+          end
+          it { should eq 'default' }
+        end
+      end
+    end
+  end
+end