net-yail 1.5.1 → 1.6.0

data/lib/net/yail.rb

@@ -10,12 +10,14 @@ require 'net/yail/magic_events'
 require 'net/yail/default_events'
 require 'net/yail/output_api'
 require 'net/yail/legacy_events'
+require 'net/yail/dispatch'
 
 # This tells us our version info.
 require 'net/yail/yail-version'
 
-# Finally, a real class to include!
+# Finally, real classes to include!
 require 'net/yail/event'
+require 'net/yail/handler'
 
 # If a thread crashes, I want the app to die.  My threads are persistent, not
 # temporary.
@@ -40,7 +42,7 @@ module Net
 #
 # YAIL at its core is an event handler with some logic specific to IRC socket messages.  BaseEvent
 # is the parent of all event objects.  An event is run through various pre-callback filters, a
-# single callback, and post-callback filters.  Up until the post-callback filters start, the handler
+# single callback, and post-callback filters.  Up until the callback is hit, the handler
 # "chain" can be stopped by calling the event's .handled! method.  It is generally advised against
 # doing this, as it will stop things like post-callback stats gathering and similar plugin-friendly
 # features, but it does make sense in certain situations (an "ignore user" module, for instance).
@@ -58,9 +60,12 @@ module Net
 # and filter is explained above (1 callback per event, many filters), but at their core they are
 # just code that handles some aspect of the event.
 #
-# All handlers require some block of code.  You can explicitly create a Proc object, use
-# Something.method, or just pass in a block.  The block yields the event object which will have
-# all relevant data for the event.  See the examples below for a basic idea.
+# Handler methods must receive a block of code.  This can be passed in as a simple Ruby block, or
+# manually created via Proc.new, lambda, Foo.method(:bar), etc.  The <tt>method</tt> parameter of
+# all the handler methods is optional so that, as mentioned, a block can be used instead of a Proc.
+#
+# The handlers, when fired, will yield the event object containing all relevant data for the event.
+# See the examples below for a basic idea.
 #
 # To register an event's callback, you have the following options:
 # * <tt>set_callback(event_type, method = nil, &block)</tt>: Sets the event type's callback, clobbering any
@@ -69,7 +74,7 @@ module Net
 #   The "xxx" must be replaced by the incoming event's short type name.  For example,
 #   <tt>on_welcome {|event| ...}</tt> would be used in place of <tt>set_callback(:incoming_welcome, xxx)</tt>.
 #
-# To register a before- or after-callback filter:
+# To register a before- or after-callback filter, the following methods are available:
 # * <tt>before_filter(event_type, method = nil, &block)</tt>: Sets a before-callback filter, adding it to
 #   the current list of before-callback filters for the given event type.
 # * <tt>after_filter(event_type, method = nil, &block)</tt>: Sets an after-callback filter, adding it to
@@ -83,6 +88,23 @@ module Net
 # * <tt>said_xxx(method = nil, &block)</tt>: Adds an after-callback filter for the given outgoing event
 #   type, such as <tt>said_act {|event| ...}</tt>
 #
+# ===Conditional Filtering
+#
+# For some situations, you want your filter to only be called if a certain condition is met.  Enter conditional filtering!
+# By using this exciting feature, you can set up handlers and callbacks which only trigger when certain conditions are
+# met.  Be warned, though, this can get confusing....
+#
+# Conditions can be added to any filter method, but should **never** be used on the callback, since *there can be only one*.
+# To add a filter, you simply supply a hash with a key of either `:if` or `:unless`, and a value which is either another
+# hash of conditions, or a proc.
+#
+# If a proc is sent, it will be a method that is called and passed the event object.  If the proc returns true, an `:if`
+# condition is met and un `:unless` condition is not met.  If a condition is not met, the filter is skipped entirely.
+#
+# If a hash is sent, each key is expected to be an attribute on the event object.  It's similar to a lambda where you
+# return true if each attribute equals the value in the hash.  For instance, `:if => {:message => "food", :nick => "Simon"}`
+# is the same as `:if => lambda {|e| e.message == "food" && e.nick == "Simon"}`.
+#
 # ==Incoming events
 #
 # *All* incoming events will have, at the least, the following methods:
@@ -232,14 +254,14 @@ module Net
 #
 #     require 'rubygems'
 #     require 'net/yail'
-#     
+#
 #     irc = Net::YAIL.new(
 #       :address    => 'irc.someplace.co.uk',
 #       :username   => 'Frakking Bot',
 #       :realname   => 'John Botfrakker',
 #       :nicknames  => ['bot1', 'bot2', 'bot3']
 #     )
-#     
+#
 #     # Automatically join #foo when the server welcomes us
 #     irc.on_welcome {|event| irc.join("#foo") }
 #
@@ -249,11 +271,12 @@ module Net
 #
 #     # Loops forever until CTRL+C
 #     irc.start_listening!
-class YAIL 
+class YAIL
   include Net::IRCEvents::Magic
   include Net::IRCEvents::Defaults
   include Net::IRCOutputAPI
   include Net::IRCEvents::LegacyEvents
+  include Dispatch
 
   attr_reader(
     :me,                # Nickname on the IRC server
@@ -358,7 +381,7 @@ class YAIL
     else
       @log = Logger.new(options[:log_io] || STDERR)
       @log.level = Logger::WARN
- 
+
       if (options[:silent] || options[:loud])
         @log.warn '[DEPRECATED] - passing :silent and :loud options to constructor are deprecated as of 1.4.1'
       end
@@ -472,6 +495,8 @@ class YAIL
     set_callback :outgoing_ctcp, self.method(:magic_out_ctcp)
     set_callback :outgoing_act, self.method(:magic_out_act)
 
+    # WHOIS is tricky due to how weird its argument positioning is, so can't use create_command, either
+
     # All PRIVMSG events eventually hit this - it's a legacy thing, and kinda dumb, but there you
     # have it.  Just sends a raw PRIVMSG out to the socket.
     create_command :privmsg, "PRIVMSG :target ::message", :target, :message
@@ -527,7 +552,7 @@ class YAIL
     return [@socket.gets] unless @ssl
 
     # SSL socket == return all lines available
-    return @socket.readpartial(Buffering::BLOCK_SIZE).split($/).collect {|message| message}
+    return @socket.readpartial(OpenSSL::Buffering::BLOCK_SIZE).split($/).collect {|message| message}
   end
 
   # Reads incoming data - should only be called by io_loop, and only when
@@ -660,12 +685,12 @@ class YAIL
   # before the event callback has run, and can stop the event (and other filters) from running by calling the event's
   # end_chain() method.  Filters shouldn't do this very often!  Before-filtering can modify output text before the
   # event callback runs, ignore incoming events for a given user, etc.
-  def before_filter(event_type, method = nil, &block)
+  def before_filter(event_type, method = nil, conditions = {}, &block)
     filter = block_given? ? block : method
     if filter
       event_type = numeric_event_type_convert(event_type)
       @before_filters[event_type] ||= Array.new
-      @before_filters[event_type].unshift(filter)
+      @before_filters[event_type].unshift(Net::YAIL::Handler.new(filter, conditions))
     end
   end
 
@@ -673,22 +698,22 @@ class YAIL
   # longer a concept of multiple callbacks!  Use filters for that kind of functionality.  Think this way: the callback
   # is the action that takes place when an event hits.  Filters are for functionality related to the event, but not
   # the definitive callback - logging, filtering messages, stats gathering, ignoring messages from a set user, etc.
-  def set_callback(event_type, method = nil, &block)
+  def set_callback(event_type, method = nil, conditions = {}, &block)
     callback = block_given? ? block : method
     event_type = numeric_event_type_convert(event_type)
-    @callback[event_type] = callback
+    @callback[event_type] = Net::YAIL::Handler.new(callback, conditions)
     @callback.delete(event_type) unless callback
   end
 
   # Prepends the given block or method to the after_filters array for the given type.  After-filters are called after
   # the event callback has run, and cannot stop other after-filters from running.  Best used for logging or statistics
   # gathering.
-  def after_filter(event_type, method = nil, &block)
+  def after_filter(event_type, method = nil, conditions = {}, &block)
     filter = block_given? ? block : method
     if filter
       event_type = numeric_event_type_convert(event_type)
       @after_filters[event_type] ||= Array.new
-      @after_filters[event_type].unshift(filter)
+      @after_filters[event_type].unshift(Net::YAIL::Handler.new(filter, conditions))
     end
   end
 
@@ -708,42 +733,6 @@ class YAIL
     return type
   end
 
-  # Given an event, calls pre-callback filters, callback, and post-callback filters.  Uses hacky
-  # :incoming_any event if event object is of IncomingEvent type.
-  def dispatch(event)
-    # Add all before-callback stuff to our chain
-    chain = []
-    chain.push @before_filters[:incoming_any] if Net::YAIL::IncomingEvent === event
-    chain.push @before_filters[:outgoing_any] if Net::YAIL::OutgoingEvent === event
-    chain.push @before_filters[event.type]
-    chain.flatten!
-    chain.compact!
-
-    # Run each filter in the chain, exiting early if event was handled
-    for filter in chain
-      filter.call(event)
-      return if event.handled?
-    end
-
-    # Legacy handler - return if true, since that's how the old system works - EXCEPTION for outgoing events, since
-    # the old system didn't allow the outgoing "core" code to be skipped!
-    if true == legacy_process_event(event)
-      return unless Net::YAIL::OutgoingEvent === event
-    end
-
-    # Add new callback and all after-callback stuff to a new chain
-    chain = []
-    chain.push @callback[event.type]
-    chain.push @after_filters[event.type]
-    chain.push @after_filters[:incoming_any] if Net::YAIL::IncomingEvent === event
-    chain.push @after_filters[:outgoing_any] if Net::YAIL::OutgoingEvent === event
-    chain.flatten!
-    chain.compact!
-
-    # Run all after-filters blindly - none can affect callback, so after-filters can't set handled to true
-    chain.each {|filter| filter.call(event)}
-  end
-
   # Handles magic listener setup methods: on_xxx, hearing_xxx, heard_xxx, saying_xxx, and said_xxx
   def method_missing(name, *args, &block)
     method = nil
@@ -773,13 +762,14 @@ class YAIL
 
     # Magic methods MUST have an arg or a block!
     filter_or_callback_method = block_given? ? block : args.shift
+    conditions = args.shift || {}
 
     # If we didn't match a magic method signature, or we don't have the expected parameters, call
     # parent's method_missing.  Just to be safe, we also return, in case YAIL one day subclasses
     # from something that handles some method_missing stuff.
     return super if method.nil? || event_type.nil? || args.length > 0
 
-    self.send(method, event_type, filter_or_callback_method)
+    self.send(method, event_type, filter_or_callback_method, conditions)
   end
 end
 

data/lib/net/yail/dispatch.rb

@@ -0,0 +1,47 @@
+module Net
+class YAIL
+
+module Dispatch
+  # Given an event, calls pre-callback filters, callback, and post-callback filters.  Uses
+  # *_any event, where * is the event's event_class value
+  def dispatch(event)
+    # We always have an "any" filter option, so we build the symbol first
+    any_filter_sym = (event.event_class + "_any").to_sym
+
+    before_any = @before_filters[any_filter_sym]
+    run_chain(event, :allow_halt => true, :handlers => [before_any, @before_filters[event.type]])
+
+    # Have to break here if before filters said so
+    return if event.handled?
+
+    # Legacy handler - return if true, since that's how the old system works - EXCEPTION for outgoing events, since
+    # the old system didn't allow the outgoing "core" code to be skipped!
+    if true == legacy_process_event(event)
+      return unless Net::YAIL::OutgoingEvent === event
+    end
+
+    # Add new callback and all after-callback stuff to a new chain
+    after_any = @after_filters[any_filter_sym]
+    run_chain(event, :allow_halt => false, :handlers => [@callback[event.type], @after_filters[event.type], after_any])
+  end
+
+  # Consolidates all handlers passed in, flattening into a single array of handlers and
+  # removing any nils, then runs the methods on each event, respecting filter conditions
+  def run_chain(event, opts = {})
+    handlers = opts[:handlers]
+    handlers.flatten!
+    handlers.compact!
+
+    allow_halt = opts[:allow_halt]
+
+    # Run each filter in the chain if conditions are met, exiting early if event was handled
+    for handler in handlers
+      handler.call(event)
+      return if event.handled? && true == allow_halt
+    end
+
+  end
+end
+
+end
+end

data/lib/net/yail/event.rb

@@ -38,19 +38,28 @@ class YAIL
 
     # Cheesy shortcut to @handled in "boolean" form
     def handled?; return @handled; end
+
+    def event_class
+      return "base"
+    end
+
+    def type
+      return ("%s_%s" % [event_class, @type]).to_sym
+    end
   end
 
   # The outgoing event class - outgoing events haven't got much in
   # common, so this class is primarily to facilitate the new system.
   class OutgoingEvent < BaseEvent
     # Outgoing events in our system are always :outgoing_xxx
-    def type
-      return :"outgoing_#{@type.to_s}"
+    def event_class
+      return "outgoing"
     end
   end
 
   # Custom event is just a base event that doesn't crash when accessing type :)
   class CustomEvent < BaseEvent
+    def event_class; return "custom"; end
     def type; return @type; end
   end
 
@@ -95,7 +104,9 @@ class YAIL
     end
 
     # Incoming events in our system are always :incoming_xxx
-    def type; return :"incoming_#{@type.to_s}"; end
+    def event_class
+      return "incoming"
+    end
 
     # Effectively our event "factory" - uses Net::YAIL::MessageParser and returns an event
     # object - usually just one, but TODO: some lines actually contain multiple messages.  When

data/lib/net/yail/handler.rb

@@ -0,0 +1,38 @@
+module Net
+class YAIL
+
+  # Represents a method and meta-data for handling an event
+  class Handler
+    def initialize(method, conditions = {})
+      @method = method
+
+      # Make sure even an explicit nil is turned into an empty hash
+      @conditions = conditions || {}
+    end
+
+    # Calls the handler with the given arguments if the conditions are met
+    def call(event)
+      # Get out if :if/:unless aren't met
+      return if @conditions[:if] && !condition_check(@conditions[:if], event)
+      return if @conditions[:unless] && condition_check(@conditions[:unless], event)
+
+      return @method.call(event)
+    end
+
+    # Checks the condition.  Procs are simply run and returned, while Hash-based conditions return
+    # true if value === event.send(key)
+    def condition_check(condition, event)
+      # Procs are the easiest to evaluate
+      return condition.call(event) if condition.is_a?(Proc)
+
+      # If not a proc, condition must be a hash - iterate over values.  All must be true to
+      # return true.
+      for (key, value) in condition
+        return false unless value === event.send(key)
+      end
+      return true
+    end
+  end
+
+end
+end

data/lib/net/yail/legacy_events.rb

@@ -12,8 +12,11 @@ module LegacyEvents
   def prepend_handler(event, *procs, &block)
     raise "Cannot change handlers while threads are listening!" if @ioloop_thread
 
-    @log.warn "[DEPRECATED] - Net::YAIL#prepend_handler is deprecated as of 1.5.0 - please see documentation on the new " +
-        "event handling model methods - http://ruby-irc-yail.nerdbucket.com/"
+    unless $deprecated_prepend_warning
+      @log.warn "[DEPRECATED] - Net::YAIL#prepend_handler is deprecated as of 1.5.0 - please see documentation on the new " +
+          "event handling model methods - http://ruby-irc-yail.nerdbucket.com/"
+      $deprecated_prepend_warning = true
+    end
 
     # Allow blocks as well as procs
     if block_given?
@@ -190,22 +193,6 @@ module LegacyEvents
 
       when :outgoing_begin_connection
         return handle(event.type, event.username, event.address, event.realname)
-
-      # Unknown line - if an incoming event, we need to log it as that shouldn't be able to happen,
-      # but we don't want to kill somebody's app for it.  An outgoing event that's part of the
-      # system should NEVER hit this, so we throw an error in that case.  Custom events just get
-      # handled with no arguments, to allow for things like :irc_loop.
-      else
-        case event
-          when Net::YAIL::IncomingEvent
-            @log.warn 'Unknown line: %s!' % event.raw.inspect
-            @log.warn "Please report this to the github repo at https://github.com/Nerdmaster/ruby-irc-yail/issues"
-            return handle(:incoming_miscellany, event.raw)
-          when Net::YAIL::OutgoingEvent
-            raise "Unknown outgoing event: #{event.inspect}"
-          else
-            handle(event.type)
-        end
     end
   end
 end

data/lib/net/yail/magic_events.rb

@@ -53,6 +53,11 @@ module Magic
     privmsg(event.target, "\001ACTION #{event.message}\001")
   end
 
+  # WHOIS - here because first parameter might be the nick and might be the optional server
+  def magic_out_whois(event)
+    raw "WHOIS %s%s" % [event.server.to_s.empty? ? "" : event.server, event.nick]
+  end
+
 end
 
 end

data/lib/net/yail/output_api.rb

@@ -39,6 +39,15 @@ module IRCOutputAPI
     buffer_output Net::YAIL::OutgoingEvent.new(:type => :act, :target => target, :message => message)
   end
 
+  # WHOIS is tricky - it can optionally take a :target parameter, which is the *first* parameter
+  # if it's present, rather than added to the parameter list.  BAD SPECIFICATIONS!  NO BISCUIT!
+  # (If it were more standard, we could just use create_command)
+  #
+  # Note that "nick" can actually be a comma-separated list of masks for whois querying.
+  def whois(nick, server = nil)
+    dispatch Net::YAIL::OutgoingEvent.new(:type => :whois, :nick => nick, :server => server)
+  end
+
   # Creates an output command and its handler.  output_base is a template of the command without
   # any conditional arguments (for simple commands this is the full template).  args is a list of
   # argument symbols to determine how the event is built and handled.  If an argument symbol is

data/lib/net/yail/yail-version.rb

@@ -1,5 +1,5 @@
 module Net
   class YAIL
-    VERSION = '1.5.1'
+    VERSION = '1.6.0'
   end
 end

data/tests/tc_yail.rb

@@ -241,4 +241,154 @@ class YailSessionTest < Test::Unit::TestCase
       assert_equal 'Quit: Bye byes', @quit[:message]
     end
   end
+
+  # Verifies that chains are broken properly for before filters and the callback, but not for after filters
+  def test_chain_breaking
+    @msg = Hash.new(0)
+
+    # First call means last filter - this one proves that the last one did or didn't run
+    @yail.hearing_msg { |e| @msg[:before_last] += 1; e.handled! if e.message == "quit 2" }
+
+    # Second call means first filter - this one actually allows or skips all other filters and callbacks
+    @yail.hearing_msg { |e| e.handled! if e.message == "quit 1" }
+
+    # Actual callback - this is hit as long as a before filter didn't stop the chain
+    @yail.on_msg      { |e| @msg[:callback] += 1; e.handled! }
+
+    # After filters never stop the chain
+    @yail.heard_msg   { |e| @msg[:after_msg] += 1; e.handled! }
+    @yail.heard_msg   { |e| @msg[:after_msg] += 1; e.handled! }
+    @yail.heard_msg   { |e| @msg[:after_msg] += 1; e.handled! }
+    @yail.heard_msg   { |e| @msg[:after_msg] += 1; e.handled! }
+
+    @yail.start_listening
+
+    wait_for_irc
+
+    # quit 1 means no filters are hit after the first
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :quit 1" do
+      assert_equal 0, @msg[:before_last]
+      assert_equal 0, @msg[:callback]
+      assert_equal 0, @msg[:after_msg]
+    end
+
+    # quit 2 means we hit the first before filter, but stopped after the second
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :quit 2" do
+      assert_equal 1, @msg[:before_last]
+      assert_equal 0, @msg[:callback]
+      assert_equal 0, @msg[:after_msg]
+    end
+
+    # After filters get run when before filters don't stop things, even though callback and after
+    # filters keep trying to break the chain
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :Well hello there, test!" do
+      assert_equal 1, @msg[:before_last]
+      assert_equal 1, @msg[:callback]
+      assert_equal 4, @msg[:after_msg]
+    end
+  end
+
+  # Verify that *_any filters are run appropriately and in order - before filter should be the
+  # first filter run, and after filter should be the last
+  def test_any_filters_and_filter_order
+    step = 1
+
+    # First we should hit the incoming "any" before filter
+    @yail.hearing_any do |e|
+      if e.type == :incoming_msg
+        assert_equal 1, step
+        step += 1
+      end
+    end
+
+    # Second, incoming message before filter
+    @yail.hearing_msg { |e| assert_equal 2, step; step += 1 }
+
+    # Third, the callback
+    @yail.on_msg      { |e| assert_equal 3, step; step += 1 }
+
+    # Fourth, incoming message after callback
+    @yail.heard_msg   { |e| assert_equal 4, step; step += 1 }
+
+    # Last, incoming "any" after filter
+    @yail.heard_any do |e|
+      if e.type == :incoming_msg
+        assert_equal 5, step
+      end
+    end
+
+    @yail.start_listening
+
+    wait_for_irc
+
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :Well hello there, test!" do
+      # We should have no handlers hit more than once - step should be 5 still
+      assert_equal 5, step
+    end
+  end
+
+  def test_conditional_filters
+    @msg = Hash.new(0)
+
+    # Conditional filters are really ugly when passing a block instead of a method, so let's
+    # at least try to make this look decent
+    hearing_food    = lambda { @msg[:food] += 1 }
+    not_hearing_bad = lambda { @msg[:not_bad] += 1 }
+    heard_nothing   = lambda { @msg[:nothing] += 1 }
+
+    # If the message looks like "food", the handler will be hit
+    @yail.hearing_msg(hearing_food, :if => lambda {|e| e.message =~ /food/})
+
+    # Unless the message looks like "bad", the handler will be hit
+    @yail.hearing_msg(not_hearing_bad, :unless => lambda {|e| e.message =~ /bad/})
+
+    # Verify after-filter is called, and hash conditions are respected
+    @yail.heard_msg(heard_nothing, :if => {:message => ""})
+
+    # Verify multiple hash conditions are anded - do it with a block just so we can see how
+    # wonderfully bad it looks
+    @yail.heard_msg(:if => {:message => "bah", :pm? => true}) do
+      @msg[:heard_2] += 1
+    end
+
+    # GO GO GO
+    @yail.start_listening
+
+    wait_for_irc
+
+    # Food
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :this food is bad" do
+      assert_equal({:food => 1}, @msg)
+    end
+
+    # Good food!
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :this food is good!" do
+      assert_equal({:food => 1, :not_bad => 1}, @msg)
+    end
+
+    # Good drink
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :this drink is good!" do
+      assert_equal({:not_bad => 1}, @msg)
+    end
+
+    # Nothing, but not bad
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :" do
+      assert_equal({:not_bad => 1, :nothing => 1}, @msg)
+    end
+
+    # Private message for multiple hash test
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #{@yail.me} :bah" do
+      assert_equal({:not_bad => 1, :heard_2 => 1}, @msg)
+    end
+
+    # Private message without bah does *not* fire off multiple hash handler
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #{@yail.me} :hey there buddy" do
+      assert_equal({:not_bad => 1}, @msg)
+    end
+
+    # "bah" without being pm doesn't fire off handler, either
+    mock_message ":Nerdmaster!nerd@nerdbucket.com PRIVMSG #foosball :bah" do
+      assert_equal({:not_bad => 1}, @msg)
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: net-yail
 version: !ruby/object:Gem::Version 
-  hash: 1
-  prerelease: false
+  hash: 15
+  prerelease: 
   segments: 
   - 1
-  - 5
-  - 1
-  version: 1.5.1
+  - 6
+  - 0
+  version: 1.6.0
 platform: ruby
 authors: 
 - Jeremy Echols
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-18 00:00:00 -04:00
-default_executable: 
+date: 2012-11-08 00:00:00 Z
 dependencies: []
 
 description: |-
@@ -35,37 +34,37 @@ extra_rdoc_files: []
 
 files: 
 - examples/simple/dumbbot.rb
-- examples/logger/logger_bot.rb
-- examples/logger/default.yml
 - examples/logger/run.rb
-- examples/loudbot/loudbot.rb
-- examples/loudbot/bot_runner.rb
-- examples/loudbot/shuffle.rb
+- examples/logger/default.yml
+- examples/logger/logger_bot.rb
 - lib/net/yail.rb
+- lib/net/yail/irc_bot.rb
+- lib/net/yail/yail-version.rb
+- lib/net/yail/message_parser.rb
 - lib/net/yail/magic_events.rb
+- lib/net/yail/legacy_events.rb
+- lib/net/yail/report_events.rb
+- lib/net/yail/output_api.rb
 - lib/net/yail/eventmap.yml
-- lib/net/yail/IRCBot.rb
-- lib/net/yail/message_parser.rb
 - lib/net/yail/default_events.rb
-- lib/net/yail/output_api.rb
+- lib/net/yail/dispatch.rb
+- lib/net/yail/IRCBot.rb
 - lib/net/yail/event.rb
-- lib/net/yail/yail-version.rb
-- lib/net/yail/irc_bot.rb
-- lib/net/yail/legacy_events.rb
-- lib/net/yail/report_events.rb
-- tests/net_yail.rb
-- tests/tc_message_parser.rb
+- lib/net/yail/handler.rb
 - tests/tc_event.rb
 - tests/tc_yail.rb
+- tests/tc_message_parser.rb
 - tests/mock_irc.rb
-has_rdoc: true
+- tests/net_yail.rb
 homepage: http://ruby-irc-yail.nerdbucket.com/
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --main
+- -m
 - Net::YAIL
+- -f
+- sdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -89,13 +88,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: net-yail
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: "Yet Another IRC Library: wrapper for IRC communications in Ruby."
 test_files: 
-- tests/net_yail.rb
-- tests/tc_message_parser.rb
 - tests/tc_event.rb
 - tests/tc_yail.rb
+- tests/tc_message_parser.rb
 - tests/mock_irc.rb
+- tests/net_yail.rb

data/examples/loudbot/bot_runner.rb

@@ -1,114 +0,0 @@
-# This is a demonstration of net-yail just to see what a "real" bot could do without much work.
-# Chances are good that you'll want to put things in classes and/or modules rather than go this
-# route, so take this example with a grain of salt.
-#
-# Yes, this is a very simple copy of an existing "loudbot" implementation, but using YAIL to
-# demonstrate the INCREDIBLE POWER THAT IS Net::YAIL.  Plus, plagiarism is a subset of the cool
-# crime of stealing.
-#
-# Example of running this thing:
-#     ruby bot_runner.rb --network irc.somewhere.org --channel "#bots"
-
-require 'rubygems'
-
-# Want a specific version of net/yail?  Try uncommenting this:
-# gem 'net-yail', '1.x.y'
-
-require 'net/yail'
-require 'getopt/long'
-
-# Hacks Array#shuffle and Array#shuffle! for people not using the latest ruby
-require 'shuffle'
-
-# Pulls in all of loudbot's methods - filter/callback handlers for IRC events
-require 'loudbot'
-
-# User specifies network, channel and nick
-opt = Getopt::Long.getopts(
-  ['--network', Getopt::REQUIRED],
-  ['--channel', Getopt::REQUIRED],
-  ['--nick', Getopt::REQUIRED],
-  ['--debug', Getopt::BOOLEAN]
-)
-
-# Create bot object
-@irc = Net::YAIL.new(
-  :address    => opt['network'],
-  :username   => 'Frakking Bot',
-  :realname   => 'John Botfrakker',
-  :nicknames  => [opt['nick'] || "SUPERLOUD"]
-)
-
-# Loud messages can be newline-separated strings in louds.txt or an array or hash serialized in
-# louds.yml.  If messages are an array, we convert all of them to hash keys with a score of 1.
-@messages = FileTest.exist?("louds.yml") ? YAML.load_file("louds.yml") :
-            FileTest.exist?("louds.txt") ? IO.readlines("louds.txt") :
-            {"ROCK ON WITH SUPERLOUD" => 1}
-if Array === @messages
-  dupes = @messages.dup
-  @messages = {}
-  dupes.each {|string| @messages[string.strip] = 1}
-end
-
-@random_messages = @messages.keys.shuffle
-@last_message = nil
-@dirty_messages = false
-
-# If --debug is passed on the command line, we spew lots of filth at the user
-@irc.log.level = Logger::DEBUG if opt['debug']
-
-#####
-#
-# To learn the YAIL, begin below with attentiveness to commented wording
-#
-#####
-
-# This is a filter.  Because it's past-tense ("heard"), it runs after the server's welcome message
-# has been read - i.e., after any before-filters and the main hanler happen.
-@irc.heard_welcome { |e| @irc.join(opt['channel']) if opt['channel'] }
-
-# on_xxx means it's a callback for an incoming event.  Callbacks run after before-filters, and
-# replaces any existing incoming invite callback.  YAIL has very few built-in callbacks, so
-# this is a safe operation.
-@irc.on_invite { |e| @irc.join(e.channel) }
-
-# This is just another callback, using the do/end block form.  We auto-message the channel on join.
-@irc.on_join do |e|
-  @irc.msg(e.channel, "WHATS WRONG WITH BEING SEXY") if e.nick == @irc.me
-end
-
-# You should *never* override the on_ping callback unless you handle the PONG manually!!
-# Filters, however, are perfectly fine.
-#
-# Here we're using the ping filter to actually do the serialization of our messages hash.  Since
-# we know pings are regular, this is kind of a hack to serialize every few minutes.
-@irc.heard_ping do
-  unless @dirty_messages
-    File.open("louds.yml", "w") {|f| f.puts @messages.to_yaml}
-    @dirty_messages = false
-  end
-end
-
-# This is a before-filter - using the present tense means it's a before-filter, and using a tense
-# of "hear" means it's for incoming messages (as opposed to "saying" and "said", where we'd filter
-# our outgoing messages).  Here we intercept all potential commands and send them to a method.
-@irc.hearing_msg {|e| do_command($1, e) if e.message =~ /^!(.*)$/ }
-
-# Another filter, but in-line this time - we intercept messages directly to the bot.  The call to
-# +handled!+ tells the event not to run any more filters or the main callback.
-@irc.hearing_msg do |e|
-  if e.message =~ /^#{@irc.me}/
-    random_message(e.channel)
-    e.handled!
-  end
-end
-
-# This is our primary message callback.  We know our filters have caught people talking to us and
-# any command-style messages, so we don't need to worry about those situations here.  The decision
-# to make this the primary callback is pretty arbitrary - do what makes the most sense to you.
-#
-# Note that this is a proc-based filter - we handle the message entirely in incoming_message.
-@irc.on_msg self.method(:incoming_message)
-
-# Start the bot - the bang (!) calls the version of start_listening that runs an endless loop
-@irc.start_listening!

data/examples/loudbot/loudbot.rb

@@ -1,87 +0,0 @@
-# Stores a LOUD message into the hash and responds.
-def it_was_loud(message, channel)
-  @irc.log.debug "IT WAS LOUD!  #{message.inspect}"
-
-  @messages[message] ||= 1
-  random_message(channel)
-end
-
-# This is our main message handler.
-#
-# We store and respond if messages meet the following criteria:
-# * It is long (11 characters or more)
-# * It has at least one space
-# * It has no lowercase letters
-# * At least 60% of the characters are uppercase letters
-def incoming_message(e)
-  # We don't respond to "private" messages
-  return if e.pm?
-
-  text = e.message
-
-  return if text =~ /[a-z]/
-
-  # Count various exciting things
-  len = text.length
-  uppercase_count = text.scan(/[A-Z]/).length
-  space_count = text.scan(/\s/).length
-
-  if len >= 11 && uppercase_count >= (len * 0.60) && space_count >= 1
-    it_was_loud(e.message, e.channel)
-  end
-end
-
-# Pulls a random message from our messages array and sends it to the given channel.  Reshuffles
-# the main array if the randomized array is empty.
-def random_message(channel)
-  @random_messages = @messages.keys.shuffle if @random_messages.empty?
-  @last_message = @random_messages.pop
-  @irc.msg(channel, @last_message)
-end
-
-# Just keepin' the plagiarism alive, man.  At least in my version, size is always based on requester.
-def send_dong(channel, user_hash)
-  old_seed = srand(user_hash)
-  @irc.msg(channel, "8" + ('=' * (rand(20).to_i + 8)) + "D")
-  srand(old_seed)
-end
-
-# Adds +value+ to the score of the last message, if there was one.  If the score goes too low, we
-# remove that message forever.
-def vote(value)
-  return unless @last_message
-
-  @messages[@last_message] += value
-  if @messages[@last_message] <= -1
-    @last_message = nil
-    @messages.delete(@last_message)
-  end
-  @dirty_messages = true
-end
-
-# Reports the last message's score
-def score(channel)
-  if !@last_message
-    @irc.msg(channel, "NO LAST MESSAGE OR IT WAS DELETED BY !DOWNVOTE")
-    return
-  end
-
-  @irc.msg(channel, "#{@last_message}: #{@messages[@last_message]}")
-end
-
-# Handles a command (string begins with ! - to keep with the pattern, I'm making our loudbot only
-# respond to loud commands)
-def do_command(command, e)
-  case command
-    when "DONGME"         then send_dong(e.channel, e.msg.user.hash + e.msg.host.hash)
-    when "UPVOTE"         then vote(1)
-    when "DOWNVOTE"       then vote(-1)
-    when "SCORE"          then score(e.channel)
-    when "HELP"           then @irc.msg(e.channel, "I HAVE COMMANDS AND THEY ARE !DONGME !UPVOTE !DOWNVOTE !SCORE AND !HELP")
-  end
-
-  # Here we're saying that we don't want any other handling run - no filters, no handler.  For
-  # commands, I put this here because I know I don't want any other handlers having to deal with
-  # strings beginning with a bang.
-  e.handled!
-end

data/examples/loudbot/shuffle.rb

@@ -1,17 +0,0 @@
-# Dynamically adds Array shuffling as described in http://www.ruby-forum.com/topic/163649
-class Array
-  # Shuffle the array
-  def shuffle!
-    n = length
-    for i in 0...n
-      r = Kernel.rand(n-i)+i
-      self[r], self[i] = self[i], self[r]
-    end
-    self
-  end
-
-  # Return a shuffled copy of the array
-  def shuffle
-    dup.shuffle!
-  end
-end