nadoka 0.8.0

data/ndk/client.rb

@@ -0,0 +1,288 @@
+#
+# Copyright (c) 2004-2005 SASADA Koichi <ko1 at atdot.net>
+#
+# This program is free software with ABSOLUTELY NO WARRANTY.
+# You can re-distribute and/or modify this program under
+# the same terms of the Ruby's license.
+#
+#
+# $Id$
+# Create : K.S. 04/04/17 16:50:10
+#
+
+require 'thread'
+
+module Nadoka
+  class NDK_Client
+    def initialize config, sock, manager
+      @sock   = sock
+
+      @config = config
+      @logger = config.logger
+      @manager= manager
+      @state  = manager.state
+
+      @queue  = Queue.new
+      @remote_host = @sock.peeraddr[2]
+      @thread = Thread.current
+      @connected = false
+
+      # client information
+      @realname = nil
+      @hostname = nil
+    end
+
+    attr_writer :logger
+    attr_reader :remote_host
+
+    def start
+      send_thread = Thread.new{
+        begin
+          while q = @queue.pop
+            begin
+              send_to_client q
+            end
+          end
+        rescue Exception => e
+          @manager.ndk_error e
+        end
+      }
+      begin
+        if login
+          @connected = true
+          begin
+            @manager.invoke_event :leave_away, @manager.client_count
+            @manager.invoke_event :invoke_bot, :client_login, @manager.client_count, self
+            while msg = recv_from_client
+              send_from_client msg, self
+            end
+          rescue NDK_QuitClient
+            # finish
+          ensure
+            @manager.invoke_event :invoke_bot, :client_logout, @manager.client_count, self
+          end
+        end
+      rescue Exception
+        @manager.ndk_error $!
+      ensure
+        @logger.slog "Client #{@realname}@#{@remote_host} disconnected."
+        @sock.close
+        send_thread.kill if send_thread && send_thread.alive?
+      end
+    end
+    
+    def kill
+      @thread && @thread.kill
+    end
+    
+    def recv_from_client
+      while !@sock.closed?
+        begin
+          str = @sock.gets
+          if str
+            msg = ::RICE::Message::parse str
+            
+            case msg.command
+            when 'PING'
+              send_msg Cmd.pong(*msg.params[0]), false
+            when 'PONG'
+              # ignore
+            else
+              @logger.dlog "[C>] #{str}"
+              return msg
+            end
+          else
+            break
+          end
+        rescue ::RICE::UnknownCommand, ::RICE::InvalidMessage
+          @logger.slog "Invalid Message: #{str}"
+        rescue Exception => e
+          @manager.ndk_error e
+          break
+        end
+      end
+    end
+    
+    def push msg
+      if @connected
+        @queue << msg
+      end
+    end
+    alias << push
+    
+    def login
+      pass = nil
+      nick = nil
+      @username = nil
+      
+      while (nick == nil) || (@username == nil)
+        msg = recv_from_client
+        return nil if msg == nil
+        
+        case msg.command
+        when 'USER'
+          @username, @hostname, @servername, @realname = msg.params
+        when 'NICK'
+          nick = msg.params[0]
+        when 'PASS'
+          pass = msg.params[0]
+        else
+          raise "Illegal login sequence: #{msg}"
+        end
+      end
+      
+      if @config.client_server_pass && (@config.client_server_pass != pass)
+        send_reply Rpl.err_passwdmismatch(nick, "Password Incorrect.")
+        return false
+      end
+      
+      send_reply Rpl.rpl_welcome( nick,
+        'Welcome to the Internet Relay Network '+"#{nick}!#{@username}@#{@remote_host}")
+      send_reply Rpl.rpl_yourhost(nick, "Your host is nadoka, running version #{NDK_Version}")
+      send_reply Rpl.rpl_created( nick, 'This server was created ' + NDK_Created.asctime)
+      send_reply Rpl.rpl_myinfo(  nick, "nadoka #{NDK_Version} aoOirw abeiIklmnoOpqrstv")
+
+      send_motd(nick)
+      
+      send_command Cmd.nick(@state.nick), nick
+      nick = @manager.state.nick
+
+      @manager.state.current_channels.each{|ch, chs|
+        send_command Cmd.join(chs.name)
+        if chs.topic
+          send_reply Rpl.rpl_topic(@state.nick, chs.name, chs.topic)
+        else
+          send_reply Rpl.rpl_notopic(@state.nick, chs.name, "No topic is set.")
+        end
+        send_reply Rpl.rpl_namreply(  @state.nick, chs.state, chs.name, chs.names.join(' '))
+        send_reply Rpl.rpl_endofnames(@state.nick, chs.name, "End of NAMES list.")
+      }
+
+      @logger.slog "Client #{@realname}@#{@remote_host} connected."
+      true
+    end
+    
+    def send_motd nick
+      send_reply Rpl.rpl_motdstart(nick, "- Nadoka Message of the Day - ")
+      send_reply Rpl.rpl_motd(nick, "- Enjoy IRC chat with Nadoka chan!")
+      send_reply Rpl.rpl_motd(nick, "- ")
+      send_reply Rpl.rpl_endofmotd(nick, "End of MOTD command.")
+    end
+    
+    # :who!~username@host CMD ..
+    def send_command cmd, nick = @manager.state.nick
+      msg = add_prefix(cmd, "#{nick}!#{@username}@#{@remote_host}")
+      send_msg msg
+    end
+
+    # :serverinfo REPL ...
+    def send_reply repl
+      msg = add_prefix(repl, @config.nadoka_server_name)
+      send_msg msg
+    end
+
+    def send_msg msg, logging=true
+      @logger.dlog "[C<] #{msg}" if logging
+      unless @sock.closed?
+        begin
+          @sock.write msg.to_s
+        rescue Exception => e
+          @manager.ndk_error e
+        end
+      end
+    end
+    
+    def send_to_client msg
+      if /^\d+/ =~ msg.command
+        send_reply msg
+      else
+        send_msg msg
+      end
+    end
+    
+    def add_prefix cmd, prefix = "#{@manager.state.nick}!#{@username}@#{@remote_host}"
+      cmd.prefix = prefix
+      cmd
+    end
+    
+    def add_prefix2 cmd, nick
+      cmd.prefix = "#{nick}!#{@username}@#{@remote_host}"
+      cmd
+    end
+    
+
+    ::RICE::Command.regist_command('NADOKA')
+    
+    # client -> server handling
+    def send_from_client msg, from
+      until @manager.connected
+        # ignore
+        return
+      end
+      
+      case msg.command
+      when 'NADOKA'
+        nadoka_client_command msg.params[0], msg.params[1..-1]
+        return
+      when 'QUIT'
+        raise NDK_QuitClient
+      when 'PRIVMSG', 'NOTICE'
+        if /^\/nadoka/ =~ msg.params[1]
+          _, cmd, *args = msg.params[1].split(/\s+/)
+          nadoka_client_command cmd, args
+          return
+        end
+        if @manager.send_to_bot(:client_privmsg, self, msg.params[0], msg.params[1])
+          @manager.send_to_server msg
+          @manager.send_to_clients_otherwise msg, from
+        end
+      else
+        @manager.send_to_server msg
+      end
+    end
+
+    def client_notice msg
+      self << Cmd.notice(@state.nick, msg)
+    end
+
+    def state
+      "client from #{@remote_host}(#{@username}, #{@hostname}, #{@servername}, #{@realname})"
+    end
+    
+    NdkCommandDescription = {
+      #
+      'QUIT'    => 'quite nadoka program',
+      'RESTART' => 'restart nadoka program(not relaod *.rb programs)',
+      'RELOAD'  => 'reload configurations and bot programs(*.nb)',
+      'RECONNECT' => 'reconnect next server',
+      'STATUS'  => 'show nadoka running status',
+    }
+    def nadoka_client_command cmd, args
+      cmd ||= ''
+      case cmd.upcase
+      when 'QUIT'
+        @manager.invoke_event :quit_program
+        client_notice 'nadoka will be quit. bye!'
+      when 'RESTART'
+        @manager.invoke_event :restart_program, self
+        client_notice 'nadoka will be restart. see you later.'
+      when 'RELOAD'
+        @manager.invoke_event :reload_config, self
+      when 'RECONNECT'
+        @manager.invoke_event :reconnect_to_server, self
+      when 'STATUS'
+        @manager.ndk_status.each{|msg| client_notice msg}
+      when 'HELP'
+        self << Cmd.notice(@state.nick, 'available: ' + NdkCommandDescription.keys.join(', '))
+        if args[1]
+          self << Cmd.notice(@state.nick, "#{args[1]}: #{NdkCommandDescription[args[1].upcase]}")
+        end
+      else
+        if @manager.send_to_bot :nadoka_command, self, cmd, *args
+          self << Cmd.notice(@state.nick, 'No such command. Use /NADOKA HELP.')
+        end
+      end
+    end
+  end
+end
+

data/ndk/config.rb

@@ -0,0 +1,571 @@
+#
+# Copyright (c) 2004-2005 SASADA Koichi <ko1 at atdot.net>
+#
+# This program is free software with ABSOLUTELY NO WARRANTY.
+# You can re-distribute and/or modify this program under
+# the same terms of the Ruby's license.
+#
+#
+# $Id$
+# Create : K.S. 04/04/17 16:50:33
+#
+#
+# You can check RCFILE with following command:
+#
+#   ruby ndk_config.rb [RCFILE]
+#
+
+require 'uri'
+require 'socket'
+require 'kconv'
+
+require 'ndk/logger'
+
+module Nadoka
+  
+  class NDK_ConfigBase
+    # system
+    # 0: quiet, 1: normal, 2: system, 3: debug
+    Loglevel     = 2
+    Setting_name = nil
+    
+    # client server
+    Client_server_port = 6667 # or nil (no listen)
+    Client_server_host = nil
+    Client_server_pass = 'NadokaPassWord' # or nil
+    Client_server_acl  = nil
+    ACL_Object = nil
+    
+    # 
+    Server_list = [
+    # { :host => '127.0.0.1', :port => 6667, :pass => nil }
+    ]
+    Servers = []
+
+    Reconnect_delay    = 150
+    
+    Default_channels   = []
+    Login_channels     = []
+
+    #
+    User       = ENV['USER'] || ENV['USERNAME'] || 'nadokatest'
+    Nick       = 'ndkusr'
+    Hostname   = Socket.gethostname
+    Servername = '*'
+    Realname   = 'nadoka user'
+    Mode       = nil
+    
+    Away_Message = 'away'
+    Away_Nick    = nil
+
+    Quit_Message = "Quit Nadoka #{::Nadoka::NDK_Version} - http://www.atdot.net/nadoka/"
+    
+    #
+    Channel_info = {}
+    # log
+    
+    Default_log = {
+      :file           => '${setting_name}-${channel_name}/%y%m%d.log',
+      :time_format    => '%H:%M:%S',
+      :message_format => {
+        'PRIVMSG' => '<{nick}> {msg}',
+        'NOTICE'  => '{{nick}} {msg}',
+        'JOIN'    => '+ {nick} ({prefix:user}@{prefix:host})',
+        'NICK'    => '* {nick} -> {newnick}',
+        'QUIT'    => '- {nick} (QUIT: {msg}) ({prefix:user}@{prefix:host})',
+        'PART'    => '- {nick} (PART: {msg}) ({prefix:user}@{prefix:host})',
+        'KICK'    => '- {nick} kicked by {kicker} ({msg})',
+        'MODE'    => '* {nick} changed mode ({msg})',
+        'TOPIC'   => '<{ch} TOPIC> {msg} (by {nick})',
+        'SYSTEM'  => '[NDK] {orig}',
+        'OTHER'   => '{orig}',
+        'SIMPLE'  => '{orig}',
+      },
+    }
+
+    System_log = {
+      :file           => '${setting_name}-system.log',
+      :time_format    => '%y/%m/%d-%H:%M:%S',
+      :message_format => {
+        'PRIVMSG' => '{ch} <{nick}> {msg}',
+        'NOTICE'  => '{ch} {{nick}} {msg}',
+        'JOIN'    => '{ch} + {nick} ({prefix:user}@{prefix:host})',
+        'NICK'    => '{ch} * {nick} -> {newnick}',
+        'QUIT'    => '{ch} - {nick} (QUIT: {msg}) ({prefix:user}@{prefix:host})',
+        'PART'    => '{ch} - {nick} (PART: {msg}) ({prefix:user}@{prefix:host})',
+        'KICK'    => '{ch} - {nick} kicked by {kicker} ({msg})',
+        'MODE'    => '{ch} * {nick} changed mode ({msg})',
+        'TOPIC'   => '{ch} <{ch} TOPIC> {msg} (by {nick})',
+        'SYSTEM'  => '[NDK] {orig}',
+        'OTHER'   => nil,
+        'SIMPLE'  => nil,
+      },
+    }
+
+    Debug_log = {
+      :io             => $stdout,
+      :time_format    => '%y/%m/%d-%H:%M:%S',
+      :message_format => System_log[:message_format],
+    }
+
+    Talk_log = {
+      :file           => '${setting_name}-talk/%y%m%d.log',
+      :time_format    => Default_log[:time_format],
+      :message_format => {
+        'PRIVMSG' => '[{sender} => {receiver}] {msg}',
+        'NOTICE'  => '{{sender} -> {receiver}} {msg}',
+      }
+    }
+
+    System_Logwriter  = nil
+    Debug_Logwriter   = nil
+    Default_Logwriter = nil
+    Talk_Logwriter    = nil
+
+    BackLog_Lines     = 20
+
+    # file name encoding setting
+    # 'euc' or 'sjis' or 'jis' or 'utf8'
+    FilenameEncoding =
+      case RUBY_PLATFORM
+      when /mswin/, /cygwin/, /mingw/
+        'sjis'
+      else
+        if /UTF-?8/i =~ ENV['LANG']
+          'utf8'
+        else
+          'euc'
+        end
+      end
+    
+    # dirs
+    Default_Plugins_dir = File.expand_path('../../plugins', __FILE__)
+    Plugins_dir = './plugins'
+    Log_dir     = './log'
+    
+    # bots
+    BotConfig   = []
+
+    # filters
+    Privmsg_Filter = []
+    Notice_Filter  = []
+    Primitive_Filters = {}
+
+    # ...
+    Privmsg_Filter_light = []
+    Nadoka_server_name   = 'NadokaProgram'
+    
+    def self.inherited subklass
+      ConfigClass << subklass
+    end
+  end
+  ConfigClass = [NDK_ConfigBase]
+  
+  class NDK_Config
+    NDK_ConfigBase.constants.each{|e|
+      eval %Q{
+        def #{e.downcase}
+          @config['#{e.downcase}'.intern]
+        end
+      }
+    }
+    
+    def initialize manager, rcfile = nil
+      @manager = manager
+      @bots = []
+      load_config(rcfile || './nadokarc')
+    end
+    attr_reader :config, :bots, :logger
+
+    def remove_previous_setting
+      # remove setting class
+      klass = ConfigClass.shift
+      while k = ConfigClass.shift
+        Object.module_eval{
+          remove_const(k.name)
+        }
+      end
+      ConfigClass.push(klass)
+
+
+      # clear required files
+      RequiredFiles.replace []
+
+      # remove current NadokaBot
+      Object.module_eval %q{
+        remove_const :NadokaBot
+        module NadokaBot
+          def self.included mod
+            Nadoka::NDK_Config::BotClasses['::' + mod.name.downcase] = mod
+          end
+        end
+      }
+      
+      # clear bot class
+      BotClasses.each{|k, v|
+        Object.module_eval{
+          if /\:\:/ !~ k.to_s && const_defined?(v.name)
+            remove_const(v.name)
+          end
+        }
+      }
+      BotClasses.clear
+      
+      # destruct bot instances
+      @bots.each{|bot|
+        bot.bot_destruct
+      }
+      @bots = []
+
+      GC.start
+    end
+
+    def load_bots
+      # for compatibility
+      return load_bots_old if @config[:botconfig].kind_of? Hash
+      @bots = @config[:botconfig].map{|bot|
+        if bot.kind_of? Hash
+          next nil if bot[:disable]
+          name = bot[:name]
+          cfg  = bot
+          raise "No bot name specified. Check rcfile." unless name
+        else
+          name = bot
+          cfg  = nil
+        end
+        load_botfile name.to_s.downcase
+        make_bot_instance name, cfg
+      }.compact
+    end
+
+    # for compatibility
+    def load_bots_old
+      (@config[:botfiles] + (@config[:defaultbotfiles]||[])).each{|file|
+        load_botfile file
+      }
+      
+      @config[:botconfig].keys.each{|bk|
+        bkn = bk.to_s
+        bkni= bkn.intern
+        
+        unless BotClasses.any?{|n, c| n == bkni}
+          if @config[:botfiles]
+            raise "No such BotClass: #{bkn}"
+          else
+            load_botfile "#{bkn.downcase}.nb"
+          end
+        end
+      }
+      
+      @bots = BotClasses.map{|bkname, bk|
+        if @config[:botconfig].has_key? bkname
+          if (cfg = @config[:botconfig][bkname]).kind_of? Array
+            cfg.map{|c|
+              make_bot_instance bk, c
+            }
+          else
+            make_bot_instance bk, cfg
+          end
+        else
+          make_bot_instance bk, nil
+        end
+      }.flatten
+    end
+
+    def server_setting
+      if svrs = @config[:servers]
+        svl = []
+        svrs.each{|si|
+          ports = si[:port] || 6667
+          host  = si[:host]
+          pass  = si[:pass]
+          ssl_params  = si[:ssl_params]
+          if ports.respond_to? :each
+            ports.each{|port|
+              svl << {:host => host, :port => port,  :pass => pass, :ssl_params => ssl_params}
+            }
+          else
+            svl <<   {:host => host, :port => ports, :pass => pass, :ssl_params => ssl_params}
+          end
+        }
+        @config[:server_list] = svl
+      end
+    end
+
+    def make_logwriter log
+      return unless log
+      
+      case log
+      when Hash
+        if    log.has_key?(:logwriter)
+          return log[:logwriter]
+        elsif log.has_key?(:logwriterclass)
+          klass = log[:logwriterclass]
+        elsif log.has_key?(:io)
+          klass = IOLogWriter
+        elsif log.has_key?(:file)
+          klass = FileLogWriter
+        else
+          klass = FileLogWriter
+        end
+        opts = @config[:default_log].merge(log)
+        klass.new(self, opts)
+        
+      when String
+        opts = @config[:default_log].dup
+        opts[:file] = log
+        FileLogWriter.new(self, opts)
+        
+      when IO
+        opts = @config[:default_log].dup
+        opts[:io] = log
+        IOLogWriter.new(self, opts)
+        
+      else
+        raise "Unknown LogWriter setting"
+      end
+    end
+
+    def make_default_logwriter
+      if @config[:default_log].kind_of? Hash
+        dl = @config[:default_log]
+      else
+        # defult_log must be Hash
+        dl = @config[:default_log]
+        @config[:default_log] = NDK_ConfigBase::Default_log.dup
+      end
+      
+      @config[:default_logwriter] ||= make_logwriter(dl)
+      @config[:system_logwriter]  ||= make_logwriter(@config[:system_log])
+      @config[:debug_logwriter]   ||= make_logwriter(@config[:debug_log])
+      @config[:talk_logwriter]    ||= make_logwriter(@config[:talk_log])
+    end
+    
+    def channel_setting
+      # treat with channel information
+      if chs = @config[:channel_info]
+        dchs = []
+        lchs = []
+        cchs = {}
+        
+        chs.each{|ch, setting|
+          ch = identical_channel_name(ch)
+          setting = {} unless setting.kind_of?(Hash)
+          
+          if !setting[:timing] || setting[:timing] == :startup
+            dchs << ch
+          elsif setting[:timing] == :login
+            lchs << ch
+          end
+
+          # log writer
+          setting[:logwriter] ||= make_logwriter(setting[:log]) || @config[:default_logwriter]
+          
+          cchs[ch] = setting
+        }
+        chs.replace cchs
+        @config[:default_channels] = dchs
+        @config[:login_channels]   = lchs
+      end
+    end
+
+    def acl_setting
+      if @config[:client_server_acl] && !@config[:acl_object]
+        require 'drb/acl'
+        
+        acl = @config[:client_server_acl].strip.split(/\s+/)
+        @config[:acl_object] = ACL.new(acl)
+        @logger.slog "ACL: #{acl.join(' ')}"
+      end
+    end
+
+    def load_config(rcfile)
+      load(rcfile) if rcfile
+      
+      @config = {}
+      klass = ConfigClass.last
+
+      klass.ancestors[0..-3].reverse_each{|kl|
+        kl.constants.each{|e|
+          @config[e.downcase.intern] = klass.const_get(e)
+        }
+      }
+      
+      @config[:setting_name] ||= File.basename(@manager.rc).sub(/\.?rc$/, '')
+
+      if $NDK_Debug
+        @config[:loglevel] = 3
+      end
+      
+      make_default_logwriter
+      @logger = NDK_Logger.new(@manager, self)
+      @logger.slog "load config: #{rcfile}"
+
+      server_setting
+      channel_setting
+      acl_setting
+      load_bots
+    end
+
+    def ch_config ch, key
+      channel_info[ch] && channel_info[ch][key]
+    end
+    
+    def canonical_channel_name ch
+      ch = ch.sub(/^\!.{5}/, '!')
+      identical_channel_name ch
+    end
+
+    def identical_channel_name ch
+      # use 4 gsub() because of the compatibility of RFC2813(3.2)
+      ch.toeuc.downcase.tr('[]\\~', '{}|^').tojis.force_encoding('ASCII-8BIT')
+    end
+
+    RName = {        # ('&','#','+','!')
+      '#' => 'CS-',
+      '&' => 'CA-',
+      '+' => 'CP-',
+      '!' => 'CE-',
+    }
+    
+    def make_logfilename tmpl, rch, cn
+      unless cn
+        cn = rch.sub(/^\!.{5}/, '!')
+
+        case @config[:filenameencoding].to_s.downcase[0]
+        when ?e # EUC
+          cn = cn.toeuc.downcase
+        when ?s # SJIS
+          cn = cn.tosjis.downcase
+        when ?u # utf-8
+          cn = cn.toutf8.downcase
+        else    # JIS
+          cn = cn.toeuc.downcase.tojis
+          cn = URI.encode(cn)
+        end
+
+        # escape
+        cn = cn.sub(/^[\&\#\+\!]|/){|c|
+          RName[c]
+        }
+        cn = cn.tr("*:/", "__I")
+      end
+
+      # format
+      str = Time.now.strftime(tmpl)
+      str.gsub(/\$\{setting_name\}/, setting_name).
+          gsub(/\$\{channel_name\}|\{ch\}/, cn)
+    end
+
+    def log_format timefmt, msgfmts, msgobj
+      text = log_format_message(msgfmts, msgobj)
+      
+      if timefmt && !msgobj[:nostamp]
+        text = "#{msgobj[:time].strftime(timefmt)} #{text}"
+      end
+      
+      text
+    end
+
+    def log_format_message msgfmts, msgobj
+      type   = msgobj[:type]
+      format = msgfmts.fetch(type, @config[:default_log][:message_format][type])
+
+      if format.kind_of? Proc
+        text = format.call(params)
+      elsif format
+        text = format.gsub(/\{([a-z]+)\}|\{prefix\:([a-z]+)\}/){|key|
+          if $2
+            method = $2.intern
+            if msgobj[:orig].respond_to?(:prefix)
+              (msgobj[:orig].prefix || '') =~ /^(.+?)\!(.+?)@(.+)/
+              case method
+              when :nick
+                $1
+              when :user
+                $2
+              when :host
+                $3
+              else
+                "!!unknown prefix attribute: #{method}!!"
+              end
+            end
+          else
+            if m = msgobj[$1.intern]
+              m
+            else
+              "!!unknown attribute: #{$1}!!"
+            end
+          end
+        }
+      else
+        text = msgobj[:orig].to_s
+      end
+    end
+
+    def make_bot_instance bk, cfg
+      bk = BotClasses[bk.to_s.downcase.intern] unless bk.kind_of? Class
+      bot = bk.new @manager, self, cfg || {}
+      @logger.slog "bot instance: #{bot.bot_state}"
+      bot
+    end
+
+    def load_botfile file
+      loaded = false
+      
+      if @config[:plugins_dir].respond_to? :each
+        @config[:plugins_dir].each{|dir|
+          if load_file File.expand_path("#{file}.nb", dir)
+            loaded = true
+            break
+          end
+        }
+      else
+        loaded = load_file File.expand_path("#{file}.nb", @config[:plugins_dir])
+      end
+
+      unless loaded
+        raise "No such bot file: #{file}"
+      end
+    end
+
+    def load_file file
+      if FileTest.exist? file
+        Nadoka.require_bot file
+        true
+      else
+        false
+      end
+    end
+    
+    RequiredFiles       = []
+    BotClasses          = {}
+  end
+
+  def self.require_bot file
+    return if NDK_Config::RequiredFiles.include? file
+    
+    NDK_Config::RequiredFiles.push file
+    begin
+      ret = ::Kernel.load(file)
+    rescue
+      NDK_Config::RequiredFiles.pop
+      raise
+    end
+    ret
+  end
+end
+
+module NadokaBot
+  # empty module for bot namespace
+  # this module is reloadable
+  def self.included mod
+    Nadoka::NDK_Config::BotClasses['::' + mod.name.downcase] = mod
+  end
+end
+
+if $0 == __FILE__
+  require 'pp'
+  pp Nadoka::NDK_Config.new(nil, ARGV.shift)
+end
+