butler 1.8.1 → 1.8.2

data/lib/butler/plugin/configproxy.rb

@@ -6,27 +6,47 @@
 
 
 
+require 'thread'
+
+
+
 class Butler
 	class Plugin
 		class ConfigProxy
 			def initialize(config, base="")
 				@config = config
 				@base   = base
+				@mutex  = Mutex.new
+			end
+			
+			# Synchronize access to this piece of config
+			def synchronize
+				@mutex.synchronize {
+					yield self
+				}
 			end
 			
+			# assign a config key, hands off to Configuration#[]= and prepends
+			# Plugin#base to the key
 			def []=(key, value)
 				@config[key.empty? ? @base : "#{@base}/#{key}"] = value
 			end
 			
+			# access a config key, hands off to Configuration#[] and prepends
+			# Plugin#base to the key
 			def [](key, *args)
 				@config[(key.empty? ? @base : "#{@base}/#{key}"), *args]
 			end
 
+			# test existence of a key, hands off to Configuration#exist? and prepends
+			# Plugin#base to the key
 			def exist?(key)
 				@config.exist?(key.empty? ? @base : "#{@base}/#{key}")
 			end
 			alias has_key? exist?
 			
+			# delete a config key, hands off to Configuration#delete and prepends
+			# Plugin#base to the key
 			def delete(key)
 				@config.delete(key.empty? ? @base : "#{@base}/#{key}")
 			end

data/lib/butler/plugin/mapper.rb

@@ -7,13 +7,94 @@
 
 
 require 'butler/plugin'
-require 'ostruct'
+require 'ostructfixed'
 
 
 
 class Butler
 	class Plugin
+		# For TypeMaps, to indicate that a validation failed
+		class ValidationFailure < RuntimeError; end
+
+		# Map arguments of a specific type to their actual value
+		# The mapping may raise an exception inherited from
+		# Butler::Plugin::ValidationFailure to indicate that the value
+		# didn't validate
+		class TypeMap
+
+			# name of the typemap
+			attr_reader :name
+
+			# type matches only this regex
+			attr_reader :regex
+
+			# validate and convert the matched value
+			attr_reader :validation
+
+			# Example:
+			#   TypeMap.new "IP", /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ do |butler, value|
+			#     value.split(/\./).map { |e|
+			#       i = e.to_i
+			#       raise ValidationFailure unless i.between?(0,255)
+			#       i
+			#     }
+			#   end
+			def initialize(name, regex, &validation)
+				@name       = name
+				@regex      = regex
+				@validation = validation
+			end
+			
+			# map the value, can raise a ValidationFailure
+			def map(butler, value)
+				@validation ? @validation[butler, value] : value
+			end
+		end
+
 		class Mapper
+			include Comparable
+
+			# priority of Mappers, don't change. Mappers should run with higher priority than
+			# less precise invocation mechanisms.
+			Priority = 10
+			
+			module Pattern
+				# A portion that may contain color information
+				def self.colored(item)
+					"#{Color}?#{Regexp.escape(item)}#{Color}?"
+				end
+				
+				# Multiple items of a specific regex
+				def self.one_or_more_of(single)
+					"(?:#{single}(?:(?:,\\s*|\\s+)#{single})*?)"
+				end
+				
+				def self.one_of(items)
+					"(?i:#{items.map { |item| Regexp.escape(item) }.join('|')})"
+				end
+				
+				def self.quoted_variants(pattern)
+					"(?:#{pattern}|\"#{pattern}\"|'#{pattern}')"
+				end
+			
+				# MIRC color information
+				Color     = '(?:[\x02\x0f\x12\x1f\x1d\x09]|\cc\d{1,2}(?:,\d{1,2})?)'.freeze
+				
+				# A single argument
+				Argument  = '(?:(?:\\\\.|[^\\\\"\'\s])+|"(?:\\\\.|[^\\\\"])*"|\'(?:\\\\.|[^\\\\\'])*\')'.freeze
+				
+				# A list of arguments, comma or whitespace separated
+				Arguments = one_or_more_of(Argument).freeze
+				
+				# An arbitrary string
+				String    = "(?:.*?)".freeze
+				
+				# In the definition string, a variable definition
+				Variable  = /([+:*])?(\w+)(?:@([\w+-]+))?(?:\{([\w,]+)\})?|(\S+)/
+			end
+			
+			Capture = Struct.new("Capture", :name, :scan, :typemap)
+			
 			attr_reader :authorization
 			attr_reader :hash
 			attr_reader :language
@@ -33,32 +114,55 @@ class Butler
 				@name          = "mapper:#{@language}:#{@expression}".freeze
 				@hash          = @name.hash
 				
-				tiles = expression.strip.scan(/(?:^|\s)[:*]\w+(?:\[[^\]]+\])?|\S+/).map { |word|
-					word.strip!
-					case word
-						when /:(\w+)(.*)/
-							@captures << [$1.to_sym, $2]
-							'(\S+)'
-						when /\*(\w+)(.*)/
-							@captures << [$1.to_sym, $2]
-							'(\S+(?:\s+\S+)*?)'
-						else
-							Regexp.escape(word)
+				# process expression
+				structure      = structure(expression)
+				raise "No Trigger" unless String === structure.first
+				trigger, tmp   = structure.shift.split(/\s+/, 2)
+				trigger.strip!
+				structure.unshift(tmp) if tmp and !tmp.empty?
+				raise "No Trigger" if (!trigger || trigger.empty? || trigger =~ /\W/)
+
+				append         = "^"+Pattern.colored(trigger)
+				captures       = []
+				structure.each { |item|
+					if Array === item
+						optional(item, append)
+					else
+						regexify(item, append)
 					end
 				}
-				@regexp      = Regexp.new('^'+tiles.join('\s+')+'$')
+				append << "$"
+				
+				@regexp        = Regexp.new(append)
 			end
 			
 			def invoked_by?(message)
-				if match = @regexp.match(message.post_arguments[0]) then
-					params = {}
-					@captures.zip(match.captures) { |(name, valid), value|
-						params[name] = value
-					}
-					[OpenStruct.new(params)]
-				else
-					nil
-				end
+				return nil unless match = @regexp.match(message.text[message.invocation.length..-1])
+				params = {}
+				butler = @plugin.butler
+				@captures.zip(match.captures) { |capture, value|
+					if value then
+						if capture.scan then
+							params[capture.name] = value.scan(capture.scan).map { |element|
+								if capture.typemap then
+									capture.typemap.map(butler, unwrap(element))
+								else
+									unwrap(element)
+								end
+							}
+						else
+							params[capture.name] = capture.typemap ? capture.typemap.map(butler, unwrap(value)) : unwrap(value)
+						end
+					else
+						params[capture.name] = nil
+					end
+				}
+				[OpenStruct.new(params)]
+			rescue ValidationFailure
+				nil
+			rescue Exception => e
+				@plugin.exception(e)
+				nil
 			end
 			
 			def call(message, params)
@@ -66,11 +170,11 @@ class Butler
 			end
 
 			def priority
-				-10
+				Priority
 			end
 			
 			def <=>(other)
-				-10 <=> other.priority
+				other.priority <=> Priority
 			end
 			
 			def abort_invocations?
@@ -80,6 +184,186 @@ class Butler
 			def eql?(other)
 				other.kind_of?(Mapper) && @name.eql?(other.name)
 			end
+			
+			def inspect
+				"#<%s:0x%08x %s %s>" %  [
+					self.class,
+					object_id << 1,
+					@expression.inspect,
+					@regexp.inspect
+				]
+			end
+			
+			def to_s
+				"#<%s:0x%08x %s>" %  [
+					self.class,
+					object_id << 1,
+					@expression.inspect
+				]
+			end
+			
+			private
+			# parse the optional parts of a mapping and structure it as nested array
+			def structure(str)
+				curr   = []
+				stack  = [curr]
+				offset = 0
+				o,c = str.index("[", offset), str.index("]", offset)
+			
+				while o or c
+					if o && c && o < c then
+						substr = str[offset...o].strip
+						curr  << substr unless substr.empty?
+						curr  << []
+						stack << curr.last
+						curr   = stack.last
+						offset = o+1
+					elsif c then
+						substr = str[offset...c].strip
+						curr << substr unless substr.empty?
+						stack.pop
+						curr = stack.last
+						offset = c+1
+					else
+						raise "Invalid expression, Orphan ["
+					end
+					o,c = str.index("[", offset), str.index("]", offset)
+				end
+				curr << str[offset..-1].strip unless offset == str.length
+				curr
+			end # structure
+			
+			# recursively create the regex for structured optional parts
+			def optional(item, append)
+				append << "(?:"
+				item.each { |item|
+					if Array === item then
+						optional(item, append)
+					else
+						regexify(item, append)
+					end
+				}
+				append << ")??"
+			end
+			
+			# convert a part into its regex pendant, parse out captures, types and restrictions
+			def regexify(string, append)
+				string.scan(Pattern::Variable) { |type, name, map, one_of, literal|
+					if literal then
+						# non-whitespace, non-word, non-argument(s) - probably interpunctuation
+						append << Regexp.escape(literal)
+					else
+						case type
+							when nil
+								raise "Forgot :, * or + prefix? Invalid pattern" if map or one_of
+								# literal
+								append << '\s+'+Pattern.colored(name)
+							when "+"
+								# string
+								append   << "\\s+(#{Pattern::String})"
+								@captures << Capture.new(name.to_sym, nil, nil)
+							when ":"
+								# argument
+								raise "Unknown type '#{map}'" if map and !(typemap = @plugin.typemap(map))
+								if one_of then
+									append   << "\\s+(#{Pattern.one_of(one_of.split(/,\s*/))})"
+								elsif map then
+									append   << "\\s+(#{typemap.regex})"
+								else
+									append   << "\\s+(#{Pattern::Argument})"
+								end
+								@captures << Capture.new(name.to_sym, nil, @plugin.typemap(map))
+							when "*"
+								# arguments
+								raise "Unknown type '#{map}'" if map and !(typemap = @plugin.typemap(map))
+								if one_of then
+									scan = Pattern.one_of(one_of.split(/,\s*/))
+									append   << "\\s+(#{Pattern.one_or_more_of(scan)})"
+									scan = /#{scan}/
+								elsif map then
+									append   << "\\s+(#{Pattern.one_or_more_of(typemap.regex)})"
+									scan = typemap.regex
+								else
+									append   << "\\s+(#{Pattern.one_or_more_of(Pattern::Argument)})"
+									scan = /#{Pattern::Argument}/
+								end
+								@captures << Capture.new(name.to_sym, /#{scan}/, typemap)
+						end
+					end
+				}
+			end
+			
+			# remove quotes if necessary and unescape
+			def unwrap(value)
+				value = case value[0,1]
+					when '"': value[1..-2].gsub(/\\./) { |m| ['"', "'", ' '].include?(m) ? m[1,1] : m }
+					when "'": value[1..-2].gsub(/\\./) { |m| ['"', "'", ' '].include?(m) ? m[1,1] : m }
+					else      value.gsub(/\\./) { |m| ['"', "'", ' '].include?(m) ? m[1,1] : m }
+				end
+			end
+		end
+
+
+		# add a mapping type for :map:'s
+		# The regular expression MUST NOT contain any captures!
+		# For grouping use (?: ... ), which does not capture
+		# The provided block can convert the value and do additional testing for validity
+		# If the value is invalid, raise a ValidationFailure
+		# Example:
+		#   map_type "IP", /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ do |butler, value|
+		#     value.split(/\./).map { |e|
+		#       i = e.to_i
+		#       raise ValidationFailure unless i.between?(0,255)
+		#       i
+		#     }
+		#   end
+		def self.map_type(name, regex, &validation)
+			@mapping_type[name] = TypeMap.new(name, regex, &validation)
+		end
+		
+		# get the TypeMap for a type
+		def self.typemap(name)
+			(@mapping_type || MappingTypes)[name]
+		end
+
+		# Basic mapping types, includes:
+		# * Integer:     any valid integer. Converted to a Fix- or Bignum.
+		# * +Integer:    any positive integer. Converted to a Fix- or Bignum.
+		# * -Integer:    any negative integer. Converted to a Fix- or Bignum.
+		# * Float:       any valid float. Converted to a Float.
+		# * +Float:      any positive float. Converted to a Float.
+		# * -Float:      any negative float. Converted to a Float.
+		# * Nick:        a valid nickname (not necessarily online)
+		# * User:        a currently online and for butler visible user. Converted to an IRC::User.
+		# * Channelname: a valid channelname (not necessarily one butler participates)
+		# * Channel:     a channel butler is in. Converted to an IRC::Channel.
+		MappingTypes = {}
+		# Provide additional warnings
+		def MappingTypes.[]=(name, typemap) # :nodoc:
+			warn "redefining TypeMap '#{name}'" if has_key?(name)
+			super
 		end
+		[
+			["Integer",     %r{[+-]?\d+},                         proc { |butler, value| Integer(value) }],
+			["+Integer",    %r{\+?\d+},                           proc { |butler, value| Integer(value) }],
+			["-Integer",    %r{\-\d+},                            proc { |butler, value| Integer(value) }],
+			["Float",       %r{[+-]?\d+(?:\.\d+)},                proc { |butler, value| Float(value) }],
+			["+Float",      %r{\+?\d+(?:\.\d+)},                  proc { |butler, value| Float(value) }],
+			["-Float",      %r{\-?\d+(?:\.\d+)},                  proc { |butler, value| Float(value) }],
+			["Nick",        %r{[0-9A-Za-z_\-\|\\\[\]\{\}\^\`]+}],
+			["Channelname", %r{[&#!\+][^\x07\x0A\x0D,: ]{1,50}}],
+			["User",        %r{[0-9A-Za-z_\-\|\\\[\]\{\}\^\`]+},  proc { |butler, value|
+				butler.users[value]
+			}],
+			["Channel",     %r{[&#!\+][^\x07\x0A\x0D,: ]{1,50}},  proc { |butler, value|
+				butler.channels[value]
+			}],
+		].each { |name, regex, validation|
+			MappingTypes[name] = TypeMap.new(
+				name,
+				Mapper::Pattern.quoted_variants(regex),
+				&validation
+			)
+		}
 	end
 end

data/lib/butler/plugin/matcher.rb

@@ -9,6 +9,8 @@
 class Butler
 	class Plugin
 		class Matcher
+			include Comparable
+
 			attr_reader :priority
 			attr_reader :hash
 			attr_reader :en_match
@@ -32,7 +34,7 @@ class Butler
 			end
 			
 			def <=>(other)
-				@priority <=> other.priority
+				other.priority <=> @priority
 			end
 			
 			def eql?(other)

data/lib/butler/plugin/more.rb

@@ -0,0 +1,65 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler
+	class Plugin
+		class More
+			MessageLength = 300
+			String        = {
+				"en" => "![c(white),(black)]more...![o]".mirc_formatted,
+				"de" => "![c(white),(black)]mehr...![o]".mirc_formatted,
+			}
+			
+			attr_reader :lead
+			attr_reader :text
+			attr_reader :index
+			attr_reader :length
+			
+			def initialize(message, lead, text)
+				@language = message.language
+				@lead     = !lead || lead.empty? ? nil : lead
+				@text     = text
+				@index    = 0
+				chunks    = MessageLength-(lead ? lead.length+4 : 2)-tail.length
+				@pieces   = text.scan(/.{1,#{chunks}}(?:\b|$)/m)
+				@length   = @pieces.length
+			end
+			
+			def succ
+				raise "Reached end already" if @index+1 >= @length
+				@pieces[@index+=1]
+			end
+			
+			def prev
+				raise "Reached start already" if @index.zero?
+				@pieces[@index-=1]
+			end
+			
+			def succ?
+				@index+1 < @length
+			end
+			
+			def prev?
+				!@index.zero?
+			end
+			
+			def current
+				@pieces[@index]
+			end
+			
+			# show adds lead and tail depending on requirement (no tail for last message, no lead if empty)
+			def show
+				"#{lead+': ' if lead}#{@pieces[@index]}#{', '+tail if succ?}"
+			end
+		
+			def tail
+				String[@language] || String["en"]
+			end
+		end
+	end
+end