nadoka 0.8.0

data/plugins/gonzuibot.nb

@@ -0,0 +1,41 @@
+# gonzui bot
+#
+
+require 'open-uri'
+require 'uri'
+
+class GonzuiBot < Nadoka::NDK_Bot
+  ResultRegexp = %r(>Results <strong\n>(\d+)</strong\n> - <strong\n>(\d+)</strong\n> of <strong\n>(\d+)</strong)
+
+  def on_privmsg prefix, ch, msg
+    if /\Agonzui(?:\:([\w\-\+]+))?>\s*(.+)/ =~ msg
+      send_notice ch, "gonzui bot: #{gonzui_result($1, $2)}"
+    end
+  end
+
+  EngineURI = {
+    'raa'   => 'http://raa.ruby-lang.org/gonzui/',
+    'gnome' => 'http://gonzui.tagonome.org/',
+    'cpan'  => 'http://cpansearch.bulknews.net/',
+    'b-src' => 'http://b-src.cbrc.jp/',
+  }
+
+  def gonzui_result engine, key
+    engine ||= 'raa'
+    key_uri = URI.encode(key)
+    engine_uri = EngineURI[engine.downcase]
+    return "unknown engine: #{engine}" unless engine_uri 
+
+    url = "#{engine_uri}search?q=#{key_uri}"
+    open(url){|f|
+      result = f.read
+      if ResultRegexp =~ result
+        "#{$3} for #{key} - #{url}"
+      else
+        "#{key} - not found in #{engine}"
+      end
+    }
+    
+  end
+end
+

data/plugins/googlebot.nb

@@ -0,0 +1,345 @@
+# -*-ruby-*-
+#
+# Copyright (c) 2004-2005 SASADA Koichi <ko1 at atdot.net>
+# Copyright (c) 2009, 2010 Kazuhiro NISHIYAMA
+#
+# 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$
+#
+
+=begin
+
+== Usage with irc client
+
+  google> keyword
+    -> search keyword by google with default search langage
+
+  google:[lang]> keyword
+    -> search keyword by google with [lang] langage
+
+  googlec> k1 k2 k3 k4 k5(max 5 words)
+    -> search and show each hit count
+
+  googlec> k1 k2 k3 k4 k5(max 5 words)
+    -> search and show each hit count with default count language
+
+  googlec:[lang]> k1 k2 k3 k4 k5(max 5 words)
+    -> search and show each hit count with [lang] langage
+
+
+== Configuration:
+
+BotConfig = [
+{
+  :name                => :GoogleBot,
+  :ch                  => /.*/,
+  :headers             => {
+    #"User-Agent" => "Ruby/#{RUBY_VERSION}",
+    'Referer' => 'https://github.com/nadoka/nadoka',
+  },
+  # Register URL at http://code.google.com/intl/ja/apis/ajaxsearch/signup.html
+  # and set your URL to :referer and your API key to :api_key if you want.
+  :api_key             => nil,
+  :googlec_maxwords    => 5,
+  :search_default_lang => 'ja',
+  :count_default_lang  => '',
+  :ch_kcode            => :tojis,
+},
+]
+
+=end
+
+
+require 'iconv'
+require 'kconv'
+require 'shellwords'
+require 'cgi'
+require 'open-uri'
+begin
+  require 'json'
+rescue LoadError
+  require 'rubygems'
+  require 'json'
+end
+
+class GoogleBot < Nadoka::NDK_Bot
+  def bot_initialize
+    bot_init_utils
+
+    @search_default_lang = (@bot_config[:search_default_lang] || 'ja').sub(/^lang_/, '')
+    @googlec_maxwords    = @bot_config[:googlec_maxwords] || 5
+    @count_default_lang  = (@bot_config[:count_default_lang] || '').sub(/^lang_/, '')
+    @headers = @bot_config.fetch(:headers, {})
+    @api_key = @bot_config[:api_key]
+    @uri_slog = @bot_config.fetch(:uri_slog, false)
+    @ch_kcode = @bot_config.fetch(:ch_kcode, :tojis)
+  end
+
+  def on_privmsg prefix, ch, msg
+    return unless @available_channel === ch
+    return if same_bot?(ch)
+    if response = dispatch_command(msg)
+      send_notice(ch, response)
+    end
+  end
+
+  SEARCHER = %w!web calc code local video blogs news books images ime imed patent suggest!.freeze
+  SEARCHER_RE = Regexp.new("(?:" + SEARCHER.join('|') + ")").freeze
+
+  def search_searcher key 
+    SEARCHER.each{|searcher|
+      if /\A#{key}/ =~ searcher
+        return searcher
+      end
+    }; nil
+  end
+
+  def dispatch_command msg
+    begin
+      case msg
+      when /^goo(o*)gle( #{SEARCHER_RE})?(:.*?)?>\s*(.+)/o, /^gu(u*)guru(#{SEARCHER_RE})?(:.+)?>\s*(.+)/o
+        "goo#{$1}gle#{$2} bot#{$3}: #{search($1.length, $3, $4, $2)}"
+      when /^googlec( #{SEARCHER_RE})?(:.*?)?>\s*(.+)/o
+        "googlec#{$1} bot#{$2}: #{googlec($1, $3, $2)}"
+      when /^g(\w+)?(:.*?)?>\s*(.+)/
+        searcher = $1 ? search_searcher($1) : 'web'
+        "google #{searcher} bot#{$2}: #{search(0, $2, $3, searcher)}" if searcher
+      end
+    rescue Exception => e
+      @manager.ndk_error e
+      "google bot: #{e.class} (#{e.message} @ #{e.backtrace[0]})"
+    end
+  end
+
+  def do_search word, cnt, lang, searcher='web'
+    i = 0
+    begin
+      uri = "http://ajax.googleapis.com/ajax/services/search/"
+      uri << searcher
+      uri << "?v=1.0&q="
+      uri << CGI.escape(word)
+      if @api_key
+        uri << "&key=#{CGI.escape(@api_key)}"
+      end
+      cnt = cnt.to_i
+      if cnt > 0
+        uri << "&start=#{cnt.to_i}"
+      end
+      if lang
+        uri << "&hl=#{CGI.escape(lang)}"
+        if searcher == 'web'
+          uri << "&lr=lang_#{CGI.escape(lang)}"
+        end
+      end
+      @logger.slog "GoogleBot: #{uri}" if @uri_slog
+
+      result = open(uri, @headers) do |f|
+        JSON.parse(f.read)
+      end
+      def result.estimatedTotalResultsCount
+        self["responseData"]["cursor"]["estimatedResultCount"]
+      end
+      result
+    rescue Exception => e
+      retry if (i+=1) < 5
+      raise
+    end
+  end
+
+  def api_search word, cnt, lang, searcher
+    result = do_search word, cnt, lang, searcher
+
+    count = result.estimatedTotalResultsCount.to_i
+
+    if count > 0
+      count = count.to_s.gsub(/(\d)(?=\d{3}+$)/, '\\1,')
+      url = title = ''
+
+      e = result["responseData"]["results"][0]
+      url   = e['unescapedUrl'] || e['url'] || e['postUrl']
+      title = show_char_code_and_erase_tag(e['titleNoFormatting'])
+      "#{title} - #{url} (and #{count} hit#{(count.to_i > 1) ? 's' : ''})"
+    else
+      "no match"
+    end
+  end
+
+  def google_calc exp
+    @logger.slog("google_calc<#{exp.dump}")
+    uri = "http://www.google.co.jp/search?ie=UTF8&oe=UTF-8&q=#{CGI.escape(exp)}"
+    html = open(uri, @headers) do |f|
+      f.read
+    end
+    if /class=r [^<>]+><b>(.+?)<\/b>/u =~ html
+      result = $1
+      # @logger.slog("google_calc>#{result.dump}")
+      result.gsub!(/<sup>(.+?)<\/sup>/u) { "^(#{$1})" }
+      result.gsub!(/<.+?>/u, '')
+      result.gsub!(/&\#215;/u, "\303\227")
+      result.send(@ch_kcode) # NKF.nkf('-j', result)
+    else
+      "response error"
+    end
+  rescue Exception
+    $!.to_s
+  end
+
+  def google_suggest(word, lang)
+    uri = "http://suggestqueries.google.com/complete/search?output=firefox"
+    uri << "&q="
+    uri << CGI.escape(word)
+    if lang
+      uri << "&hl=#{CGI.escape(lang)}"
+    end
+    @logger.slog "GoogleBot: #{uri}" if @uri_slog
+
+    result = open(uri, @headers) do |f|
+      JSON.parse(f.read)
+    end
+    result[1].join(", ").send(@ch_kcode)
+  end
+
+  def google_code key
+    return "http://google.com/codesearch#search/&q=#{CGI.escape(key)}&ct=os"
+  end
+
+  if defined?(URI.encode_www_form)
+    def encode_www_form(enum)
+      URI.encode_www_form(enum)
+    end
+  else
+    def encode_www_form(enum)
+      enum.map do |k, v|
+        "#{URI.encode(k)}=#{URI.encode(v)}"
+      end.join('&')
+    end
+  end
+
+  # see http://www.google.com/intl/ja/ime/cgiapi.html
+  def google_ime text, d=false
+    url = 'http://www.google.com/transliterate?'
+    url << encode_www_form('langpair' => 'ja-Hira|ja', 'text' => text)
+    data = open(url,@headers){|f|
+      # TODO: gsub fix invalid JSON, should remove after fix response
+      # see http://www.google.com/support/forum/p/ime/thread?tid=06501c8b7a16add3&hl=ja
+      JSON.parse(f.read.gsub(/,(?=\n\])/,''))
+    }
+    if d
+      result = data.map do |org, candidates|
+        "#{org}=#{candidates.join('/')}"
+      end.join(' ')
+    else
+      result = data.map do |org, candidates|
+        candidates[0]
+      end.join('')
+    end
+    show_char_code_and_erase_tag(result)
+  rescue Exception
+    $!.to_s[/.+/] # first line
+  end
+
+  def search cnt, lang, word, searcher=nil
+    lang = lang_check(lang)
+    searcher = searcher_check(searcher)
+    word = search_char_code(word)
+
+    case searcher
+    when 'code'
+      google_code word
+    when 'calc'
+      google_calc word
+    when 'ime'
+      google_ime word
+    when 'imed'
+      google_ime word, true
+    when 'suggest'
+      google_suggest word, lang
+    else
+      api_search word, cnt, lang, searcher
+    end
+ end
+
+  def googlec lang, word, searcher=nil
+    lang = lang_check(lang, @count_default_lang)
+    searcher = searcher_check(searcher)
+    words = Shellwords.shellwords(word).map{|e| "\"#{e}\""}
+    return 'too many options' if words.size > @googlec_maxwords
+
+    words.map{|rw|
+      w = search_char_code(rw)
+      result = do_search "'#{w}'", 0, lang, searcher
+      "#{rw}(#{result.estimatedTotalResultsCount.to_s.gsub(/(\d)(?=\d{3}+$)/, '\\1,')})"
+    }.join(', ')
+  end
+
+  def erase_tag str
+    CGI.unescapeHTML(str.gsub(/\<.+?\>/, ''))
+  end
+
+  def lang_check lang, default = @search_default_lang
+    if !lang
+      @search_default_lang
+    else
+      lang = lang[1..-1]
+      if lang.empty?
+        nil
+      elsif /^lang_/ =~ lang
+        lang.sub(/^lang_/, '')
+      else
+        lang
+      end
+    end
+  end
+
+  def searcher_check searcher
+    if !searcher
+      'web'
+    else
+      searcher = searcher.strip
+      if SEARCHER.include?(searcher)
+        searcher
+      else
+        'web'
+      end
+    end
+  end
+
+  def show_char_code_and_erase_tag str
+    return CGI.unescapeHTML(erase_tag(str.toeuc)).send(@ch_kcode)
+
+    case $KCODE
+    when 'EUC', 'SJIS'
+      CGI.unescapeHTML(str.gsub(/\<.+?\>/, '')).send(@ch_kcode)
+    when 'NONE', 'UTF-8'
+      begin
+        str = Iconv.conv("EUC-JP", "UTF-8", str)
+        CGI.unescapeHTML(str.gsub(/\<.+?\>/, '')).send(@ch_kcode)
+      rescue => e
+        "(char code problem: #{e.class}[#{e.message.dump}])"
+      end
+    else
+      str
+    end
+  end
+
+  def search_char_code str
+    case $KCODE
+    when 'EUC', 'SJIS'
+      str.toeuc
+    when 'NONE'
+      begin
+        Iconv.conv("UTF-8", "EUC-JP", str.toeuc)
+      rescue => e
+        raise "(char code problem: #{e.class})"
+      end
+    when 'UTF-8'
+      str
+    else
+      raise
+    end
+  end
+end

data/plugins/identifynickserv.nb

@@ -0,0 +1,43 @@
+# -*-ruby-*-
+#
+# Copyright (c) 2009 Kazuhiro NISHIYAMA
+#
+# 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.
+#
+
+=begin
+
+== Abstract
+
+send IDENTIFY to NickServ.
+
+== Configuration
+
+  BotConfig << {
+    :name => :IdentifyNickServ,
+    #:nickserv => "NickServ",
+    :nick => "nadoka",
+    :pass => "hoge",
+  }
+
+=end
+
+class IdentifyNickServ < Nadoka::NDK_Bot
+  def bot_initialize
+    @nickserv = @bot_config.fetch(:nickserv, "NickServ")
+    @nick = @bot_config.fetch(:nick, false)
+    @pass  = @bot_config.fetch(:pass, false)
+  end
+
+  def on_server_connected(*args)
+    if @pass
+      if @nick
+        send_privmsg @nickserv, "IDENTIFY #{@nick} #{@pass}"
+      else
+        send_privmsg @nickserv, "IDENTIFY #{@pass}"
+      end
+    end
+  end
+end

data/plugins/marldiabot.nb

@@ -0,0 +1,99 @@
+# -*-ruby-*-
+require 'cgi'
+require 'net/http'
+require 'rexml/document'
+require 'uri'
+require 'time'
+require 'json'
+
+class MarldiaBot < Nadoka::NDK_Bot
+  def bot_initialize
+    @chats      = @bot_config.fetch(:chats,      nil)
+    @proxy_addr = @bot_config.fetch(:proxy_addr, nil)
+    @proxy_port = @bot_config.fetch(:proxy_port, 80)
+
+    @chs = @chats.keys
+    @chats.each_value do |chat|
+      chat[:uri] = URI(chat[:url])
+      chat[:query] = 'type=xml&' + chat[:data].
+        map{|k,v|"#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"}.join('&')
+      req = Net::HTTP::Get.new(chat[:uri].path+ '?' + chat[:query])
+      chat[:req] = req
+    end
+  end
+
+  def bot_state
+    "<#{self.class.to_s}>"
+  end
+
+  def slog(msg, nostamp = false)
+    current_method = caller.first[/:in \`(.*?)\'/, 1].to_s
+    msg.each_line do |line|
+      @logger.slog "#{self.class.to_s}##{current_method} #{line}", nostamp
+    end
+  end
+
+  def on_timer(t)
+    @chats.each_pair do |ch, chat|
+      uri = chat[:uri]
+      current_id = chat[:current_id]
+      body = nil
+      messages = []
+      Net::HTTP::Proxy(@proxy_addr, @proxy_port).start(uri.host, uri.port) do |http|
+        body = http.request(chat[:req]).body
+      end
+      doc = REXML::Document.new(body)
+      doc.each_element('feed/entry/log/article') do |art|
+        id = art.text('id')
+        break if current_id == id
+        time = Time.parse(art.text('updated'))
+        next if time + 10 * 60 < Time.now
+        user = art.text('author/name')
+        text = CGI.unescapeHTML(art.text('body')).gsub(/\n|<.*?>/," ")
+        text = text[/^[\w\W]{0,100}/u]
+        text.gsub!(/([\w\W])/u){|c|c == "\xA0" ? " " : c}
+        messages << "#{time.strftime('%H:%M')} #{user}: #{text}"
+      end
+      messages.reverse_each do |message|
+        send_notice ch, message
+        sleep 0.5
+      end
+      chat[:current_id] = doc.text('/feed/entry/log/article/id')
+    end
+  rescue Errno::ETIMEDOUT, Timeout::Error, SocketError
+  rescue Errno::ECONNRESET => err
+    slog "%s: %s (%s)" % [err.backtrace[0], err.message, err.class]
+  rescue Exception => err
+    detail = ("%s: %s (%s)\n" % [err.backtrace[0], err.message, err.class]) + err.backtrace[1..-1].join("\n")
+    slog "Exception\n#{detail}"
+  end
+
+  def send_marldia(ch, message)
+    chat = @chats[ch]
+    uri = chat[:uri]
+    req = Net::HTTP::Post.new(uri.path)
+    req.body = chat[:query] + '&type=xml&body=' + CGI.escape(message)
+
+    Net::HTTP::Proxy(@proxy_addr, @proxy_port).start(uri.host, uri.port) {|http|
+      http.read_timeout = @timeout
+      res = http.request(req)
+      @logger.dlog res.code
+    }
+    return true
+  rescue Errno::ECONNRESET => err
+    slog "%s: %s (%s)" % [err.backtrace[0], err.message, err.class]
+  rescue Exception => err
+    detail = ("%s: %s (%s)\n" % [err.backtrace[0], err.message, err.class]) +
+      err.backtrace[1..-1].join("\n")
+    slog "Exception\n#{detail}"
+    return false
+  end
+
+  def on_client_privmsg(client, ch, message)
+    ch.downcase!
+    return unless @chs.include?(ch)
+    msg = send_marldia(ch, message) ? 'sent to marldia: ' : 'marldia send faild: '
+    msg << message
+    slog msg
+  end
+end