net-yail 1.4.6 → 1.5.1

data/lib/net/yail/report_events.rb

@@ -0,0 +1,173 @@
+module Net
+module IRCEvents
+
+# This is the module for reporting a bunch of crap, included basically for legacy compatibility
+# and bots that need to be easy to use / debug right off the bat
+module Reports
+  # Set up reporting filters - allows users who want it to keep reporting in their app relatively
+  # easily while getting rid of it for everybody else
+  def setup_reporting(yail)
+    @yail = yail
+
+    incoming_reporting = [
+      :msg, :act, :notice, :ctcp, :ctcpreply, :mode, :join, :part, :kick,
+      :quit, :nick, :welcome, :bannedfromchan, :badchannelkey, :channelurl, :topic,
+      :topicinfo, :endofnames, :motd, :motdstart, :endofmotd, :invite
+    ]
+    for event in incoming_reporting
+      yail.after_filter(:"incoming_#{event}", self.method(:"r_#{event}") )
+    end
+
+    outgoing_reporting = [
+      :msg, :act, :ctcp, :ctcpreply, :notice
+    ]
+    for event in outgoing_reporting
+      yail.after_filter(:"outgoing_#{event}", self.method(:"r_out_#{event}") )
+    end
+
+    generic_out_report = [
+      :join, :mode, :part, :quit, :nick, :user, :pass, :oper, :topic, :names, :list, :invite, :kick
+    ]
+    for event in generic_out_report
+      yail.after_filter(:"outgoing_#{event}", self.method(:r_out_generic))
+    end
+  end
+
+  private
+  def r_msg(event)
+    report "{%s} <%s> %s" % [event.target || event.channel, event.nick, event.message]
+  end
+
+  def r_act(event)
+    report "{%s} * %s %s" % [event.target || event.channel, event.nick, event.message]
+  end
+
+  def r_notice(event)
+    nick = event.server? ? '' : event.nick
+    report "{%s} -%s- %s" % [event.target || event.channel, nick, event.message]
+  end
+
+  def r_ctcp(event)
+    report "{%s} [%s %s]" % [event.target || event.channel, event.nick, event.message]
+  end
+
+  def r_ctcpreply(event)
+    report "{%s} [Reply: %s %s]" % [event.target || event.channel, event.nick, event.message]
+  end
+
+  def r_mode(event)
+    report "{%s} %s sets mode %s %s" % [event.channel, event.from, event.message, event.targets.join(' ')]
+  end
+
+  def r_join(event)
+    report "{#{event.channel}} #{event.nick} joins"
+  end
+
+  def r_part(event)
+    report "{#{event.channel}} #{event.nick} parts (#{event.message})"
+  end
+
+  def r_kick(event)
+    report "{#{event.channel}} #{event.nick} kicked #{event.target} (#{event.message})"
+  end
+
+  def r_quit(event)
+    report "#{event.nick} quit (#{event.message})"
+  end
+
+  # Incoming invitation
+  def r_invite(event)
+    report "[#{event.nick}] INVITE to #{event.target}"
+  end
+
+  # Reports nick change unless nickname is us - we check nickname here since
+  # the magic method changes @yail.me to the new nickname.
+  def r_nick(event)
+    report "#{event.nick} changed nick to #{event.message}" unless event.nick == @yail.me
+  end
+
+  def r_bannedfromchan(event)
+    event.message =~ /^(\S*) :Cannot join channel/
+    report "Banned from channel #{$1}"
+  end
+
+  def r_badchannelkey(event)
+    event.message =~ /^(\S*) :Cannot join channel/
+    report "Bad channel key (password) for #{$1}"
+  end
+
+  def r_welcome(event)
+    report "*** Logged in as #{@yail.me}. ***"
+  end
+
+  # Channel URL
+  def r_channelurl(event)
+    event.message =~ /^(\S+) :?(.+)$/
+    report "{#{$1}} URL is #{$2}"
+  end
+
+  # Channel topic
+  def r_topic(event)
+    event.message =~ /^(\S+) :?(.+)$/
+    report "{#{$1}} Topic is: #{$2}"
+  end
+
+  # Channel topic setter
+  def r_topicinfo(event)
+    event.message =~ /^(\S+) (\S+) (\d+)$/
+    report "{#{$1}} Topic set by #{$2} on #{Time.at($3.to_i).asctime}"
+  end
+
+  # End of names
+  def r_endofnames(event)
+    event.message =~ /^(\S+)/
+    report "{#{$1}} Nickname list complete"
+  end
+
+  # MOTD line
+  def r_motd(event)
+    event.message =~ /^:?(.+)$/
+    report "*MOTD* #{$1}"
+  end
+
+  # Beginning of MOTD
+  def r_motdstart(event)
+    event.message =~ /^:?(.+)$/
+    report "*MOTD* #{$1}"
+  end
+
+  # End of MOTD
+  def r_endofmotd(event)
+    report "*MOTD* End of MOTD"
+  end
+
+  # Sent a privmsg (non-ctcp)
+  def r_out_msg(event)
+    report "{#{event.target}} <#{@yail.me}> #{event.message}"
+  end
+
+  # Sent a ctcp
+  def r_out_ctcp(event)
+    report "{#{event.target}} [#{@yail.me} #{event.message}]"
+  end
+
+  # Sent ctcp action
+  def r_out_act(event)
+    report "{#{event.target}} <#{@yail.me}> #{event.message}"
+  end
+
+  def r_out_notice(event)
+    report "{#{event.target}} -#{@yail.me}- #{event.message}"
+  end
+
+  def r_out_ctcpreply(event)
+    report "{#{event.target}} [Reply: #{@yail.me} #{event.message}]"
+  end
+
+  def r_out_generic(event)
+    report "bot: #{event.inspect}"
+  end
+end
+
+end
+end

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

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

data/tests/mock_irc.rb

@@ -71,13 +71,14 @@ class MockIRC
 
       when /^NICK/    then handle_nick(cmd)
       when /^JOIN/    then handle_join(cmd)
+      when /^MODE/    then handle_mode(cmd)
     end
   end
 
   # Handles a connection command (USER) or errors
   def handle_connected(cmd)
     if cmd =~ /^USER (\S+) (\S+) (\S+) :(.*)$/
-      add_output "NOTICE AUTH :*** Looking up your hostname..."
+      add_output ":#{SERVER} NOTICE AUTH :*** Looking up your hostname..."
       @connected = true
       return
     end
@@ -85,6 +86,14 @@ class MockIRC
     add_output ":#{SERVER} ERROR :You need to authenticate or something"
   end
 
+  # Dumb handling of a MODE command
+  def handle_mode(cmd)
+    # Eventually this could be used to make really interesting mode messages
+    cmd =~ /^MODE(\s+\S+)?(\s+\S+)?(\s+\S+)?$/
+
+    add_output ":#{@nick}!#{USERHOST} MODE#{$2}#{$3}"
+  end
+
   # Handles a NICK request, but no error if no nick set - not sure what a real server does here
   def handle_nick(cmd)
     unless cmd =~ /^NICK :(.*)$/
@@ -102,7 +111,8 @@ class MockIRC
     @nick = nick
 
     unless @logged_in
-      add_output ":#{SERVER} NOTICE #{@nick} :*** You are exempt from user limits. congrats.",
+      add_output "NOTICE AUTH :*** Looking up your hostname",
+                 ":#{SERVER} NOTICE #{@nick} :*** You are exempt from user limits. congrats.",
                  ":#{SERVER} 001 #{@nick} :Welcome to the Fakey-fake Internet Relay Chat Network #{@nick}",
                  ":#{SERVER} 002 #{@nick} :Your host is #{SERVER}[0.0.0.0/6667], running version mock-irc-1.7.7",
                  ":#{SERVER} 003 #{@nick} :This server was created Nov 21 2009 at 21:20:48",
@@ -135,7 +145,7 @@ class MockIRC
     channel = $1
     pass = $2
     if "#banned" == channel
-      add_output ":#{SERVER} 474 T-meister #{channel}:Cannot join channel (+b)"
+      add_output ":#{SERVER} 474 #{@nick} #{channel}:Cannot join channel (+b)"
       return
     end
 

data/tests/tc_event.rb

@@ -7,7 +7,7 @@ class MessageParserEventTest < Test::Unit::TestCase
   # Simplest test case, I think
   def test_ping
     event = Net::YAIL::IncomingEvent.parse("PING :nerdbucket.com")
-    assert_equal 'nerdbucket.com', event.text
+    assert_equal 'nerdbucket.com', event.message
     assert_equal :incoming_ping, event.type
     assert !event.respond_to?(:servername)
     assert !event.respond_to?(:nick)
@@ -20,7 +20,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     event = Net::YAIL::IncomingEvent.parse(":Dude!dude@nerdbucket.com TOPIC #nerdtalk :31 August 2010 \357\277\275 Foo.")
     assert_equal :incoming_topic_change, event.type
     assert_equal 'Dude', event.nick
-    assert_equal "31 August 2010 \357\277\275 Foo.", event.text
+    assert_equal "31 August 2010 \357\277\275 Foo.", event.message
     assert_equal '#nerdtalk', event.channel
     assert_equal 'Dude!dude@nerdbucket.com', event.fullname
   end
@@ -34,13 +34,13 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal 'jeremy', event.msg.user
     assert_equal 'nerdbucket.com', event.msg.host
     assert_equal 'Nerdmaster!jeremy@nerdbucket.com', event.fullname
-    assert_equal 'Nerdmaster!jeremy@nerdbucket.com', event.from
+    assert_equal 'Nerdmaster', event.from
     assert !event.server?
     assert_equal 'PRIVMSG', event.msg.command
     assert_equal :incoming_msg, event.type
     assert_equal 'Nerdminion', event.target
     assert_equal true, event.pm?
-    assert_equal 'Do my bidding!!', event.text
+    assert_equal 'Do my bidding!!', event.message
 
     # CTCP to user
     event = Net::YAIL::IncomingEvent.parse(":Nerdmaster!jeremy@nerdbucket.com PRIVMSG Nerdminion :\001FOO is to bar as BAZ is to...?\001")
@@ -49,9 +49,9 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_nil event.channel
     assert_equal 'Nerdminion', event.target
     assert_equal true, event.pm?
-    assert_equal 'FOO is to bar as BAZ is to...?', event.text
+    assert_equal 'FOO is to bar as BAZ is to...?', event.message
     assert_equal :incoming_msg, event.parent.type
-    assert_equal "\001FOO is to bar as BAZ is to...?\001", event.parent.text
+    assert_equal "\001FOO is to bar as BAZ is to...?\001", event.parent.message
     assert_nil event.parent.parent
 
     # Action to channel
@@ -60,11 +60,11 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal :incoming_act, event.type
     assert_equal '#bottest', event.channel
     assert_equal false, event.pm?
-    assert_equal 'gives Towelie a joint', event.text
+    assert_equal 'gives Towelie a joint', event.message
     assert_equal :incoming_ctcp, event.parent.type
-    assert_equal "ACTION gives Towelie a joint", event.parent.text
+    assert_equal "ACTION gives Towelie a joint", event.parent.message
     assert_equal :incoming_msg, event.parent.parent.type
-    assert_equal "\001ACTION gives Towelie a joint\001", event.parent.parent.text
+    assert_equal "\001ACTION gives Towelie a joint\001", event.parent.parent.message
     assert_nil event.parent.parent.parent
 
     # PM to channel with less common prefix
@@ -77,8 +77,8 @@ class MessageParserEventTest < Test::Unit::TestCase
   # Quick test of a numeric message I've ACTUALLY SEEN!!
   def test_numeric
     event = Net::YAIL::IncomingEvent.parse(':nerdbucket.com 266 Nerdmaster :Current global users: 22  Max: 33')
-    assert_equal 'Current global users: 22  Max: 33', event.text
-    assert_equal :incoming_266, event.type
+    assert_equal 'Current global users: 22  Max: 33', event.message
+    assert_equal :incoming_numeric_266, event.type
     assert_equal 'nerdbucket.com', event.servername
     assert_equal 'nerdbucket.com', event.from
     assert_equal 'Nerdmaster', event.target
@@ -93,8 +93,8 @@ class MessageParserEventTest < Test::Unit::TestCase
 
     # Numeric with multiple args
     event = Net::YAIL::IncomingEvent.parse(':someserver.co.uk.fn.bb 366 Towelie #bottest :End of /NAMES list.')
-    assert_equal :incoming_366, event.type
-    assert_equal '#bottest End of /NAMES list.', event.text
+    assert_equal :incoming_numeric_366, event.type
+    assert_equal '#bottest End of /NAMES list.', event.message
     assert_equal ['#bottest', 'End of /NAMES list.'], event.parameters
 
     # First param in the message params list should still be nick
@@ -106,7 +106,7 @@ class MessageParserEventTest < Test::Unit::TestCase
         "\0031,8TuTTi AnCoRa In PRoVa..\0034M\00307w\00308a\00303H\00311u\0031 \0031,9PrEpArAtE Le RiChIeStE PeR Il RiCoVeRo a ViTa\0030,13PoStI " +
         "LiBeRi!!\0031,4!PaZZi Da STaRe InSiEmE. :\336")
     assert_equal 'irc.somehost.xx', event.from
-    assert_equal :incoming_322, event.type
+    assert_equal :incoming_numeric_322, event.type
     assert_equal :incoming_numeric, event.parent.type
     assert_equal 'user', event.target
     assert_equal ['#CrAzY_MaNiCoMiCuM', '12'], event.parameters[0..1]
@@ -114,7 +114,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal "#CrAzY_MaNiCoMiCuM 12 [+ntr] \253'\002\0033,3 \0030 I \0030,0 \0034T \0034,4 \0031A \0031,1\0038\273\0031,9 OrA NuOvO " +
         "ErOtIcI Su FFTXL\0030,13 #CrAzY_MaNiCoMiCuM:\0032,4 QuI ReGnAnO PeR OrA I + PaZZi DeL WeB, \0031,8TuTTi AnCoRa In PRoVa..\0034M" +
         "\00307w\00308a\00303H\00311u\0031 \0031,9PrEpArAtE Le RiChIeStE PeR Il RiCoVeRo a ViTa\0030,13PoStI LiBeRi!!\0031,4!PaZZi Da " +
-        "STaRe InSiEmE. :\336", event.text
+        "STaRe InSiEmE. :\336", event.message
   end
 
   # Test an invite
@@ -137,7 +137,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     event = Net::YAIL::IncomingEvent.parse(':Nerdminion!minion@nerdbucket.com PART #nerd-talk :No, YOU GO TO HELL')
     assert_equal '#nerd-talk', event.channel
     assert_equal 'Nerdminion', event.nick
-    assert_equal 'No, YOU GO TO HELL', event.text
+    assert_equal 'No, YOU GO TO HELL', event.message
     assert_equal :incoming_part, event.type
   end
 
@@ -147,14 +147,14 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal 'Nerdminion', event.target
     assert_equal 'Nerdmaster', event.nick
     assert_equal :incoming_kick, event.type
-    assert_equal %q|You can't quit!  You're FIRED!|, event.text
+    assert_equal %q|You can't quit!  You're FIRED!|, event.message
   end
 
   def test_quit
     event = Net::YAIL::IncomingEvent.parse(':TheTowel!ce611d7b0@nerdbucket.com QUIT :Bye bye')
     assert_equal 'TheTowel', event.nick
     assert_equal :incoming_quit, event.type
-    assert_equal 'Bye bye', event.text
+    assert_equal 'Bye bye', event.message
   end
 
   def test_nick
@@ -163,7 +163,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     event = Net::YAIL::IncomingEvent.parse(':[|\|1]!~nerdmaste@nerd.nerdbucket.com NICK :Deadnerd')
     assert_equal '[|\|1]', event.nick
     assert_equal :incoming_nick, event.type
-    assert_equal 'Deadnerd', event.text
+    assert_equal 'Deadnerd', event.message
   end
 
   # Test some notice stuff
@@ -176,7 +176,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal 'Nerdminion', event.target
     assert !event.respond_to?(:nick)
     assert !event.respond_to?(:fullname)
-    assert_equal 'You suck.  A lot.', event.text
+    assert_equal 'You suck.  A lot.', event.message
 
     # This CTCP message...
     #     ":Nerdmaster!jeremy@nerdbucket.com PRIVMSG Nerdminion \001USERINFO\001"
@@ -187,8 +187,8 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal 'Nerdmaster', event.target
     assert_equal 'Nerdminion', event.nick
     assert_equal 'Nerdminion!minion@nerdbucket.com', event.fullname
-    assert_equal 'Nerdminion!minion@nerdbucket.com', event.from
-    assert_equal 'USERINFO :Minion of the nerd', event.text
+    assert_equal 'Nerdminion', event.from
+    assert_equal 'USERINFO :Minion of the nerd', event.message
 
     # Channel-wide notice
     event = Net::YAIL::IncomingEvent.parse(":Nerdmaster!jeremy@nerdbucket.com NOTICE #channel-ten-news :Tonight's late-breaking story...")
@@ -198,7 +198,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal '#channel-ten-news', event.channel
     assert_nil event.target
     assert_equal 'Nerdmaster!jeremy@nerdbucket.com', event.fullname
-    assert_equal %q|Tonight's late-breaking story...|, event.text
+    assert_equal %q|Tonight's late-breaking story...|, event.message
   end
 
   def test_modes
@@ -208,7 +208,7 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal :incoming_mode, event.type
     assert_equal '#bots', event.channel
     assert_equal ['Towelie', 'Doogles!*@*'], event.targets
-    assert_equal '+ob', event.text
+    assert_equal '+ob', event.message
 
     # Newly-created channels do this
     event = Net::YAIL::IncomingEvent.parse(':nerdbucket.com MODE #bots +nt')
@@ -222,14 +222,14 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal :incoming_mode, event.type
     assert_equal '#bots', event.channel
     assert_equal ['Doogles!*@*', 'Towelie', 'Nerdmaster'], event.targets
-    assert_equal '-bivv', event.text
+    assert_equal '-bivv', event.message
 
     event = Net::YAIL::IncomingEvent.parse(":Nerdmaster!jeremy@nerdbucket.com MODE #bots +m")
     assert_equal 'Nerdmaster', event.nick
     assert_equal :incoming_mode, event.type
     assert_equal '#bots', event.channel
     assert_equal [], event.targets
-    assert_equal '+m', event.text
+    assert_equal '+m', event.message
 
     # TODO: This is even worse than above - this is a pretty specific message (setting channel key
     # to 'foo'), but has to be parsed in a pretty absurd way to get that info.
@@ -238,13 +238,13 @@ class MessageParserEventTest < Test::Unit::TestCase
     assert_equal :incoming_mode, event.type
     assert_equal '#bots', event.channel
     assert_equal ['foo'], event.targets
-    assert_equal '+k', event.text
+    assert_equal '+k', event.message
   end
 
   # Simple test of error event
   def test_error
     event = Net::YAIL::IncomingEvent.parse 'ERROR :Closing Link: nerdbucket.com (Quit: Terminated by user)'
     assert_equal :incoming_error, event.type
-    assert_equal 'Closing Link: nerdbucket.com (Quit: Terminated by user)', event.text
+    assert_equal 'Closing Link: nerdbucket.com (Quit: Terminated by user)', event.message
   end
 end

data/tests/tc_yail.rb

@@ -19,24 +19,25 @@ class YailSessionTest < Test::Unit::TestCase
   # Sets up all our handlers the legacy way - allows testing that things work as they used to
   def setup_legacy_handling
     ###
-    # Simple counters for basic testing of successful handler registration
+    # Simple counters for basic testing of successful handler registration - note that all handlers
+    # must add "; false" to the end to avoid stopping the built-in handlers
     ###
 
     @msg = Hash.new(0)
-    @yail.prepend_handler(:incoming_welcome)        { |text, args|                          @msg[:welcome] += 1 }
-    @yail.prepend_handler(:incoming_endofmotd)      { |text, args|                          @msg[:endofmotd] += 1 }
-    @yail.prepend_handler(:incoming_notice)         { |f, actor, target, text|              @msg[:notice] += 1 }
-    @yail.prepend_handler(:incoming_nick)           { |f, actor, nick|                      @msg[:nick] += 1 }
-    @yail.prepend_handler(:incoming_bannedfromchan) { |text, args|                          @msg[:bannedfromchan] += 1 }
-    @yail.prepend_handler(:incoming_join)           { |f, actor, target|                    @msg[:join] += 1 }
-    @yail.prepend_handler(:incoming_mode)           { |f, actor, target, modes, objects|    @msg[:mode] += 1 }
-    @yail.prepend_handler(:incoming_msg)            { |f, actor, target, text|              @msg[:msg] += 1 }
-    @yail.prepend_handler(:incoming_act)            { |f, actor, target, text|              @msg[:act] += 1 }
-    @yail.prepend_handler(:incoming_ctcp)           { |f, actor, target, text|              @msg[:ctcp] += 1 }
-    @yail.prepend_handler(:incoming_ping)           { |text|                                @msg[:ping] += 1 }
-    @yail.prepend_handler(:incoming_quit)           { |f, actor, text|                      @msg[:quit] += 1 }
-    @yail.prepend_handler(:outgoing_mode)           { |target, modes, objects|              @msg[:o_mode] += 1 }
-    @yail.prepend_handler(:outgoing_join)           { |channel, pass|                       @msg[:o_join] += 1 }
+    @yail.prepend_handler(:incoming_welcome)        { |message, args|                          @msg[:welcome] += 1; false }
+    @yail.prepend_handler(:incoming_endofmotd)      { |message, args|                          @msg[:endofmotd] += 1; false }
+    @yail.prepend_handler(:incoming_notice)         { |f, actor, target, message|              @msg[:notice] += 1; false }
+    @yail.prepend_handler(:incoming_nick)           { |f, actor, nick|                         @msg[:nick] += 1; false }
+    @yail.prepend_handler(:incoming_bannedfromchan) { |message, args|                          @msg[:bannedfromchan] += 1; false }
+    @yail.prepend_handler(:incoming_join)           { |f, actor, target|                       @msg[:join] += 1; false }
+    @yail.prepend_handler(:incoming_mode)           { |f, actor, target, modes, objects|       @msg[:mode] += 1; false }
+    @yail.prepend_handler(:incoming_msg)            { |f, actor, target, message|              @msg[:msg] += 1; false }
+    @yail.prepend_handler(:incoming_act)            { |f, actor, target, message|              @msg[:act] += 1; false }
+    @yail.prepend_handler(:incoming_ctcp)           { |f, actor, target, message|              @msg[:ctcp] += 1; false }
+    @yail.prepend_handler(:incoming_ping)           { |message|                                @msg[:ping] += 1; false }
+    @yail.prepend_handler(:incoming_quit)           { |f, actor, message|                      @msg[:quit] += 1; false }
+    @yail.prepend_handler(:outgoing_mode)           { |target, modes, objects|                 @msg[:o_mode] += 1; false }
+    @yail.prepend_handler(:outgoing_join)           { |channel, pass|                          @msg[:o_join] += 1; false }
 
     ###
     # More complex handlers to test parsing of messages
@@ -50,16 +51,68 @@ class YailSessionTest < Test::Unit::TestCase
 
     # Gotta store extra info on notices to test event parsing
     @notices = []
-    @yail.prepend_handler(:incoming_notice) do |f, actor, target, text|
-      @notices.push({:server => f, :nick => actor, :target => target, :text => text})
+    @yail.prepend_handler(:incoming_notice) do |f, actor, target, message|
+      @notices.push({:from => f, :nick => actor, :target => target, :message => message})
+    end
+
+    @yail.prepend_handler(:incoming_ping) { |message|                        @ping_message = message; false }
+    @yail.prepend_handler(:incoming_quit) { |f, actor, message|              @quit = {:full => f, :nick => actor, :message => message}; false }
+    @yail.prepend_handler(:outgoing_join) { |channel, pass|               @out_join = {:channel => channel, :password => pass}; false }
+    @yail.prepend_handler(:incoming_msg)  { |f, actor, channel, message|     @privmsg = {:channel => channel, :nick => actor, :message => message}; false }
+    @yail.prepend_handler(:incoming_ctcp) { |f, actor, channel, message|     @ctcp = {:channel => channel, :nick => actor, :message => message}; false }
+    @yail.prepend_handler(:incoming_act)  { |f, actor, channel, message|     @act = {:channel => channel, :nick => actor, :message => message}; false }
+  end
+
+  # "New" handlers are set up (the 1.5+ way of doing things) here to perform tests in common with
+  # legacy.  Note that because handlers are different, we have to use filtering for things like the
+  # welcome message, otherwise we don't let YAIL do its default stuff.
+  def setup_new_handlers
+    ###
+    # Simple counters for basic testing of successful handler registration
+    ###
+
+    @msg = Hash.new(0)
+    @yail.heard_welcome           { @msg[:welcome] += 1 }
+    @yail.heard_endofmotd         { @msg[:endofmotd] += 1 }
+    @yail.heard_notice            { @msg[:notice] += 1 }
+    @yail.heard_nick              { @msg[:nick] += 1 }
+    @yail.heard_bannedfromchan    { @msg[:bannedfromchan] += 1 }
+    @yail.heard_join              { @msg[:join] += 1 }
+    @yail.heard_mode              { @msg[:mode] += 1 }
+    @yail.heard_msg               { @msg[:msg] += 1 }
+    @yail.heard_act               { @msg[:act] += 1 }
+    @yail.heard_ctcp              { @msg[:ctcp] += 1 }
+    @yail.heard_ping              { @msg[:ping] += 1 }
+    @yail.heard_quit              { @msg[:quit] += 1 }
+    @yail.said_mode               { @msg[:o_mode] += 1 }
+    @yail.said_join               { @msg[:o_join] += 1 }
+
+    ###
+    # More complex handlers to test parsing of messages
+    ###
+
+    # Channels list helps us test joins
+    @channels = []
+    @yail.on_join do |event|
+      @channels.push(event.channel) if @yail.me == event.nick
+    end
+
+    # Gotta store extra info on notices to test event parsing
+    @notices = []
+    @yail.on_notice do |event|
+      # Notices are tricky - we have to check server? and pm? to mimic legacy handler info
+      notice = {:from => event.from, :message => event.message}
+      notice[:nick] = event.server? ? "" : event.nick
+      notice[:target] = event.pm? ? event.target : event.channel
+      @notices.push notice
     end
 
-    @yail.prepend_handler(:incoming_ping) { |text| @ping_message = text }
-    @yail.prepend_handler(:incoming_quit) { |f, actor, text| @quit = {:full => f, :nick => actor, :text => text} }
-    @yail.prepend_handler(:outgoing_join) {|channel, pass| @out_join = {:channel => channel, :password => pass} }
-    @yail.prepend_handler(:incoming_msg) {|f, actor, channel, text| @privmsg = {:channel => channel, :nick => actor, :text => text} }
-    @yail.prepend_handler(:incoming_ctcp) {|f, actor, channel, text| @ctcp = {:channel => channel, :nick => actor, :text => text} }
-    @yail.prepend_handler(:incoming_act) {|f, actor, channel, text| @act = {:channel => channel, :nick => actor, :text => text} }
+    @yail.heard_ping  { |event| @ping_message = event.message }
+    @yail.on_quit     { |event| @quit = {:full => event.fullname, :nick => event.nick, :message => event.message} }
+    @yail.saying_join { |event| @out_join = {:channel => event.channel, :password => event.password} }
+    @yail.on_msg      { |event| @privmsg = {:channel => event.channel, :nick => event.nick, :message => event.message} }
+    @yail.on_ctcp     { |event| @ctcp = {:channel => event.channel, :nick => event.nick, :message => event.message} }
+    @yail.on_act      { |event| @act = {:channel => event.channel, :nick => event.nick, :message => event.message} }
   end
 
   # Waits until the mock IRC reports it has no more output - i.e., we've read everything available
@@ -82,6 +135,14 @@ class YailSessionTest < Test::Unit::TestCase
     common_tests
   end
 
+  # Exact same tests as above - just verifying functionality is the same as it was in legacy
+  def test_new
+    setup_new_handlers
+    wait_for_irc
+
+    common_tests
+  end
+
   # Resets the messages hash, mocks the IRC server to send string to us, waits for the response, yields to the block
   def mock_message(string)
     @msg = Hash.new(0)
@@ -102,12 +163,12 @@ class YailSessionTest < Test::Unit::TestCase
     assert_equal 3, @msg[:notice]
 
     # Intense notice test - make sure all events were properly translated
-    assert_equal ['fakeirc.org', 'fakeirc.org', ''], @notices.collect {|n| n[:server]}
+    assert_equal ['fakeirc.org', nil, 'fakeirc.org'], @notices.collect {|n| n[:from]}
     assert_equal ['', '', ''], @notices.collect {|n| n[:nick]}
-    assert_equal ['AUTH', 'Bot', 'Bot'], @notices.collect {|n| n[:target]}
-    assert_match %r|looking up your host|i, @notices[0][:text]
-    assert_match %r|you are exempt|i, @notices[1][:text]
-    assert_match %r|ERROR|i, @notices[2][:text]
+    assert_equal ['AUTH', 'AUTH', 'Bot'], @notices.collect {|n| n[:target]}
+    assert_match %r|looking up your host|i, @notices.first[:message]
+    assert_match %r|looking up your host|i, @notices[1][:message]
+    assert_match %r|you are exempt|i, @notices.last[:message]
 
     # Test magic methods that set up the bot
     assert_equal "Bot", @yail.me, "Should have set @yail.me automatically on welcome handler"
@@ -141,7 +202,7 @@ class YailSessionTest < Test::Unit::TestCase
 
       assert_equal "Nerdmaster", @privmsg[:nick]
       assert_equal "#foosball", @privmsg[:channel]
-      assert_equal "#{@yail.me}: Welcome!", @privmsg[:text]
+      assert_equal "#{@yail.me}: Welcome!", @privmsg[:message]
     end
 
     # CTCP
@@ -152,7 +213,7 @@ class YailSessionTest < Test::Unit::TestCase
 
       assert_equal "Nerdmaster", @ctcp[:nick]
       assert_equal "#foosball", @ctcp[:channel]
-      assert_equal "CTCP THING", @ctcp[:text]
+      assert_equal "CTCP THING", @ctcp[:message]
     end
 
     # ACT
@@ -163,7 +224,7 @@ class YailSessionTest < Test::Unit::TestCase
 
       assert_equal "Nerdmaster", @act[:nick]
       assert_equal "#foosball", @act[:channel]
-      assert_equal "vomits on you", @act[:text]
+      assert_equal "vomits on you", @act[:message]
     end
 
     # PING
@@ -177,7 +238,7 @@ class YailSessionTest < Test::Unit::TestCase
       assert_equal 1, @msg[:quit]
       assert_equal 'Nerdmaster!nerd@nerdbucket.com', @quit[:full]
       assert_equal 'Nerdmaster', @quit[:nick]
-      assert_equal 'Quit: Bye byes', @quit[:text]
+      assert_equal 'Quit: Bye byes', @quit[:message]
     end
   end
 end