flirt 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b120f2410701ad2d63d29cc453c273021a5a23dc
-  data.tar.gz: da528cc1e2678262357854934f86064e723a6568
+  metadata.gz: e91741f80d191782e97feb4f999ea217cea73ab0
+  data.tar.gz: c82e4ca1147147b4dbe58eceda66cb1f24724e9c
 SHA512:
-  metadata.gz: 8ebacbf7408b4e5d48702204e9b16490c4e1ef1e4810f56ae0940d6e9af7ea3cd03e47f01c56cc67cec8eaf63130dbfa2aa1e5965414719482ae60b30c425949
-  data.tar.gz: 00232c11f40b4b5051d679c95af55e4a6f974790befbd511acd99a9777d67b29f52df01136cde92a2cdd4f707d37211f72bcc18f7bce9a81223e05b72881c594
+  metadata.gz: 663901d78250f3486d9deee98b17a299032270f93bbaa8c833a7838d597dbef8d5b5ee57565ee9417ef1e0292530504d75a0e28e4b72c8c2f78a473ae5dcb635
+  data.tar.gz: e9176cd92e3178a0ee7d291dab6fbf97956a4ca24aa39af78debd4b3ac96202148de7573fe90c41b619d778990ece3d79bfb19e69b33c466d7a6f34b1773cda6

data/lib/flirt/callback.rb

@@ -12,5 +12,9 @@ module Flirt
         def call(event_data)
             object.send callback_name, event_data
         end
+
+        def ==(other_callback)
+            object == other_callback.object && callback_name == other_callback.callback_name
+        end
     end
 end

data/lib/flirt/version.rb

@@ -1,3 +1,3 @@
 module Flirt
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/flirt.rb

@@ -8,25 +8,31 @@ module Flirt
 
     class << self
 
-        def broadcast(event_name, event_data)
+        def publish(event_name, event_data)
             return if disabled
             raise ArgumentError.new("Event name must be a symbol") unless event_name.is_a? Symbol
             (callbacks[event_name] || []).each do |callback|
                 callback.call(event_data)
             end
         end
-        alias_method :publish, :broadcast
+        alias_method :broadcast, :publish
 
         def subscribe(object, event_name, options = {})
-            raise ArgumentError.new("You must pass a callback")    unless options[:with].is_a? Symbol
-            raise ArgumentError.new("You must pass an object")     if     object.nil?
-            raise ArgumentError.new("You must pass an event name") unless event_name.is_a? Symbol
+            check_subscription_arguments(event_name, object, options)
             callback = Flirt::Callback.new object: object,
                                            callback_name: options[:with]
             add_callback(event_name, callback)
         end
         alias_method :listen, :subscribe
 
+        def unsubscribe(object, event_name, options = {})
+            check_subscription_arguments(event_name, object, options)
+            callback = Flirt::Callback.new object: object,
+                                           callback_name: options[:with]
+            remove_callback(event_name, callback)
+        end
+        alias_method :unlisten, :unsubscribe
+
         def enable
             self.disabled = false
         end
@@ -53,6 +59,20 @@ module Flirt
             callbacks[event_name] << callback
         end
 
+        def remove_callback(event_name, callback_to_delete)
+            return unless callbacks[event_name]
+
+            callbacks[event_name].each do |callback|
+                callbacks[event_name].delete(callback) if callback == callback_to_delete
+            end
+        end
+
+        def check_subscription_arguments(event_name, object, options)
+            raise ArgumentError.new("You must pass a callback") unless    options[:with].is_a? Symbol
+            raise ArgumentError.new("You must pass an object")  if        object.nil?
+            raise ArgumentError.new("You must pass an event name") unless event_name.is_a? Symbol
+        end
+
     end
 
 end

data/spec/flirt/flirt_callback_spec.rb

@@ -5,7 +5,7 @@ describe Flirt::Callback do
         Flirt.enable
     end
 
-    describe "when instantiated with an object and callback" do
+    describe "when instantiated with an object and callback name" do
 
         let(:listener) { Object.new }
         let(:callback_name) { :call_me }
@@ -29,5 +29,10 @@ describe Flirt::Callback do
                 callback.call(event_data)
             end
         end
+
+        it "tests equality if object and callback are the same" do
+            other_callback = Flirt::Callback.new object: listener, callback_name: callback_name
+            expect(callback).to eq(other_callback)
+        end
     end
 end

data/spec/flirt/flirt_listener_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'flirt/flirt_test_classes'
+#require 'flirt/flirt_test_classes'
 
 describe Flirt::Listener do
     before(:each) do
@@ -10,16 +10,32 @@ describe Flirt::Listener do
         let(:event)               { :grabbed_coin }
         let(:callback_name)       { :increase_score }
         let(:event_data)          { { value: 100 } }
-        let(:instance_subscriber) { TestInstanceSubscriber.new event, callback_name }
-        let(:instance_listener)   { TestInstanceListener.new event, callback_name }
+        let(:test_class)          { Class.new }
+        let(:test_instance)       { test_class.new }
+
+        before(:each) do
+            test_class.class_eval do
+                include Flirt::Listener
+            end
+        end
 
         it "subscribes to an event" do
-            expect(instance_subscriber).to receive(callback_name).with(event_data)
+            block_event = event
+            block_callback_name = callback_name
+            test_instance.instance_eval do
+                subscribe_to block_event, with: block_callback_name
+            end
+            expect(test_instance).to receive(callback_name).with(event_data)
             Flirt.broadcast event, event_data
         end
 
         it "listens to an event" do
-            expect(instance_listener).to receive(callback_name).with(event_data)
+            block_event = event
+            block_callback_name = callback_name
+            test_instance.instance_eval do
+                listen_to block_event, with: block_callback_name
+            end
+            expect(test_instance).to receive(callback_name).with(event_data)
             Flirt.broadcast event, event_data
         end
     end
@@ -28,22 +44,26 @@ describe Flirt::Listener do
         let(:event)               { :event_name }
         let(:callback_name)       { :callback_name }
         let(:event_data)          { { value: 100 } }
-        let(:class_subscriber)    { TestClassSubscriber }
-        let(:class_listener)      { TestClassListener }
-
-        # Because rspec has to clear the Flirt callbacks for each test,
-        # we need to require the test classes after rspec init.
+        let(:test_class)          { Class.new }
 
         it "subscribes to an event" do
-            require 'flirt/test_class_subscriber'
-            expect(class_subscriber).to receive(callback_name).with(event_data)
-            Flirt.broadcast event, event_data
+            block_event = event
+            block_callback_name = callback_name
+            expect(Flirt).to receive(:subscribe).with(test_class, event, { with: callback_name })
+            test_class.class_eval do
+                extend Flirt::Listener
+                subscribe_to block_event, with: block_callback_name
+            end
         end
 
         it "listens to an event" do
-            require 'flirt/test_class_listener'
-            expect(class_listener).to receive(callback_name).with(event_data)
-            Flirt.broadcast event, event_data
+            block_event = event
+            block_callback_name = callback_name
+            expect(Flirt).to receive(:subscribe).with(test_class, event, { with: callback_name })
+            test_class.class_eval do
+                extend Flirt::Listener
+                listen_to block_event, with: block_callback_name
+            end
         end
     end
 end

data/spec/flirt/flirt_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'flirt/flirt_test_classes'
+#require 'flirt/flirt_test_classes'
 
 describe Flirt do
 
@@ -8,26 +8,92 @@ describe Flirt do
         let(:response)    { { topping: "cream" } }
         let(:event)       { :pancake_fried }
         let(:wrong_event) { :spud_baked }
-        let!(:listener)   { TestListener.new(event) }
+        let(:callback)    { :respond }
+        let!(:listener)   { Object.new }
+
+        before(:each) do
+            Flirt.listen listener, event, with: callback
+        end
 
         it "listens to the correct broadcast event" do
+            expect(listener).to receive(callback).with(response)
             Flirt.broadcast event, response
-            expect(listener.responded).to eq(response)
         end
 
         it "listens to the correct publish event" do
+            expect(listener).to receive(callback).with(response)
             Flirt.publish event, response
-            expect(listener.responded).to eq(response)
         end
 
         it "doesn't listen to the wrong broadcast event" do
+            expect(listener).not_to receive(callback)
             Flirt.broadcast wrong_event, response
-            expect(listener.responded).to be_nil
         end
 
         it "doesn't listen to the wrong publish event" do
+            expect(listener).not_to receive(callback)
             Flirt.broadcast wrong_event, response
-            expect(listener.responded).to be_nil
+        end
+
+        describe "when disabled" do
+            before(:each) { Flirt.disable }
+            after(:each) { Flirt.enable }
+
+            it "doesn't broadcast" do
+                expect(listener).not_to receive(callback)
+                Flirt.broadcast event, response
+            end
+
+            it "doesn't publish" do
+                expect(listener).not_to receive(callback)
+                Flirt.publish event, response
+            end
+        end
+
+        describe "when cleared" do
+
+            let(:callback2)    { :respond2 }
+
+            before(:each) do
+                Flirt.listen listener, event, with: callback2
+                Flirt.clear
+            end
+
+            it "forgets listeners" do
+                expect(listener).not_to receive(callback)
+                expect(listener).not_to receive(callback2)
+                Flirt.publish event, response
+            end
+
+        end
+
+        describe "when unlistened" do
+
+            let(:callback2)    { :respond2 }
+
+            before(:each) do
+                Flirt.listen listener, event, with: callback2
+                Flirt.unlisten listener, event, with: callback
+            end
+
+            it "forgets the listener" do
+                expect(listener).not_to receive(callback)
+                expect(listener).to receive(callback2).with(response)
+                Flirt.broadcast event, response
+            end
+
+        end
+
+        describe "when unsubscribed" do
+            before(:each) do
+                Flirt.unsubscribe listener, event, with: callback
+            end
+
+            it "forgets the listener" do
+                expect(listener).not_to receive(callback).with(response)
+                Flirt.publish event, response
+            end
+
         end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flirt
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Benjamin Randles-Dunkley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-28 00:00:00.000000000 Z
+date: 2015-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,9 +74,6 @@ files:
 - spec/flirt/flirt_callback_spec.rb
 - spec/flirt/flirt_listener_spec.rb
 - spec/flirt/flirt_spec.rb
-- spec/flirt/flirt_test_classes.rb
-- spec/flirt/test_class_listener.rb
-- spec/flirt/test_class_subscriber.rb
 - spec/spec_helper.rb
 homepage: https://github.com/chemica/flirt
 licenses:
@@ -106,7 +103,4 @@ test_files:
 - spec/flirt/flirt_callback_spec.rb
 - spec/flirt/flirt_listener_spec.rb
 - spec/flirt/flirt_spec.rb
-- spec/flirt/flirt_test_classes.rb
-- spec/flirt/test_class_listener.rb
-- spec/flirt/test_class_subscriber.rb
 - spec/spec_helper.rb

data/spec/flirt/flirt_test_classes.rb

@@ -1,45 +0,0 @@
-
-class TestSubscriber
-
-    attr_accessor :responded
-
-    def initialize(event)
-        Flirt.subscribe self, event, with: :respond
-    end
-
-    def respond(event_data)
-        self.responded = event_data
-    end
-end
-
-
-class TestListener
-
-    attr_accessor :responded
-
-    def initialize(event)
-        Flirt.listen self, event, with: :respond
-    end
-
-    def respond(event_data)
-        self.responded = event_data
-    end
-end
-
-class TestInstanceSubscriber
-    include Flirt::Listener
-
-    def initialize(event, callback)
-        subscribe_to event, with: callback
-    end
-end
-
-class TestInstanceListener
-    include Flirt::Listener
-
-    attr_accessor :responded
-
-    def initialize(event, callback)
-        listen_to event, with: callback
-    end
-end

data/spec/flirt/test_class_listener.rb

@@ -1,9 +0,0 @@
-class TestClassListener
-    extend Flirt::Listener
-
-    class << self
-        attr_accessor :responded
-    end
-
-    listen_to :event_name, with: :callback_name
-end

data/spec/flirt/test_class_subscriber.rb

@@ -1,9 +0,0 @@
-class TestClassSubscriber
-    extend Flirt::Listener
-
-    class << self
-        attr_accessor :responded
-    end
-
-    subscribe_to :event_name, with: :callback_name
-end