net-yail 1.0.1 → 1.1.1

data/CHANGELOG

@@ -2,3 +2,21 @@
 * Fixed IRCBot to be part of the net/yail namespace so you can subclass
   without copying the file into your own project
 * Fixed IRCBot to actually be usable (fixed require)
+
+2008-07-02:
+* Minor documentation fixes
+* Args aren't automatically duped for all handlers anymore, as that caused
+  output handling to break (args come in, go to handler, get duped, get
+  filtered, handler chain ends, required YAIL output methods finish with the
+  original, unfiltered args)
+* All output APIs now dup the args at the top level to deal with above issue
+* Added more details to Rakefile - homepage and rubyforge project
+* Bumped to version 1.0.2 - will release gem only after a little testing,
+  though
+
+2008-07-03:
+* IRCBot can now auto-join multiple channels, and has a built-in uptime
+  system.
+* Net::YAIL now has handling for INVITE messages
+* Added fully working logger bot for a solid example
+* Since changes are more extensive then a minor release, bumping to 1.1.1

data/examples/logger/default.yml

@@ -0,0 +1,4 @@
+silent: false
+loud: false
+output-dir: /tmp/logs
+master: Nerdmaster

data/examples/logger/logger_bot.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'net/yail/IRCBot'
+require 'date'
+
+class LoggerBot < IRCBot
+  BOTNAME = 'Logger'
+  BOTVERSION = 'v0.1.0'
+
+  public
+  # Starts a new instance
+  #
+  # Options:
+  # * <tt>:irc_network</tt>: IP/name of server
+  # * <tt>:port</tt>: ...
+  # * <tt>:loud</tt>: Overly-verbose logging
+  # * <tt>:silent</tt>: Very little logging
+  # * <tt>:master</tt>: User who can order quits
+  # * <tt>:output_dir</tt>: Where to store log files
+  def initialize(options = {})
+    @master       = options.delete(:master)
+    @output_dir   = options.delete(:output_dir) || File.dirname(__FILE__)
+
+    # Log files per channel - logs rotate every so often, so we have to store
+    # filenames on a per-channel basis
+    @current_log  = {}
+    @log_date     = {}
+
+    options[:username] = BOTNAME
+    options[:realname] = BOTNAME
+    options[:nicknames] = ['LoggerBot', 'Logger_Bot', 'logger_bot', '_LoggerBot', 'LoggerBot_']
+
+    # Set up IRCBot, our loving parent, and begin
+    super(options)
+    self.connect_socket
+    self.start_listening
+  end
+
+  # Add hooks on startup (base class's start method calls add_custom_handlers)
+  def add_custom_handlers
+    # Set up hooks
+    @irc.prepend_handler(:incoming_msg,             self.method(:_in_msg))
+    @irc.prepend_handler(:incoming_act,             self.method(:_in_act))
+    @irc.prepend_handler(:incoming_invite,          self.method(:_in_invited))
+    @irc.prepend_handler(:incoming_kick,            self.method(:_in_kick))
+  end
+
+  private
+  # Incoming message handler
+  def _in_msg(fullactor, user, channel, text)
+    # check if this is a /msg command, or normal channel talk
+    incoming_private_message(user, text) if (channel =~ /#{bot_name}/)
+    incoming_channel_message(user, channel, text)
+  end
+
+  def _in_act(fullactor, user, channel, text)
+    # check if this is a /msg command, or normal channel talk
+    return if (channel =~ /#{bot_name}/)
+    log_channel_message(user, channel, "#{user} #{text}")
+  end
+
+  # TODO: recalls the most recent logs for a given channel by reading from
+  # the file system or using a hash of log data.  Num maxes out at 100 for
+  # general sanity
+  def recent_logs(channel, num = 10)
+    raise "Not implemented"
+  end
+
+  def incoming_channel_message(user, channel, text)
+    # check for special stuff before keywords
+    # Nerdmaster is allowed to do special ordering
+    if @master == user
+      if (text == "#{bot_name}: QUIT")
+        self.irc.quit("Ordered by my master")
+        sleep 1
+        exit
+      end
+    end
+
+    case text
+      when /^\s*#{bot_name}(:|)\s*uptime\s*$/i
+        msg(channel, get_uptime_string)
+
+      when /botcheck/i
+        msg(channel, "#{BOTNAME} #{BOTVERSION}")
+
+      else
+        log_channel_message(user, channel, "<#{user}> #{text}")
+    end
+  end
+
+  # Logs the message data to a flat text file.  Fun.
+  def log_channel_message(user, channel, text)
+    today = Date.today
+    if @current_log[channel].nil? || @log_date[channel] != today
+      chan_dir = @output_dir + '/' + channel
+      Dir::mkdir(chan_dir) unless File.exists?(chan_dir)
+      filename = chan_dir + '/' + today.strftime('%Y%m%d') + '.log'
+      @current_log[channel] = filename
+      @log_date[channel] = today
+    end
+
+    time = Time.now.strftime '%H:%M:%S'
+    File.open(@current_log[channel], 'a') do |f|
+      f.puts "[#{time}] #{text}"
+    end
+  end
+
+  # Invited to a channel for logging purposes - simply auto-join for now.
+  # Maybe allow only @master one day, or array of authorized users.
+  def _in_invited(fullactor, actor, target)
+    join target
+  end
+
+  # If bot is kicked, he must rejoin!
+  def _in_kick(fullactor, actor, target, object, text)
+    if object == bot_name
+      # Rejoin almost immediately - logging is important.
+      join target
+    end
+
+    return true
+  end
+end

data/examples/logger/run.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'logger_bot'
+require 'getopt/long'
+
+# This code just launches our logger with certain parameters.
+#
+# If options are specified, they override the default yaml file.  If a
+# different yaml file is specified, its settings are read, then overridden
+# by options.
+
+opt = Getopt::Long.getopts(
+  ['--silent',      '-s', Getopt::BOOLEAN],
+  ['--loud',        '-l', Getopt::BOOLEAN],
+  ['--network',     '-n', Getopt::OPTIONAL],
+  ['--output-dir',  '-o', Getopt::OPTIONAL],
+  ['--master',      '-m', Getopt::OPTIONAL],
+  ['--yaml',        '-y', Getopt::OPTIONAL]
+)
+
+opt['yaml'] ||= File.dirname(__FILE__) + '/default.yml'
+if File.exists?(opt['yaml'])
+  options = File.open(opt['yaml']) {|f| YAML::load(f)}
+else
+  options = {}
+end
+
+for key in %w{silent loud network output-dir master}
+  options[key] ||= opt[key]
+end
+
+@bot = LoggerBot.new(
+  :silent       => options['silent'],
+  :loud         => options['loud'],
+  :irc_network  => options['network'],
+  :output_dir   => options['output-dir'],
+  :master       => options['master']
+)
+@bot.irc_loop

data/lib/net/yail.rb

@@ -15,6 +15,14 @@ require 'net/yail/output_api'
 # * Build a system to allow numeric events to get sent post-processed data
 #   if it makes sense (converting the text to specific parts instead of all
 #   handlers having to regex it themselves, for instance)
+# * To deal with the required post-handler logic in the output API, and
+#   "nicely" deal with filtering output, it may be better to have a separate
+#   hash of YAIL-required post-handlers.  This would allow all logic to be
+#   done as handlers (makes things more consistent) as well as getting rid of
+#   the funky arg duping on a per-API-method basis (putting the auto-dupe back
+#   in the handle method)
+# * Handle this:
+#   (14:45.25) +++INCOMING: :Nerdmaster!xxx@yyyy INVITE botname :#channel_name
 
 # If a thread crashes, I want the app to die.  My threads are persistent, not
 # temporary.
@@ -45,6 +53,7 @@ module Net
 # Current list of incoming events and the parameters sent to the handler:
 # * :incoming_msg(fullactor, actor, target, text) - Normal message from actor to target
 # * :incoming_act(fullactor, actor, target, text) - CTCP "action" (emote) from actor to target
+# * :incoming_invite(fullactor, actor, target, text) - INVITE to target channel from actor
 # * :incoming_ctcp(fullactor, actor, target, text) - CTCP other than "action" from actor to target
 # * :incoming_ctcpreply(fullactor, actor, target, text) - CTCP NOTICE from actor to target
 # * :incoming_notice(fullactor, actor, target, text) - other NOTICE from actor to target
@@ -158,7 +167,7 @@ module Net
 #     :nicknames  => ['bot1', 'bot2', 'bot3']
 #   )
 #
-#   irc.prepend_handler :incoming_welcome, proc {
+#   irc.prepend_handler :incoming_welcome, proc {|text, args|
 #     irc.join('#foo')
 #     return false
 #   }
@@ -178,7 +187,7 @@ module Net
 #   require 'rubygems'
 #   require 'net/yail'
 #
-#   def welcome
+#   def welcome(text, args)
 #     @irc.join('#channel')
 #     return false
 #   end
@@ -199,7 +208,9 @@ module Net
 #
 # =Better example
 #
-# See the included IRCBot for a basic bot base class example.
+# See the included logger bot (under the examples directory of this project)
+# for use of the IRCBot base class.  It's a fully working bot example with
+# real-world use.
 class YAIL 
   include Net::IRCEvents::Magic
   include Net::IRCEvents::Defaults
@@ -417,7 +428,9 @@ class YAIL
   # Gets some input, sends stuff off to a handler.  Yay.
   def process_input(line)
     case line
-      when /^:((.+?)(?:!.+?)?) PRIVMSG (\S+?) :?\001ACTION (.+?)\001$/i
+      when /^:((.+?)(?:!.+?)?) INVITE \S+ :(\S+)/i
+        handle :incoming_invite, $1, $2, $3
+      when /^:((.+?)(?:!.+?)?) PRIVMSG (\S+) :?\001ACTION (.+?)\001$/i
         handle :incoming_act, $1, $2, $3, $4
       when /^:((.+?)(?:!.+?)?) PRIVMSG (\S+?) :?\001(.+?)\001$/i
         handle :incoming_ctcp, $1, $2, $3, $4
@@ -483,11 +496,6 @@ class YAIL
 
     report "+++EVENT HANDLER: Handling event #{event} via #{@handlers[event].inspect}:" if @loud
 
-    # To allow others to modify args without messing up potentially important
-    # internal data, dupe the array using a deep copy.  Hacky for sure, but
-    # effective.
-    new_args = Marshal.load(Marshal.dump(arguments))
-
     # Call all hooks in order until one breaks the chain.  For incoming
     # events, we want something to break the chain or else it'll likely
     # hit a reporter.  For outgoing events, we tend to report them anyway,
@@ -495,7 +503,7 @@ class YAIL
     # to take full control over them.
     result = false
     for handler in @handlers[event]
-      result = handler.call(*new_args)
+      result = handler.call(*arguments)
       break if result == true
     end
   end

data/lib/net/yail/IRCBot.rb

@@ -2,9 +2,6 @@ require 'rubygems'
 require 'net/yail'
 
 # My abstraction from adapter to a real bot.
-#
-# At the moment this only supports single-channel joining.  It's just a very
-# basic example, kids.  Deal with it.
 class IRCBot
   attr_reader :irc
 
@@ -16,7 +13,7 @@ class IRCBot
   #
   # Options:
   # * <tt>:irc_network</tt>: Name/IP of the IRC server
-  # * <tt>:channel</tt>: Channel name to join
+  # * <tt>:channels</tt>: Channels to automatically join on connect
   # * <tt>:port</tt>: Port number, defaults to 6667
   # * <tt>:username</tt>: Username reported to server
   # * <tt>:realname</tt>: Real name reported to server
@@ -24,7 +21,9 @@ class IRCBot
   # * <tt>:silent</tt>: Silence a lot of reports
   # * <tt>:loud</tt>: Lots more verbose reports
   def initialize(options = {})
-    @channel = options[:channel]
+    @start_time = Time.now
+
+    @channels = options[:channels] || []
     @irc_network = options[:irc_network]
     @port = options[:port] || 6667
     @username = options[:username] || 'IRCBot'
@@ -34,6 +33,23 @@ class IRCBot
     @loud = options[:loud] || false
   end
 
+  # Returns a string representing uptime
+  def get_uptime_string
+    uptime = (Time.now - @start_time).to_i
+    seconds = uptime % 60
+    minutes = (uptime / 60) % 60
+    hours = (uptime / 3600) % 24
+    days = (uptime / 86400)
+
+    str = []
+    str.push("#{days} day(s)") if days > 0
+    str.push("#{hours} hour(s)") if hours > 0
+    str.push("#{minutes} minute(s)") if minutes > 0
+    str.push("#{seconds} second(s)") if seconds > 0
+
+    return str.join(', ')
+  end
+
   # Creates the socket connection and registers the (very simple) default
   # welcome handler.  Subclasses should build their hooks in
   # add_custom_handlers to allow auto-creation in case of a restart.
@@ -89,9 +105,9 @@ class IRCBot
   end
 
   private
-  # Basic handler for joining a single channel upon successful registration
+  # Basic handler for joining our channels upon successful registration
   def welcome(text, args)
-    @irc.join(@channel)
+    @channels.each {|channel| @irc.join(channel) }
     # Let the default welcome stuff still happen
     return false
   end

data/lib/net/yail/default_events.rb

@@ -37,6 +37,7 @@ module Defaults
     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)
@@ -186,6 +187,11 @@ module Defaults
     nick @nicknames[0]
   end
 
+  # Incoming invitation
+  def r_invite(fullactor, actor, target)
+    report "[#{actor}] INVITE to #{target}"
+  end
+
 end
 
 end

data/lib/net/yail/output_api.rb

@@ -3,6 +3,21 @@ module Net
 # All output APIs live here.  In most cases, an outgoing handler will get a
 # call, but will not be able to stop the socket output since that's sorta
 # an essential part of this whole library.
+#
+# ==Argument Duping
+#
+# Output APIs dup incoming args before sending them off to handlers.  This
+# is a mechanism that I think could be done better, but I can't figure a good
+# way to do it at the moment.  The reason this is necessary is for a specific
+# situation where a bot has an array of response messages, and needs to filter
+# those messages.  A call to "msg(messages[rand(10)])" with a handler on :outgoing_msg
+# that does something like <code>text.gsub!('a', '@')</code> (like a leetspeek
+# filter) shouldn't destroy the original data in the messages array.
+#
+# This could be left up to the programmer, but it seems like something that
+# a library should own - protecting the programmer for having to remember that
+# sort of crap, especially if the app is calling msg, act, ctcp, etc. in
+# various ways from multiple points in the code....
 module IRCOutputAPI
   # Spits a raw string out to the server - in case a subclass wants to do
   # something special on *all* output, please make all output go through this
@@ -24,6 +39,10 @@ module IRCOutputAPI
   # straight out to the channel.  The output thread has to deal with
   # sending these out.
   def privmsg(target, text, report_string)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_privmsg, target, text)
 
     @privmsg_buffer_mutex.synchronize do
@@ -37,6 +56,10 @@ module IRCOutputAPI
   # shortcut methods for those types.  Target is a channel or username, text
   # is the message.
   def msg(target, text)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_msg, target, text)
 
     report_string = @silent ? '' : "{#{target}} <#{@me}> #{text}"
@@ -45,6 +68,10 @@ module IRCOutputAPI
 
   # Calls :outgoing_ctcp handler, then sends CTCP to target channel or user
   def ctcp(target, text)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_ctcp, target, text)
 
     report_string = @silent ? '' :  "{#{target}}  [#{@me} #{text}]"
@@ -54,6 +81,10 @@ module IRCOutputAPI
   # Calls :outgoing_act handler, then ctcp to send a CTCP ACTION (text) to
   # a given user or channel (target)
   def act(target, text)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_act, target, text)
 
     ctcp(target, "ACTION #{text}")
@@ -61,6 +92,10 @@ module IRCOutputAPI
 
   # Calls :outgoing_notice handler, then outputs raw NOTICE message
   def notice(target, text)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_notice, target, text)
 
     report "{#{target}} -#{@me}- #{text}" unless @silent
@@ -70,6 +105,10 @@ module IRCOutputAPI
   # Calls :outgoing_ctcpreply handler, then uses notice method to send the
   # CTCP text
   def ctcpreply(target, text)
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_ctcpreply, target, text)
 
     report "{#{target}} [Reply: #{@me} #{text}]" unless @silent
@@ -80,6 +119,11 @@ module IRCOutputAPI
   # and possibly specific users (objects).  If modes and objects are blank,
   # just sends a raw MODE query.
   def mode(target, modes = '', objects = '')
+    # Dup strings so handler can filter safely
+    target = target.dup
+    modes = modes.dup
+    objects = objects.dup
+
     handle(:outgoing_mode, target, modes, objects)
 
     message = "MODE #{target}"
@@ -90,6 +134,9 @@ module IRCOutputAPI
 
   # Calls :outgoing_join handler and then raw JOIN message for a given channel
   def join(target)
+    # Dup strings so handler can filter safely
+    target = target.dup
+
     handle(:outgoing_join, target)
 
     raw "JOIN #{target}"
@@ -98,6 +145,10 @@ module IRCOutputAPI
   # Calls :outgoing_part handler and then raw PART for leaving a given channel
   # (with an optional message)
   def part(target, text = '')
+    # Dup strings so handler can filter safely
+    target = target.dup
+    text = text.dup
+
     handle(:outgoing_part, target, text)
 
     request = "PART #{target}";
@@ -108,6 +159,9 @@ module IRCOutputAPI
   # Calls :outgoing_quit handler and then raw QUIT message with an optional
   # reason
   def quit(text = '')
+    # Dup strings so handler can filter safely
+    text = text.dup
+
     handle(:outgoing_quit, text)
 
     request = "QUIT";
@@ -118,12 +172,21 @@ module IRCOutputAPI
   # Calls :outgoing_nick handler and then sends raw NICK message to change
   # nickname.
   def nick(new_nick)
+    # Dup strings so handler can filter safely
+    new_nick = new_nick.dup
+
     handle(:outgoing_nick, new_nick)
 
     raw "NICK :#{new_nick}"
   end
 
   def user(username, myaddress, address, realname)
+    # Dup strings so handler can filter safely
+    username = username.dup
+    myaddress = myaddress.dup
+    address = address.dup
+    realname = realname.dup
+
     handle(:outgoing_user, username, myaddress, address, realname)
 
     raw "USER #{username} #{myaddress} #{address} :#{realname}"

metadata

@@ -1,55 +1,65 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: net-yail
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
-date: 2008-07-01 00:00:00 -04:00
-summary: "Yet Another IRC Library: wrapper for IRC communications in Ruby."
-require_paths: 
-- lib
-email: yail<at>nerdbucket dot com
-homepage: 
-rubyforge_project: 
-description: 
-autorequire: net/yail
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.1.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Jeremy Echols
+autorequire: net/yail
+bindir: bin
+cert_chain: []
+
+date: 2008-07-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: yail<at>nerdbucket dot com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
 files: 
+- examples/logger/logger_bot.rb
+- examples/logger/run.rb
+- examples/logger/default.yml
 - lib/net/yail.rb
 - CHANGELOG
+- lib/net/yail/eventmap.yml
+- lib/net/yail/IRCBot.rb
 - lib/net/yail/magic_events.rb
 - lib/net/yail/default_events.rb
 - lib/net/yail/output_api.rb
-- lib/net/yail/eventmap.yml
-- lib/net/yail/IRCBot.rb
 - README
-test_files: []
-
+has_rdoc: true
+homepage: http://ruby-irc-yail.nerdbucket.com/
+post_install_message: 
 rdoc_options: 
 - --main
 - README
-extra_rdoc_files: 
-- README
-- CHANGELOG
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: net-yail
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: "Yet Another IRC Library: wrapper for IRC communications in Ruby."
+test_files: []