drama_queen 0.1.0

data/lib/drama_queen/producer.rb

@@ -0,0 +1,32 @@
+require_relative '../drama_queen'
+require_relative 'exchange'
+
+
+module DramaQueen
+
+  # A +producer+ is an object that has content to provide on a +topic+.  When
+  # it decides it has content to +publish+ on that topic, it simply passes that
+  # info on to all of the +consumer+s that have +subscribe+d to the topic.
+  # Actually, it doesn't have to pass any info on--it can simply act like a ping
+  # to the subscribers; this is up to how you want to use them.
+  module Producer
+
+    # @param routing_key
+    # @param args
+    # @return [Boolean] +true+ if anything was published; +false+ if not.
+    def publish(routing_key, *args)
+      exchange = DramaQueen.exchange_for(routing_key)
+      exchange ||= DramaQueen::Exchange.new(routing_key)
+
+      all_exchanges = [exchange] + exchange.related_exchanges
+      subscription_count = 0
+
+      all_exchanges.each do |exchange|
+        subscription_count += exchange.subscribers.size
+        exchange.notify_with(*args)
+      end
+
+      !subscription_count.zero?
+    end
+  end
+end

data/lib/drama_queen/version.rb

@@ -0,0 +1,3 @@
+module DramaQueen
+  VERSION = '0.1.0'
+end

data/spec/acceptance/drama_city_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'drama_queen/consumer'
+require 'drama_queen/producer'
+
+class BigPublisher
+  include DramaQueen::Producer
+
+  def do_stuff
+    publish 'stuff1', 'the stuff1'
+    publish 'stuff2', 'the stuff2'
+    publish 'stuff5', 'the stuff3'
+    publish 'stuff3', 'the stuff4'
+    publish 'stuff5', 'the stuff5'
+  end
+end
+
+class BigConsumer
+  include DramaQueen::Consumer
+
+  def initialize(callback1, callback2)
+    100000.times do
+      subscribe 'stuff1', callback1
+      subscribe 'stuff2', callback2
+      subscribe 'stuff3', callback1
+      subscribe 'stuff4', callback2
+      subscribe 'stuff5', ->(arg) {
+        #puts arg
+      }
+    end
+  end
+end
+
+class A
+  include DramaQueen::Consumer
+
+  def initialize(callback)
+    subscribe 'root.*.children', callback
+  end
+
+  def call_me(*args)
+    puts "A got called with args: #{args}"
+  end
+end
+
+class B
+  include DramaQueen::Producer
+
+  def do_stuff
+    publish 'root.parent', 1, 2, 3
+  end
+end
+
+class C
+  include DramaQueen::Producer
+
+  def do_stuff
+    publish 'root.parent.children', 'one', 'two', 'three'
+  end
+end
+
+describe 'Draaaamaaaa' do
+  before do
+    DramaQueen.unsubscribe_all
+  end
+
+  describe 'lots of action' do
+    it 'calls all of the things' do
+      callback1 = Proc.new {}
+      callback2 = Proc.new {}
+      expect(callback1).to receive(:call).at_least(10000).times.with('the stuff1')
+      expect(callback1).to receive(:call).at_least(10000).times.with('the stuff4')
+      expect(callback2).to receive(:call).at_least(10000).times.with('the stuff2')
+      expect(callback2).to receive(:call).at_most(10002)
+
+      a = BigPublisher.new
+      b = BigConsumer.new(callback1, callback2)
+
+      a.do_stuff
+      b.subscribe 'things', ->(arg) { puts arg }
+
+      a.do_stuff
+      a.publish 'things', 'hi'
+    end
+  end
+
+  describe 'topic matching' do
+    it 'calls only the topics that match' do
+      callback = Proc.new {}
+      #expect(callback).to receive(:call).with 'one', 'two', 'three'
+      expect(callback).to receive(:call)
+
+      a = A.new(callback)
+      b = B.new
+      c = C.new
+
+      b.do_stuff
+      c.do_stuff
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$:.unshift File.expand_path('../lib', __FILE__)

data/spec/unit/drama_queen/consumer_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'drama_queen/consumer'
+
+
+describe DramaQueen::Consumer do
+  subject do
+    Object.new.extend(DramaQueen::Consumer)
+  end
+
+  let(:exchange) { double 'DramaQueen::Exchange', subscribers: [] }
+  let(:callback) { double 'Method', call: true }
+
+  describe '#subscribe' do
+    before do
+      allow(DramaQueen).to receive(:exchange_for).with('test') { exchange }
+    end
+
+    context 'routing key exists' do
+      before do
+        allow(DramaQueen).to receive(:routes_to?).with('test') { true }
+      end
+
+      it "creates a new exchange and adds itself to exchange's subscribers" do
+        expect(DramaQueen.exchanges).to_not receive(:<<)
+        expect(subject).to receive(:method).with(:call_me) { callback }
+
+        subject.subscribe('test', :call_me)
+
+        expect(exchange.subscribers).to eq [callback]
+      end
+    end
+
+    context 'routing key does not exist' do
+      before do
+        allow(DramaQueen).to receive(:routes_to?).with('test') { false }
+      end
+
+      it "find the exchange and adds itself to exchange's subscribers" do
+        expect(DramaQueen::Exchange).to receive(:new).with('test') { exchange }
+        expect(DramaQueen.exchanges).to receive(:<<).with(exchange)
+        expect(subject).to receive(:method).with(:call_me) { callback }
+
+        subject.subscribe('test', :call_me)
+
+        expect(exchange.subscribers).to eq [callback]
+      end
+    end
+  end
+end

data/spec/unit/drama_queen/exchange_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+require 'drama_queen/exchange'
+
+
+describe DramaQueen::Exchange do
+  let(:prim_object) { Object.new }
+  let(:prim_all) { '**' }
+  let(:prim_all_root) { '*' }
+  let(:prim_root) { 'root' }
+  let(:prim_notroot) { 'not-root' }
+  let(:prim_root_and_tree) { 'root.**' }
+  let(:prim_root_and_children) { 'root.*' }
+  let(:prim_root_child1) { 'root.child1' }
+  let(:prim_root_child2) { 'root.child2' }
+  let(:prim_root_child1_and_children) { 'root.child1.*' }
+  let(:prim_root_child2_and_children) { 'root.child2.*' }
+  let(:prim_root_child2_and_grandchild) { 'root.child2.grandchild' }
+  let(:prim_root_child2_and_greatgrandchild) { 'root.child2.grandchild.great_grandchild' }
+  let(:prim_root_child3_and_grandchild) { 'root.child3.grandchild' }
+  let(:prim_root_all_children_with_grandchild) { 'root.*.grandchild' }
+
+  let(:key_object) { described_class.new(prim_object) }
+  let(:key_all) { described_class.new '**' }
+  let(:key_all_root) { described_class.new '*' }
+  let(:key_root) { described_class.new 'root' }
+  let(:key_notroot) { described_class.new 'not-root' }
+  let(:key_root_and_tree) { described_class.new 'root.**' }
+  let(:key_root_and_children) { described_class.new 'root.*' }
+  let(:key_root_child1) { described_class.new 'root.child1' }
+  let(:key_root_child2) { described_class.new 'root.child2' }
+  let(:key_root_child1_and_children) { described_class.new 'root.child1.*' }
+  let(:key_root_child2_and_children) { described_class.new 'root.child2.*' }
+  let(:key_root_child2_and_grandchild) { described_class.new 'root.child2.grandchild' }
+  let(:key_root_child2_and_greatgrandchild) { described_class.new 'root.child2.grandchild.great_grandchild' }
+  let(:key_root_child3_and_grandchild) { described_class.new 'root.child3.grandchild' }
+  let(:key_root_all_children_with_grandchild) { described_class.new 'root.*.grandchild' }
+
+  let(:exchanges) do
+    [
+      key_object,
+      key_all,
+      key_all_root,
+      key_root,
+      key_notroot,
+      key_root_and_tree,
+      key_root_and_children,
+      key_root_child1,
+      key_root_child2,
+      key_root_child1_and_children,
+      key_root_child2_and_children,
+      key_root_child2_and_grandchild,
+      key_root_child2_and_greatgrandchild,
+      key_root_child3_and_grandchild,
+      key_root_all_children_with_grandchild
+    ]
+  end
+
+  before do
+    allow(DramaQueen).to receive(:exchanges) { exchanges }
+  end
+
+  describe '#related_keys' do
+    context '**' do
+      subject { described_class.new(prim_all) }
+
+      it 'returns all keys' do
+        expect(subject.related_exchanges).to eq exchanges
+      end
+    end
+
+    context '*' do
+      subject { described_class.new(prim_all_root) }
+
+      it 'returns all root level keys' do
+        expect(subject.related_exchanges).to eq [
+          key_root,
+          key_notroot
+        ]
+      end
+    end
+
+    context 'an object' do
+      subject { described_class.new(prim_object) }
+
+      specify do
+        expect(subject.related_exchanges).to eq []
+      end
+    end
+
+    context 'root' do
+      subject { described_class.new(prim_root) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_all_root
+        ]
+      end
+    end
+
+    context 'not-root' do
+      subject { described_class.new(prim_notroot) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_all_root,
+        ]
+      end
+    end
+
+    context 'root.**' do
+      subject { described_class.new(prim_root_and_tree) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_children,
+          key_root_child1,
+          key_root_child2,
+          key_root_child1_and_children,
+          key_root_child2_and_children,
+          key_root_child2_and_grandchild,
+          key_root_child2_and_greatgrandchild,
+          key_root_child3_and_grandchild,
+          key_root_all_children_with_grandchild
+        ]
+      end
+    end
+
+    context 'root.*' do
+      subject { described_class.new(prim_root_and_children) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_child1,
+          key_root_child2
+        ]
+      end
+    end
+
+    context 'root.child1' do
+      subject { described_class.new(prim_root_child1) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_and_children,
+        ]
+      end
+    end
+
+    context 'root.child2' do
+      subject { described_class.new(prim_root_child2) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_and_children,
+        ]
+      end
+    end
+
+    context 'root.child1.*' do
+      subject { described_class.new(prim_root_child1_and_children) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+        ]
+      end
+    end
+
+    context 'root.child2.*' do
+      subject { described_class.new(prim_root_child2_and_children) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_child2_and_grandchild
+        ]
+      end
+    end
+
+    context 'root.child2.grandchild' do
+      subject { described_class.new(prim_root_child2_and_grandchild) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_child2_and_children,
+          key_root_all_children_with_grandchild
+        ]
+      end
+    end
+
+    context 'root.child2.grandchild.great_grandchild' do
+      subject { described_class.new(prim_root_child2_and_greatgrandchild) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+        ]
+      end
+    end
+
+    context 'root.child3.grandchild' do
+      subject { described_class.new(prim_root_child3_and_grandchild) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_all_children_with_grandchild
+        ]
+      end
+    end
+
+    context 'root.*.grandchild' do
+      subject { described_class.new(prim_root_all_children_with_grandchild) }
+
+      specify do
+        expect(subject.related_exchanges).to eq [
+          key_root_and_tree,
+          key_root_child2_and_grandchild,
+          key_root_child3_and_grandchild,
+        ]
+      end
+    end
+  end
+
+  describe '#notify_with' do
+    let(:object) { Object.new }
+
+    subject do
+      described_class.new 'test_key'
+    end
+
+    context 'list is empty' do
+      it 'does not raise an error' do
+        expect { subject.notify_with('stuff') }.to_not raise_exception
+      end
+    end
+
+    context 'list is not empty' do
+      it 'it #calls each subscriber with the given args' do
+        subscriber = double 'Subscriber'
+        subject.instance_variable_set(:@subscribers, [subscriber])
+        expect(subscriber).to receive('call').with(1, 2, 3)
+
+        subject.notify_with 1, 2, 3
+      end
+    end
+  end
+end

data/spec/unit/drama_queen/producer_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'drama_queen/producer'
+
+
+describe DramaQueen::Producer do
+  subject { Object.new.extend(described_class) }
+
+  let(:exchange) { double 'DramaQueen::Exchange', subscribers: [] }
+
+  before do
+    allow(DramaQueen).to receive(:exchange_for).with('test') { exchange }
+  end
+
+  describe '#publish' do
+    context 'with no related exchanges' do
+      context 'with no subscribers' do
+        before do
+          allow(exchange).to receive(:related_exchanges) { [] }
+        end
+
+        it 'returns false' do
+          allow(exchange).to receive(:notify_with)
+          expect(subject.publish('test', :an_arg)).to eq false
+        end
+
+        it 'calls #notify_with on the exchange' do
+          expect(exchange).to receive(:notify_with).with(:an_arg)
+          subject.publish('test', :an_arg)
+        end
+      end
+
+      context 'with subscribers' do
+        before do
+          allow(exchange).to receive(:related_exchanges) { [] }
+          exchange.subscribers << [1, 2]
+        end
+
+        it 'returns true' do
+          allow(exchange).to receive(:notify_with)
+          expect(subject.publish('test', :an_arg)).to eq true
+        end
+
+        it 'calls #notify_with on the exchange' do
+          expect(exchange).to receive(:notify_with).with(:an_arg)
+          subject.publish('test', :an_arg)
+        end
+      end
+    end
+
+    context 'with related exchanges' do
+      let(:another_exchange) do
+        double 'DramaQueen::Exchange'
+      end
+
+      before do
+        allow(exchange).to receive(:related_exchanges) { [another_exchange] }
+      end
+
+      context 'with no subscribers' do
+        before do
+          allow(another_exchange).to receive(:subscribers) { [] }
+        end
+
+        it 'calls #notify_with' do
+          expect(exchange).to receive(:notify_with).with(:an_arg)
+          expect(another_exchange).to receive(:notify_with).with(:an_arg)
+          subject.publish('test', :an_arg)
+        end
+
+        it 'returns false' do
+          allow(exchange).to receive(:notify_with)
+          allow(another_exchange).to receive(:notify_with)
+          expect(subject.publish('test', :an_arg)).to eq false
+        end
+      end
+
+      context 'with subscribers' do
+        before do
+          allow(another_exchange).to receive(:subscribers) { [1, 2] }
+        end
+
+        it 'calls #notify_with' do
+          expect(exchange).to receive(:notify_with).with(:an_arg)
+          expect(another_exchange).to receive(:notify_with).with(:an_arg)
+          subject.publish('test', :an_arg)
+        end
+
+        it 'returns true' do
+          allow(exchange).to receive(:notify_with)
+          allow(another_exchange).to receive(:notify_with)
+          expect(subject.publish('test', :an_arg)).to eq true
+        end
+      end
+    end
+  end
+end