brainguy 0.0.1

data/spec/brainguy/manifest_emitter_spec.rb

@@ -0,0 +1,68 @@
+require "rspec"
+require "brainguy/manifest_emitter"
+
+module Brainguy
+  RSpec.describe ManifestEmitter do
+    it "starts with an empty set of known events" do
+      set = ManifestEmitter.new(instance_double(Emitter))
+      expect(set.known_types).to be_empty
+    end
+
+    it "warns when a handler is added for an unknown event" do
+      set = ManifestEmitter.new(
+          instance_double(Emitter, on: nil))
+      expect { set.on(:foo) {} }
+          .to output(/unknown event type 'foo'/i).to_stderr
+    end
+
+    it "warns when an unknown event is emitted" do
+      set = ManifestEmitter.new(
+          instance_double(Emitter, emit: nil))
+      expect { set.emit(:foo) {} }
+          .to output(/unknown event type 'foo'/i).to_stderr
+    end
+
+    it "does not warn when a handler is added for an known event" do
+      set = ManifestEmitter.new(
+          instance_double(Emitter, on: nil))
+      set.known_types << :foo
+      expect { set.on(:foo) {} }
+          .not_to output.to_stderr
+    end
+
+    it "does not warn when an known event is emitted" do
+      set = ManifestEmitter.new(
+          instance_double(Emitter, emit: nil))
+      set.known_types << :foo
+      expect { set.emit(:foo) {} }
+          .not_to output.to_stderr
+    end
+
+    context "configured to raise errors" do
+      it "fails when a handler is added for an unknown event" do
+        set = ManifestEmitter.new(
+            instance_double(Emitter, on: nil),
+            policy: :raise_error)
+        expect { set.on(:foo) {} }
+            .to raise_error(UnknownEvent, /unknown event type 'foo'/i)
+      end
+
+      it "fails when an unknown event is emitted" do
+        set = ManifestEmitter.new(
+            instance_double(Emitter, emit: nil),
+            policy: :raise_error)
+        expect { set.emit(:foo) {} }
+            .to raise_error(UnknownEvent, /unknown event type 'foo'/i)
+      end
+
+      it "reports exception from the send point" do
+        set = ManifestEmitter.new(
+            instance_double(Emitter, emit: nil),
+            policy: :raise_error)
+        error = set.emit(:foo) rescue $!; line = __LINE__
+        file  = File.basename(__FILE__)
+        expect(error.backtrace[0]).to include("#{file}:#{line}")
+      end
+    end
+  end
+end

data/spec/brainguy/manifestly_observable_spec.rb

@@ -0,0 +1,43 @@
+require "rspec"
+require "brainguy/manifestly_observable"
+require "support/shared_examples_for_eventful_modules"
+
+module Brainguy
+  RSpec.describe ManifestlyObservable do
+    include_examples "an eventful module",
+                     ManifestlyObservable.new(:heat, :drip, :done)
+
+    it "adds a ManifestEmitter to the class" do
+      klass = Class.new do
+        include ManifestlyObservable.new(:red, :green)
+      end
+      obj   = klass.new
+      expect(obj.events).to be_a(ManifestEmitter)
+    end
+
+    it "adds the specified event names to the known list" do
+      klass = Class.new do
+        include ManifestlyObservable.new(:red, :green)
+      end
+      obj   = klass.new
+      expect(obj.events.known_types).to eq([:red, :green])
+    end
+
+    it "inherits event names" do
+      parent = Class.new do
+        include ManifestlyObservable.new(:red, :green)
+      end
+      child  = Class.new(parent) do
+        include ManifestlyObservable.new(:yellow)
+      end
+      obj    = child.new
+      expect(obj.events.known_types).to eq([:red, :green, :yellow])
+    end
+
+    it "stringifies meaningfully" do
+      mod = ManifestlyObservable.new(:red, :green)
+      expect(mod.to_s).to eq("ManifestlyObservable(:red, :green)")
+    end
+
+  end
+end

data/spec/brainguy/observable_spec.rb

@@ -0,0 +1,9 @@
+require "rspec"
+require "brainguy/observable"
+require "support/shared_examples_for_eventful_modules"
+
+module Brainguy
+  RSpec.describe Observable do
+    include_examples "an eventful module", Observable
+  end
+end

data/spec/brainguy/observer_spec.rb

@@ -0,0 +1,72 @@
+require "rspec"
+require "brainguy/observer"
+
+module Brainguy
+  RSpec.describe Observer do
+    class AccountListener
+      def on_open(event)
+      end
+
+      include Observer
+
+      def on_deposit(event)
+      end
+
+      def on_withdrawal(event)
+      end
+    end
+
+    it "routes events to their appropriate handler methods" do
+      listener = AccountListener.new
+      allow(listener).to receive(:on_deposit)
+      allow(listener).to receive(:on_withdrawal)
+
+      listener.call(e1 = Event[:deposit])
+      expect(listener).to have_received(:on_deposit).with(e1)
+
+      listener.call(e2 = Event[:withdrawal])
+      expect(listener).to have_received(:on_withdrawal).with(e2)
+    end
+
+    it "picks up handler methods defined before module inclusion" do
+      klass    = Class.new do
+        def on_open(event)
+
+        end
+
+        include Observer
+      end
+      listener = klass.new
+      allow(listener).to receive(:on_open)
+      listener.call(e2 = Event[:open])
+      expect(listener).to have_received(:on_open).with(e2)
+    end
+
+    it "ignores events which lack handler methods" do
+      listener = AccountListener.new
+      expect { listener.call(Event[:not_defined]) }.to_not raise_error
+    end
+
+    it "doesn't blow up on a handler-less class" do
+      expect do
+        Class.new do
+          include Observer
+        end
+      end.to_not raise_error
+    end
+
+    it "passes unknown events to a catch-all method" do
+      events = []
+      klass = Class.new do
+        include Observer
+        define_method :event_handler_missing do |event|
+          events << event
+        end
+      end
+      listener = klass.new
+      listener.call(unknown_event = Event[:unknown_event])
+      expect(events).to eq([unknown_event])
+    end
+
+  end
+end

data/spec/brainguy/open_observer_spec.rb

@@ -0,0 +1,57 @@
+require "rspec"
+require "brainguy/open_observer"
+
+module Brainguy
+  RSpec.describe OpenObserver do
+    it "can be constructed from a hash" do
+      probe  = spy("probe")
+      ol     = OpenObserver.new(foo: ->(e) { probe.handle_foo(e) },
+                                bar: ->(e) { probe.handle_bar(e) })
+      source = double("source")
+      ol.call(e1 = Event[:foo])
+      ol.call(e2 = Event[:bar])
+      expect(probe).to have_received(:handle_foo).with(e1)
+      expect(probe).to have_received(:handle_bar).with(e2)
+    end
+
+    it "can be constructed using on_* methods" do
+      probe = spy("probe")
+      ol    = OpenObserver.new
+      ol.on_foo do |e|
+        probe.handle_foo(e)
+      end
+          .on_bar do |e|
+        probe.handle_bar(e)
+      end
+      source = double("source")
+      ol.call(e1 = Event[:foo])
+      ol.call(e2 = Event[:bar])
+      expect(probe).to have_received(:handle_foo).with(e1)
+      expect(probe).to have_received(:handle_bar).with(e2)
+    end
+
+    it "yields self on init" do
+      probe  = spy("probe")
+      ol     = OpenObserver.new do |l|
+        l.on_foo do |e|
+          probe.handle_foo(e)
+        end
+        l.on_bar do |e|
+          probe.handle_bar(e)
+        end
+      end
+      source = double("source")
+      ol.call(e1 = Event[:foo])
+      ol.call(e2 = Event[:bar])
+      expect(probe).to have_received(:handle_foo).with(e1)
+      expect(probe).to have_received(:handle_bar).with(e2)
+    end
+
+    it "has correct #respond_to? behavior" do
+      ol = OpenObserver.new
+      expect(ol).to respond_to(:on_blub)
+      expect(ol).to_not respond_to(:blub)
+    end
+  end
+end
+

data/spec/brainguy/single_event_subscription_spec.rb

@@ -0,0 +1,16 @@
+require "rspec"
+require "brainguy/single_event_subscription"
+
+module Brainguy
+  RSpec.describe SingleEventSubscription do
+    it "is not equal to another subscription with a different event" do
+      owner = double("owner")
+      listener = double("listener")
+      sub1 = SingleEventSubscription.new(owner, listener, double)
+      sub2 = SingleEventSubscription.new(owner, listener, double)
+      expect(sub1).not_to eq(sub2)
+      expect(sub1.hash).not_to eq(sub2.hash)
+      expect(sub1).not_to eql(sub2)
+    end
+  end
+end

data/spec/brainguy/subscription_scope_spec.rb

@@ -0,0 +1,72 @@
+require "rspec"
+require "brainguy/subscription_scope"
+
+module Brainguy
+  RSpec.describe SubscriptionScope do
+    it "proxies subscriptions to an underlying subscription set" do
+      scope = SubscriptionScope.new(set = instance_double(Emitter))
+      allow(set).to receive(:on).and_return(sub1 = double("sub1"))
+      allow(set).to receive(:attach).and_return(sub2 = double("sub2"))
+      expect(scope.on(:foo)).to be(sub1)
+      expect(scope.attach(arg2 = double)).to be(sub2)
+      expect(set).to have_received(:on).with(:foo)
+      expect(set).to have_received(:attach).with(arg2)
+    end
+
+    it "removes subscriptions on close" do
+      scope = SubscriptionScope.new(set = instance_double(Emitter))
+      allow(set).to receive(:on)
+                        .and_return(sub1 = instance_spy(Subscription))
+      allow(set).to receive(:attach)
+                        .and_return(sub2 = instance_spy(Subscription))
+      scope.on(:foo)
+      scope.attach(double)
+      scope.close
+      expect(sub1).to have_received(:cancel)
+      expect(sub2).to have_received(:cancel)
+    end
+
+    it "removes subscriptions only once" do
+      scope = SubscriptionScope.new(set = instance_double(Emitter))
+      allow(set).to receive(:on)
+                        .and_return(sub1 = instance_spy(Subscription))
+      scope.on(:foo)
+      scope.close
+      scope.close
+      expect(sub1).to have_received(:cancel).once
+    end
+
+    it "supports a block form" do
+      set = instance_double(Emitter)
+      allow(set).to receive(:on)
+                        .and_return(sub1 = instance_spy(Subscription))
+      allow(set).to receive(:attach)
+                        .and_return(sub2 = instance_spy(Subscription))
+
+      SubscriptionScope.open(set) do |scope|
+        scope.on(:foo)
+        scope.attach(double)
+      end
+
+      expect(sub1).to have_received(:cancel)
+      expect(sub2).to have_received(:cancel)
+    end
+
+    it "ensures subscriptions are cancelled despite errors in block" do
+      set = instance_double(Emitter)
+      allow(set).to receive(:on)
+                        .and_return(sub1 = instance_spy(Subscription))
+      allow(set).to receive(:attach)
+                        .and_return(sub2 = instance_spy(Subscription))
+
+      SubscriptionScope.open(set) do |scope|
+        scope.on(:foo)
+        scope.attach(double)
+        fail "Whoopsie"
+      end rescue nil
+
+      expect(sub1).to have_received(:cancel)
+      expect(sub2).to have_received(:cancel)
+    end
+  end
+end

data/spec/brainguy/subscription_spec.rb

@@ -0,0 +1,46 @@
+require "rspec"
+require "brainguy/subscription"
+
+module Brainguy
+  RSpec.describe Subscription do
+
+    it "is equal to another subscription with the same owner and listener" do
+      listener = double("listener")
+      owner    = double("owner")
+      sub1     = Subscription.new(owner, listener)
+      sub2     = Subscription.new(owner, listener)
+      expect(sub1).to eq(sub2)
+      expect(sub1.hash).to eq(sub2.hash)
+      expect(sub1).to eql(sub2)
+
+      set = Set.new([sub1])
+      expect(set.add?(sub2)).to be_nil
+      expect(set.size).to eq(1)
+      set.delete(sub2)
+      expect(set.size).to eq(0)
+    end
+
+    it "is not equal to another subscription with a different owner" do
+      listener = double("listener")
+      sub1     = Subscription.new(double, listener)
+      sub2     = Subscription.new(double, listener)
+      expect(sub1).not_to eq(sub2)
+      expect(sub1.hash).not_to eq(sub2.hash)
+      expect(sub1).not_to eql(sub2)
+    end
+
+    it "is not equal to another subscription with a different listener" do
+      owner = double("owner")
+      sub1  = Subscription.new(owner, double)
+      sub2  = Subscription.new(owner, double)
+      expect(sub1).not_to eq(sub2)
+      expect(sub1.hash).not_to eq(sub2.hash)
+      expect(sub1).not_to eql(sub2)
+    end
+
+    it "is frozen" do
+      s = Subscription.new(double, double)
+      expect(s).to be_frozen
+    end
+  end
+end

data/spec/features/basics_spec.rb

@@ -0,0 +1,153 @@
+require "rspec"
+require "brainguy"
+
+module Brainguy
+  class AuctionBid
+    attr_reader :events
+
+    def initialize
+      @events = Brainguy::Emitter.new(self)
+    end
+
+    def reject_bid
+      events.emit(:rejected)
+    end
+
+    def make_counter_offer
+      events.emit(:rejected, counter_amount: 101, valid_for_minutes: 60)
+    end
+
+    def accept_bid
+      events.emit(:accepted)
+    end
+  end
+
+  RSpec.describe Brainguy do
+    it "enables objects to publish simple events" do
+      mike = spy("mike")
+      bid  = AuctionBid.new
+      bid.events.on(:rejected) do
+        mike.handle_rejection
+      end
+      bid.reject_bid
+      expect(mike).to have_received(:handle_rejection)
+    end
+
+    it "allows multiple listeners to attach" do
+      mike = spy("mike")
+      crow = spy("crow")
+      bid  = AuctionBid.new
+      bid.events.on(:rejected) do
+        mike.handle_rejection
+      end
+      bid.events.on(:rejected) do
+        crow.handle_rejection
+      end
+      bid.reject_bid
+      expect(mike).to have_received(:handle_rejection)
+      expect(crow).to have_received(:handle_rejection)
+    end
+
+    it "allows multiple events to be emitted" do
+      crow = spy("crow")
+      bid  = AuctionBid.new
+      bid.events.on(:rejected) do
+        crow.handle_rejection
+      end
+      bid.events.on(:accepted) do
+        crow.handle_acceptance
+      end
+      bid.reject_bid
+      expect(crow).to have_received(:handle_rejection)
+      expect(crow).to_not have_received(:handle_acceptance)
+      bid.accept_bid
+      expect(crow).to have_received(:handle_acceptance)
+    end
+
+    it "allows for zero subscribers" do
+      bid = AuctionBid.new
+      expect { bid.reject_bid }.to_not raise_error
+    end
+
+    it "passes extra event args on to the handler block" do
+      bid = AuctionBid.new
+      expect do |b|
+        bid.events.on(:rejected, &b)
+        bid.make_counter_offer
+      end.to yield_with_args({counter_amount:    101,
+                              valid_for_minutes: 60})
+    end
+
+    it "allows a subscription to be removed" do
+      bid = AuctionBid.new
+      expect do |b|
+        subscription = bid.events.on(:rejected, &b)
+        subscription.cancel
+        bid.reject_bid
+      end.to_not yield_control
+    end
+
+    it "allows an object to listen to all events" do
+      bid      = AuctionBid.new
+      listener = spy("listener")
+      bid.events.attach(listener)
+
+      bid.reject_bid
+      expect(listener).to have_received(:call).with(Event[:rejected, bid])
+
+      bid.accept_bid
+      expect(listener).to have_received(:call).with(Event[:accepted, bid])
+    end
+
+    it "allows a listener to be unsubscribed" do
+      bid          = AuctionBid.new
+      listener     = spy("listener")
+      subscription = bid.events.attach(listener)
+
+      bid.reject_bid
+      expect(listener).to have_received(:call).with(Event[:rejected, bid])
+
+      subscription.cancel
+
+      bid.accept_bid
+      expect(listener).not_to have_received(:call).with(Event[:accepted, bid])
+    end
+
+    it "allows a listener to be unsubscribed by identity" do
+      bid      = AuctionBid.new
+      listener = spy("listener")
+      bid.events.attach(listener)
+
+      bid.reject_bid
+      expect(listener).to have_received(:call).with(Event[:rejected, bid])
+
+      bid.events.detach(listener)
+      expect(bid.events).to be_empty
+
+      bid.accept_bid
+      expect(listener).not_to have_received(:call).with(Event[:accepted, bid])
+    end
+
+    it "does not allow the same listener to be subscribed twice" do
+      bid      = AuctionBid.new
+      listener = spy("listener")
+      bid.events.attach(listener)
+      bid.events.attach(listener)
+      bid.reject_bid
+      expect(listener).to have_received(:call).once
+    end
+
+    it "provides scoped subscriptions" do
+      bid   = AuctionBid.new
+      probe = spy("probe")
+      bid.events.with_subscription_scope do |scope|
+        scope.on(:rejected) do
+          probe.handle_rejection
+        end
+        bid.reject_bid
+      end
+      bid.reject_bid
+      expect(probe).to have_received(:handle_rejection).once
+    end
+  end
+end