signals 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 682db5800cf5ba91ba8694e672f9ba94cc766e27
-  data.tar.gz: 360251fd4a443e0ddac0b738af93e4a05e713026
+  metadata.gz: d0a17dcf963e613b1958719ee6335e765e1f4233
+  data.tar.gz: f322c5f49706eb819a44e39a8bb54211bf7fc49b
 SHA512:
-  metadata.gz: 2bfa9e3d66d07c05840b374089148a69a124fce7fbfd4760ccf896fd331a033751b81a87ecb174d47bfbadba11a95411abdb094301ff53deb07b471d5cbd2fe2
-  data.tar.gz: 684f968ef7cdfd6be8c9ca7a28e0a49f5e67a7a042a3ad35d703f675809d6b538968017089b3c2a7fa006aa540814888b963a8ab322e7b67a5f11248451b7bb2
+  metadata.gz: c6317c3d341b4fd50be0eaf0ef67e5ce8bbab4e1bb99ab60c4a4fa21dbe27d3d3bf6efbc57831b0ca82bb31572dd7be9b020d4ebcc8a3524fe403c4b425de9e0
+  data.tar.gz: e20efc2de3708bbf8e53ba7a574dd353799dfd0d58d51787f16e895844287c4f94000ecbbe61a4c142bccb4180841d608a2e2e724804f52ceabef8bf0778eccb

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.sublime-workspace
+*.sublime-project

data/README.md

@@ -17,30 +17,43 @@ require 'signals'
 
 class Coach
   include Signals::Publisher
-
-  def run_play
-    broadcast(:v_formation, self)
-  end
 end
 
 class Player
+  include Signals::Subscriber
+
+  listen_for :v_formation => :run
+  listen_for [:hat_trick, :v_formation] => :audible
+  listen_for :stop => [:look, :run]
+  listen_for :stop => :audible
+
   def initialize(name)
     @name = name
   end
 
-  def v_formation(coach)
-    puts "#{@name} is in position"
+  def run(coach)
+    puts "#{@name} is running"
+  end
+
+  def audible(coach)
+    puts "#{@name} is calling an audible"
+  end
+
+  def look(coach)
+    puts "#{@name} is looking"
   end
 end
 
-coach = Coach.new
+coach   = Coach.new
 forward = Player.new('John')
-center = Player.new('Jeff')
+center  = Player.new('Jeff')
 
 coach.subscribe(forward)
 coach.subscribe(center)
 
-coach.run_play
+coach.on(:stop) do |c|
+  puts "I'm telling you to stop"
+end
 ```
 
 ## Contributing

data/lib/signals/block_listener.rb

@@ -10,7 +10,7 @@ module Signals
       @event = event
     end
 
-    def execute(event, *args)
+    def execute_event(event, *args)
       if self.event == event
         self.listener.call(*args)
       end

data/lib/signals/publisher.rb

@@ -1,34 +1,45 @@
 module Signals
 
   module Publisher
-    # Broadcasts an event to all of the subscribed listeners
-    # @return [void]
-    def broadcast(event, *args)
-      listeners.each do |listener|
-        listener.execute(event, *args)
-      end
-      nil
-    end
 
-    # Creates a one off listener that will respond to the event provided only
-    # @param [Object] event the event that is triggered
-    # @return [void]
-    def on(event, &block)
-      listeners.add(BlockListener.new(event, &block))
-      nil
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
     end
 
-    # Subscribe a listener to the publisher
-    # @return [void]
-    def subscribe(listener)
-      listeners.add(Listener.new(listener))
-      nil
+    module ClassMethods
     end
 
-    # All of the listeners subscribed to a publisher
-    # @return [Set] a unique set of listeners
-    def listeners
-      @listeners ||= Set.new
+    module InstanceMethods
+      # Broadcasts an event to all of the subscribed listeners
+      # @return [void]
+      def broadcast(event, *args)
+        listeners.each do |listener|
+          listener.execute_event(event, *args)
+        end
+        nil
+      end
+
+      # Creates a one off listener that will respond to the event provided only
+      # @param [Object] event the event that is triggered
+      # @return [void]
+      def on(event, &block)
+        listeners.add(BlockListener.new(event, &block))
+        nil
+      end
+
+      # Subscribe a listener to the publisher
+      # @return [void]
+      def subscribe(listener)
+        listeners.add(listener)
+        nil
+      end
+
+      # All of the listeners subscribed to a publisher
+      # @return [Set] a unique set of listeners
+      def listeners
+        @listeners ||= Set.new
+      end
     end
   end
 

data/lib/signals/subscriber.rb

@@ -0,0 +1,125 @@
+module Signals
+
+  module Subscriber
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      # Register the class to listen for specific events and react accordingly.
+      # Any combination can be used. Listen for only accepts a hash as the
+      # parameter.
+      #
+      # == Example
+      #
+      #   class Something
+      #     include Signals::Subscriber
+      #
+      #     listen_for :one => :action
+      #     listen_for :one => [:action, :another]
+      #     listen_for :one => [:and_another]
+      #     listen_for [:one, :two] => :action
+      #     listen_for [:one, :two] => [:action]
+      #     listen_for [:one] => [:and_another]
+      #   end
+      #
+      # @param [Hash] params
+      # @return [void]
+      def listen_for(params={})
+        params.each do |k, v|
+          if k.is_a?(Array)
+            k.each { |e| add_event(e, v) }
+          else
+            add_event(k, v)
+          end
+        end
+        nil
+      end
+
+      # @param [Symbol] e the event
+      # @param [Array|Symbol] actions the actions to be taken
+      def add_event(e, actions)
+        event(e).concat(actions.is_a?(Array) ? actions : [actions])
+      end
+
+      # @return [Hash]
+      def events
+        @@events ||= Hash.new
+      end
+
+      private
+
+      # @param [Symbol] key
+      # @return [Array]
+      def event(key)
+        events[key] ||= Array.new
+      end
+    end
+
+    module InstanceMethods
+      def execute_event(event, *args)
+        if event_enabled?(event)
+          actions_for(event).each do |action|
+            self.send(action, *args) if self.respond_to?(action)
+          end
+        end
+      end
+
+      # Disables an event temporarily
+      # @param [Symbol] event
+      # @return [void]
+      def disable_event(event)
+        disabled_events.add(event)
+        nil
+      end
+
+      # Enables an event that was disabled
+      # @param [Symbol] event
+      # @return [void]
+      def enable_event(event)
+        disabled_events.delete(event)
+        nil
+      end
+
+      # Checks to see if the event is disabled
+      # @param [Symbol] event
+      # @return [Boolean]
+      def event_disabled?(event)
+        disabled_events.include?(event)
+      end
+
+      # Checks to see if the event is enabled
+      # @param [Symbol] event
+      # @return [Boolean]
+      def event_enabled?(event)
+        !event_disabled?(event)
+      end
+
+      # Checks to see if the event is present
+      # @param [Symbol] event
+      # @return [Boolean]
+      def event?(event)
+        events.include?(event)
+      end
+
+      def actions_for(event)
+        self.events[event] || Array.new
+      end
+
+      # The set of disabled events
+      # @return [Set] a set of disabled events
+      def disabled_events
+        @disabled_events ||= Set.new
+      end
+
+      # The hash of events that the subscriber is listening for
+      # @return [Hash]
+      def events
+        self.class.events.freeze
+      end
+    end
+  end
+
+end

data/lib/signals/version.rb

@@ -1,3 +1,3 @@
 module Signals
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/lib/signals.rb

@@ -3,6 +3,6 @@ end
 
 require 'set'
 require 'signals/version'
-require 'signals/listener'
 require 'signals/block_listener'
 require 'signals/publisher'
+require 'signals/subscriber'

data/spec/signals/block_listener_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Signals::BlockListener do
 
-  describe '#execute' do
+  describe '#execute_event' do
     it 'should execute the event it was registered for' do
       block = Signals::BlockListener.new(:testing)
       block.stub(listener: double('lambda', call: true))
 
-      block.execute(:testing)
+      block.execute_event(:testing)
 
       block.listener.should have_received(:call).once
     end
@@ -16,7 +16,7 @@ describe Signals::BlockListener do
       block = Signals::BlockListener.new(:testing)
       block.stub(listener: double('lambda', call: true))
 
-      block.execute(:another)
+      block.execute_event(:another)
 
       block.listener.should_not have_received(:call)
     end
@@ -25,7 +25,7 @@ describe Signals::BlockListener do
       block = Signals::BlockListener.new(:testing)
       block.stub(listener: double('lambda', call: true))
 
-      block.execute(:testing, 1, 2)
+      block.execute_event(:testing, 1, 2)
 
       block.listener.should have_received(:call).with(1,2).once
     end

data/spec/signals/publisher_spec.rb

@@ -5,42 +5,49 @@ describe Signals::Publisher do
     include Signals::Publisher
   end
 
-  class SimpleListener
-  end
-
-  let(:publisher) { DummyPublisher.new }
-
   describe '#broadcast' do
-    it 'should broadcast an event' do
-      listener = double('AListener', execute: true)
-      publisher.stub(listeners: Set.new([listener]))
+    it 'should broadcast an event to subscribers' do
+      publisher = DummyPublisher.new
+      listener  = double('Listener', execute_event: true)
+      listeners = [listener]
+      publisher.stub(listeners: listeners)
 
       publisher.broadcast(:event, 1, 2)
 
-      listener.should have_received(:execute).with(:event, 1, 2)
+      listener.should have_received(:execute_event).with(:event, 1, 2)
     end
   end
 
-  describe '#subscribe' do
-    it 'should subscribe a listener' do
-      expect {
-        publisher.subscribe(SimpleListener.new)
-      }.to_not raise_error
+  describe '#on' do
+    it 'should should be successful' do
+      publisher = DummyPublisher.new
+      listeners = double('Set', add: true)
+      publisher.stub(listeners: listeners)
+
+      publisher.on(:event) do
+        true
+      end
+
+      listeners.should have_received(:add).once
     end
   end
 
-  describe '#on' do
-    it 'should subscribe a block listener' do
-      publisher.stub(listeners: double('Set', add: true))
+  describe '#subscribe' do
+    it 'should subscribe a subscriber' do
+      publisher = DummyPublisher.new
+      listeners = double('Set', add: true)
+      listener = double('Listener')
+      publisher.stub(listeners: listeners)
 
-      publisher.on(:event) { true }
+      publisher.subscribe(listener)
 
-      publisher.listeners.should have_received(:add).once
+      listeners.should have_received(:add).with(listener).once
     end
   end
 
   describe '#listeners' do
-    subject { publisher.listeners }
+    subject { DummyPublisher.new.listeners }
     it { should be_a(Set) }
   end
+
 end

data/spec/signals/subscriber_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe Signals::Subscriber do
+  class DummySubscriber
+    include Signals::Subscriber
+
+    listen_for :event => :action_1
+    listen_for :complex => [:action_2, :action_3]
+    listen_for [:event, :complex] => :action_4
+    listen_for [:event, :complex] => [:action_5, :action_6]
+  end
+
+  describe '#execute_event' do
+    context 'when the event is disabled' do
+      it 'should not execute the actions' do
+        subscriber = DummySubscriber.new
+        subscriber.stub(event_enabled?: false, action_1: true)
+
+        subscriber.execute_event(:event)
+
+        subscriber.should_not have_received(:action_1)
+      end
+    end
+
+    context 'when the event is enabled' do
+      it 'should execute the actions' do
+        subscriber = DummySubscriber.new
+        subscriber.stub(event_enabled?: true, action_1: true)
+
+        subscriber.execute_event(:event)
+
+        subscriber.should have_received(:action_1).once
+      end
+    end
+  end
+
+
+  describe '#disable_event' do
+    it 'should disable an event' do
+      subscriber = DummySubscriber.new
+      events = double('Events', add: true)
+      subscriber.stub(disabled_events: events)
+
+      subscriber.disable_event(:event)
+
+      events.should have_received(:add).with(:event).once
+    end
+  end
+
+
+  describe '#enable_event' do
+    it 'should enable an event' do
+      subscriber = DummySubscriber.new
+      events = double('Events', delete: true)
+      subscriber.stub(disabled_events: events)
+
+      subscriber.enable_event(:event)
+
+      events.should have_received(:delete).with(:event).once
+    end
+  end
+
+
+  describe '#event_disabled?' do
+    context 'when an event is disabled' do
+      it 'should return true' do
+        subscriber = DummySubscriber.new
+        set = Set.new([:event])
+        subscriber.stub(disabled_events: set)
+
+        subscriber.event_disabled?(:event).should be_true
+      end
+    end
+
+    context 'when an event is enabled' do
+      it 'should return false' do
+        subscriber = DummySubscriber.new
+        set = Set.new([])
+        subscriber.stub(disabled_events: set)
+
+        subscriber.event_disabled?(:event).should be_false
+      end
+    end
+  end
+
+
+  describe '#event_enabled?' do
+    context 'when an event is disabled' do
+      it 'should return false' do
+        subscriber = DummySubscriber.new
+        set = Set.new([:event])
+        subscriber.stub(disabled_events: set)
+
+        subscriber.event_enabled?(:event).should be_false
+      end
+    end
+
+    context 'when an event is enabled' do
+      it 'should return true' do
+        subscriber = DummySubscriber.new
+        set = Set.new([])
+        subscriber.stub(disabled_events: set)
+
+        subscriber.event_enabled?(:event).should be_true
+      end
+    end
+  end
+
+
+  describe '#event?' do
+    context 'when the event is on the subscriber' do
+      it 'should return true' do
+        subscriber = DummySubscriber.new
+        subscriber.event?(:event).should be_true
+      end
+    end
+
+    context 'when the event is not on the subscriber' do
+      it 'should return false' do
+        subscriber = DummySubscriber.new
+        subscriber.event?(:not_here).should be_false
+      end
+    end
+  end
+
+
+  describe '#actions_for' do
+    context 'when the event is on the subscriber' do
+      it 'should return return its actions' do
+        subscriber = DummySubscriber.new
+        subscriber.actions_for(:event).should eq([:action_1, :action_4, :action_5, :action_6])
+      end
+    end
+
+    context 'when the event is not on the subscriber' do
+      it 'should return false' do
+        subscriber = DummySubscriber.new
+        subscriber.actions_for(:not_here).should eq([])
+      end
+    end
+  end
+
+
+  describe '#disabled_events' do
+    context 'when no events are disabled' do
+      it 'should be an empty set' do
+        subscriber = DummySubscriber.new
+        subscriber.disabled_events.should be_empty
+      end
+    end
+
+    context 'when an event is disabled' do
+      it 'should not be empty' do
+        subscriber = DummySubscriber.new
+        subscriber.disable_event(:event)
+        subscriber.disabled_events.should_not be_empty
+      end
+    end
+  end
+
+
+  describe '#events' do
+    it 'should not be empty' do
+      subscriber = DummySubscriber.new
+      subscriber.events.should_not be_empty
+    end
+  end
+
+
+  describe '.listen_for' do
+    class SubscriberListenTest
+      include Signals::Subscriber
+    end
+    let(:klass) { SubscriberListenTest }
+    context 'when the event is a symbol' do
+      context 'when the action is a symbol' do
+        it 'should register the action for the event' do
+          klass.stub(add_event: true)
+
+          klass.listen_for(:event_1 => :action_1)
+
+          klass.should have_received(:add_event).with(:event_1, :action_1)
+        end
+      end
+
+      context 'when the action is an array of symbols' do
+        it 'should register the actions for the event' do
+          klass.stub(add_event: true)
+
+          klass.listen_for(:event_1 => [:action_2, :action_3])
+
+          klass.should have_received(:add_event).with(:event_1, [:action_2, :action_3])
+        end
+      end
+    end
+
+    context 'when the event is an array of symbols' do
+      context 'when the action is a symbol' do
+        it 'should register the action for the events' do
+          klass.stub(add_event: true)
+
+          klass.listen_for([:event_2, :event_3] => :action_1)
+
+          klass.should have_received(:add_event).twice
+        end
+      end
+      context 'when the action is an array of symbols' do
+        it 'should register the actions for the events' do
+          klass.stub(add_event: true)
+
+          klass.listen_for([:event_2, :event_3] => [:action_1, :action_2])
+
+          klass.should have_received(:add_event).twice
+        end
+      end
+    end
+  end
+
+
+  describe '.add_event' do
+    class SubscriberAddEvent
+      include Signals::Subscriber
+    end
+    let(:klass) { SubscriberAddEvent }
+
+    context 'when the actions is an array of symbols' do
+      it 'should be successful' do
+        hash = double('Hash', concat: true)
+        klass.stub(event: hash)
+
+        klass.add_event(:event_1, [:action_1, :action_2])
+
+        klass.should have_received(:event).with(:event_1)
+      end
+    end
+    context 'when the action is a symbol' do
+      it 'should be successful' do
+        hash = double('Hash', concat: true)
+        klass.stub(event: hash)
+
+        klass.add_event(:event_1, :action_3)
+
+        klass.should have_received(:event).with(:event_1)
+      end
+    end
+  end
+
+
+  describe '.events' do
+    subject { DummySubscriber.events }
+    it { should be_a(Hash) }
+  end
+
+
+  describe '.event' do
+    it 'should raise an exception' do
+      expect {
+        DummySubscriber.event(1)
+      }.to raise_error
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: signals
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Matthew Johnston
@@ -69,13 +69,13 @@ files:
 - Rakefile
 - lib/signals.rb
 - lib/signals/block_listener.rb
-- lib/signals/listener.rb
 - lib/signals/publisher.rb
+- lib/signals/subscriber.rb
 - lib/signals/version.rb
 - signals.gemspec
 - spec/signals/block_listener_spec.rb
-- spec/signals/listener_spec.rb
 - spec/signals/publisher_spec.rb
+- spec/signals/subscriber_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/warmwaffles/signals
 licenses:
@@ -103,6 +103,6 @@ specification_version: 4
 summary: A lightweight publish / subscribe library
 test_files:
 - spec/signals/block_listener_spec.rb
-- spec/signals/listener_spec.rb
 - spec/signals/publisher_spec.rb
+- spec/signals/subscriber_spec.rb
 - spec/spec_helper.rb

data/lib/signals/listener.rb

@@ -1,21 +0,0 @@
-module Signals
-
-  class Listener
-    attr_reader :listener
-
-    # @param [Object] listener the listener you want to use
-    def initialize(listener)
-      @listener = listener
-    end
-
-    # @param [Object] event
-    # @return [void]
-    def execute(event, *args)
-      if @listener.respond_to?(event)
-        @listener.send(event, *args)
-      end
-      nil
-    end
-  end
-
-end

data/spec/signals/listener_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Signals::Listener do
-
-  describe '#execute' do
-    it 'should execute an existing method with no params' do
-      simple = double('SimpleListener', testing: true)
-      listener = Signals::Listener.new(simple)
-
-      listener.execute(:testing)
-
-      listener.listener.should have_received(:testing).once
-    end
-
-    it 'should execute an existing method with params' do
-      simple = double('SimpleListener', testing: true)
-      listener = Signals::Listener.new(simple)
-
-      listener.execute(:testing, 1, 2)
-
-      listener.listener.should have_received(:testing).with(1, 2).once
-    end
-
-    it 'should not raise an error when the method does not exist' do
-      simple = double('SimpleListener')
-      listener = Signals::Listener.new(simple)
-
-      expect { listener.execute(:testing) }.to_not raise_error
-    end
-  end
-end