triggerful 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 517ba6c637f620f99edd9a6ad33fa536ae2b7064
-  data.tar.gz: cd8f10f45e3d1b6cf5a0d74975d87d5df35c4df1
+  metadata.gz: 9924e5a6de21a1d92e2447af8c77b528e7ebcfac
+  data.tar.gz: 50fb8c654671f3e945efaf4b4868b3ac985855ca
 SHA512:
-  metadata.gz: e64c5a28098f8bc53dc91ec8f12e1896b5697905645727d521ff65c490a08ce6b900f814e3bc3e8af5a99504b074a62edc4b10a7119a3661f9d1e54147697487
-  data.tar.gz: 77af13c34863c0c2f238a38f098427b6ec4f5baa278010515ff8d66abc9d5ff299f13bf340f6d79dc396329bc7daae1c193d5242daa30022d411d953dfe7350c
+  metadata.gz: 17fd69f8e4dca8215e521b61aaba65a77ff36c416a678dc18e9e7cdc297a6585b3b7d57f857e8f4c2f6df1b96203c685f1ea8a9ea6d2940739675663fe527925
+  data.tar.gz: dc8cb9db6eef6339a962a9fd941da64777331c0e865ef0535fc7da102827a79a199ef01a97acdcd368166809ebc177e1ed717a9c234683c287ae241ed47b8745

data/example/methods.rb

@@ -1,84 +1,43 @@
 # A more comprehensive list of methods that Triggerful supports
 require 'triggerful'
 
+$errors = 0
 $foobar = 0
 
-def foo
-  amount_of_change = rand(0..100)
-  $foobar += amount_of_change
-  
-  # The return value will be appended to the arguments sent
-  # to the callback.
-  amount_of_change
+def add(amount = 1)
+  $foobar += 1
 end
 
-def say_foobar(amount_of_change)
-  puts "$foobar has increased by #{amount_of_change} and is now #{$foobar}"
+def sub(amount = 1)
+  $foobar -= amount
 end
 
-# Set the second argument to true to append the return value
-# from the trigger to the callback.
-_foo = Trigger.new(:foo, true, :say_foobar)
-_foo.trigger
-
-# Sometimes you don't care about creating a new method the
-# normal way and you just want to use a Proc instead.
-_bar = Trigger.new(Proc.new{ $foobar += 1; 1 }, true, :say_foobar)
-_bar.trigger
-
-# You might even want to have a class's public method be
-# an event. To get a hold of that, use instance.public_method(:symbol)
-class FooBar
-  def initialize amount
-    @amount = amount
-  end
-  
-  def add
-    $foobar += @amount
-    @amount
-  end
-  
-  def subtract
-    $foobar -= @amount
-    @amount
-  end
-  
-  def amount
-    @amount
+def err_unless(line = 'unknown line', statement = true)
+  if !statement
+    $errors += 1
+    puts "Incorrect value at #{line}"
   end
 end
 
-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(:subtract), Proc.new{ puts "$foobar has decreased by #{twenty.amount} and is now #{$foobar}" })
-
-_twenty_add.trigger
-_twenty_subtract.trigger
-
-# Triggers support a few methods that regular arrays support,
-# such as remove, delete_at, length, and index(symbol). If you
-# want an actual array of callbacks, then call Trigger.list
-_twenty_subtract.add(:foo)
-puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
-
-_twenty_subtract.insert(1, _twenty_add)
-puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
-
-_twenty_subtract.delete_at(0)
-puts "(#{_twenty_subtract.length}) #{_twenty_subtract.list}\n----"
-
-_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}"
-
-# 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 event: #{_bar.event}"
-puts "Symbol event: #{_foo.event}"
-puts "Public Method event: #{_twenty_add.event}"
+event = Trigger.new(:add, true, :sub)
+err_unless __LINE__, event.trigger == 1
+err_unless __LINE__, (event.add(:sub,:sub).is_a? Array)
+err_unless __LINE__, event.trigger == 1
+err_unless __LINE__, $foobar == -2
+err_unless __LINE__, (event.remove_all == [])
+err_unless __LINE__, event.insert(0, ->{ $foobar -= $foobar }).size == 1
+err_unless __LINE__, (proc_callback = event.list[0]; proc_callback.is_a? Proc)
+err_unless __LINE__, event.remove(proc_callback).empty?
+err_unless __LINE__, event.toggle_event_returns == false
+err_unless __LINE__, (event << :sub).length == 1
+err_unless __LINE__, event.include?(:sub)
+err_unless __LINE__, (event << ->{ $foobar -= $foobar }).count == 2
+# this may be a bug within Ruby itself
+err_unless __LINE__, event.first == [:sub]
+err_unless __LINE__, event.reverse!.last == :sub
+
+if $errors > 0
+  puts "Total errors: #{$errors}"
+else
+  puts "No errors! Looking all right to me."
+end

data/example/usage.rb

@@ -1,4 +1,3 @@
-# Triggerful usage
 require 'triggerful'
 
 $foobar = 0
@@ -11,24 +10,17 @@ def bar
   puts $foobar
 end
 
-# create Trigger and callback, then trigger the Trigger
+# create Trigger with an event and callback, then trigger it
 _foo = Trigger.new(:foo, :bar)
 _foo.trigger
 
 # create a method to determine if bar has been called before
-$bar_called? = false
-def bar_called
-  $bar_called = true
-end
-
-# create a callback for the callback
-_bar = Trigger.new(:bar, :bar_called)
+$bar_called = false
+_bar = Trigger.new(:bar, Proc.new{ $bar_called = true })
 
-# replace old callback with new one (note that no symbol was used for the callback)
-_foo.remove(:bar)
-_foo.add(_bar)
+# replace old callback with new one
+_foo.replace(_bar)
 
-# methods are not called when added to Trigger callbacks, only when triggered
-puts $bar_called?
+puts $bar_called
 _foo.trigger
-puts $bar_called?
+puts $bar_called

data/lib/triggerful.rb

@@ -1,81 +1,76 @@
 class Trigger
-  def initialize event, *callbacks
-    @event, @callbacks = event, callbacks
+  # event is the Proc, Method, Trigger, Symbol, or String that gets called before the callbacks
+  # event_returns determines whether or not the callbacks should receive the output of the event appended in the arguments
+  # *callbacks is any number of Procs, Methods, Triggers, Symbols, or Strings that will be called after the event
+  def initialize event, event_returns = false, *callbacks
+    @event_name, @event_returns, @callbacks = event, event_returns, callbacks
+    @event = to_method(@event_name)
     
-    # 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)
-    when FalseClass
-      @progression = false
-      @callbacks.delete_at(0)
-    else
-      @progression = false
+    case @event_returns
+    when Proc, Method, Symbol, String, Trigger
+      @callbacks.unshift(event_returns)
+      @event_returns = false
     end
+    
+    update_callback_procs
   end
   
   # fires the event and all callbacks normally
   def trigger(*args)
     arguments  = *args.dup
-    event_data = case @event
-    when Proc, Method
-      @event.call(*args)
-    else
-      method(@event).call(*args)
-    end
-    
-    arguments << event_data if @progression
-    
-    silent_trigger(*arguments)
-  end
-  
-  # 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, Method
-          callback.call(*args)
-        else
-          method(callback).call(*args)
-        end
-      end
-    end
+    event_data = @event.call(*args)
+    arguments << event_data if @event_returns
+    @callback_procs.each{ |c| c.call(*arguments) }
+    event_data
+  end
+  
+  def toggle_event_returns
+    @event_returns = !@event_returns
   end
   
   # add callback(s) to instance
   def add(*callbacks)
     @callbacks.concat(callbacks)
+    update_callback_procs
   end
   
   # insert a callback at a specific index
   def insert(index, *callbacks)
-    @callbacks.insert(index, callbacks)
+    @callbacks.insert(index, *callbacks)
+    update_callback_procs
   end
   
-  # remove callback(s) from instance
+  # remove specified callback(s) from instance
   def remove(*callbacks)
+    callbacks.each do |callback|
+      @callbacks.delete(callback)
+    end
+    update_callback_procs
+  end
+  
+  # remove first callback for each specified callback(s) from instance
+  def remove_first(*callbacks)
     callbacks.each do |callback|
       @callbacks.delete_at(@callbacks.index(callback) || @callbacks.length)
     end
+    update_callback_procs
   end
   
   def delete(callback)
     @callbacks.delete(callback)
+    update_callback_procs
   end
   
   # remove a callback from a specific index
   def delete_at(index)
     @callbacks.delete_at(index)
+    update_callback_procs
   end
   
   # remove all callbacks from the event
   def remove_all
     @callbacks = []
+    update_callback_procs
   end
   
   # fetch index of a callback from instance
@@ -89,8 +84,8 @@ class Trigger
   end
   
   # fetch a callback at an index
-  def fetch(index, default = nil)
-    @callbacks.fetch(index, default)
+  def fetch(index, err_log = nil)
+    @callbacks.fetch(index, err_log)
   end
   
   # fetch the first callback(s) on event
@@ -103,41 +98,11 @@ class Trigger
     @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?
@@ -148,9 +113,10 @@ class Trigger
     @callbacks.include?(callback)
   end
   
-  # replaces callbacks with a new array of callbacks
-  def replace(callbacks)
+  # replaces callbacks with a new splat of callbacks
+  def replace(*callbacks)
     @callbacks.replace(callbacks)
+    update_callback_procs
   end
   
   # returns a reversed version of callbacks
@@ -161,5 +127,44 @@ class Trigger
   # returns a reversed version of callbacks and changes the original
   def reverse!
     @callbacks.reverse!
+    update_callback_procs
+  end
+  
+  def <<(callback)
+    @callbacks << callback
+    update_callback_procs
+  end
+  
+  def +(*callbacks)
+    @callbacks + callbacks
+  end
+  
+  def -(*callbacks)
+    @callbacks - callbacks
+  end
+  
+  attr_accessor :event_name, :event_returns, :callbacks
+  alias :list :callbacks
+  alias :event :event_name
+  
+  alias_method :call, :trigger
+  alias_method :size, :length
+  alias_method :count, :length
+  alias_method :clear, :remove_all
+  
+  private
+  
+  # turns the array of Procs, Methods, Triggers, Symbols, and Strings into a callable array
+  def update_callback_procs
+    @callback_procs = @callbacks.map{ |c| to_method(c) }
+    @callbacks
+  end
+  
+  # converts Triggers, Strings, and Symbols into objects that can be used with the .call method
+  def to_method(event)
+    case event
+    when Proc, Method, Trigger then event
+    else self.class.superclass.method(event)
+    end
   end
 end

metadata

@@ -1,17 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: triggerful
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Andrew Bob Garrett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-12 00:00:00.000000000 Z
+date: 2013-10-29 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.
+description: |
+  Create callbacks to methods that you can easily and dynamically
+  create/remove. Quite useful for lightweight event based programming. Even
+  the medic agrees. If there's any kind of feature you think this gem is
+  missing or if there is a bug, feel free to email me at andrew@karbon.tk
+  any time. Special thanks to: My brother Matt, m_x
+  (http://codereview.stackexchange.com/users/24548/m-x), and Cary Swoveland
+  (http://codereview.stackexchange.com/users/30157/cary-swoveland)'
 email: andrew@karbon.tk
 executables: []
 extensions: []
@@ -33,7 +39,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='