flirt 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddeb6e470d1d83c9d031c9eadbd763929ea01863
-  data.tar.gz: b9f82e07bde11c678184ee7ac79007c6e2ce7bea
+  metadata.gz: 564e3009a8c2864fb2de008cb57be72e8440017f
+  data.tar.gz: 87e6f2718d7ffa0d922b79f73bb718b469704a56
 SHA512:
-  metadata.gz: 9b57170b981b3bbcc68cb5e57304ca0ccd341898eab2d668bb0d22a434c2addab6f73792cf029c084072a6346797ab0fc254a6493cccb82616d5a34e1e88649d
-  data.tar.gz: c7519ff2ae78315188bb0ce004fc22ce36cb70708ab3cba8a62d69bcaeee1c3b6d930d87832abe1abbc90901b6270c5a5d21304acbd6d4bad880a9630c9d151d
+  metadata.gz: b97a5309761523a1e376c56333ebaaf4d9a8315d21774fd84b8b66bd37ffcdfe0d1e801bd9e37b7c9bf40f7feaeb821a46b5e90c22684574f2324677c2fdaa04
+  data.tar.gz: 19ffd5697790350cdab302e69aaaf39437589d17c0f6fcec617c1e22708a97a342ca3c3c1eb745c04f0bbdf44fe7a8f7b2b763f05b4b2784445a54d27dfef2f9

data/README.md

@@ -29,14 +29,15 @@ Or install it yourself as:
 
 ## Usage
 
-To publish an event:
+###To publish an event:
 
 
 ```ruby
+event_data = { fruit: 'apple' }
 Flirt.publish :picked, event_data
 ```
 
-To subscribe:
+###To subscribe:
 
 ```ruby
 class MyListener
@@ -50,7 +51,7 @@ class MyListener
 end
 ```
 
-To unsubscribe:
+###To unsubscribe:
 
 ```ruby
     Flirt.unsubscribe self, :picked, with: :picked_callback
@@ -94,7 +95,7 @@ end
 
 ```unsubscribe_from``` can technically be used in the class context, but probably doesn't have as much use.
 
-Flirt defaults to 'enabled'. Switch Flirt off:
+###Flirt defaults to 'enabled'. Switch Flirt off:
 
 ```ruby
 Flirt.disable
@@ -106,27 +107,48 @@ And back on again:
 Flirt.enable
 ```
 
-TODO: Disable only a set of events:
+Enabled status affects publishing only, listeners can still be added and will be
+remembered. No listeners will be removed.
+
+###Disable only a set of events:
 
 ```ruby
 Flirt.disable only: [:pancake_cooked, :picked]
 ```
 
-TODO: Enable only a set of events:
+###Enable only a set of events:
 
 ```ruby
 Flirt.enable only: [:topping_added, :pancake_flipped]
 ```
 
-Enabled status affects broadcast/publish, listeners can still be added and will be
-remembered. No listeners will be removed.
+Disabling and enabling sets of events is not cumulative. The new set of events will overwrite all previous calls.
+For example:
+
+```ruby
+Flirt.disable only: [:pancake_cooked, :picked]
+Flirt.disable only: [:flipped]
+```
 
-Clear all listeners:
+The above code will leave only ```:flipped``` disabled.
+
+```ruby
+Flirt.enable only: [:flipped, :picked]
+Flirt.disable only: [:flipped]
+```
+
+The above code will also leave only ```:flipped``` disabled.
+
+Calling ```Flirt.enable``` or ```Flirt.disable``` will clear any previously set enabled or disabled events.
+
+###Clear all listeners:
 
 ```ruby
 Flirt.clear
 ```
 
+This operation cannot be undone.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/flirt/fork )

data/flirt.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "byebug", "~> 4.0"
 end

data/lib/flirt/listener.rb

@@ -7,8 +7,6 @@
 #
 #     def initialize
 #         subscribe_to :picked, with: :picked_callback
-#         # or the alias
-#         listen_to :picked, with: :picked_callback
 #     end
 #
 #     def picked_callback(event_data)
@@ -22,8 +20,6 @@
 #     extend Flirt::Listener
 #
 #     subscribe_to :picked, with: :picked_callback
-#     # or the alias
-#     listen_to :picked, with: :picked_callback
 #
 #     def self.picked_callback(event_data)
 #         puts "The #{event_data[:fruit]} has been picked"

data/lib/flirt/version.rb

@@ -1,5 +1,5 @@
 module Flirt
 
-  VERSION = "0.0.4"
-    
+  VERSION = "0.1.0"
+
 end

data/lib/flirt.rb

@@ -11,7 +11,10 @@ module Flirt
 
         def publish(event_name, event_data)
             return if disabled
+            return if disabled_list && disabled_list.include?(event_name)
+            return if enabled_list && !enabled_list.include?(event_name)
             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
@@ -34,13 +37,23 @@ module Flirt
         end
 
 
-        def enable
+        def enable(opts = {})
+            clear_event_lists
+            if opts[:only]
+                set_enabled opts[:only]
+            end
             self.disabled = false
         end
 
 
-        def disable
-            self.disabled = true
+        def disable(opts = {})
+            clear_event_lists
+            if opts[:only]
+                set_disabled opts[:only]
+                self.disabled = false
+            else
+                self.disabled = true
+            end
         end
 
 
@@ -52,7 +65,7 @@ module Flirt
         private
 
         attr_reader   :callbacks
-        attr_accessor :disabled
+        attr_accessor :disabled, :disabled_list, :enabled_list
 
 
         def callbacks
@@ -66,6 +79,26 @@ module Flirt
         end
 
 
+        def set_disabled(events)
+            self.disabled_list = wrap_event_list(events)
+        end
+
+
+        def set_enabled(events)
+            self.enabled_list = wrap_event_list(events)
+        end
+
+
+        def clear_event_lists
+            self.enabled_list  = nil
+            self.disabled_list = nil
+        end
+
+
+        def wrap_event_list(events)
+            events.is_a?(Array) ? events : [events]
+        end
+
         def remove_callback(event_name, callback_to_delete)
             return unless callbacks[event_name]
 

data/spec/flirt/flirt_spec.rb

@@ -50,6 +50,126 @@ describe Flirt do
             end
 
 
+            describe "then more listeners added" do
+
+                let(:event2)       { :topping_added }
+
+                let(:event3)       { :plated_up }
+
+                let(:callback2)    { :respond2 }
+
+                let(:callback3)    { :respond3 }
+
+                before(:each) do
+                    Flirt.subscribe listener, event2, with: callback2
+
+                    Flirt.subscribe listener, event3, with: callback3
+                end
+
+                after(:each) { Flirt.enable }
+
+                describe "when a single event is disabled" do
+
+                    it "disables just that event" do
+                        Flirt.disable only: :pancake_fried
+                        expect(listener).not_to receive(callback)
+                        expect(listener).to     receive(callback2).with(response)
+                        expect(listener).to     receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+                end
+
+                describe "when multiple events are disabled" do
+
+                    before(:each) { Flirt.disable only: [:pancake_fried, :topping_added] }
+
+                    it "disables those events" do
+                        expect(listener).not_to receive(callback)
+                        expect(listener).not_to receive(callback2)
+                        expect(listener).to     receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+                    it "forgets those events after a call to #enable" do
+                        Flirt.enable
+                        expect(listener).to receive(callback)
+                        expect(listener).to receive(callback2).with(response)
+                        expect(listener).to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+
+                    it "forgets those events after a call to #disable" do
+                        Flirt.disable
+                        expect(listener).not_to receive(callback)
+                        expect(listener).not_to receive(callback2).with(response)
+                        expect(listener).not_to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+                end
+
+                describe "when a single event is enabled" do
+
+                    it "enables just that event" do
+                        Flirt.enable only: :pancake_fried
+                        expect(listener).to     receive(callback)
+                        expect(listener).not_to receive(callback2).with(response)
+                        expect(listener).not_to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+                end
+
+
+                describe "when multiple events are enabled" do
+
+                    before(:each) { Flirt.enable only: [:pancake_fried, :topping_added] }
+                    it "enables those events" do
+                        Flirt.enable only: [:pancake_fried, :topping_added]
+                        expect(listener).    to receive(callback)
+                        expect(listener).    to receive(callback2).with(response)
+                        expect(listener).not_to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+
+                    it "forgets those events after a call to #enable" do
+                        Flirt.enable
+                        expect(listener).to receive(callback)
+                        expect(listener).to receive(callback2).with(response)
+                        expect(listener).to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+
+
+                    it "forgets those events after a call to #disable" do
+                        Flirt.disable
+                        expect(listener).not_to receive(callback)
+                        expect(listener).not_to receive(callback2).with(response)
+                        expect(listener).not_to receive(callback3).with(response)
+                        Flirt.publish event,  response
+                        Flirt.publish event2, response
+                        Flirt.publish event3, response
+                    end
+                end
+            end
+
+
             describe "when cleared" do
 
                 let(:callback2)    { :respond2 }

data/spec/spec_helper.rb

@@ -9,6 +9,7 @@ require 'rubygems'
 require 'bundler/setup'
 Bundler.setup
 
+require 'byebug'
 require 'flirt'
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flirt
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Benjamin Randles-Dunkley
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: " Provides a single point for the publication and subscription of events,
   promoting extreme decoupling. "
 email: