ircbot 0.1.5 → 0.2.0

data/lib/ircbot/utils/html_parser.rb

@@ -0,0 +1,26 @@
+require 'cgi'
+
+module Ircbot
+  module Utils
+    module HtmlParser
+      def get_title(html)
+        title = $1.strip if %r{<title>(.*?)</title>}mi =~ html
+        title ? trim_tags(title) : ""
+      end
+
+      def trim_tags(html)
+        html.gsub!(%r{<head.*?>.*?</head>}mi, '')
+        html.gsub!(%r{<script.*?>.*?</script>}mi, '')
+        html.gsub!(%r{<style.*?>.*?</style>}mi, '')
+        html.gsub!(%r{<noscript.*?>.*?</noscript>}mi, '')
+        html.gsub!(%r{</?.*?>}, '')
+        html.gsub!(%r{<\!--.*?-->}mi, '')
+        html.gsub!(%r{<\!\w.*?>}mi, '')
+        html.gsub!(/\s+/m, ' ')
+        html.strip!
+        html = CGI.unescapeHTML(html)
+        return html
+      end
+    end
+  end
+end

data/lib/ircbot/utils/watcher.rb

@@ -0,0 +1,36 @@
+module Ircbot
+  module Utils
+    class Watcher
+      dsl_accessor :interval, 60, :instance=>true
+      dsl_accessor :callback, proc{|e| puts e}, :instance=>true
+
+      def initialize(options = {})
+        interval options[:interval] || self.class.interval
+        callback options[:callback] || self.class.callback
+      end
+
+      def srcs
+        return []
+      end
+
+      def process(src)
+        return true
+      end
+
+      def run
+        loop do
+          srcs.each do |src|
+            if process(src)
+              callback.call(src)
+            end
+          end
+          sleep interval
+        end
+      end
+
+      def start
+        Thread.new{ run }
+      end
+    end
+  end
+end

data/lib/ircbot/version.rb

@@ -1,4 +1,4 @@
 module Ircbot
-  VERSION  = '0.1.5'
+  VERSION  = '0.2.0'
   HOMEPAGE = "http://github.com/maiha/ircbot"
 end

data/old/plugins/summary.cpi

@@ -0,0 +1,267 @@
+#!/usr/bin/ruby -Ke
+load 'html.rb'
+
+require 'ggcl/net/http'
+require 'cgi'
+
+class SummaryAgent
+  WAIT_SEC = 3
+  OUT_SIZE = 90		# ɽ��ʸ����
+  CONTENT_LENGTH_LIMIT = 3 * 1024 * 1024		# within 3Mbytes
+
+  class IRCFloodError		< StandardError; end
+  class AlreadyOpenedError	< StandardError; end
+  class NonTextError		< StandardError; end
+  class SizeExceededError	< StandardError; end
+  class MissingUrlError		< StandardError; end
+  class NoSummaryError		< StandardError; end
+
+  PARENTHESIS = Hash[*%w|
+    ( ) [ ] { } �� �� �� ��
+  |]
+
+  class <<self
+    def adjust_parenthesis (url, prefix)
+      # xxx(http://.../) �ʾ�硢�����γ�̤�Ĵ�����롣
+      keys = PARENTHESIS .keys
+      vals = PARENTHESIS .values
+      regexp1 = '(' + keys .collect{|i| Regexp.escape(i)} .join('|') + ')'
+      regexp2 = '(' + vals .collect{|i| Regexp.escape(i)} .join('|') + ')'
+      if /(#{regexp1}+)$/ === prefix .to_s
+	url .gsub!(/#{regexp2}+$/, '')
+      end
+      url
+    end
+
+    PATTERN_EUC = '[\xa1-\xfe][\xa1-\xfe]'
+    REGEXP_EUC  = Regexp .new(PATTERN_EUC, 'n')
+    def adjust_2bytes_code (url)
+      if REGEXP_EUC === url
+	url = $`
+      end
+      return url
+    end
+
+    def adjust_url(url, prefix)
+      url = adjust_2bytes_code(url)
+      adjust_parenthesis(url, prefix)
+    end
+
+    def extract_url (string)
+      case string .to_s
+      when /http:\/\/([^:\/]+)(:(\d+))?(\/[^#\s��]*)(#(\S+))?/oi
+	return adjust_url($&, $`)
+      when /https:\/\/([^:\/]+)(:(\d+))?(\/[^#\s��]*)(#(\S+))?/oi
+	return adjust_url($&, $`)
+      else
+	raise MissingUrlError
+      end
+    end
+  end
+
+  def initialize (*)
+    @url_history = []
+    @previous_times = {}	# �ܵ�ǽ�κǽ����ѳ��ϻ���(�ƥ桼����)
+    @options = {}		# �Ƽ索�ץ����
+
+    title(true)
+  end
+
+  def title (setter = nil)
+    if setter
+      return @options[:title] = setter
+    else
+      return @options[:title]
+    end
+  end
+
+  def out_size
+    @out_size || OUT_SIZE
+  end
+
+  def wait_sec
+    @wait_sec || WAIT_SEC
+  end
+
+  def do_help (msg)
+    nick = msg[:client].config[:nick]
+    <<HELP
+[Web�ڡ���������](#{wait_sec}���Ե���#{out_size}ʸ��ɽ��)
+���ޥ��: #{nick}.(summary|����).{wait=,size=,title=(on/off)}
+������ˡ: URL �� #{nick}.(summary|����)
+HELP
+  end
+
+  def check_type (url)
+    response = GGCL::Net::HTTP .new(url) .head
+    response .content_type
+  end
+
+  def text? (url)
+    /text/i === check_type(url)
+  end
+
+  def response (url)
+    GGCL::Net::HTTP .new(url) .head
+  end
+
+  def check_header (url)
+    res = response(url)
+
+    # Content-Type ��Ĵ�٤�
+    /text/i === res .content_type or
+      raise NonTextError
+
+    # Content-Length ��Ĵ�٤�
+    size = res['content-length'] .to_i
+    size <= CONTENT_LENGTH_LIMIT or
+      raise SizeExceededError .new("#{size}bytes for #{CONTENT_LENGTH_LIMIT}")
+  end
+
+  def maybe_flood? (from)
+    (Time .now .to_i - @previous_times[from] .to_i) < wait_sec
+  end
+
+  def check_flood (from)
+    maybe_flood? and raise IRCFloodError
+  end
+
+  def summary (url, size = nil)
+    html  = HTML.get(url)
+
+    if html .frame?
+      frame = html .frames .sort .first
+      if frame .src
+	url = HTML::compose_path(url, frame .src)
+	return summary(url, size)
+      end
+    end
+
+    value = html .summary(size || out_size)
+
+    if title
+#      lead  = html .title_or_nil
+      lead = ''
+      if /<TITLE(.*?)>(.*?)<\/TITLE>/im =~ html.html then
+       lead = $2
+      end	
+      if lead
+	lead .gsub!(/\s+/, '')
+	lead = "[#{lead}]"
+      end
+      return "#{lead}#{value}"
+    else
+      return value
+    end
+  end
+
+  def already_opened? (url)
+    bool = @url_history .include? url
+    @url_history << url
+    return bool
+  end
+
+  def check_duplicate_url (url)
+    already_opened?(url) and
+      raise AlreadyOpenedError
+  end
+
+  def do_summary (msg, wait = nil)
+    begin
+      from = msg[:from]
+      return nil if from =~ /sama-zu/
+      maybe_flood?(from) if wait
+      url = self.class.extract_url(msg[:str])
+      return nil if url =~ /onamae/
+      return nil if url =~ /dzz.jp\/up\/download/
+      check_duplicate_url(url)
+      check_header(url)
+
+      @previous_times[from] = Time .now
+      buffer = summary(url) or raise NoSummaryError
+      buffer = CGI::unescapeHTML(buffer)
+      return ">> #{buffer}"
+
+    rescue IRCFloodError
+    rescue AlreadyOpenedError
+    rescue NonTextError
+    rescue SizeExceededError	; return "error: size exceeded. #{$!}"
+    rescue MissingUrlError
+    rescue NoSummaryError
+    rescue Exception		; return "error: #{$!}"
+    end
+
+    return nil
+  end
+
+  def do_command (msg)
+    case msg[:command] .to_s
+    when 'summary', '����'
+      return do_summary(msg)
+    when /^(summary|����).title=/io
+      case $' .to_s
+      when /off/i, /0/, ''
+	title(nil)
+	return "���Ф���OFF�ˤ����ˤ㡼��"
+      else
+	title(true)
+	return "���Ф���ON�ˤ����ˤ㡼��"
+      end
+
+    when /^(summary|����).size=/io
+      range = (5..1000)
+      if range === (size = $'.to_i)
+	@out_size = size
+	return "ɽ��ʸ������#{out_size}bytes���ѹ������ˤ㡼��"
+      else
+	return "error: ɽ��������(#{range})��ȿ�Ǥ���"
+      end
+
+    when /^(summary|����).wait=/io
+      if (sec = $'.to_i) >= WAIT_SEC
+	@wait_sec = sec
+	return "�Ե����֤�#{wait_sec}�ä��ѹ������ˤ㡼��"
+      else
+	return "error: �Ե����֤β��¤�#{WAIT_SEC}�ä����ꤵ��Ƥ��ޤ���"
+      end
+    end
+    return nil
+  end
+
+  def do_reply (msg)
+    return do_summary(msg, :wait)
+  end
+end
+
+if $0 == __FILE__
+
+#   require 'nkf'
+#   str = NKF::nkf('-e', ARGF.read)
+#   str = 'aho'
+#   html = HTML .new(str)
+#   p html .frame?
+#   frames = html .frames
+#   best = frames .sort .first
+#   p best
+#   exit
+
+  agent = SummaryAgent .new
+  string = 'http://www.asahi.com/'
+  sum = SummaryAgent.new.summary(string,100)
+  puts sum	
+
+
+#  string = '���㥢������ http://www.zdnet.co.jp/news/bursts/0111/09/zaku.html �������������������ˤ㡼����������'
+#  p SummaryAgent::extract_url(string)
+
+#  string = 'http://kazu.nori.org/'
+#  string = "http://pucca.astron.s.u-tokyo.ac.jp/image/ogiyahagi1.mpg"
+#  string = 'http://kazu.nori.org/1.png'
+#  agent .check_type(string)
+
+#  string = 'http://www.asahi.com/'
+
+#  p agent .do_reply({:from, :AnnaChan, :str, string})
+end
+
+SummaryAgent .new

data/plugins/plugins.rb

@@ -16,7 +16,7 @@ commands: load, start, stop, delete
   def reply(text)
     if me?
       case command
-      when "load", "register"
+      when "load"
         plugins.load arg
         done "Loaded #{arg}"
 

data/plugins/reminder.rb

@@ -1,15 +1,8 @@
 #!/usr/bin/env ruby -Ku
 # -*- coding: utf-8 -*-
 
-######################################################################
-# [Install]
-#
-# gem install chawan night-time dm-core dm-migrations dm-timestamps do_sqlite3 data_objects dm-sqlite-adapter -V
-#
-
 require 'rubygems'
 require 'ircbot'
-require 'chawan'
 require 'night-time'
 
 require 'dm-core'
@@ -17,28 +10,24 @@ require 'dm-migrations'
 require 'dm-timestamps'
 
 module Reminder
-  def self.connect(path = nil)
-    @connecteds ||= {}
-    @connecteds[path] ||=
-      (
-       path ||= Pathname(Dir.getwd) + "db" + "reminder.db"
-       path = Pathname(path).expand_path
-       path.parent.mkpath
-       DataMapper.setup(:default, "sqlite3://#{path}")
-       Reminder::Event.auto_upgrade!
-       )
+  REPOSITORY_NAME = :reminder
+
+  def self.connect(uri)
+    DataMapper.setup(REPOSITORY_NAME, uri)
+    Reminder::Event.auto_upgrade!
   end
 
   ######################################################################
   ### Exceptions
 
   class EventNotFound < RuntimeError; end
-  class EventNotSaved < RuntimeError
+  class EventFound    < RuntimeError
     attr_accessor :event
     def initialize(event)
       @event = event
     end
   end
+  class EventNotSaved < EventFound   ; end
   class EventHasDone  < EventNotSaved; end
   class StartNotFound < EventNotSaved; end
 
@@ -46,14 +35,18 @@ module Reminder
   ### Event
 
   class Event
+    def self.default_repository_name; REPOSITORY_NAME; end
+    def self.default_storage_name   ; "event"; end
+
     include DataMapper::Resource
 
     property :id       , Serial
     property :st       , DateTime                   # 開始日時
     property :en       , DateTime                   # 終了日時
-    property :title    , String                     # 件名
-    property :desc     , String                     # 詳細
-    property :where    , String                     # 場所
+    property :title    , String, :length=>255       # 件名
+    property :desc     , Text                       # 詳細
+    property :where    , String, :length=>255       # 場所
+    property :source   , String, :length=>255       # 情報ソース
     property :allday   , Boolean , :default=>false  # 終日フラグ
     property :alerted  , Boolean , :default=>false  # お知らせ済
     property :alert_at , DateTime                   # お知らせ日時
@@ -62,12 +55,12 @@ module Reminder
     ### Class methods
 
     class << self
-      def default_storage_name
-        "event"
+      def alerts
+        all(:alerted=>false, :alert_at.lt=>Time.now, :order=>[:alert_at])
       end
 
-      def reminders
-        all(:alerted=>false, :alert_at.lt=>Time.now, :order=>[:alert_at])
+      def future
+        all(:alerted=>false, :alert_at.gt=>Time.now, :order=>[:alert_at])
       end
     end
 
@@ -84,33 +77,35 @@ module Reminder
     end
   end
 
-  module TimeParser
-    def parse(text)
+  def self.parse!(text)
+    case text
+    when /^\s*>>/
+      # 引用は無視
+      raise EventNotFound
+
+    else
+      # 先頭40bytesに時刻ぽい文字列があれば登録とみなす
+      jst    = NightTime::Jst.new(text[0,40])
+      array  = jst.parse
+
+      # 日付なし
+      array[1] && array[2] or raise EventNotFound
+
       event = Event.new
       event.desc   = text
       event.title  = text.sub(%r{^[\s\d:-]+}, '')
-      event.allday = false
-
-      t = Date._parse(text)
-      # => {:zone=>"-14:55", :year=>2010, :hour=>13, :min=>30, :mday=>4, :offset=>-53700, :mon=>1}
-
-      if t[:year] && t[:mon] && t[:mday] && t[:hour]
-        event.st = Time.mktime(t[:year], t[:mon], t[:mday], t[:hour], t[:min], t[:sec])
-        if t[:zone].to_s =~ /^-?(\d+):(\d+)(:(\d+))?$/
-          event.en = Time.mktime(t[:year], t[:mon], t[:mday], $1, $2, $4)
-        end
-      else
-        event.allday = true
-        event.st     = Time.mktime(t[:year], t[:mon], t[:mday]) rescue nil
-      end
+      event.allday = array[3].nil?
+      event.st     = jst.time
 
       return event
     end
+  end
 
-    def register(text)
-      event = parse(text)
+  module Registable
+    def register(event)
       event.st or raise StartNotFound, event
       if event.st.to_time > Time.now
+        event.source   = "irc/reminder"
         event.alert_at = Time.at(event.st.to_time.to_i - 30*60)
         event.save or raise EventNotSaved, event
         return event
@@ -120,160 +115,69 @@ module Reminder
     end
   end
 
-  extend TimeParser
+  extend Registable
 end
 
 
 class ReminderPlugin < Ircbot::Plugin
-  class EventWatcher
-    attr_accessor :interval
-    attr_accessor :callback
+  class EventWatcher < Ircbot::Utils::Watcher
+    def srcs
+      Reminder::Event.alerts
+    end
+  end
+
+  def help
+    ["list -> show future reminders",
+     "YYYY-mm-dd or YYYY-mm-dd HH:MM text -> register the text"].join("\n")
+  end
+
+  def setup
+    return if @watcher
+    bot = self.bot
 
-    def initialize(options = {})
-      @interval = options[:interval] || 60
-      @callback = options[:callback] || proc{|e| puts e}
+    uri = self[:db]
+    unless uri
+      path = Ircbot.root + "db" + "#{config.nick}-reminder.db"
+      uri  = "sqlite3://#{path}"
+      path.parent.mkpath
     end
 
-    def start
-      loop do
-        if callback
-          events = Reminder::Event.reminders
-          #debug "#{self.class} found #{events.size} events"
-          events.each do |event|
-            callback.call(event)
-            event.done!
-          end
-        end
-        sleep interval
-      end
+    Reminder.connect(uri)
+    callback = proc{|event| bot.broadcast event.to_s; event.done!}
+    reminder = EventWatcher.new(:interval=>60, :callback=>callback)
+    @watcher = Thread.new { reminder.start }
+  end
+
+  def list
+    events = Reminder::Event.future
+    if events.size == 0
+      return "no reminders"
+    else
+      lead = "#{events.size} reminder(s)"
+      body = events.map(&:to_s)[0,5]
+      return ([lead] + body).join("\n")
     end
   end
 
   def reply(text)
-    start_reminder
-
     # strip noise
     text = text.sub(/^<.*?>/,'').strip
-
-    case text
-    when %r{^\d{4}.?\d{1,2}.?\d{1,2}}
-      event = Reminder.register(text)
-      text  = "Remind you again at %s" % event.alert_at.strftime("%Y-%m-%d %H:%M")
-      return text
-    end
-    return nil
+   
+    event = Reminder.parse!(text)
+    Reminder.register(event)
+    text  = "Remind you again at %s" % event.alert_at.strftime("%Y-%m-%d %H:%M")
+    return text
 
   rescue Reminder::EventNotFound
     return nil
 
   rescue Reminder::StartNotFound => e
-    return "Reminder cannot detect start: #{e.event.st}"
+    # return "Reminder cannot detect start: #{e.event.st}"
+    return nil
 
   rescue Reminder::EventHasDone => e
     puts "Reminder ignores past event: #{e.event.st}"
     return nil
   end
-
-  private
-    def start_reminder(&callback)
-      bot = self.bot
-      callback ||= proc{|event| bot.broadcast event.to_s}
-      @event_watcher_thread ||=
-        (connect
-         reminder = EventWatcher.new(:interval=>60, :callback=>callback)
-         Thread.new { reminder.start })
-    end
-
-    def reminder_db_path
-      Ircbot.root + "db" + "reminder-#{config.nick}.db"
-    end
-
-    def connect
-      @connect ||= Reminder.connect(reminder_db_path)
-    end
-end
-
-
-######################################################################
-### Spec in file:
-###   ruby plugins/reminder.rb
-
-if $0 == __FILE__
-
-  def spec(src, buffer, &block)
-    buffer = "require '#{Pathname(src).expand_path}'\n" + buffer
-    tmp = Tempfile.new("dynamic-spec")
-    tmp.print(buffer)
-    tmp.close
-    block.call(tmp)
-  ensure
-    tmp.close(true)
-  end
-
-  spec($0, DATA.read{}) do |tmp|
-    system("rspec -cfs #{tmp.path}")
-  end
 end
 
-__END__
-
-require 'rspec'
-require 'ostruct'
-
-module RSpec
-  module Core
-    module SharedExampleGroup
-      def parse(text, &block)
-        describe "(#{text})" do
-          subject {
-            event = Reminder.parse(text)
-            hash  = {
-              :st     => (event.st.strftime("%Y-%m-%d %H:%M:%S") rescue nil),
-              :en     => (event.en.strftime("%Y-%m-%d %H:%M:%S") rescue nil),
-              :title  => event.title.to_s,
-              :desc   => event.title.to_s,
-              :allday => event.allday,
-            }
-            OpenStruct.new(hash)
-          }
-          instance_eval(&block)
-        end
-      end
-    end
-  end
-end
-
-describe "Reminder#parse" do
-
-  parse '' do
-    its(:st)     { should == nil }
-  end
-
-  parse '2010-01-04 CX' do
-    its(:st)     { should == "2010-01-04 00:00:00" }
-    its(:en)     { should == nil }
-    its(:title)  { should == "CX" }
-    its(:allday) { should == true }
-  end
-
-  parse '2010-01-04 13:30 CX' do
-    its(:st)     { should == "2010-01-04 13:30:00" }
-    its(:en)     { should == nil }
-    its(:title)  { should == "CX" }
-    its(:allday) { should == false }
-  end
-
-  parse '2010-01-04 13:30-14:55 CX' do
-    its(:st)     { should == "2010-01-04 13:30:00" }
-    its(:en)     { should == "2010-01-04 14:55:00" }
-    its(:title)  { should == "CX" }
-    its(:allday) { should == false }
-  end
-
-  parse '2010-01-18 27:15-27:45 TX' do
-    its(:st)     { should == "2010-01-19 03:15:00" }
-    its(:en)     { should == "2010-01-19 03:45:00" }
-    its(:title)  { should == "TX" }
-    its(:allday) { should == false }
-  end
-end