flirt 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e91741f80d191782e97feb4f999ea217cea73ab0
-  data.tar.gz: c82e4ca1147147b4dbe58eceda66cb1f24724e9c
+  metadata.gz: 3595d41a6ad627adc7eefdbb93242a03522ff4e5
+  data.tar.gz: d2a89c116bf434fe75827ca5c85ae3fcfe6958de
 SHA512:
-  metadata.gz: 663901d78250f3486d9deee98b17a299032270f93bbaa8c833a7838d597dbef8d5b5ee57565ee9417ef1e0292530504d75a0e28e4b72c8c2f78a473ae5dcb635
-  data.tar.gz: e9176cd92e3178a0ee7d291dab6fbf97956a4ca24aa39af78debd4b3ac96202148de7573fe90c41b619d778990ece3d79bfb19e69b33c466d7a6f34b1773cda6
+  metadata.gz: 1c42aba9604a42b718bca09e68d7ade30b6dbdfc0d10e9114ca658762bc3e72485b27f0c0740227e7621aac39c907446a3fd67ba7c97641ab78532364d9d77d6
+  data.tar.gz: 55d2e892fd50a3694b5c13da4c5d8f4e32da0839d9fbec8b39670c536fee612995d08c423c2b8c171fa6857ccac1280bad2f0a87bf3c37e630281c0a1b5970e9

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 .idea
+*.gem

data/lib/flirt/callback.rb

@@ -3,18 +3,23 @@
 
 module Flirt
     class Callback
+
         attr_accessor :object, :callback_name
+
         def initialize(opts = {})
             self.callback_name = opts.fetch(:callback_name)
             self.object        = opts.fetch(:object)
         end
 
+
         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/listener.rb

@@ -38,5 +38,13 @@ module Flirt
             Flirt.subscribe self, event_name, opts
         end
         alias_method :listen_to, :subscribe_to
+
+
+        def unsubscribe_from(event_name, opts = {})
+            raise ArgumentError.new("You must pass a callback") unless opts[:with].is_a? Symbol
+            Flirt.unsubscribe self, event_name, opts
+        end
+        alias_method :forget, :unsubscribe_from
+
     end
 end

data/lib/flirt/version.rb

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

data/lib/flirt.rb

@@ -1,8 +1,9 @@
 require "flirt/version"
 require "flirt/callback"
 require "flirt/listener"
-# The Flirt module provides the main interface for dealing with Flirt.
-#
+
+# The Flirt module provides the main interface for dealing with Flirt. Callbacks can be registered or unregistered
+# against events, and Flirt can be enabled or disabled.
 
 module Flirt
 
@@ -17,6 +18,7 @@ module Flirt
         end
         alias_method :broadcast, :publish
 
+
         def subscribe(object, event_name, options = {})
             check_subscription_arguments(event_name, object, options)
             callback = Flirt::Callback.new object: object,
@@ -25,6 +27,7 @@ module Flirt
         end
         alias_method :listen, :subscribe
 
+
         def unsubscribe(object, event_name, options = {})
             check_subscription_arguments(event_name, object, options)
             callback = Flirt::Callback.new object: object,
@@ -33,32 +36,39 @@ module Flirt
         end
         alias_method :unlisten, :unsubscribe
 
+
         def enable
             self.disabled = false
         end
 
+
         def disable
             self.disabled = true
         end
 
+
         def clear
             @callbacks = {}
         end
 
+
         private
 
         attr_reader   :callbacks
         attr_accessor :disabled
 
+
         def callbacks
             @callbacks ||= {}
         end
 
+
         def add_callback(event_name, callback)
             callbacks[event_name] ||= []
             callbacks[event_name] << callback
         end
 
+
         def remove_callback(event_name, callback_to_delete)
             return unless callbacks[event_name]
 
@@ -67,6 +77,7 @@ module Flirt
             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?
@@ -74,5 +85,4 @@ module Flirt
         end
 
     end
-
 end

data/spec/flirt/flirt_callback_spec.rb

@@ -8,31 +8,40 @@ describe Flirt::Callback do
     describe "when instantiated with an object and callback name" do
 
         let(:listener) { Object.new }
+
         let(:callback_name) { :call_me }
 
         let(:callback) { Flirt::Callback.new object: listener, callback_name: callback_name }
 
+
         it "sets the object" do
             expect(callback.object).to eq(listener)
         end
 
+
         it "sets the callback" do
             expect(callback.callback_name).to eq(callback_name)
         end
 
+
         describe "when called" do
 
             let(:event_data) { {event: :data} }
 
+
             it "calls the callback with the event data" do
                 expect(listener).to receive(callback_name).with(event_data)
                 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

@@ -7,63 +7,96 @@ describe Flirt::Listener do
     end
 
     describe "when included in an instance" do
+
         let(:event)               { :grabbed_coin }
+
         let(:callback_name)       { :increase_score }
+
         let(:event_data)          { { value: 100 } }
+
         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
-            block_event = event
-            block_callback_name = callback_name
-            test_instance.instance_eval do
-                subscribe_to block_event, with: block_callback_name
+
+        [:listen_to, :subscribe_to].each do |method|
+            it "subscribes to an event with ##{method}" do
+                block_event = event
+                block_callback_name = callback_name
+                expect(Flirt).to receive(:subscribe).with(test_instance, event, { with: callback_name })
+                test_instance.instance_eval do
+                    send method, block_event, with: block_callback_name
+                end
+
             end
-            expect(test_instance).to receive(callback_name).with(event_data)
-            Flirt.broadcast event, event_data
+
         end
 
-        it "listens to an event" do
-            block_event = event
-            block_callback_name = callback_name
-            test_instance.instance_eval do
-                listen_to block_event, with: block_callback_name
+
+        [:forget, :unsubscribe_from].each do |method|
+            it "unsubscribes from an event with ##{method}" do
+                block_event = event
+                block_callback_name = callback_name
+                expect(Flirt).to receive(:unsubscribe).with(test_instance, event, { with: callback_name })
+                test_instance.instance_eval do
+                    send method, block_event, with: block_callback_name
+                end
+
             end
-            expect(test_instance).to receive(callback_name).with(event_data)
-            Flirt.broadcast event, event_data
+
         end
+
     end
 
+
     describe "when included in a class" do
+
         let(:event)               { :event_name }
+
         let(:callback_name)       { :callback_name }
+
         let(:event_data)          { { value: 100 } }
+
         let(:test_class)          { Class.new }
 
-        it "subscribes to an event" do
-            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
+
+        [:listen_to, :subscribe_to].each do |method|
+            it "subscribes to an event with ##{method}" do
+                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
+                    send method, block_event, with: block_callback_name
+                end
+
             end
+
         end
 
-        it "listens to an event" do
-            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
+
+        [:forget, :unsubscribe_from].each do |method|
+            it "unsubscribes from an event with ##{method}" do
+                block_event = event
+                block_callback_name = callback_name
+                expect(Flirt).to receive(:unsubscribe).with(test_class, event, { with: callback_name })
+                test_class.class_eval do
+                    extend Flirt::Listener
+                    send method, block_event, with: block_callback_name
+                end
+
             end
+
         end
+
     end
+
 end

data/spec/flirt/flirt_spec.rb

@@ -6,94 +6,101 @@ describe Flirt do
     describe "with a single :pancake_fried subscriber" do
 
         let(:response)    { { topping: "cream" } }
+
         let(:event)       { :pancake_fried }
+
         let(:wrong_event) { :spud_baked }
+
         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
-        end
+        [:subscribe, :listen].each do |method|
 
-        it "listens to the correct publish event" do
-            expect(listener).to receive(callback).with(response)
-            Flirt.publish event, response
-        end
+            describe "and a listener added with ##{method}" do
 
-        it "doesn't listen to the wrong broadcast event" do
-            expect(listener).not_to receive(callback)
-            Flirt.broadcast wrong_event, response
-        end
+                before(:each) do
+                    Flirt.send method, listener, event, with: callback
+                end
 
-        it "doesn't listen to the wrong publish event" do
-            expect(listener).not_to receive(callback)
-            Flirt.broadcast wrong_event, response
-        end
 
-        describe "when disabled" do
-            before(:each) { Flirt.disable }
-            after(:each) { Flirt.enable }
+                [:publish, :broadcast].each do |method|
 
-            it "doesn't broadcast" do
-                expect(listener).not_to receive(callback)
-                Flirt.broadcast event, response
-            end
+                    it "listens to the correct event published with ##{method}" do
+                        expect(listener).to receive(callback).with(response)
+                        Flirt.send method, event, response
+                    end
 
-            it "doesn't publish" do
-                expect(listener).not_to receive(callback)
-                Flirt.publish event, response
-            end
-        end
 
-        describe "when cleared" do
+                    it "doesn't listen to the wrong event published with ##{method}" do
+                        expect(listener).not_to receive(callback)
+                        Flirt.send method, wrong_event, response
+                    end
 
-            let(:callback2)    { :respond2 }
 
-            before(:each) do
-                Flirt.listen listener, event, with: callback2
-                Flirt.clear
-            end
+                    describe "when disabled" do
 
-            it "forgets listeners" do
-                expect(listener).not_to receive(callback)
-                expect(listener).not_to receive(callback2)
-                Flirt.publish event, response
-            end
+                        before(:each) { Flirt.disable }
 
-        end
+                        after(:each) { Flirt.enable }
 
-        describe "when unlistened" do
 
-            let(:callback2)    { :respond2 }
+                        it "doesn't broadcast an event published with ##{method}" do
+                            expect(listener).not_to receive(callback)
+                            Flirt.send method, event, response
+                        end
 
-            before(:each) do
-                Flirt.listen listener, event, with: callback2
-                Flirt.unlisten listener, event, with: callback
-            end
+                    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
 
-        end
+                describe "when cleared" do
 
-        describe "when unsubscribed" do
-            before(:each) do
-                Flirt.unsubscribe listener, event, with: callback
-            end
+                    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
+
+                [:unsubscribe, :unlisten].each do |method|
+
+                    describe "when another listener is added and the original unsubscribed with ##{method}" do
+
+                        let(:callback2)    { :respond2 }
+
+
+                        before(:each) do
+                            Flirt.listen listener, event, with: callback2
+                            Flirt.send method, listener, event, with: callback
+                        end
+
+
+                        it "it forgets the original listener but remembers the new one" do
+                            expect(listener).not_to receive(callback)
+                            expect(listener).to receive(callback2).with(response)
+                            Flirt.broadcast event, response
+                        end
+
+                    end
+
+                end
 
-            it "forgets the listener" do
-                expect(listener).not_to receive(callback).with(response)
-                Flirt.publish event, response
             end
 
         end
+
     end
+
 end

data/spec/spec_helper.rb

@@ -12,7 +12,9 @@ Bundler.setup
 require 'flirt'
 
 RSpec.configure do |config|
+
   config.run_all_when_everything_filtered = true
+
   config.filter_run :focus
 
   config.before(:each) do
@@ -24,4 +26,5 @@ RSpec.configure do |config|
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flirt
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Benjamin Randles-Dunkley