ircbot 0.0.2 → 0.1.0

data/lib/irc/localize.rb

@@ -1,260 +0,0 @@
-=begin header
-localization extension
-  IO supporting coding system conversion
-
-  $Author: igarashi $
-  $Date: 2001/01/02 00:21:18 $
-
-  Copyright (C) 1998-2001 Hiroshi IGARASHI
-=end
-
-require 'kconv'
-#require 'uconv'
-
-$vsave, $VERBOSE = $VERBOSE, FALSE
-
-module Kernel
-  private
-
-  def println(*args)
-=begin
-print with ln
-=end
-    STDOUT.println(*args)
-  end
-
-  def eprint(*args)
-=begin
-print to stderr
-=end
-    STDERR.print(*args)
-  end
-
-  def eprintln(*args)
-=begin
-eprint with ln
-=end
-    STDERR.println(*args)
-  end
-end
-
-# IO class extension
-class IO
-  def println(*args)
-=begin
-print with ln
-=end
-    if args.length > 0
-      print(*args)
-    end
-    print("\n")
-  end
-  public(:println)
-end
-
-class << ARGF
-  def lineno
-    $.
-  end
-  def path
-    filename
-  end
-end
-
-## available only if kconv ext module imported
-if defined?(Kconv)
-
-  module Kernel
-    private
-
-    # lreadline
-    def lreadline(*arg)
-      Kconv.tointern(readline(*arg))
-    end
-
-    # lgets
-    def lgets(*arg)
-      ret = gets(*arg)
-      unless ret.nil?
-	Kconv.tointern(ret)
-      else
-	nil
-      end
-    end
-
-    def p(*args)
-      args.each { |arg|
-	println(Kconv.toextern(arg.inspect))
-      }
-    end
-
-    # lprint
-    def lprint(*args)
-      STDOUT.lprint(*args)
-    end
-  
-    # lprint with ln
-    def lprintln(*args)
-      STDOUT.lprintln(*args)
-    end
-
-    # leprint
-    def leprint(*args)
-      STDERR.lprint(*args)
-    end
-
-    def leprintln(*args)
-=begin
-leprint with ln
-=end
-      STDERR.lprintln(*args)
-    end
-  end
-
-  # Kconv module extension
-  module Kconv
-    ## local encoding
-    case $KIOCODE
-    ## EUC
-    when 'EUC'
-      alias_method(:toextern, :toeuc)
-    ## JIS
-    when 'JIS'
-      alias_method(:toextern, :tojis)
-    ## SJIS
-    when 'SJIS'
-      alias_method(:toextern, :tosjis)
-    else
-      case $KCODE
-      ## EUC
-      when 'EUC'
-	alias_method(:toextern, :toeuc)
-      ## JIS
-      when 'JIS'
-	alias_method(:toextern, :tojis)
-      ## SJIS
-      when 'SJIS'
-	alias_method(:toextern, :tosjis)
-      when 'NONE'
-	def toextern(str)
-	  str
-	end
-      else
-	raise "Unknown coding system(\"#{$KIOCODE}\")."
-      end
-    end
-
-    case $KCODE
-    ## EUC
-    when 'EUC'
-      alias_method(:tointern, :toeuc)
-    ## SJIS
-    when 'SJIS'
-      alias_method(:tointern, :tosjis)
-    when 'NONE'
-      def tointern(str)
-	str
-      end
-    else
-      raise "Unknown coding system(\"#{$KCODE}\")."
-    end
-
-    alias_method(:tolocal, :toextern)
-    module_function(:toextern, :tolocal, :tointern)
-  end
-end
-
-class << ARGF
-
-  if defined?(Kconv)
-    # lreadline
-    def lreadline(*arg)
-      Kconv.tointern(readline(*arg))
-    end
-    # lgets
-    def lgets(*arg)
-      ret = gets(*arg)
-      unless ret.nil?
-	Kconv.tointern(ret)
-      else
-	nil
-      end
-    end
-  end
-
-end
-
-class IO
-
-  if defined?(Kconv)
-
-    # lreadline
-    def lreadline(*arg)
-      Kconv.tointern(readline(*arg))
-    end
-
-    # lgets
-    def lgets(*arg)
-      ret = gets(*arg)
-      unless ret.nil?
-	Kconv.tointern(ret)
-      else
-	nil
-      end
-    end
-
-    # convert to local encoding and print 
-    def lprint(*args)
-      args.each { |arg|
-	print(Kconv.toextern(arg.to_s))
-      }
-    end
-    def jisprint(*args)
-      args.each { |arg|
-	print(Kconv.tojis(arg.to_s))
-      }
-    end
-    def eucprint(*args)
-      args.each { |arg|
-	print(Kconv.toeuc(arg.to_s))
-      }
-    end
-    def sjisprint(*args)
-      args.each { |arg|
-	print(Kconv.tosjis(arg.to_s))
-      }
-    end
-
-    def lprintln(*args)
-      lprint(*args)
-      print("\n")
-    end
-
-    def set_codesys(codesys_name)
-      case codesys_name
-      ## JIS
-      when 'JIS'
-	class << self
-	  alias_method(:lprint, :jisprint)
-	end
-      ## EUC
-      when 'EUC'
-	class << self
-	  alias_method(:lprint, :eucprint)
-	end
-      ## SJIS
-      when 'SJIS'
-	class << self
-	  alias_method(:lprint, :sjisprint)
-	end
-      when 'NONE'
-	alias_method(:lprint, :print)
-      else
-	raise "Unknown coding system(\"#{codesys_name}\")."
-      end
-    end
-    public(:lreadline, :lprint, :lprintln)
-  end
-end
-
-$VERBOSE = $vsave

data/lib/ircbot/agent_manager.rb

@@ -1,89 +0,0 @@
-# -*- coding: euc-jp -*-
-
-module Ircbot
-  ######################################################################
-  ### agent ��������륯�饹
-  ### (ľ�� agent �����Ѥ��ʤ��Τϡ�agent �δ�����ʻ���ƹԤ�����)
-  ######################################################################
-  class AgentManager
-    attr :cpi, true
-    attr :name
-    attr :created
-    attr :alive
-
-    def initialize (name, obj, client, arg = nil)
-      @name	= name
-      @cpi	= obj
-      @created	= Time.now
-      @alive	= nil
-      @client	= client
-      @arg      = arg
-
-      method = :do_construct
-      if @cpi.respond_to?(method)
-	@cpi.send(method, client)
-      end
-    end
-
-    def notifyMessage (msg)
-      # NOP
-    end
-
-    def start (arg = nil)
-      @arg = arg if arg
-
-      method = :do_start
-      if @cpi.respond_to?(method)
-	@cpi.send(method, @arg)
-      end
-
-      @alive = true
-    end
-
-    def stop
-      method = :do_destruct
-      if @cpi.respond_to?(method)
-	@cpi.send(method, nil)
-      end
-      @alive = nil
-    end
-
-    def alive?
-      @alive
-    end
-
-    def send (method, *args)
-      if alive?
-	return @cpi.send(method, *args)
-      else
-	return nil
-      end
-    end
-
-    # ���ꤵ�줿�᥽�åɷ���缡�¹Ԥ���
-    # 1�ļ¹Ԥ����齪λ���ɤΥ᥽�åɤ�������Ƥʤ����� nil ���֤���
-    def apply_methods (msg, methods)
-      methods = [methods] unless methods.is_a? Array
-      methods.each do |method|
-	next unless @cpi.respond_to?(method)
-	begin
-	  if msg
-	    if (result = send(method, msg))
-	      return result
-	    end
-	  else
-	    if (result = send(method))
-	      return result
-	    end
-	  end
-	rescue Exception => err
-	  error = "error: #{err} in #{self.name}"
-	  @client.syslog(error, :error)
-	  @client.syslog($@.join("\n"), :error)
-	  return error
-	end
-      end
-      return nil
-    end
-  end
-end

data/lib/ircbot/config_client.rb

@@ -1,369 +0,0 @@
-# -*- coding: euc-jp -*-
-
-require 'ircbot/agent_manager'
-require 'ircbot/ordered_hash'
-
-module Ircbot
-  class ConfigClient < IRC::Client
-    include ActiveSupport::Rescuable
-
-    attr :config
-    attr :messages
-    attr :agents
-
-    PARAM_STRING = %w( nick server username realname password port log syslog help pidfile )
-    PARAM_ARRAY  = %w( agents channels )
-    PARAM_KEYS   = PARAM_STRING + PARAM_ARRAY
-
-    class << self
-      ######################################################################
-      ### config �ե����뤫�������ͤ��ɤ߹��ߡ�Client ���֥������Ȥ����
-      ######################################################################
-      def read_config(input, debug = nil)
-	case input
-	when IO			# already IO (NOP)
-	when String		# maybe file
-	  begin
-	    input = File.open(input)
-	  rescue Exception
-	    $stderr.puts("cannot read config file. (#{input})")
-	    exit
-	  end
-	else
-	  $stderr.puts("missing config file.")
-	  exit
-	end
-
-	params		= {}
-	param_regexp	= self::PARAM_KEYS.join('|')
-	while (line = input.gets)
-	  case line
-	  when /^#/		# ignore
-	  when /^(#{param_regexp})\s*=\s*/io
-	    key, val = $1.downcase, $'.chomp
-	    symbol = key.intern
-	    case key
-	    when *self::PARAM_STRING
-	      params[symbol] = val
-	    when *self::PARAM_ARRAY
-	      params[symbol] = val.split(/[,\s]+/)
-	    else		# IGNORE...
-	      $stderr.puts "ignore: #{key} = #{params[symbol].inspect}(#{params[symbol].class})"
-	    end
-	    if debug
-	      $stderr.puts "debug: #{key} = #{params[symbol].inspect}(#{params[symbol].class})"
-	    end
-	  end
-	end
-	self.new(params)
-      end
-    end
-
-    def initialize (hash = {})
-      @config	= hash
-
-      # ɬ�ܹ���
-      @nick	= hash[:nick]			|| missing_error(:nick)
-      @server	= hash[:server]			|| missing_error(:server)
-      @username = hash[:username] || @nick	|| missing_error(:username)
-      @realname = hash[:realname] || @nick	|| missing_error(:realname)
-      @channels	= hash[:channels]
-
-      @port	= hash[:port]		|| 6667
-      @password = hash[:password]	|| 'xxx'
-      @log	= hash[:log]
-      @syslog	= hash[:syslog]
-      @help	= hash[:help]		|| '�إ�פ�����ޤ���(config �� help �Ԥ򸫤ޤ�)'
-      @agents	= OrderedHash.new	# String��Agent
-
-      @agents_opt = {}          # ����������Ȥε�ư�����Ѥ��륪�ץ����
-
-      @mynames		= [@nick, @realname].compact.sort.uniq
-      @cachesize	= (hash[:cachesize].to_i < 1) ? 100 : hash[:cachesize].to_i
-      @last_message_id	= 0
-      @messages		= []
-
-      @last_ping_time	= nil   # �Ǹ�� CMD_PING �������ä�����
-    end
-
-    def each_agent
-      @agents.each_pair do |name, agent|
-	yield(agent)
-      end
-    end
-
-    def missing_error (arg)
-      syslog("#{arg}�����ꤵ��Ƥ��ޤ���", :fatal)
-    end
-
-    def syslog (message, level = :normal)
-      line = Time.now.strftime("%Y-%m-%d %H:%M:%S #{message}")
-      case level
-      when :normal
-	if @syslog
-	  File.open!(@syslog, "a+") {|file| file.puts line; file.flush}
-	end
-      when :error
-	syslog(message, :normal)
-	$stderr.puts line
-      when :fatal
-	syslog(message, :error)
-	exit 1
-      else
-	syslog("syslog: wrong level(#{level}): mes=[#{message}]", :error)
-      end
-    end
-
-    def write_pid_file
-      # write pid information to a file
-      filename = config[:pidfile]
-      pid = Process::pid
-      if filename
-	if exist_process?
-	  raise "another process is running. (pid=#{pid})"
-	end
-	File::write!(pid.to_s, filename, 'w+')
-	File::chmod(0664, filename)
-      end
-    end
-
-    def exist_process?
-      filename = config[:pidfile]	or return nil
-      File::exists?(filename)		or return nil
-      pid = File::open(filename).read	or return nil
-
-      begin
-	Process::getpgid(pid.to_i)
-	return pid.chomp
-      rescue Errno::ESRCH
-	return nil
-      end
-    end
-
-    def do_log (message)
-      begin
-	case @log
-	when NilClass
-	  return nil
-	when /\/$/
-	  format = "#{@log}/%Y%m/%d.log"
-	when String
-	  format = @log
-	else
-	  syslog("do_log: unknown type #{@log.class}", :error)
-	  @log = nil
-	  return nil
-	end
-
-	now  = Time.now
-	path = now.strftime(format)
-	from = message[:from]
-	to   = message[:to]
-	str  = message[:str]
-
-	File.open!(path, "a+") {|file|
-	  file.puts now.strftime("%H:%M <#{to}:#{from}> #{str}")
-	}
-	return nil
-      rescue
-	syslog("do_log: #{$!}", :error)
-	@log = nil
-      end
-    end
-
-
-    ######################################################################
-    ### IRC �Υ��ͥ������ط�
-    ######################################################################
-
-    def start
-      write_pid_file
-      syslog("#{self.class}: system starts.")
-
-      create_message_thread
-
-      # ����³�ΰ٤ˡ�initialize ��Ǥʤ������ǸƤӽФ���
-
-      connect
-      join
-
-      # ����������Ȥ���Ͽ
-      @config[:agents].each do |name|
-        registerAgent(name)
-      end
-      each_agent {|agent| agent.start}
-
-      startThreads
-      @message_thread.join
-      @log_thread.raise(Stop.new)
-      @log_thread.join
-
-    rescue Exception => e
-      begin
-        syslog("catch exception: #{e}(#{e.class})", :error)
-        rescue_with_handler(e) or raise
-      rescue Recover => recover
-        irc.stop
-        sleep recover.wait
-        retry
-      end
-    end
-
-    def ping_timeout
-      stop
-      exit
-    end
-
-    def startThreads
-      super
-      @ping_thread = Thread.start {
-        eprintln("ping_thread started.") if $DEBUG
-        #_putlog("debug", "ping_thread started.")
-        sec = 3600 # �����ÿ� PING ���ʤ��� ping_timeout��Ƥ�
-        while true
-          sleep 60
-          case @last_ping_time
-          when Time
-            if Time.now > @last_ping_time + sec
-              ping_timeout
-            end
-          end
-        end
-        eprintln("ping_thread stopped.") if $DEBUG
-        #_putlog("debug", "ping_thread stopped.")
-      }
-      eprintln("ping_thread created.") if $DEBUG
-    end
-
-    # derived from original ruby-irc::Client#stop
-    def stop
-      # Agent�����
-      each_agent do |agent|
-	agent.stop
-      end
-
-      disconnect
-      @message_thread.raise(IRC::Stop.new)
-      destroy_message_thread
-    end
-
-    # derived from original ruby-irc::Client's one.
-    def connect 
-      @log_queue	= Queue.new
-      @connection	= IRC::Connection::new(@log_queue)
-
-      @connection.connect(@server, @port.to_s)
-      @connection.sendPASS(@password)
-      @connection.sendNICK(@nick)
-      @connection.sendUSER(nil, @username, "hostname", "servername", @realname)
-    end
-
-    # derived from original ruby-irc::Client's one.
-    def disconnect 
-      @connection.sendQUIT(@nick, nil)
-      @connection.disconnect
-    end
-
-    def join
-      channels	= @channels.join(',')
-      @connection.send(CMD_JOIN, nil, @nick, channels, '')
-    end
-
-    def names (channel = nil)
-      @connection.sendNAMES(channel)
-    end
-
-    ######################################################################
-    ### Message Handling
-    ######################################################################
-
-    def handlePING(msg)
-#      p [:handlePING, Time.now]
-      super
-      @last_ping_time = Time.now
-    end
-
-    def add_message (msg)
-      index = (@last_message_id += 1) % @cachesize
-      @messages[index] = msg
-
-      return index
-    end
-
-    def previous_message (msg)
-      index = (@cachesize + msg[:id].to_i - 1) % @cachesize
-      @messages[index]
-    end
-
-    def last_messages (size)
-      mes = @messages[@last_message_id % @cachesize] or return []
-      array = []
-      i = 0
-      j = 0
-
-      while (size > 0)
-        j += 1
-        break if i > @cachesize # maybe looping. give up
-        break if j > 100
-        break unless mes
-
-        i += 1
-#        p [mes[:from],mes[:to],mes[:str], size, i, mes[:from] == mes[:to]]
-        unless mes[:from] == mes[:to]
-          array << mes
-          size -= 1
-        end
-        mes = mes.previous
-      end
-      return array
-    end
-
-    # created by yu-yan@4th.to
-    def create_message_thread
-      @message_last   = nil
-      @message_timer  = Time.now
-      @message_queue  = Queue.new
-      @message_thread = Thread.new(@message_timer, @message_queue) { |message_timer, message_queue|
-	loop {
-	  now           = Time.now
-	  message_timer = [message_timer, now].max + 2
-
-	  if (message_timer - now) > 15
-	    sleep(3)
-	  else
-	    sleep(0.1)
-	  end
-
-#	  STDERR.print("timer:#{message_timer.strftime('%H:%M:%S')} - now:#{now.strftime('%H:%M:%S')} = #{message_timer - now}\n")
-
-	  message, to = message_queue.pop
-	  privmsg(message, to)
-#	  STDERR.print("MSG:", message, "\n")
-	}
-      }
-    end
-
-    def destroy_message_thread
-      if @message_thread.is_a? Thread
-	@message_thread.kill
-      end
-    end
-
-    # derived from original ruby-irc::Client's one.
-    def handleMessageLoop 
-      loop do
-        msg = @connection.recv
-        if msg.nil?
-          syslog("handleMessageLoop: Abnormal terminated.", :error)
-	  abnormal_terminated
-        end
-        handleMessageInternal(msg)
-        distributeMessage(msg)
-      end
-    end
-
-    def abnormal_terminated
-      raise IRC::AbnormalTerminated
-    end
-  end
-end