triggerful 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61ac309ae45567aa35b123196c6668b619884283
-  data.tar.gz: efe1ceb742a31cc93022ce6d5c68a7390d4344be
+  metadata.gz: 517ba6c637f620f99edd9a6ad33fa536ae2b7064
+  data.tar.gz: cd8f10f45e3d1b6cf5a0d74975d87d5df35c4df1
 SHA512:
-  metadata.gz: 8725c277b0204333e982a4d2a24de50f41b4323157311ddd0bc7d4a6cb4eb4fa22e7615a4aad8df5c26fa1948b02e79d9f924d115a19551e79ffe3691645b593
-  data.tar.gz: 74119b4bb875d04155dfdd80a8cf87a94c3cce59cf5012247084d66aaaaeb41b3d127c9dd0d3c53b413d0ffdf70d48f14d2bbb617975bbb2329e098a357681d8
+  metadata.gz: e64c5a28098f8bc53dc91ec8f12e1896b5697905645727d521ff65c490a08ce6b900f814e3bc3e8af5a99504b074a62edc4b10a7119a3661f9d1e54147697487
+  data.tar.gz: 77af13c34863c0c2f238a38f098427b6ec4f5baa278010515ff8d66abc9d5ff299f13bf340f6d79dc396329bc7daae1c193d5242daa30022d411d953dfe7350c

data/example/game-logic.rb

@@ -5,7 +5,7 @@ class Player
   def initialize name, power, toughness, crit
     @name, @power, @toughness, @crit = name, power, toughness, crit
     @health = 100
-    @gear = []
+    @gear   = []
   end
   
   def name(*set)
@@ -93,8 +93,7 @@ def display_stats(*players)
 end
 
 attacked_event = Trigger.new(:attacked, true, :barbed_shield, fred.public_method(:to_s), will.public_method(:to_s))
-attack_event = Trigger.new(:attack, true, attacked_event)
-
+attack_event   = Trigger.new(:attack,   true, attacked_event)
 
 # Arbitrarily equip fred with barbed_shield.
 # Also, do not use equipment like this. You should really use classes.

data/example/methods.rb

@@ -1,5 +1,5 @@
 # A more comprehensive list of methods that Triggerful supports
-require '~/Test/triggerful/lib/triggerful.rb'
+require 'triggerful'
 
 $foobar = 0
 
@@ -53,7 +53,7 @@ twenty = FooBar.new(20)
 # Note that FooBar.subtract has a return value, but you don't
 # need to turn progression on to use the callback.
 _twenty_add = Trigger.new(twenty.public_method(:add), true, :say_foobar)
-_twenty_subtract = Trigger.new(twenty.public_method(:add), Proc.new{ puts "$foobar has decreased by #{twenty.amount} and is now #{$foobar}" })
+_twenty_subtract = Trigger.new(twenty.public_method(:subtract), Proc.new{ puts "$foobar has decreased by #{twenty.amount} and is now #{$foobar}" })
 
 _twenty_add.trigger
 _twenty_subtract.trigger
@@ -74,9 +74,11 @@ _twenty_subtract.delete_at(_twenty_subtract.index(:foo))
 puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
 
 _twenty_subtract.remove_all
-puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
+puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}"
 
 # If you're ever unsure of what your event is called,
 # such as when you're using a Proc, then you may call
 # the Trigger.event to fetch that data
-puts "Proc: #{_bar.event}\nSymbol: #{_foo.event}\nPublic Method: #{_twenty_add.event}"
+puts "Proc event: #{_bar.event}"
+puts "Symbol event: #{_foo.event}"
+puts "Public Method event: #{_twenty_add.event}"

data/lib/triggerful.rb

@@ -1,12 +1,14 @@
 class Trigger
   def initialize event, *callbacks
-    @callbacks = callbacks
-    @event = event
+    @event, @callbacks = event, callbacks
     
-    if @callbacks[0].is_a? TrueClass
+    # check to see if the second argument is either true or false
+    # if not, then it must be a callback
+    case @callbacks[0]
+    when TrueClass
       @progression = true
       @callbacks.delete_at(0)
-    elsif @callbacks[0].is_a? FalseClass
+    when FalseClass
       @progression = false
       @callbacks.delete_at(0)
     else
@@ -14,58 +16,30 @@ class Trigger
     end
   end
   
+  # fires the event and all callbacks normally
   def trigger(*args)
-    case @event
-    when Proc
-      event_data = @event.call
-    when Method
-      event_data = @event.call
+    arguments  = *args.dup
+    event_data = case @event
+    when Proc, Method
+      @event.call(*args)
     else
-      event_data = self.method(@event).call(*args)
-    end
-    @callbacks.each do |callback|
-      if callback.instance_of? Trigger
-        if @progression
-          callback.trigger(*args, event_data)
-        else
-          callback.trigger(*args)
-        end
-      else
-        case callback
-        when Proc
-          if @progression
-            callback.call(*args, event_data)
-          else
-            callback.call(*args)
-          end
-        when Method
-          if @progression
-            callback.call(*args, event_data)
-          else
-            callback.call(*args)
-          end
-        else
-          if @progression
-            method(callback).call(*args, event_data)
-          else
-            method(callback).call(*args)
-          end
-        end
-      end
+      method(@event).call(*args)
     end
+    
+    arguments << event_data if @progression
+    
+    silent_trigger(*arguments)
   end
   
-  #triggers the callbacks without executing the original method
+  # triggers the callbacks without executing the original event
   def silent_trigger(*args)
     @callbacks.each do |callback|
       if callback.instance_of? Trigger
         callback.trigger(*args)
       else
         case callback
-        when Proc
-          callback.call
-        when Method
-          callback.call
+        when Proc, Method
+          callback.call(*args)
         else
           method(callback).call(*args)
         end
@@ -75,9 +49,10 @@ class Trigger
   
   # add callback(s) to instance
   def add(*callbacks)
-    @callbacks.concat callbacks
+    @callbacks.concat(callbacks)
   end
   
+  # insert a callback at a specific index
   def insert(index, *callbacks)
     @callbacks.insert(index, callbacks)
   end
@@ -89,42 +64,102 @@ class Trigger
     end
   end
   
+  def delete(callback)
+    @callbacks.delete(callback)
+  end
+  
+  # remove a callback from a specific index
   def delete_at(index)
     @callbacks.delete_at(index)
   end
   
+  # remove all callbacks from the event
   def remove_all
     @callbacks = []
   end
   
-  # fetch info from instance
+  # fetch index of a callback from instance
   def index(callback)
     @callbacks.index(callback)
   end
   
+  # fetch a callback at an index
+  def at(index)
+    @callbacks.at(index)
+  end
+  
+  # fetch a callback at an index
+  def fetch(index, default = nil)
+    @callbacks.fetch(index, default)
+  end
+  
+  # fetch the first callback(s) on event
+  def first(count = 1)
+    @callbacks.first(count)
+  end
+  
+  # fetch the last callback(s) on event
+  def last(count = 1)
+    @callbacks.last(count)
+  end
+  
+  # fetch the event, which may be a Proc, Symbol, String, or Method
   def event
     @event
   end
   
+  # fetch the number of callbacks
   def length
     @callbacks.length
   end
   
+  # fetch the number of callbacks
+  def count
+    @callbacks.count
+  end
+  
+  # fetch the number of callbacks
+  def size
+    @callbacks.size
+  end
+  
+  # returns an array object of callbacks
   def list
     @callbacks
   end
   
+  # alias for list
   def callbacks
     @callbacks
   end
+  
+  # remove all callbacks from the event
+  def clear
+    @callbacks = []
+  end
+  
+  # returns true if there are no callbacks or false otherwise
+  def empty?
+    @callbacks.empty?
+  end
+  
+  # returns true if specified callback exists in callbacks or false otherwise
+  def include?(callback)
+    @callbacks.include?(callback)
+  end
+  
+  # replaces callbacks with a new array of callbacks
+  def replace(callbacks)
+    @callbacks.replace(callbacks)
+  end
+  
+  # returns a reversed version of callbacks
+  def reverse
+    @callbacks.reverse
+  end
+  
+  # returns a reversed version of callbacks and changes the original
+  def reverse!
+    @callbacks.reverse!
+  end
 end
-
-=begin
-  A short scrib of notes for humans
-    
-    Semantically speaking, caller, event, and trigger are synonymous.
-    The trigger that is triggered is similar to a javascript event
-    that is listened to. The callbacks would be called from the
-    caller, ie the event/trigger.
-    
-=end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: triggerful
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Andrew Bob Garrett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-09 00:00:00.000000000 Z
+date: 2013-10-12 00:00:00.000000000 Z
 dependencies: []
 description: Create callbacks to methods that you can easily and dynamically create/remove.
   Quite useful for lightweight event based programming. Even the medic agrees.