meimei 0.1.1

data/CHANGES

@@ -0,0 +1,7 @@
+= meimei Changelog
+
+=== Version 0.1.1
+* Fixed bug with plugins
+
+=== Version 0.1.0
+* Initial public release

data/LICENSE

@@ -0,0 +1,31 @@
+Copyright (c) 2008, Albert Yi
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+ 
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the
+      distribution.  
+      
+    * Neither the name of Albert Yi nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,28 @@
+= meimei
+
+== DESCRIPTION
+Meimei is a simple IRC bot framework. It is designed to be easily extensible. In the interest of simplicity it only implements a subset RFC 1459, mainly those dealing with PRIVMSGs.
+
+=== Usage
+
+  require 'meimei'
+  client = Meimei::Client.new("meimei")
+  client.add_server("irc.synirc.net", 6667, "#meimei, #bonklers")
+  client.start()
+  
+=== Plugins
+
+  # In plugins/reload.rb
+  define_plugin("!reload") do |msg|
+    load_plugins()
+    reply("Plugins reloaded.")
+  end
+  
+  # In plugins/clock.rb
+  define_plugin("@1h") do
+    say("localhost", "#meimei", "One hour has passed.")
+  end
+
+=== Thread Safety
+
+Meimei does not use any global or class variables, so a single client instance should be thread safe. Obviously Meimei does make use of instance variables, so using threads from within a single client may cause issues.

data/Rakefile

@@ -0,0 +1,14 @@
+# make sure our project's ./lib directory is added to the ruby search path
+$: << File.join(File.dirname(__FILE__),"lib")
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/contrib/sshpublisher'
+
+require 'meimei'
+
+load 'tasks/setup.rb'
+
+

data/lib/meimei/array_extensions.rb

@@ -0,0 +1,7 @@
+module ArrayExtensions
+  def pick_random
+    return self[rand(size)]
+  end
+end
+
+Array.__send__(:include, ArrayExtensions)

data/lib/meimei/client.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+require 'socket'
+
+module Meimei
+  class Client
+    # === Parameters
+    # - nick: The nickname your bot will use.
+    # - options[:username]: The username of your bot (will default to nick).
+    # - options[:realname]: The real name of your bot (will default to nick).
+    # - options[:password]: The password for your bot's account.
+    # - options[:plugin_dir]: An absolute path to the directory where Meimei plugins will be stored.
+    # - options[:log_dir]: An absolute path to where log files will be stored.
+    # - options[:log_level]: The log level. Can be: :error, :info, :debug.
+    def initialize(nick, options = {})
+      @servers = []
+      @running = false
+      @command_plugins = []
+      @timer_plugins = []
+      @nick = nick
+      @username = options[:username] || @nick
+      @realname = options[:realname] || @nick
+      @password = options[:password]
+      @plugin_dir = options[:plugin_dir] || "plugins"
+      @log_dir = options[:log_dir] || "."
+      @log_level = options[:log_level] || :info
+      @logger = Logger.new(open("#{@log_dir}/#{@nick}-#{Time.now.strftime('%Y%m%d-%H%M')}.log", "w"))
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+    end
+    
+    # Registers a server with the client. This method will not open a connection.
+    def add_server(hostname, port, autojoin)
+      @servers << Server.new(hostname, port, autojoin, :log_dir => @log_dir, :log_level => @log_level)
+    end
+    
+    # Reloads all plugins.
+    def load_plugins
+      @command_plugins.clear()
+      @timer_plugins.clear()
+
+      # TODO: This is hackish
+      Dir["#{@plugin_dir}/*.rb"].sort.each do |file|
+        eval(File.open(file, "r").read, binding, file)
+      end
+    end
+    
+    # Creates a new plugin.
+    #
+    # === Parameters
+    # - name: The name of the plugin. There are two special cases: (1) If the name begins with "!", then it is considered a command. For example, a plugin named "!wiki" would only be invoked if a message began with "!wiki". The message passed to the plugin will have the command stripped out. (2) If the plugin begins with "@", then it is considered a timer event. For example, a plugin named "@60" will run every 60 seconds. "@10m" will run every 10 minutes, and "@4h" will run every 4 hours.
+    # - options[:position]: Insert plugin at position n (lower number positions will be run first).
+    def define_plugin(name, options = {}, &block)
+      # TODO: Is there a memory leak here?
+      
+      case name
+      when /^@(\d+)([mh])?/
+        interval = $1.to_i
+                
+        if $2 == "m"
+          interval = interval * 60
+        elsif $2 == "h"
+          interval = interval * 60 * 60
+        end
+        
+        plugins = @timer_plugins
+        plugin = [name, interval, Time.now, block, options]
+        
+      else
+        plugins = @command_plugins
+        plugin = [name, block, options]
+      end
+
+      if options[:position]
+        plugins.insert(options[:position], plugin)
+      else
+        plugins << plugin
+      end
+      
+      plugins.compact!
+    end
+    
+    # Run all timer plugins.
+    def check_timer_plugins
+      @timer_plugins.each do |plugin|
+        begin
+          # Need to refer directly to the array since we'll be changing its values
+          # plugin[0]: name
+          # plugin[1]: interval
+          # plugin[2]: next_run_at
+          # plugin[3]: block
+          # plugin[4]: options
+          
+          if plugin[2] < Time.now
+            plugin[3].call()
+            plugin[2] = Time.now + plugin[1]
+          end
+        rescue Exception => e
+          e.dump(@logger)
+        end
+      end
+    end
+    
+    # Run all command plugins.
+    def check_command_plugins(msg)
+      @command_plugins.each do |name, block, options|
+        begin
+          if name.index("!") == 0
+            if msg =~ /^#{name}\b/
+              msg = msg.gsub(/!\S+\s*/, "")
+              block.call(msg)
+            end
+          else
+            block.call(msg)
+          end
+        rescue Exception => e
+          reply "Error: #{e.class}"
+          e.dump(@current_server.logger)
+        end
+      end
+    end
+
+    # Returns the first server that has data to be read.
+    def select
+      sockets = @servers.map {|x| x.socket}.compact
+      socket = Kernel.select(sockets, nil, nil, 1)
+      
+      if socket == nil
+        return nil
+      else
+        socket = socket[0][0]
+        return @servers.find {|x| x.socket.__id__ == socket.__id__}
+      end
+    end
+    
+    # Starts the main event loop.
+    def start
+      self.load_plugins()
+      @running = true
+      
+      while @running
+        @servers.each do |server|
+          unless server.is_connected
+            if server.reconnect_delay_passed? && server.connect()
+              server.write("PASS #{@password}") if @password
+              server.write("NICK #{@nick}")
+              server.write("USER #{@username} hostname servername :#{@username}")
+              server.autojoin.each do |channel|
+                server.write("JOIN #{channel}")
+              end
+            end
+          end
+
+          self.check_timer_plugins()
+          
+          @current_server = self.select()
+
+          if @current_server
+            msg = @current_server.read
+            
+            if msg != nil
+              self.process_message(msg)
+            end
+          end
+        end        
+      end
+    end
+    
+    # Quits all clients and ends the event loop.
+    def quit(msg = nil)
+      @servers.each do |server|
+        if msg
+          server.write("QUIT :#{msg}")
+        else
+          server.write("QUIT")
+        end
+      end
+      
+      @running = false
+    end
+    
+    # Respond to the current server/channel/user. If {with_nick} is true, then the messager's sender's nick will be prepended to the response.
+    def reply(msg, with_nick = true)
+      if with_nick
+        @current_server.write("PRIVMSG #{@current_to} :#{@current_from}: #{msg}")
+      else
+        @current_server.write("PRIVMSG #{@current_to} :#{msg}")
+      end
+    end
+    
+    # Send {msg} to {to} on {server}. {to} can either be a channel or someone's nick.
+    def say(server, to, msg)
+      if server.is_a?(String)
+        server = @servers.find {|x| x.hostname == server}
+      end
+      
+      server.write("PRIVMSG #{to} :#{msg}")
+    end
+    
+    # Parses a messages and dispatches as necessary.
+    def process_message(msg)
+      @current_from = nil
+      @current_to = nil
+      @current_msg = nil
+      
+      case msg
+      when /^:(.+?)!(.+?)@(\S+) PRIVMSG (\S+) :(.+)$/
+        @current_from = $1
+        @current_to = $4
+        @current_msg = $5.strip
+
+        self.check_command_plugins(@current_msg)
+        
+      when /^PING (.+)$/
+        @current_server.write("PONG #{$1}")
+      end
+    end
+  end
+end

data/lib/meimei/exception_dump.rb

@@ -0,0 +1,14 @@
+module Meimei
+  module ExceptionDumpMethods
+    def dump(logger)
+      logger.info "* #{self.class} error thrown"
+      logger.info "* Message: #{self.message}"
+      logger.info "* Backtrace:"
+      self.backtrace.each do |line|
+        logger.info "** #{line}"
+      end
+    end
+  end
+  
+  Exception.__send__(:include, ExceptionDumpMethods)
+end

data/lib/meimei/gemspec.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'meimei/specification'
+require 'meimei/version'
+require 'rake'
+
+# The Gem Specification plus some extras for meimei.
+module Meimei
+  SPEC = Meimei::Specification.new do |spec|
+    spec.name               = "meimei"
+    spec.version            = Meimei::VERSION
+    spec.rubyforge_project  = "meimei"
+    spec.author             = "Albert Yi"
+    spec.email              = "r888888888@gmail.com"
+    spec.homepage           = "http://meimei.rubyforge.org/"
+
+    spec.summary            = "A simple IRC bot framework."
+    spec.description        = <<-DESC
+    Meimei is a simple IRC bot framework. It is designed to be easily extensible. In the interest of simplicity it only implements a subset RFC 1459, mainly those dealing with PRIVMSGs.
+    DESC
+
+    spec.extra_rdoc_files   = FileList["[A-Z]*"]
+    spec.has_rdoc           = true
+    spec.rdoc_main          = "README"
+    spec.rdoc_options       = [ "--line-numbers" , "--inline-source" ]
+
+    spec.test_files         = FileList["spec/**/*.rb", "test/**/*.rb"]
+    spec.files              = spec.test_files + spec.extra_rdoc_files + 
+                              FileList["lib/**/*.rb", "resources/**/*"]
+    
+
+    # add dependencies
+    # spec.add_dependency("somegem", ">= 0.4.2")
+    
+    spec.platform           = Gem::Platform::RUBY
+
+    spec.local_rdoc_dir     = "doc/rdoc"
+    spec.remote_rdoc_dir    = "#{spec.name}/rdoc"
+    spec.local_coverage_dir = "doc/coverage"
+    spec.remote_coverage_dir= "#{spec.name}/coverage"
+
+    spec.remote_site_dir    = "#{spec.name}/"
+  end
+end
+
+

data/lib/meimei/persistent_hash.rb

@@ -0,0 +1,43 @@
+class PersistentHash
+	def initialize(file_path, commit_interval = 1)
+		@commit_interval = commit_interval
+		@commit_count = 0
+		@file_path = file_path
+		restore!
+		unless @hash.is_a?(Hash)
+			@hash = {}
+			commit!
+		end
+	end
+
+	def restore!
+		if File.exist?(@file_path)
+			mode = File::RDONLY
+		else
+			return
+		end
+
+		File.open(@file_path, mode) do |f|
+			@hash = Marshal.restore(f)
+		end
+	end
+
+	def commit!
+		File.open(@file_path, File::WRONLY | File::CREAT) do |f|
+			Marshal.dump(@hash, f)
+		end
+	end
+
+	def []=(key, value)
+		@hash[key] = value
+		@commit_count += 1
+		if @commit_count >= @commit_interval
+			@commit_count = 0
+			commit!
+		end
+	end
+
+	def method_missing(name, *params, &block)
+		@hash.send(name, *params, &block)
+	end
+end

data/lib/meimei/server.rb

@@ -0,0 +1,107 @@
+module Meimei
+  class Server
+    attr_accessor :socket, :hostname, :port, :is_connected, :logger, :autojoin
+    
+    def initialize(hostname, port, autojoin, options = {})
+      @hostname, @port, @is_connected = hostname, port, false
+      @log_dir = options[:log_dir] || "."
+      @logger = Logger.new(open("#{@log_dir}/#{@hostname}-#{Time.now.strftime('%Y%m%d-%H%M')}.log", "w"))
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      
+      case options[:log_level]
+      when :fatal
+        @logger.level = Logger::FATAL
+        
+      when :error
+        @logger.level = Logger::ERROR
+        
+      when :warn
+        @logger.level = Logger::WARN
+        
+      when :info
+        @logger.level = Logger::INFO
+        
+      when :debug
+        @logger.level = Logger::DEBUG
+        
+      else
+        @logger.level = Logger::INFO
+      end
+
+      @autojoin = autojoin.split(/,\s*/)
+    end
+
+    def close
+      begin
+        @socket.close if @socket
+      rescue Exception => x
+        @is_connected = false
+        @logger.info "* Could not close socket"
+        x.dump(@logger)
+      end
+    end
+    
+    def reconnect_delay_passed?
+      if @last_connected_at == nil
+        @last_connected_at = Time.now
+        return true
+      end
+      
+      if Time.now - @last_connected_at > 10
+        @last_connected_at = Time.now
+        return true
+      else
+        return false
+      end
+    end
+    
+    def connect
+      begin
+        self.close()
+        @socket = TCPSocket.open(@hostname, @port)
+        @is_connected = true
+        @logger.info "* Connected (resolved to #{@socket.peeraddr[3]})"
+      rescue Exception => x
+        @is_connected = false
+        @logger.info "* Connection failed"
+        x.dump(@logger)
+      end
+      
+      return @is_connected
+    end
+    
+    def read
+      begin      
+        msg = @socket.gets
+        @logger.debug "> #{msg}"
+        return msg
+      rescue Errno::ECONNRESET => x
+        @logger.info "* Connection reset"
+        @is_connected = false
+        x.dump(@logger)
+        return nil
+      rescue Exception => x
+        @logger.info "* Read failed"
+        @is_connected = false
+        x.dump(@logger)
+        return nil
+      end
+    end
+    
+    def write(msg)
+      @logger.debug "< #{msg}"
+            
+      begin
+        @socket.write(msg + "\n")
+      rescue Errno::ECONNRESET => x
+        @logger.info "* Connection reset"
+        @is_connected = false
+        x.dump(@logger)
+      rescue Exception => x
+        @logger.info "* Write failed"
+        @is_connected = false
+        x.dump(@logger)
+      end
+    end
+  end
+end

data/lib/meimei/specification.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'rake'
+
+module Meimei 
+    # Add some additional items to Gem::Specification
+    # A Meimei::Specification adds additional pieces of information the
+    # typical gem specification
+    class Specification 
+
+        RUBYFORGE_ROOT = "/var/www/gforge-projects/"
+      
+        # user that accesses remote site
+        attr_accessor :remote_user
+
+        # remote host, default 'rubyforge.org'
+        attr_accessor :remote_host
+
+        # name the rdoc main
+        attr_accessor :rdoc_main
+
+        # local directory in development holding the generated rdoc
+        # default 'doc'
+        attr_accessor :local_rdoc_dir
+
+        # remote directory for storing rdoc, default 'doc'
+        attr_accessor :remote_rdoc_dir
+
+        # local directory for coverage report
+        attr_accessor :local_coverage_dir
+        
+        # remote directory for storing coverage reports
+        # This defaults to 'coverage'
+        attr_accessor :remote_coverage_dir
+
+        # local directory for generated website, default +site/public+
+        attr_accessor :local_site_dir
+       
+        # remote directory relative to +remote_root+ for the website.
+        # website.
+        attr_accessor :remote_site_dir
+
+        # is a .tgz to be created?, default 'true'
+        attr_accessor :need_tar
+
+        # is a .zip to be created, default 'true'
+        attr_accessor :need_zip
+
+
+        def initialize
+            @remote_user = nil
+            @remote_host = "rubyforge.org"
+
+            @rdoc_main              = "README"
+            @local_rdoc_dir         = "doc"
+            @remote_rdoc_dir        = "doc"
+            @local_coverage_dir     = "coverage"
+            @remote_coverage_dir    = "coverage"
+            @local_site_dir         = "site/public"
+            @remote_site_dir        = "."
+            
+            @need_tar   = true
+            @need_zip   = true
+
+            @spec                   = Gem::Specification.new
+
+            yield self if block_given?
+
+            # update rdoc options to take care of the rdoc_main if it is
+            # there, and add a default title if one is not given
+            if not @spec.rdoc_options.include?("--main") then
+                @spec.rdoc_options.concat(["--main", rdoc_main])
+            end
+
+            if not @spec.rdoc_options.include?("--title") then
+                @spec.rdoc_options.concat(["--title","'#{name} -- #{summary}'"])
+            end
+        end
+
+        # if this gets set then it overwrites what would be the
+        # rubyforge default.  If rubyforge project is not set then use
+        # name.  If rubyforge project and name are set, but they are
+        # different then assume that name is a subproject of the
+        # rubyforge project
+        def remote_root 
+            if rubyforge_project.nil? or 
+                rubyforge_project == name then
+                return RUBYFORGE_ROOT + "#{name}/"
+            else
+                return RUBYFORGE_ROOT + "#{rubyforge_project}/#{name}/"
+            end
+        end
+
+        # rdoc files is the same as what would be generated during gem
+        # installation. That is, everything in the require paths plus
+        # the rdoc_extra_files
+        #
+        def rdoc_files 
+            flist = extra_rdoc_files.dup
+            @spec.require_paths.each do |rp|
+                flist << FileList["#{rp}/**/*.rb"]
+            end
+            flist.flatten.uniq
+        end
+
+        # calculate the remote directories
+        def remote_root_location
+            "#{remote_user}@#{remote_host}:#{remote_root}"
+        end
+           
+        def remote_rdoc_location
+            remote_root_location + @remote_rdoc_dir
+        end
+
+        def remote_coverage_location
+            remote_root_loation + @remote_coverage_dir
+        end
+
+        def remote_site_location
+            remote_root_location + @remote_site_dir
+        end
+
+        # we delegate any other calls to spec
+        def method_missing(method_id,*params,&block)
+            @spec.send method_id, *params, &block
+        end
+    end
+end

data/lib/meimei/version.rb

@@ -0,0 +1,18 @@
+module Meimei
+    class Version
+        MAJOR   = 0
+        MINOR   = 1
+        BUILD   = 1
+
+        class << self
+            def to_a
+                [MAJOR, MINOR, BUILD]
+            end
+
+            def to_s
+                to_a.join(".")
+            end
+        end
+    end
+    VERSION = Version.to_s
+end

data/lib/meimei.rb

@@ -0,0 +1,25 @@
+module Meimei
+    
+    ROOT_DIR        = File.expand_path(File.join(File.dirname(__FILE__),".."))
+    LIB_DIR         = File.join(ROOT_DIR,"lib").freeze
+    RESOURCE_DIR    = File.join(ROOT_DIR,"resources").freeze
+
+    # 
+    # Utility method to require all files ending in .rb in the directory
+    # with the same name as this file minus .rb
+    #
+    def require_all_libs_relative_to(fname)
+        prepend   = File.basename(fname,".rb")
+        search_me = File.join(File.dirname(fname),prepend)
+     
+        Dir.entries(search_me).each do |rb|
+            if File.extname(rb) == ".rb" then
+                require "#{prepend}/#{File.basename(rb,".rb")}"
+            end
+        end
+    end 
+    module_function :require_all_libs_relative_to
+
+end
+
+Meimei.require_all_libs_relative_to(__FILE__)

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: meimei
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+date: 2008-02-06 00:00:00 -05:00
+summary: A simple IRC bot framework.
+require_paths: 
+- lib
+email: r888888888@gmail.com
+homepage: http://meimei.rubyforge.org/
+rubyforge_project: meimei
+description: Meimei is a simple IRC bot framework. It is designed to be easily extensible. In the interest of simplicity it only implements a subset RFC 1459, mainly those dealing with PRIVMSGs.
+autorequire: 
+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: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Albert Yi
+files: 
+- CHANGES
+- LICENSE
+- Rakefile
+- README
+- lib/meimei/array_extensions.rb
+- lib/meimei/client.rb
+- lib/meimei/exception_dump.rb
+- lib/meimei/gemspec.rb
+- lib/meimei/persistent_hash.rb
+- lib/meimei/server.rb
+- lib/meimei/specification.rb
+- lib/meimei/version.rb
+- lib/meimei.rb
+test_files: []
+
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+- --title
+- "'meimei -- A simple IRC bot framework.'"
+extra_rdoc_files: 
+- CHANGES
+- LICENSE
+- Rakefile
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+