net-yail 1.4.6 → 1.5.1

data/lib/net/yail/default_events.rb

@@ -1,113 +1,10 @@
 module Net
 module IRCEvents
 
-# This module contains all the default events handling - mainly for
-# reporting things or simple logic.  Users can put in their own event handlers
-# that return true and ignore these, so nothing in here should be truly
-# essential to a healthy IRC app.
+# This module contains all the default events handling that hasn't yet been cleaned up for 2.0
 module Defaults
   private
 
-  # Sets up all the default handlers for events - just reporting things others
-  # don't handle in all but a few cases
-  def setup_default_handlers
-    # Incoming events
-    prepend_handler :incoming_msg,              self.method(:r_msg)
-    prepend_handler :incoming_act,              self.method(:r_act)
-    prepend_handler :incoming_notice,           self.method(:r_notice)
-    prepend_handler :incoming_ctcp,             self.method(:r_ctcp)
-    prepend_handler :incoming_ctcpreply,        self.method(:r_ctcpreply)
-    prepend_handler :incoming_mode,             self.method(:r_mode)
-    prepend_handler :incoming_join,             self.method(:r_join)
-    prepend_handler :incoming_part,             self.method(:r_part)
-    prepend_handler :incoming_kick,             self.method(:r_kick)
-    prepend_handler :incoming_quit,             self.method(:r_quit)
-    prepend_handler :incoming_nick,             self.method(:r_nick)
-    prepend_handler :incoming_miscellany,       self.method(:r_miscellany)
-
-    # Incoming numeric events here
-    prepend_handler :incoming_welcome,          self.method(:r_welcome)
-    prepend_handler :incoming_bannedfromchan,   self.method(:r_bannedfromchan)
-    prepend_handler :incoming_badchannelkey,    self.method(:r_badchannelkey)
-    prepend_handler :incoming_nicknameinuse,    self.method(:_nicknameinuse)
-    prepend_handler :incoming_channelurl,       self.method(:r_channelurl)
-    prepend_handler :incoming_topic,            self.method(:r_topic)
-    prepend_handler :incoming_topicinfo,        self.method(:r_topicinfo)
-    prepend_handler :incoming_namreply,         self.method(:_namreply)
-    prepend_handler :incoming_endofnames,       self.method(:r_endofnames)
-    prepend_handler :incoming_motd,             self.method(:r_motd)
-    prepend_handler :incoming_motdstart,        self.method(:r_motdstart)
-    prepend_handler :incoming_endofmotd,        self.method(:r_endofmotd)
-    prepend_handler :incoming_invite,           self.method(:r_invite)
-
-    # Outgoing events
-    prepend_handler :outgoing_begin_connection, self.method(:out_begin_connection)
-  end
-
-  def r_msg(fullactor, actor, target, text)
-    report "{#{target}} <#{actor}> #{text}"
-  end
-
-  def r_act(fullactor, actor, target, text)
-    report "{#{target}} * #{actor} #{text}"
-  end
-
-  def r_notice(fullactor, actor, target, text)
-    report "{#{target}} -#{actor}- #{text}"
-  end
-
-  def r_ctcp(fullactor, actor, target, text)
-    report "{#{target}} [#{actor} #{text}]"
-  end
-
-  def r_ctcpreply(fullactor, actor, target, text)
-    report "{#{target}} [Reply: #{actor} #{text}]"
-  end
-
-  def r_mode(fullactor, actor, target, modes, objects)
-    report "{#{target}} #{actor} sets mode #{modes} #{objects}"
-  end
-
-  def r_join(fullactor, actor, target)
-    report "{#{target}} #{actor} joins"
-  end
-
-  def r_part(fullactor, actor, target, text)
-    report "{#{target}} #{actor} parts (#{text})"
-  end
-
-  def r_kick(fullactor, actor, target, object, text)
-    report "{#{target}} #{actor} kicked #{object} (#{text})"
-  end
-
-  def r_quit(fullactor, actor, text)
-    report "#{actor} quit (#{text})"
-  end
-
-  # Reports nick change unless nickname is us - we check nickname here since
-  # the magic method changes @me to the new nickname.
-  def r_nick(fullactor, actor, nickname)
-    report "#{actor} changed nick to #{nickname}" unless nickname == @me
-  end
-
-  def r_bannedfromchan(text, args)
-    text =~ /^(\S*) :Cannot join channel/
-    report "Banned from channel #{$1}"
-  end
-
-  def r_badchannelkey(text, args)
-    text =~ /^(\S*) :Cannot join channel/
-    report "Bad channel key (password) for #{$1}"
-  end
-
-  def r_welcome(*args)
-    report "*** Logged in as #{@me}. ***"
-  end
-
-  def r_miscellany(line)
-    report "serv: #{line}"
-  end
-
   # Nickname change failed: already in use.  This needs a rewrite to at
   # least hit a "failed too many times" handler of some kind - for a bot,
   # quitting may be fine, but for something else, we may want to prompt a
@@ -117,8 +14,8 @@ module Defaults
   #
   # TODO: This should really not even be here.  Client should have full control over whether or not
   # they want this.  Base IRC bot class should have this, but not the core YAIL lib.
-  def _nicknameinuse(text, args)
-    text =~ /^(\S+)/
+  def _nicknameinuse(event)
+    event.message =~ /^(\S+)/
     report "Nickname #{$1} is already in use."
 
     if (!@registered)
@@ -137,29 +34,11 @@ module Defaults
     end
   end
 
-  # Channel URL
-  def r_channelurl(text, args)
-    text =~ /^(\S+) :?(.+)$/
-    report "{#{$1}} URL is #{$2}"
-  end
-
-  # Channel topic
-  def r_topic(text, args)
-    text =~ /^(\S+) :?(.+)$/
-    report "{#{$1}} Topic is: #{$2}"
-  end
-
-  # Channel topic setter
-  def r_topicinfo(text, args)
-    text =~ /^(\S+) (\S+) (\d+)$/
-    report "{#{$1}} Topic set by #{$2} on #{Time.at($3.to_i).asctime}"
-  end
-
   # Names line
   #
   # TODO: Either store this data silently or ditch this code - this verbosity doesn't belong in a core lib
-  def _namreply(text, args)
-    text =~ /^(@|\*|=) (\S+) :?(.+)$/
+  def _namreply(event)
+    event.message =~ /^(@|\*|=) (\S+) :?(.+)$/
     channeltype = {'@' => 'Secret', '*' => 'Private', '=' => 'Normal'}[$1]
     report "{#{$2}} #{channeltype} channel nickname list: #{$3}"
     @nicklist = $3.split(' ')
@@ -167,43 +46,6 @@ module Defaults
     report "First nick: #{@nicklist[0]}"
   end
 
-  # End of names
-  def r_endofnames(text, args)
-    text =~ /^(\S+)/
-    report "{#{$1}} Nickname list complete"
-  end
-
-  # MOTD line
-  def r_motd(text, args)
-    text =~ /^:?(.+)$/
-    report "*MOTD* #{$1}"
-  end
-
-  # Beginning of MOTD
-  def r_motdstart(text, args)
-    text =~ /^:?(.+)$/
-    report "*MOTD* #{$1}"
-  end
-
-  # End of MOTD
-  def r_endofmotd(text, args)
-    report "*MOTD* End of MOTD"
-  end
-
-  # We dun connected to a server!  Just sends password (if one is set) and
-  # user/nick.  This isn't quite "essential" to a working IRC app, but this data
-  # *must* be sent at some point, so be careful before skipping this handler.
-  def out_begin_connection(username, address, realname)
-    pass(@password) if @password
-    user(username, '0.0.0.0', address, realname)
-    nick(@nicknames[0])
-  end
-
-  # Incoming invitation
-  def r_invite(fullactor, actor, target)
-    report "[#{actor}] INVITE to #{target}"
-  end
-
 end
 
 end

data/lib/net/yail/event.rb

@@ -6,16 +6,35 @@ class YAIL
   # Base event class for stuff shared by any type of event.  Note that :type and :handled
   # apply to *all* events, so they're explicitly defined here.
   class BaseEvent
-    attr_reader :type, :handled
-
-    # Creates an event object and sets up some sane defaults for common elements
-    def initialize()
+    # Creates an event object and sets up some sane defaults for common elements.  Any elements
+    # in the data hash are converted to "magic" methods.
+    def initialize(data = {})
+      # Don't modify incoming data!
+      @data = data.dup
       @handled = false
-      @type = nil
+      @type = @data.delete(:type)
+
+      # All events have the capacity for a parent
+      @data[:parent] ||= nil
+
+      # Give useful accessors in a hacky but fun way!  I can't decide if I prefer the pain of
+      # using method_missing or the pain of not knowing how to do this without a string eval....
+      for key in @data.keys
+        key = key.to_s
+        self.instance_eval("def #{key}; return @data[:#{key}]; end")
+      end
+
+      raise "BaseEvent not usable - please subclass" if BaseEvent == self.class
+    end
+
+    # Helps us debug
+    def to_s
+      return super().gsub(self.class.name, "%s [%s]" % [self.class.name, @type.to_s])
     end
 
-    # Sets this event as having been handled (i.e., no further handling should occur)
-    def handle; @handled = true; end
+    # Slightly unintuitive name to avoid accidental use - we don't want it to be the norm to stop
+    # the event handling chain anymore!  Filters + callback should make that a rarity.
+    def handled!; @handled = true; end
 
     # Cheesy shortcut to @handled in "boolean" form
     def handled?; return @handled; end
@@ -30,6 +49,11 @@ class YAIL
     end
   end
 
+  # Custom event is just a base event that doesn't crash when accessing type :)
+  class CustomEvent < BaseEvent
+    def type; return @type; end
+  end
+
   # This is the incoming event class.  For all situations where the server
   # sent us some kind of event, this class handles all the data.
   #
@@ -37,9 +61,10 @@ class YAIL
   # the IRC server.  Other possible pieces of data are as follows:
   # * fullname: Rarely needed, full text of origin of an action
   # * nick: Nickname of originator of an event
+  # * from: Nickname *or* server name, should be on every event
   # * channel: Where applicable, the name of the channel in which the event
   #   happened.
-  # * text: Actual message/emote/notice/etc
+  # * message: Actual message/emote/notice/etc
   # * target: User targeted for various commands - PRIVMSG/NOTICE recipient, KICK victim, etc
   # * pm?: Set to true if the event is a "private" event (not sent to the
   #   channel).  Useful primarily for message types of events (PRIVMSG).
@@ -59,27 +84,14 @@ class YAIL
     attr_reader :raw, :msg
     private_class_method :new
 
-    # Sets up data and accessors
+    # Incoming events always have :raw and :msg in the data hash
     def initialize(data = {})
-      super()
-
       # Don't modify incoming element!
       @data = data.dup
       @raw = @data.delete(:raw)
       @msg = @data.delete(:msg)
-      @type = @data.delete(:type)
-
-      # Give useful accessors in a hacky but fun way!  I can't decide if I prefer the pain of
-      # using method_missing or the pain of not knowing how to do this without a string eval....
-      for key in @data.keys
-        key = key.to_s
-        self.instance_eval("def #{key}; return @data[:#{key}]; end")
-      end
-    end
 
-    # Helps us debug
-    def to_s
-      return super().gsub('IncomingEvent', "IncomingEvent[#{@type.to_s}]")
+      super(data)
     end
 
     # Incoming events in our system are always :incoming_xxx
@@ -92,7 +104,15 @@ class YAIL
       # Parse with MessageParser to get raw IRC info
       raw = line.dup
       msg = Net::YAIL::MessageParser.new(line)
-      data = { :raw => raw, :msg => msg, :parent => nil }
+
+      # All incoming events need .raw and .msg in addition to any base event attributes.
+      #
+      # "from" is a tricky case as it isn't used on all messages - but because it's something of
+      # a standard we rely on for so many messages, it has a default so that at the least one can
+      # rely on not getting a crash for some of the edge cases (like "NOTICE :ERROR from foo.bar.com"
+      # or a server-less "NOTICE AUTH :xxxx").  Maybe more elements should have defaults... not
+      # real sure yet.
+      data = { :raw => raw, :msg => msg, :from => nil }
 
       # Not all messages from the server identify themselves as such, so we just assume it's from
       # the server unless we explicitly see a nick
@@ -102,47 +122,42 @@ class YAIL
       if msg.servername
         data[:from] = data[:servername] = msg.servername
       elsif msg.prefix && msg.nick
-        data[:from] = data[:fullname] = msg.prefix
-        data[:nick] = msg.nick
+        data[:fullname] = msg.prefix
+        data[:from] = data[:nick] = msg.nick
         data[:server?] = false
       end
 
-      # Since "from" is something of a standard we rely on for all kinds of messages, we default
-      # to an empty string so that at the least one can rely on not getting a crash for some of
-      # the edge cases (like "NOTICE :ERROR from foo.bar.com")
-      data[:from] ||= ""
-
       case msg.command
         when 'ERROR'
           data[:type] = :error
-          data[:text] = msg.params.last
+          data[:message] = msg.params.last
           event = new(data)
 
         when 'PING'
           data[:type] = :ping
-          data[:text] = msg.params.last
+          data[:message] = msg.params.last
           event = new(data)
 
         when 'TOPIC'
           data[:type] = :topic_change
           data[:channel] = msg.params.first
-          data[:text] = msg.params.last
+          data[:message] = msg.params.last
           event = new(data)
 
         when /^\d{3}$/
           # Get base event for the "numeric" type - so many of these exist, and so few are likely
-          # to be handled directly.  Sadly, some hackery has to happen here to make "text" backward-
+          # to be handled directly.  Sadly, some hackery has to happen here to make "message" backward-
           # compatible since old YAIL auto-joined all parameters into one string.
           data[:type] = :numeric
           params = msg.params.dup
           data[:target] = params.shift
           data[:parameters] = params
-          data[:text] = params.join(' ')
+          data[:message] = params.join(' ')
           data[:numeric] = msg.command.to_i
           event = new(data)
 
           # Create child event for the specific numeric
-          data[:type] = msg.command.to_sym
+          data[:type] = :"numeric_#{msg.command.to_i}"
           data[:parent] = event
           event = new(data)
 
@@ -174,24 +189,24 @@ class YAIL
         when 'PART'
           data[:type] = :part
           data[:channel] = msg.params.first
-          data[:text] = msg.params.last
+          data[:message] = msg.params.last
           event = new(data)
 
         when 'KICK'
           data[:type] = :kick
           data[:channel] = msg.params[0]
           data[:target] = msg.params[1]
-          data[:text] = msg.params[2]
+          data[:message] = msg.params[2]
           event = new(data)
 
         when 'QUIT'
           data[:type] = :quit
-          data[:text] = msg.params.first
+          data[:message] = msg.params.first
           event = new(data)
 
         when 'NICK'
           data[:type] = :nick
-          data[:text] = msg.params.first
+          data[:message] = msg.params.first
           event = new(data)
   
         # Unknown line!  If this library is complete, we should *never* see this situation occur,
@@ -211,7 +226,7 @@ class YAIL
     def self.mode_events(msg, data)
       data[:type]     = :mode
       data[:channel]  = msg.params.shift
-      data[:text]     = msg.params.shift
+      data[:message]  = msg.params.shift
       data[:targets]  = msg.params
       event = new(data)
     end
@@ -240,22 +255,22 @@ class YAIL
 
       # Get base event
       data[:type] = :msg
-      data[:text] = msg.params.last
+      data[:message] = msg.params.last
       event = new(data)
 
       # Is this CTCP?
-      if event.text =~ /^\001(.+?)\001$/
+      if event.message =~ /^\001(.+?)\001$/
         data[:type] = :ctcp
-        data[:text] = $1
+        data[:message] = $1
         data[:parent] = event
         
         event = new(data)
       end
 
       # CTCP action?
-      if :ctcp == data[:type] && event.text =~ /^ACTION (.+)$/
+      if :ctcp == data[:type] && event.message =~ /^ACTION (.+)$/
         data[:type] = :act
-        data[:text] = $1
+        data[:message] = $1
         data[:parent] = event
 
         event = new(data)
@@ -271,12 +286,12 @@ class YAIL
 
       # Get base event
       data[:type] = :notice
-      data[:text] = msg.params.last
+      data[:message] = msg.params.last
       event = new(data)
 
-      if event.text =~ /^\001(.+?)\001$/
+      if event.message =~ /^\001(.+?)\001$/
         data[:type] = :ctcp_reply
-        data[:text] = $1
+        data[:message] = $1
         data[:parent] = event
 
         event = new(data)

data/lib/net/yail/irc_bot.rb

@@ -1,11 +1,12 @@
 require 'rubygems'
 require 'net/yail'
+require 'net/yail/report_events'
 
 # My abstraction from adapter to a real bot.
 class IRCBot
-  attr_reader :irc
+  include Net::IRCEvents::Reports
 
-  public
+  attr_reader :irc
 
   # Creates a new bot.  Options are anything you can pass to the Net::YAIL constructor:
   # * <tt>:irc_network</tt>: Name/IP of the IRC server - backward-compatibility hack, and is
@@ -60,9 +61,10 @@ class IRCBot
   # add_custom_handlers to allow auto-creation in case of a restart.
   def connect_socket
     @irc = Net::YAIL.new(@options)
+    setup_reporting(@irc)
 
     # Simple hook for welcome to allow auto-joining of the channel
-    @irc.prepend_handler :incoming_welcome, self.method(:welcome)
+    @irc.on_welcome self.method(:welcome)
 
     add_custom_handlers
   end
@@ -95,7 +97,7 @@ class IRCBot
     while true
       until @irc.dead_socket
         sleep 15
-        @irc.handle(:irc_loop)
+        @irc.dispatch Net::YAIL::CustomEvent.new(:type => :irc_loop)
         Thread.pass
       end
 
@@ -109,10 +111,8 @@ class IRCBot
 
   private
   # Basic handler for joining our channels upon successful registration
-  def welcome(text, args)
+  def welcome(event)
     @options[:channels].each {|channel| @irc.join(channel) }
-    # Let the default welcome stuff still happen
-    return false
   end
 
   ################