rbot 0.9.14 → 0.9.15

data/lib/rbot/core/unicode.rb

@@ -10,6 +10,9 @@
 # encoding. The plugin takes care of translation to/from utf-8 on server IO,
 # if necessary (translation charsets are configurable).
 
+# TODO autoconfigure using server-provided allowed charset when these are
+# available, see also comment in irc.rb
+
 require 'iconv'
 
 class UnicodePlugin < CoreBotModule
@@ -21,6 +24,7 @@ class UnicodePlugin < CoreBotModule
     Config.register Config::ArrayValue.new(
     'encoding.charsets', :default => ['utf-8', 'cp1252', 'iso-8859-15'],
     :desc => "Ordered list of iconv(3) charsets the bot should try",
+    :validate_item => Proc.new { |x| !!(Iconv.new('utf-8', x) rescue nil) },
     :on_change => Proc.new { |bot, v| reconfigure_filter(bot) })
 
     class UnicodeFilter

data/lib/rbot/core/userdata.rb

@@ -25,7 +25,7 @@ module ::Irc
     #
     # If you have to do large-scale editing of the Bot data Hash,
     # please use with_botdata.
-    # 
+    #
     def set_botdata(key, value=nil, &block)
       Irc::Utils.bot.plugins['userdata'].set_data(self, key, value, &block)
     end
@@ -38,6 +38,13 @@ module ::Irc
       Irc::Utils.bot.plugins['userdata'].with_data(self, &block)
     end
 
+    # This method removes the data associated with the key, returning
+    # the value of the deleted key.
+
+    def delete_botdata(*keys)
+      Irc::Utils.bot.plugins['userdata'].delete_data(self, *keys)
+    end
+
   end
 end
 
@@ -138,6 +145,14 @@ class UserDataModule < CoreBotModule
     return h
   end
 
+  def delete_data(user, *keys)
+    h = get_data_hash(user)
+    debug h
+    rv = keys.map { |k| h.delete k }
+    set_data_hash(user, h)
+    rv.size == 1 ? rv.first : rv
+  end
+
   def handle_get(m, params)
     user = m.server.get_user(params[:nick]) || m.source
     key = params[:key].intern

data/lib/rbot/core/utils/extends.rb

@@ -124,7 +124,50 @@ class ::Array
       replace shuffle
     end
   end
+end
+
+module ::Enumerable
+  # This method is an advanced version of #join
+  # allowing fine control of separators:
+  #
+  #   [1,2,3].conjoin(', ', ' and ')
+  #   => "1, 2 and 3
+  #
+  #   [1,2,3,4].conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
+  #   => "1.2-3.4"
+  #
+  # Code lifted from the ruby facets project:
+  # <http://facets.rubyforge.org>
+  # git-rev: c8b7395255b977d3c7de268ff563e3c5bc7f1441
+  # file: lib/core/facets/array/conjoin.rb
+  def conjoin(*args, &block)
+    num = count - 1
+
+    return first.to_s if num < 1
+
+    sep = []
+
+    if block_given?
+      num.times do |i|
+        sep << yield(i, *slice(i, 2))
+      end
+    else
+      options = (Hash === args.last) ? args.pop : {}
+      separator = args.shift || ""
+      options[-1] = args.shift unless args.empty?
+
+      sep = [separator] * num
+
+      if options.key?(:last)
+        options[-1] = options.delete(:last)
+      end
+      options[-1] ||= _(" and ")
 
+      options.each{ |i, s| sep[i] = s }
+    end
+
+    zip(sep).join
+  end
 end
 
 # Extensions to the Range class
@@ -202,6 +245,29 @@ class ::String
       warning "unknown :a_href option #{val} passed to ircify_html" if val
     end
 
+    # If opts[:img] is defined, it should be a String. Each image
+    # will be replaced by the string itself, replacing occurrences of
+    # %{alt} %{dimensions} and %{src} with the alt text, image dimensions
+    # and URL
+    if val = opts[:img]
+      if val.kind_of? String
+        txt.gsub!(/<img\s+(.*?)\s*\/?>/) do |imgtag|
+          attrs = Hash.new
+          imgtag.scan(/([[:alpha:]]+)\s*=\s*(['"])?(.*?)\2/) do |key, quote, value|
+            k = key.downcase.intern rescue 'junk'
+            attrs[k] = value
+          end
+          attrs[:alt] ||= attrs[:title]
+          attrs[:width] ||= '...'
+          attrs[:height] ||= '...'
+          attrs[:dimensions] ||= "#{attrs[:width]}x#{attrs[:height]}"
+          val % attrs
+        end
+      else
+        warning ":img option is not a string"
+      end
+    end
+
     # Paragraph and br tags are converted to whitespace
     txt.gsub!(/<\/?(p|br)(?:\s+[^>]*)?\s*\/?\s*>/i, ' ')
     txt.gsub!("\n", ' ')
@@ -283,6 +349,16 @@ class ::String
   def ircify_html_title
     self.get_html_title.ircify_html rescue nil
   end
+
+  # This method is used to wrap a nonempty String by adding
+  # the prefix and postfix
+  def wrap_nonempty(pre, post, opts={})
+    if self.empty?
+      String.new
+    else
+      "#{pre}#{self}#{post}"
+    end
+  end
 end
 
 

data/lib/rbot/core/utils/filters.rb

@@ -148,6 +148,53 @@ module ::Irc
 
       register_filter(:identity) { |stream| stream }
     end
+
+    module Plugins
+      class BotModule
+        # read accessor for the default filter group for this BotModule
+        def filter_group
+          @filter_group ||= name
+        end
+
+        # write accessor for the default filter group for this BotModule
+        def filter_group=(name)
+          @filter_group = name
+        end
+
+        # define a filter defaulting to the default filter group
+        # for this BotModule
+        def define_filter(filter, &block)
+          @bot.register_filter(filter, self.filter_group, &block)
+        end
+
+        # load filters associated with the BotModule by looking in
+        # the path(s) specified by the :path option, defaulting to
+        # * Config::datadir/filters/<name>.rb
+        # * botclass/filters/<name>.rb
+        # (note that as <name> we use #dirname() rather than #name(),
+        # since we're looking for datafiles; this is only relevant
+        # for the very few plugins whose dirname differs from name)
+        def load_filters(options={})
+          case options[:path]
+          when nil
+            file = "#{self.dirname}.rb"
+            paths = [
+              File.join(Config::datadir, 'filters', file),
+              @bot.path('filters', file)
+            ]
+          when Array
+            paths = options[:path]
+          else
+            paths = [options[:path]]
+          end
+
+          paths.each do |file|
+            instance_eval(File.read(file), file) if File.exist?(file)
+          end
+        end
+      end
+    end
+
   end
 end
 

data/lib/rbot/core/utils/httputil.rb

@@ -25,7 +25,7 @@ require 'zlib'
 module ::Net
   class HTTPResponse
     attr_accessor :no_cache
-    if !instance_methods.include?('raw_body')
+    unless method_defined? :raw_body
       alias :raw_body :body
     end
 
@@ -99,7 +99,7 @@ module ::Net
         end
       when 'deflate'
         debug "inflating body"
-        # From http://www.koders.com/ruby/fid927B4382397E5115AC0ABE21181AB5C1CBDD5C17.aspx?s=thread: 
+        # From http://www.koders.com/ruby/fid927B4382397E5115AC0ABE21181AB5C1CBDD5C17.aspx?s=thread:
         # -MAX_WBITS stops zlib from looking for a zlib header
         inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
         begin
@@ -190,7 +190,7 @@ class HttpUtil
     Bot::Config.register Bot::Config::IntegerValue.new('http.max_cache_time',
       :default => 60*24,
       :desc => "After how many minutes since first use a cached document is considered to be expired")
-    Bot::Config.register Bot::Config::IntegerValue.new('http.no_expire_cache',
+    Bot::Config.register Bot::Config::BooleanValue.new('http.no_expire_cache',
       :default => false,
       :desc => "Set this to true if you want the bot to never expire the cached pages")
     Bot::Config.register Bot::Config::IntegerValue.new('http.info_bytes',
@@ -389,7 +389,7 @@ class HttpUtil
       end
     end
 
-    h = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port, proxy_user, proxy_port)
+    h = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port, proxy_user, proxy_pass)
     h.use_ssl = true if uri.scheme == "https"
 
     h.read_timeout = opts[:read_timeout]
@@ -482,6 +482,14 @@ class HttpUtil
   #
   def get_response(uri_or_s, options = {}, &block) # :yields: resp
     uri = uri_or_s.kind_of?(URI) ? uri_or_s : URI.parse(uri_or_s.to_s)
+    unless URI::HTTP === uri
+      if uri.scheme
+        raise "#{uri.scheme.inspect} URI scheme is not supported"
+      else
+        raise "don't know what to do with #{uri.to_s.inspect}"
+      end
+    end
+
     opts = {
       :max_redir => @bot.config['http.max_redir'],
       :yield => :final,
@@ -490,7 +498,6 @@ class HttpUtil
     }.merge(options)
 
     resp = nil
-    cached = nil
 
     req_class = case opts[:method].to_s.downcase.intern
                 when :head, :"net::http::head"
@@ -524,7 +531,9 @@ class HttpUtil
 
     debug "get_response(#{uri}, #{opts.inspect})"
 
-    if opts[:cache] && cached = @cache[cache_key]
+    cached = @cache[cache_key]
+
+    if opts[:cache] && cached
       debug "got cached"
       if !cached.expired?
         debug "using cached"
@@ -537,7 +546,10 @@ class HttpUtil
     headers['Range'] = opts[:range] if opts[:range]
     headers['Authorization'] = opts[:auth_head] if opts[:auth_head]
 
-    cached.setup_headers(headers) if cached && (req_class == Net::HTTP::Get)
+    if opts[:cache] && cached && (req_class == Net::HTTP::Get)
+      cached.setup_headers headers
+    end
+
     req = req_class.new(uri.request_uri, headers)
     if uri.user && uri.password
       req.basic_auth(uri.user, uri.password)
@@ -547,22 +559,23 @@ class HttpUtil
     debug "prepared request: #{req.to_hash.inspect}"
 
     begin
-    get_proxy(uri, opts).start do |http|
-      http.request(req) do |resp|
-        resp['x-rbot-location'] = uri.to_s
-        if Net::HTTPNotModified === resp
-          debug "not modified"
-          begin
-            cached.revalidate(resp)
-          rescue Exception => e
-            error e
+      get_proxy(uri, opts).start do |http|
+        http.request(req) do |resp|
+          resp['x-rbot-location'] = uri.to_s
+          if Net::HTTPNotModified === resp
+            debug "not modified"
+            begin
+              cached.revalidate(resp)
+            rescue Exception => e
+              error e
+            end
+            debug "reusing cached"
+            resp = cached.response
+          elsif Net::HTTPServerError === resp || Net::HTTPClientError === resp
+            debug "http error, deleting cached obj" if cached
+            @cache.delete(cache_key)
           end
-          debug "reusing cached"
-          resp = cached.response
-        elsif Net::HTTPServerError === resp || Net::HTTPClientError === resp
-          debug "http error, deleting cached obj" if cached
-          @cache.delete(cache_key)
-        elsif opts[:cache]
+
           begin
             return handle_response(uri, resp, opts, &block)
           ensure
@@ -571,11 +584,8 @@ class HttpUtil
               @cache[cache_key] = cached
             end
           end
-          return ret
         end
-        return handle_response(uri, resp, opts, &block)
       end
-    end
     rescue Exception => e
       error e
       raise e.message
@@ -630,7 +640,7 @@ class HttpUtil
     opts = {:method => :post, :body => data, :cache => false}.merge(options)
     begin
       resp = get_response(uri, opts, &block)
-      raise 'http error' unless Net::HTTPOK === resp
+      raise 'http error' unless Net::HTTPOK === resp or Net::HTTPCreated === resp
       return resp
     rescue Exception => e
       error e

data/lib/rbot/core/utils/parse_time.rb

@@ -0,0 +1,193 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: rbot time parsing utilities
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# These routines read a string and return the number of seconds they
+# represent.
+
+module ::Irc
+  module Utils
+    module ParseTime
+      FLOAT_RX = /((?:\d*\.)?\d+)/
+
+      ONE_TO_NINE = {
+        :one => 1,
+        :two => 2,
+        :three => 3,
+        :four => 4,
+        :five => 5,
+        :six => 6,
+        :seven => 7,
+        :eight => 8,
+        :nine => 9,
+      }
+
+      ONE_TO_NINE_RX = Regexp.new ONE_TO_NINE.keys.join('|')
+
+      TEENS_ETC = {
+        :an => 1,
+        :a => 1,
+        :ten => 10,
+        :eleven => 11,
+        :twelve => 12,
+        :thirteen => 13,
+        :fourteen => 14,
+        :fifteen => 15,
+        :sixteen => 16,
+        :seventeen => 17,
+        :eighteen => 18,
+        :nineteen => 19,
+      }
+
+      TEENS_ETC_RX = Regexp.new TEENS_ETC.keys.join('|')
+
+      ENTIES = {
+        :twenty => 20,
+        :thirty => 30,
+        :forty => 40,
+        :fifty => 50,
+        :sixty => 60,
+      }
+
+      ENTIES_RX = Regexp.new ENTIES.keys.join('|')
+
+      LITNUM_RX = /(#{ONE_TO_NINE_RX})|(#{TEENS_ETC_RX})|(#{ENTIES_RX})\s*(#{ONE_TO_NINE_RX})?/
+
+        FRACTIONS = {
+        :"half" => 0.5,
+        :"half a" => 0.5,
+        :"half an" => 0.5,
+        :"a half" => 0.5,
+        :"a quarter" => 0.25,
+        :"a quarter of" => 0.25,
+        :"a quarter of a" => 0.25,
+        :"a quarter of an" => 0.25,
+        :"three quarter" => 0.75,
+        :"three quarters" => 0.75,
+        :"three quarter of" => 0.75,
+        :"three quarters of" => 0.75,
+        :"three quarter of a" => 0.75,
+        :"three quarters of a" => 0.75,
+        :"three quarter of an" => 0.75,
+        :"three quarters of an" => 0.75,
+      }
+
+      FRACTION_RX = Regexp.new FRACTIONS.keys.join('|')
+
+      UNITSPEC_RX = /(years?|months?|s(?:ec(?:ond)?s?)?|m(?:in(?:ute)?s?)?|h(?:(?:ou)?rs?)?|d(?:ays?)?|weeks?)/
+
+      # str must much UNITSPEC_RX
+      def ParseTime.time_unit(str)
+        case str[0,1].intern
+        when :s
+          1
+        when :m
+          if str[1,1] == 'o'
+            # months
+            3600*24*30
+          else
+            #minutes
+            60
+          end
+        when :h
+          3600
+        when :d
+          3600*24
+        when :w
+          3600*24*7
+        when :y
+          3600*24*365
+        end
+      end
+
+      # example: half an hour, two and a half weeks, 5 seconds, an hour and 5 minutes
+      def ParseTime.parse_period(str)
+        clean = str.gsub(/\s+/, ' ').strip
+
+        sofar = 0
+        until clean.empty?
+          if clean.sub!(/^(#{FRACTION_RX})\s+#{UNITSPEC_RX}/, '')
+            # fraction followed by unit
+            num = FRACTIONS[$1.intern]
+            unit = ParseTime.time_unit($2)
+          elsif clean.sub!(/^#{FLOAT_RX}\s*(?:\s+and\s+(#{FRACTION_RX})\s+)?#{UNITSPEC_RX}/, '')
+            # float plus optional fraction followed by unit
+            num = $1.to_f
+            frac = $2
+            unit = ParseTime.time_unit($3)
+            clean.strip!
+            if frac.nil? and clean.sub!(/^and\s+(#{FRACTION_RX})/, '')
+              frac = $1
+            end
+            if frac
+              num += FRACTIONS[frac.intern]
+            end
+          elsif clean.sub!(/^(?:#{LITNUM_RX})\s+(?:and\s+(#{FRACTION_RX})\s+)?#{UNITSPEC_RX}/, '')
+            if $1
+              num = ONE_TO_NINE[$1.intern]
+            elsif $2
+              num = TEENS_ETC[$2.intern]
+            elsif $3
+              num = ENTIES[$3.intern]
+              if $4
+                num += ONE_TO_NINE[$4.intern]
+              end
+            end
+            frac = $5
+            unit = ParseTime.time_unit($6)
+            clean.strip!
+            if frac.nil? and clean.sub!(/^and\s+(#{FRACTION_RX})/, '')
+              frac = $1
+            end
+            if frac
+              num += FRACTIONS[frac.intern]
+            end
+          else
+            raise "invalid time string: #{clean} (parsed #{sofar} so far)"
+          end
+          sofar += num * unit
+          clean.sub!(/^and\s+/, '')
+        end
+        return sofar
+      end
+
+      # TODO 'at hh:mm:ss', 'next week, 'tomorrow', 'saturday' etc
+    end
+
+    def Utils.parse_time_offset(str)
+      case str
+      when /^(\d+):(\d+)(?:\:(\d+))?$/ # TODO refactor
+        hour = $1.to_i
+        min = $2.to_i
+        sec = $3.to_i
+        now = Time.now
+        later = Time.mktime(now.year, now.month, now.day, hour, min, sec)
+
+        # if the given hour is earlier than current hour, given timestr
+        # must have been meant to be in the future
+        if hour < now.hour || hour <= now.hour && min < now.min
+          later += 60*60*24
+        end
+
+        return later - now
+      when /^(\d+):(\d+)(am|pm)$/ # TODO refactor
+        hour = $1.to_i
+        min = $2.to_i
+        ampm = $3
+        if ampm == "pm"
+          hour += 12
+        end
+        now = Time.now
+        later = Time.mktime(now.year, now.month, now.day, hour, min, now.sec)
+        return later - now
+      else
+        ParseTime.parse_period(str)
+      end
+    end
+
+  end
+end
+