butler 1.8.0

data/lib/butler/plugin/configproxy.rb

@@ -0,0 +1,35 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler
+	class Plugin
+		class ConfigProxy
+			def initialize(config, base="")
+				@config = config
+				@base   = base
+			end
+			
+			def []=(key, value)
+				@config[key.empty? ? @base : "#{@base}.#{key}"] = value
+			end
+			
+			def [](key, *args)
+				@config[(key.empty? ? @base : "#{@base}.#{key}"), *args]
+			end
+
+			def exist?(key)
+				@config.exist?(key.empty? ? @base : "#{@base}.#{key}")
+			end
+			alias has_key? exist?
+			
+			def delete(key)
+				@config.delete(key.empty? ? @base : "#{@base}.#{key}")
+			end
+		end
+	end
+end

data/lib/butler/plugin/mapper.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler/plugin'
+require 'ostruct'
+
+
+
+class Butler
+	class Plugin
+		class Mapper
+			attr_reader :authorization
+			attr_reader :hash
+			attr_reader :language
+			attr_reader :name
+			attr_reader :plugin
+			attr_reader :trigger
+			attr_reader :hash
+
+			def initialize(plugin, meth, language, expression)
+				@plugin        = plugin
+				@method        = meth
+				@language      = language
+				@expression    = expression
+				@trigger       = expression[/^\w+/].downcase
+				@captures      = []
+				@authorization = "plugin/#{@plugin.base}".freeze
+				@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)
+					end
+				}
+				@regexp      = Regexp.new('^'+tiles.join('\s+')+'$')
+			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
+			end
+			
+			def call(message, params)
+				@plugin.new(message).send(@method, params)
+			end
+
+			def priority
+				-10
+			end
+			
+			def <=>(other)
+				-10 <=> other.priority
+			end
+			
+			def abort_invocations?
+				true
+			end
+
+			def eql?(other)
+				other.kind_of?(Mapper) && @name.eql?(other.name)
+			end
+		end
+	end
+end

data/lib/butler/plugin/matcher.rb

@@ -0,0 +1,55 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler
+	class Plugin
+		class Matcher
+			attr_reader :priority
+			attr_reader :hash
+			attr_reader :en_match
+			attr_reader :plugin
+
+			def initialize(matcher, priority=0, &callback)
+				@matcher = case matcher
+					when Hash: matcher
+					when Regexp: { "en" => matcher }
+					else raise ArgumentError, "Matcher must be either Regexp or Hash, but is #{matcher.class}"
+				end
+				raise ArgumentError, "Matcher must supply an english variant" unless @matcher["en"]
+				@priority   = priority
+				@callback   = callback
+				@en_matcher = @matcher["en"]
+				@hash       = @en_matcher.hash
+			end
+			
+			def name
+				"matcher:#{@en_matcher}"
+			end
+			
+			def <=>(other)
+				@priority <=> other.priority
+			end
+			
+			def eql?(other)
+				other.kind_of?(Matcher) && @en_matcher.eql?(other.en_matcher)
+			end
+			
+			def ===(message)
+				if @matcher.has_key?(message.language) then
+					@matcher[message.language] =~ message.text
+				else
+					@matcher["en"] =~ message.text
+				end
+			end
+			
+			def call(*args)
+				@callback.call(self, *args)
+			end
+		end
+	end
+end

data/lib/butler/plugin/onhandlers.rb

@@ -0,0 +1,70 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler
+	class Plugin
+		module OnHandlers
+			def method_added(name, *a, &b)
+				subscribe_on_handler(name)
+			end
+			
+			def subscribe_on_handler(handler, priority=0)
+				case handler
+					when :on_join:    subscribe(:JOIN,    priority) { |listener, message| new(message).on_join(listener, message.from, message.channel) }
+					when :on_privmsg: subscribe(:PRIVMSG, priority) { |listener, message| new(message).on_privmsg(listener, message.from, message.text) }
+					when :on_notice:  subscribe(:NOTICE,  priority) { |listener, message| new(message).on_notice(listener, message.from, message.text) }
+					when :on_nick:    subscribe(:NICK,    priority) { |listener, message| new(message).on_nick(listener, message.from, message.old_nick) }
+					when :on_topic:   subscribe(:TOPIC,   priority) { |listener, message| new(message).on_topic(listener, message.from, message.channel, message.text) }
+					when :on_part:    subscribe(:PART,    priority) { |listener, message| new(message).on_part(listener, message.from, message.channel) }
+					when :on_quit:    subscribe(:QUIT,    priority) { |listener, message| new(message).on_quit(listener, message.from, message.text) }
+					when :on_kick:    subscribe(:KICK,    priority) { |listener, message| new(message).on_kick(listener) }
+					when :on_kill:    subscribe(:KILL,    priority) { |listener, message| new(message).on_kill(listener) }
+					when :on_kline:   subscribe(:KLINE,   priority) { |listener, message| new(message).on_kline(listener) }
+					when :on_invocation
+						subscribe(:PRIVMSG, priority) { |listener, message|
+							new(message).on_invocation(listener) if message.invocation
+						}
+						subscribe(:NOTICE, priority) { |listener, message|
+							new(message).on_invocation(listener) if message.invocation
+						}
+					when :on_ban
+						subscribe(:MODE, priority) { |listener, message|
+							bans = message.modes.select { |dir, type, target| dir == '+' && type == 'b' }
+							new(message).on_ban(listener, *bans.map { |a,b,c| c }) unless bans.empty?
+						}
+					when :on_unban
+						subscribe(:MODE, priority) { |listener, message|
+							unbans = message.modes.select { |dir, type, target| dir == '-' && type == 'b' }
+							new(message).on_unban(listener, *unbans.map { |a,b,c| c }) unless unbans.empty?
+						}
+					when :on_op
+						subscribe(:MODE, priority) { |listener, message|
+							ops = message.modes.select { |dir, type, target| dir == '+' && type == 'o' }
+							new(message).on_op(listener, *ops.map { |a,b,c| c }) unless ops.empty?
+						}
+					when :on_deop
+						subscribe(:MODE, priority) { |listener, message|
+							deops = message.modes.select { |dir, type, target| dir == '-' && type == 'o' }
+							new(message).on_deop(listener, *deops.map { |a,b,c| c }) unless deops.empty?
+						}
+					when :on_voice
+						subscribe(:MODE, priority) { |listener, message|
+							voices = message.modes.select { |dir, type, target| dir == '+' && type == 'v' }
+							new(message).on_voice(listener, *voices.map { |a,b,c| c }) unless voices.empty?
+						}
+					when :on_devoice
+						subscribe(:MODE, priority) { |listener, message|
+							devoices = message.modes.select { |dir, type, target| dir == '-' && type == 'v' }
+							new(message).on_devoice(listener, *devoices.map { |a,b,c| c }) unless devoices.empty?
+						}
+					# :on_action => :PRIVMSG, :NOTICE
+				end
+			end
+		end
+	end
+end

data/lib/butler/plugin/trigger.rb

@@ -0,0 +1,58 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler/plugin'
+
+
+
+class Butler
+	class Plugin
+		class Trigger
+			attr_reader :authorization
+			attr_reader :hash
+			attr_reader :language
+			attr_reader :name
+			attr_reader :plugin
+			attr_reader :trigger
+			attr_reader :hash
+
+			def initialize(plugin, language, trigger)
+				@plugin        = plugin
+				@language      = language
+				@trigger       = trigger.downcase
+				@authorization = "plugin/#{@plugin.base}".freeze
+				@name          = "trigger:#{@language}:#{@trigger}".freeze
+				@hash          = @name.hash
+			end
+			
+			def invoked_by?(message)
+				[]
+			end
+			
+			def call(message)
+				@plugin.new(message).on_trigger
+			end
+
+			def priority
+				0
+			end
+			
+			def <=>(other)
+				0 <=> other.priority
+			end
+			
+			def abort_invocations?
+				true
+			end
+
+			def eql?(other)
+				other.kind_of?(Trigger) && @name.eql?(other.name)
+			end
+		end
+	end
+end

data/lib/butler/plugins.rb

@@ -0,0 +1,147 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'scriptfile'
+require 'butler/plugin'
+require 'butler/dialog'
+require 'iterator'
+require 'log/comfort'
+require 'ruby/exception/detailed'
+
+
+
+class String
+	# CamelCase a string, e.g. "foo_bar" becomes "FooBar"
+	def camelcase
+		scan(/[^_]+/).map { |s| s.capitalize }.join("")
+	end
+end
+
+class Butler
+	# Plugins manages the plugins in Butler
+	# It uses 
+	class Plugins
+		include Enumerable
+		include Log::Comfort
+
+		Suffix = ".rb"
+
+		attr_reader :dir
+		def initialize(butler, plugin_dir)
+			@dir       = File.expand_path(plugin_dir).freeze
+			raise ArgumentError, "#{@dir} is not a directory" unless File.directory?(@dir)
+			@plugins   = {}
+			@constants = {}
+			@butler    = butler
+		end
+		
+		# returns a list with first-level groups
+		def groups
+			slice = @dir.length+1..-1
+			Dir[@dir+"/*"].reject { |file|
+				File.extname(file).downcase == Suffix
+			}.map { |file|
+				file[slice]
+			}
+		end
+		
+		def instances
+			@plugins.values
+		end
+
+		# returns a list with the bases of all plugins
+		def all
+			slice = @dir.length+1..-(Suffix.length+1)
+			Dir["#{@dir}/**/*#{Suffix}"].select { |file| File.file?(file) }.map { |file|
+				file[slice]
+			}
+		end
+		
+		# returns a list with the names of active plugins
+		def active
+			@plugins.keys
+		end
+		
+		def inactive
+			all-active
+		end
+		
+		def loaded?(base)
+			@plugins.has_key?(base)
+		end
+		
+		def [](base)
+			@plugins[base]
+		end
+		
+		def identify(name)
+			plugin = Dir["#{@dir}/**/*#{name}#{Suffix}"].first
+			plugin && plugin[@dir.length+1..-(Suffix.length+1)]
+		end
+		
+		def load_all
+			all.each { |base|
+				load(base)
+			}
+		end
+		
+		def load_group(group)
+			slice = @dir.length+1..-(Suffix.length+1)
+			Dir["#{@dir}/#{group}/**/*#{Suffix}"].select { |file| File.file?(file) }.each { |file|
+				load(file[slice])
+			}
+		end
+		
+		def load(base)
+			path     = "#{@dir}/#{base.downcase}#{Suffix}"
+			name     = File.basename(base).camelcase
+			codefile = path
+
+			unless File.file?(codefile) then
+				raise ArgumentError, "Invalid plugin '#{base}' (codefile: #{codefile})."
+			end
+			begin
+				unload(base) if loaded?(base) # a plugin may not be loaded twice
+			rescue Exception => e
+				exception(e)
+			end
+			begin
+				constant = "%s_%08X" %  [name, rand(0xffffffff)]
+			end while Butler::Plugins.const_defined?(constant)
+			plugin = Butler::Plugins.const_set(constant, Class.new(Plugin))
+			plugin.log_device = @butler.log_device
+			begin
+				plugin.load_plugin(@butler, base, path)
+				plugin.class_eval(File.read(codefile), codefile)
+				plugin.on_load
+			rescue Exception => e
+				e.extend Exception::Detailed
+				e.prepend "Loading plugin #{base} failed."
+				exception(e)
+			end
+			@constants[base] = constant.freeze
+			@plugins[base]   = plugin
+		end
+		alias reload load
+		
+		def unload(base)
+			begin
+				@plugins[base].on_unload
+				@plugins[base].unload_plugin
+			rescue Exception => e
+				e.extend Exception::Detailed
+				e.prepend "Exception raised while unloading plugin #{base}."
+				exception(e)
+			end
+			Butler::Plugins.send(:remove_const, @constants[base])
+			@plugins.delete(base)
+			@constants.delete(base)
+			true
+		end
+	end
+end