accord 0.1.0

data/spec/signature_info_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'accord/signature_info'
+
+module Accord
+  describe SignatureInfo do
+    subject { SignatureInfo.new }
+
+    describe "#param" do
+      it "adds new arguments to #arguments" do
+        subject.param(:foo)
+        expect(subject.arguments).to eq [ { name: :foo } ]
+      end
+
+      it "converts names to symbols" do
+        subject.param('foo')
+        expect(subject.arguments).to eq [ { name: :foo } ]
+      end
+
+      it "accepts a unitary hash which holds a default value" do
+        subject.param(foo: :bar)
+        expect(subject.arguments).to eq [ { name: :foo, default: :bar } ]
+      end
+
+      it "rejects anything else" do
+        expect { subject.param(1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "#splat" do
+      context "with a symbol" do
+        it "adds a splat argument" do
+          subject.splat(:foo)
+          expect(subject.arguments).to eq [ { name: :foo, splat: true } ]
+        end
+      end
+
+      context "with a string" do
+        it "sets a splat argument, as a symbol" do
+          subject.splat('foo')
+          expect(subject.arguments).to eq [ { name: :foo, splat: true } ]
+        end
+      end
+    end
+
+    describe "#block" do
+      it "returns nil if no splat argument has been set" do
+        expect(subject.block).to be_nil
+      end
+
+      context "with a symbol" do
+        it "sets a block argument" do
+          subject.block(:foo)
+          expect(subject.block).to eq :foo
+        end
+      end
+
+      context "with a string" do
+        it "sets a block argument, as a symbol" do
+          subject.block('foo')
+          expect(subject.block).to eq :foo
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'simplecov'
+SimpleCov.start

data/spec/specification_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+require 'set'
+require 'accord/specification'
+
+module Accord
+  describe Specification do
+    describe "empty specification" do
+      let(:spec) { Specification.new }
+      it "has only itself as its ancestor" do
+        expect(spec.ancestors).to eq [spec]
+      end
+
+      it "extends itself" do
+        expect(spec).to be_extends(spec)
+      end
+    end
+
+    describe "specification based on another" do
+      let(:base_spec) { Specification.new }
+      let(:spec)      { Specification.new([base_spec]) }
+
+      it "has itself as and its base specification as ancestors" do
+        expect(Set.new(spec.ancestors)).to eq Set.new([spec, base_spec])
+      end
+
+      it "extends itself" do
+        expect(spec).to be_extends(spec)
+      end
+
+      it "extends the base specification" do
+        expect(spec).to be_extends(base_spec)
+      end
+    end
+
+    describe "specification ancestry ordering" do
+      # Note that spec ancestors are not sorted like Ruby's module ancestors.
+      #
+      # The expected results should match the C3 algorithm.  For more
+      # information, refer to the MRO used in Python (introduced in Python
+      # 2.3): http://www.python.org/download/releases/2.3/mro/
+
+      let(:root) { Specification.new(:root) }
+
+      describe "impossible" do
+        let(:a) { Specification.new([root]) }
+        let(:b) { Specification.new([a, root]) }
+        let(:c) { Specification.new([root]) }
+        let(:d) { Specification.new([b, c]) }
+        # let(:s5) { Specification.new([c, b, d]) } # This should break
+
+        it "rejects such hierarchy" do
+          # This hierarchy is rejected because local order prececedence cannot
+          # be satisfied without violating monotonicity.
+          expect { Specification.new([c, b, d]) }.to raise_error(TypeError)
+        end
+      end
+
+      describe "possible" do
+        let(:a) { Specification.new(:a, [root]) }
+        let(:b) { Specification.new(:b, [root]) }
+        let(:c) { Specification.new(:c, [root]) }
+        let(:d) { Specification.new(:d, [c, a]) }
+        let(:e) { Specification.new(:e, [c, b]) }
+        let(:f) { Specification.new(:f, [e, d]) }
+
+        let(:expected_resolution_order) { [f, e, d, c, b, a, root] }
+
+        subject { f }
+        its(:ancestors) { should eq expected_resolution_order }
+      end
+
+      describe "possible" do
+        let(:a) { Specification.new(:a, [root]) }
+        let(:b) { Specification.new(:b, [root]) }
+        let(:c) { Specification.new(:c, [root]) }
+        let(:d) { Specification.new(:d, [c, a]) }
+        let(:e) { Specification.new(:e, [b, c]) }
+        let(:f) { Specification.new(:f, [e, d]) }
+
+        let(:expected_resolution_order) { [f, e, b, d, c, a, root] }
+
+        subject { f }
+        its(:ancestors) { should eq expected_resolution_order }
+      end
+
+      describe "possible" do
+        let(:a)  { Specification.new(:a,  [root]) }
+        let(:b)  { Specification.new(:b,  [root]) }
+        let(:c)  { Specification.new(:c,  [root]) }
+        let(:d)  { Specification.new(:d,  [root]) }
+        let(:e)  { Specification.new(:e,  [root]) }
+        let(:k1) { Specification.new(:k1, [a, b, c]) }
+        let(:k2) { Specification.new(:k2, [d, b, e]) }
+        let(:k3) { Specification.new(:k3, [d, a]) }
+        let(:z)  { Specification.new(:z,  [k1, k2, k3]) }
+
+        let(:expected_resolution_order) do
+          [z, k1, k2, k3, d, a, b, c, e, root]
+        end
+
+        subject { z }
+        its(:ancestors) { should eq expected_resolution_order }
+      end
+    end
+
+    describe "bad bases" do
+      context "on construction" do
+        it "complains if something other than Specification is set as a base" do
+          expect { Specification.new(['bad']) }.to raise_error(TypeError)
+        end
+      end
+
+      context "on #bases=" do
+        let(:spec) { Specification.new }
+
+        it "complains if set to not an array of Specification's" do
+          expect { spec.bases = ['bad'] }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe "bases change" do
+      let(:spec)           { Specification.new }
+      let(:dependent_spec) { Specification.new([spec]) }
+
+      it "updates ancestry in dependent specifications" do
+        base = Specification.new
+        spec.bases = [base]
+
+        expect(dependent_spec.ancestors).to eq [dependent_spec, spec, base]
+      end
+
+      it "updates ancestry in dependent specs if base change in ancestor" do
+        base1 = Specification.new
+        base2 = Specification.new([base1])
+        spec.bases = [base2]
+
+        base2.bases = []
+
+        expect(spec.ancestors).to eq [spec, base2]
+      end
+
+      it "makes old bases to not be extended by old dependent" do
+        old_base = Specification.new
+        new_base = Specification.new
+        spec.bases = [old_base]
+
+        spec.bases = [new_base]
+
+        expect(spec).to_not be_extends(old_base)
+      end
+
+      it "can leave no base" do
+        base = Specification.new
+        spec.bases = [base]
+
+        spec.bases = []
+
+        expect(spec.ancestors).to eq [spec]
+      end
+
+      it "can add bases" do
+        base1 = Specification.new
+        base2 = Specification.new
+        spec.bases = [base1]
+
+        spec.bases = [base1, base2]
+
+        expect(spec.ancestors).to eq [spec, base1, base2]
+      end
+
+      it "leaves other dependents untouched" do
+        base = Specification.new
+        spec.bases = [base]
+        other_spec = Specification.new([base])
+
+        spec.bases = []
+        expect(other_spec.ancestors).to include(base)
+      end
+
+      it "cannot modify ancestors through modifying returned bases directly" do
+        base = Specification.new
+        spec.bases << base
+
+        expect(spec.ancestors).to eq [spec]
+      end
+    end
+
+    describe "#interfaces" do
+      it "is empty by default" do
+        expect(Specification.new.interfaces).to be_empty
+      end
+
+      it "is empty when dealing only with pure specifications" do
+        base = Specification.new
+        spec = Specification.new([base])
+        expect(spec.interfaces).to be_empty
+      end
+
+      it "takes interfaces from bases through #each_interface" do
+        interface1 = stub(:i1)
+        interface2 = stub(:i2)
+
+        base1 = Specification.new
+        base1.stub(:each_interface).and_yield(interface1)
+
+        base2 = Specification.new
+        base2.stub(:each_interface).and_yield(interface2)
+
+        spec = Specification.new([base1, base2])
+
+        expect(spec.interfaces).to eq [interface1, interface2]
+      end
+
+      it "avoids duplications" do
+        interface = stub(:i)
+
+        base1 = Specification.new
+        base1.stub(:each_interface).and_yield(interface)
+
+        base2 = Specification.new
+        base2.stub(:each_interface).and_yield(interface)
+
+        spec = Specification.new([base1, base2])
+
+        expect(spec.interfaces).to eq [interface]
+      end
+
+      it "accumulates interfaces from bases' bases" do
+        interface1 = stub(:i1)
+        interface2 = stub(:i2)
+
+        base1 = Specification.new
+        base1.stub(:each_interface).and_yield(interface1)
+
+        base2 = Specification.new
+        base2.stub(:each_interface).and_yield(interface2)
+
+        base3 = Specification.new([base2])
+        spec = Specification.new([base1, base3])
+
+        expect(spec.interfaces).to eq [interface1, interface2]
+      end
+    end
+  end
+end

data/spec/subscription_registry_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+require 'accord/subscription_registry'
+
+module Accord
+  describe SubscriptionRegistry do
+    subject(:registry) { SubscriptionRegistry.new }
+
+    let(:subscriber)       { Proc.new {} }
+    let(:other_subscriber) { Proc.new {} }
+
+    let(:i1) { stub_interface }
+    let(:i2) { stub_interface }
+
+    def stub_interface(*bases)
+      stub.tap do |interface|
+        interface.stub(
+          :iro => [interface],
+          :ancestors => [interface]
+        )
+        interface.stub(:extends?).and_return(false)
+        interface.stub(:extends?).with(interface).and_return(true)
+        bases.each do |base|
+          interface.iro << base
+          interface.ancestors << base
+          interface.stub(:extends?).with(base).and_return(true)
+        end
+      end
+    end
+
+    describe "#all" do
+      it "returns no adapter when registry is empty" do
+        expect(subject.all).to be_empty
+      end
+
+      context "subscribed most simple single subscriber" do
+        it "returns that if no arguments are passed" do
+          subject.subscribe([Interface], Interface, &subscriber)
+          expect(subject.all).to eq [subscriber]
+        end
+      end
+
+      it "hits right subscriber if matches" do
+        subject.subscribe([i1], nil, &subscriber)
+        expect(
+          subject.all(required: [i1], provided: nil)
+        ).to eq [subscriber]
+      end
+
+      it "miss subscriber if none matches" do
+        subject.subscribe([i1], nil, &subscriber)
+        expect(
+          subject.all(required: [i2], provided: nil)
+        ).to be_empty
+      end
+    end
+
+    describe "#subscribe" do
+      it "complains if subscription happens without block" do
+        expect {
+          subject.subscribe([Interface], Interface, '')
+        }.to raise_error(ArgumentError)
+      end
+
+      it "allows subscribing a null subscriber" do
+        subject.subscribe([], i1, &subscriber)
+        expect(subject.all(required: [], provided: i1)).to eq [subscriber]
+      end
+
+      it "subscribes multiple subscribers" do
+        subject.subscribe([nil], nil, &subscriber)
+        subject.subscribe([nil], nil, &other_subscriber)
+        expect(
+          subject.all(required: [Interface], provided: Interface)
+        ).to eq [subscriber, other_subscriber]
+      end
+
+      context "when using [nil] and nil for required and provided" do
+        it "defaults to most simple single subscriber" do
+          subject.subscribe([nil], nil, &subscriber)
+          expect(
+            subject.all(required: [Interface], provided: Interface)
+          ).to eq [subscriber]
+        end
+      end
+
+      context "when using nil and nil for required and provided" do
+        it "defaults to most simple single subscriber" do
+          subject.subscribe(nil, nil, &subscriber)
+          expect(
+            subject.all(required: [Interface], provided: Interface)
+          ).to eq [subscriber]
+        end
+      end
+    end
+
+    describe "#lookup" do
+      it "returns no subscriber when registry is empty" do
+        expect(subject.lookup([], nil)).to be_empty
+      end
+
+      context "registered most simple single subscriber" do
+        before do
+          subject.subscribe([Interface], Interface, &subscriber)
+        end
+
+        it "returns that if required is nil and provided is nil" do
+          expect(subject.lookup(nil, nil)).to eq [subscriber]
+        end
+
+        it "returns that if required is [nil] and provided is nil" do
+          expect(subject.lookup([nil], nil)).to eq [subscriber]
+        end
+      end
+
+      it "hits right subscriber if matches exactly" do
+        subject.subscribe([i1], nil, &subscriber)
+        expect(subject.lookup([i1], nil)).to eq [subscriber]
+      end
+
+      it "hits right subscriber if required extends some registered" do
+        i12 = stub_interface(i1)
+        subject.subscribe([i1], nil, &subscriber)
+        expect(subject.lookup([i12], nil)).to eq [subscriber]
+      end
+
+      it "miss subscriber if none matches" do
+        subject.subscribe([i1], nil, &subscriber)
+        expect(subject.lookup([i2], nil)).to be_empty
+      end
+    end
+
+    describe "#unsubscribe" do
+      it "doesn't complain when unsubscribing empty registry" do
+        expect { subject.unsubscribe([nil], nil) }.to_not raise_error
+      end
+
+      it "keeps subscribed if required doesn't match on unsubscription" do
+        subject.subscribe([i1], nil, &subscriber)
+        subject.unsubscribe([i2], nil)
+        expect(
+          subject.all(required: [i1], provided: nil)
+        ).to eq [subscriber]
+      end
+
+      it "keeps subscribed if provided doesn't match on unsubscription" do
+        subject.subscribe([nil], i1, &subscriber)
+        subject.unsubscribe([nil], i2)
+        expect(
+          subject.all(required: [nil], provided: i1)
+        ).to eq [subscriber]
+      end
+
+      it "keeps subscribed if value is passed but doesn't match on "\
+         "unsubscription" do
+        subject.subscribe([i1], nil, &subscriber)
+        subject.unsubscribe([i1], nil, stub)
+        expect(
+          subject.all(required: [i1], provided: nil)
+        ).to eq [subscriber]
+      end
+
+      it "unsubscribes only subscribers matching the value passed" do
+        subject.subscribe([i1], nil, &subscriber)
+        subject.subscribe([i1], nil, &other_subscriber)
+        subject.unsubscribe([i1], nil, subscriber)
+        expect(
+          subject.all(required: [i1], provided: nil)
+        ).to eq [other_subscriber]
+      end
+
+      it "unsubscribes if value not passed and everything else matches "\
+         "previous subscription" do
+        subject.subscribe([i1], nil, &subscriber)
+        subject.unsubscribe([i1], nil)
+        expect(
+          subject.all(required: [i1], provided: nil)
+        ).to be_empty
+      end
+
+      it "unsubscribes all if value not passed" do
+        subject.subscribe([i1], nil, &subscriber)
+        subject.subscribe([i1], nil, &other_subscriber)
+        subject.unsubscribe([i1], nil)
+        expect(
+          subject.all(required: [i1], provided: nil, name: '')
+        ).to be_empty
+      end
+
+      context "when using [nil] and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.subscribe([Interface], Interface, &subscriber)
+          subject.unsubscribe([nil], nil)
+          expect(subject.all).to be_empty
+        end
+      end
+
+      context "when using nil and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.subscribe([Interface], Interface, &subscriber)
+          subject.unsubscribe(nil, nil)
+          expect(subject.all).to be_empty
+        end
+      end
+    end
+  end
+end