butler 1.8.3 → 1.9.0

data/data/butler/plugins/service/log.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+def on_start_logging(params)
+	params.channels.each { |channel|
+		service("log").start_logging(channel)
+	}
+	answer(:started_logging, :channels => params.channels)
+end
+
+def on_stop_logging(params)
+	params.channels.each { |channel|
+		service("log").stop_logging(channel)
+	}
+	answer(:stopped_logging, :channels => params.channels)
+end
+
+def on_list_logged_channels(params)
+	answer(:logging_channels, :channels => service("log").logged_channels)
+end
+
+def on_search_log(params)
+	args = {}
+	args[:nick]    = params.nick
+	args[:text]    = params.text.split(/\s+/) if params.text
+	args[:channel] = params.channel
+	
+	found = service("log").find_last(5, args)
+
+	if found.length.zero? then
+		answer(:no_match)
+	else
+		upper = [5,found.length].min
+		answer("Found (1-#{upper} of #{found.length}):")
+		found.each_with_index { |row, index|
+			answer(
+				"#{index+1}: " \
+				"[#{row.time.strftime('%Y-%m-%d %H:%M')}, " \
+				"#{row.nick} in #{row.channel}] " \
+				"#{row.text}"
+			)
+		}
+	end
+end
+
+__END__
+--- 
+:about:
+  :mail: "apeiros@gmx.net"
+  :version: "1.0.0"
+  :author: "Stefan Rusterholz"
+:help:
+  en:
+    "": Log channel messages.
+:map:
+  :on_start_logging:
+    en: start logging in *channels@Channelname
+  :on_stop_logging:
+    en: stop logging in *channels@Channelname
+  :on_list_logged_channels:
+    en: list logged channels
+  :on_search_log:
+    en: search log [for +text] [from :nick@Nick] [in :channel@Channelname]
+:strings:
+  :no_match:
+    en: "No match found."
+  :logging_channels:
+    en: |
+      Logging is active for: <%= channels.join(', ') %>.
+  :started_logging:
+    en: |
+      Logging activated in: <%= channels.join(', ') %>.
+  :stopped_logging:
+    en: |
+      Logging deactivated in: <%= channels.join(', ') %>.
+:summary:
+  en: Log channel messages
+:revision:
+  :plugin: 2
+  :configuration: 2

data/data/butler/plugins/service/seen.rb

@@ -0,0 +1,64 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+def on_seen(params)
+	found = service("log").find_last(
+		:nick => params.nick,
+		:type => [:JOIN, :PART, :QUIT, :KICK, :KILL]
+	)
+	if found then
+		case found.type
+			when :JOIN
+				answer(:still_online, :nick => params.nick)
+			when :PART
+				answer(:last_seen_part, :time => found.time, :nick => params.nick, :text => found.text || "", :channel => found.channel)
+			when :QUIT
+				answer(:last_seen_quit, :time => found.time, :nick => params.nick, :text => found.text || "")
+			when :KICK
+				answer(:last_seen_kick, :time => found.time, :nick => params.nick, :text => found.text || "", :channel => found.channel)
+			when :KILL
+				answer(:last_seen_kill, :time => found.time, :nick => params.nick, :text => found.text || "")
+		end
+	else
+		service("strings").answer(@message, "ignorance")
+	end
+end
+
+__END__
+--- 
+:about:
+  :mail: "apeiros@gmx.net"
+  :version: "1.0.0"
+  :author: "Stefan Rusterholz"
+:help:
+  en:
+    "": "Check when a user was last online."
+:map:
+  :on_seen:
+    en: "seen :nick@Nick[?]"
+    de: "hast du :nick@Nick gesehen[?]"
+:revision:
+  :plugin: 1
+:services:
+  -log
+  -strings
+:strings:
+  :still_online:
+    en: "<%= nick %> is still online."
+  :last_seen_part:
+    en: "<%= nick %> was last seen <%= time.strftime('%Y-%m-%d at %H:%M') %>, parting from <%= channel %><% if text.strip.empty? then %> not saying why<% else %> saying <%= text %><% end %>."
+  :last_seen_quit:
+    en: "<%= nick %> was last seen <%= time.strftime('%Y-%m-%d at %H:%M') %>, when he quit<% if text.strip.empty? then %> without a reason<% else %> with reason <%= text %><% end %>."
+  :last_seen_kick:
+    en: "<%= nick %> was last seen <%= time.strftime('%Y-%m-%d at %H:%M') %>, when he was kicked from <%= channel %><% if text.strip.empty? then %> for no reason<% else %> for <%= text %><% end %>."
+  :last_seen_kill:
+    en: "<%= nick %> was last seen <%= time.strftime('%Y-%m-%d at %H:%M') %>, when he was killed<% if text.strip.empty? then %> for no reason<% else %> for <%= text %><% end %>."
+:summary:
+  en: "Check when a user was last online."
+:usage:
+  en: "![b]seen![o] nick?"

data/data/butler/plugins/service/svn.rb

@@ -11,7 +11,7 @@ require 'hpricot'
 require 'cgi'
 
 configuration(
-	"frequency"    => 900,
+	"frequency"    => 900, # In seconds, default is 900 == 15 minutes
 	"repositories" => {}
 )
 
@@ -32,6 +32,7 @@ end
 every(@config["frequency"]) do
 	repositories = @config["repositories"]
 	repositories.each { |repo, data|
+		debug "Checking SVN repository #{repo}"
 		cr, lr = current_revision(repo), data[:revision]
 		if cr > lr then
 			data[:revision] = cr
@@ -77,15 +78,15 @@ __END__
   en: "Poll repositories for changes and publicate them."
 :about:
   :mail: "apeiros@gmx.net"
-  :version: "1.0.0"
+  :version: "1.2.0"
   :author: "Stefan Rusterholz"
 :usage:
-  en: "![b]svn![o] 'add' repository channel ..."
+  en: "![b]svn![o] 'add' repository #channel [#channel2...]"
 :help:
   en:
     "": "Poll repositories for changes and publicate them."
 :strings:
   :added:
-    en: Added repository <%= repository %>.
+    en: Added repository <%= repository %>
   :removed:
-    en: Added repository <%= repository %>.
+    en: Removed repository <%= repository %>

data/data/butler/plugins/util/load.rb

@@ -11,6 +11,8 @@ def on_trigger
 	vsz, rss, cpu, pmem = ps_out.scan(/\d+(?:[.,]\d+)?/).map { |e| e.gsub(/,/,'.').to_f } # ps on 10.5.1 outputs ',' instead of '.' for MEM%
 	virtual, real = (vsz-rss).div(1024), rss.div(1024)
 	answer(:memusage, :real => real, :virtual => virtual, :cpu => cpu, :pmem => pmem)
+rescue Interrupt
+	raise
 rescue Exception => e
 	answer(:failure, :exception => e)
 end
@@ -32,7 +34,7 @@ __END__
 :strings:
   :memusage:
     en: |
-      Memory: <%= real %>MB real, <%= virtual %>MB virtual (<%= pmem %>%), CPU: <%= cpu %>%.
+      Memory: <%= pmem %>% (<%= real %>MB real, <%= virtual %>MB virtual), CPU: <%= cpu %>%.
   :failure:
     en: |
       Failed with exception <%= exception %>.

data/data/butler/services/org.rubyforge.butler/calculator/1/service.rb

@@ -0,0 +1,96 @@
+require 'blank'
+
+class Functions
+	def initialize
+		@functions = {}
+	end
+	
+	def [](name)
+		@functions[name.to_s]
+	end
+
+	def []=(name, definition)
+		@functions[name.to_s] = definition
+	end
+	
+	def call(m, *args)
+		@functions[m.to_s].call(*args)
+	end
+	
+	def respond_to?(m, *a)
+		super || @functions.has_key?(m.to_s)
+	end
+
+	def method_missing(m, *args)
+		super unless @functions.has_key?(m.to_s)
+		@functions[m.to_s].call(*args)
+	end
+end
+
+class Calculator < Blank('inspect', 'binding', 'method_missing')
+	include Math
+	
+	attr_reader :term
+
+	def initialize(term, delegate=nil)
+		@term      = term.scan(/\s+|,|[a-z]*\(|\)|-?\d(?:\.\d+)?|[a-z]+|[*\/%+-]/).join.gsub(/%[^\d\s]/, '')
+		@variables = {}
+		@delegate  = delegate
+		@results   = []
+	end
+	
+	def result(variables={})
+		@variables = variables
+		error      = nil
+		@results.unshift Thread.new {
+			begin
+				Kernel.eval(@term, binding)
+			rescue Exception => e
+				error = e
+				nil
+			end
+		}.value
+		if error then
+			@results.shift
+			Kernel.raise error
+		end
+		@results.pop if @results.length > 10
+		@results.first
+	end
+	alias call result
+	
+	def load(result)
+		@results[result]
+	end
+	
+	def method_missing(m, *a)
+		if a.empty? && @variables.has_key?(m.to_s) then
+			@variables[m.to_s]
+		elsif @delegate.respond_to?(m) then
+			@delegate.call(m, *a)
+		else
+			super
+		end
+	end
+end
+
+class CalcService
+	def initialize
+		@functions = Functions.new
+	end
+	
+	def register_function(name, variables, term)
+		calculator = Calculator.new(term, @functions)
+		@functions[name] = proc { |*args|
+			hash = {}
+			variables.zip(args) { |key, value| hash[key.to_s] = value }
+			calculator.result(hash)
+		}
+	end
+	
+	def calculate(term)
+		Calculator.new(term, @functions).result
+	end
+end
+
+register(CalcService.new)

data/data/butler/services/org.rubyforge.butler/log/1/service.rb

@@ -6,37 +6,44 @@
 
 
 
+# FIXME, remove as soon as the sqlite people figured out how to init globals
+$swig_runtime_data_type_pointer2 = nil unless defined? $swig_runtime_data_type_pointer2
+require 'log/comfort'
 require 'sqlite3'
 require 'thread'
 require 'ruby/file/write'
 
 
 
-MessageTypes = [:PRIVMSG, :NOTICE, :JOIN, :PART, :QUIT, :KICK, :KILL]
-Row = Struct.new(:oid, :time, :channel, :nick, :type, :text)
+MessageTypes = [:PRIVMSG, :NOTICE, :JOIN, :PART, :QUIT, :KICK, :KILL, :NICK, :TOPIC]
+Row = Struct.new(:oid, :time, :channel, :nick, :type, :text, :identified)
 def Row.from_row(row)
-	oid, time, channel, nick, type, text = *row
-	new(oid.to_i, Time.at(oid.to_i), channel, nick, MessageTypes[type.to_i], text)
+	oid, time, channel, nick, type, text, identified = *row
+	new(oid.to_i, Time.at(time.to_i), channel, nick, MessageTypes[type.to_i], text, identified=="1")
 end
 
 class IRCLogger
+	include Log::Comfort
+
 	def initialize(db, channels)
 		@db_file = db
 		@db      = SQLite3::Database.new(db)
+		@logger  = nil
 		@db.execute %q{
 			CREATE TABLE IF NOT EXISTS messages(
-				oid INTEGER PRIMARY KEY AUTOINCREMENT,
-				time INTEGER,
-				channel TEXT,
-				nick TEXT,
-				type INTEGER,
-				text TEXT
+				oid        INTEGER PRIMARY KEY AUTOINCREMENT,
+				time       INTEGER,
+				channel    TEXT,
+				nick       TEXT,
+				type       INTEGER,
+				text       TEXT,
+				identified INTEGER
 			)
 		}
 		@insert  = @db.prepare %q{
 			INSERT INTO messages
-			(time, channel, nick, type, text)
-			VALUES (:time, :channel, :nick, :type, :text)
+			(time, channel, nick, type, text, identified)
+			VALUES (:time, :channel, :nick, :type, :text, :identified)
 		}
 		File.write(channels, {}.to_yaml) unless File.exist?(channels)
 		@channels    = YAML.load_file(channels)
@@ -58,6 +65,10 @@ class IRCLogger
 		}
 	end
 	
+	def logged_channels
+		@channels.keys
+	end
+	
 	def logged?(channel)
 		@channels.has_key?(channel)
 	end
@@ -67,7 +78,7 @@ class IRCLogger
 	end
 	
 	def select(statement=nil, *values)
-		query = "SELECT * FROM messages #{statement}"
+		debug(query = "SELECT * FROM messages #{statement}")
 		if block_given? then
 			@db.execute(query, *values) { |row|
 				yield(Row.from_row(row))
@@ -80,26 +91,67 @@ class IRCLogger
 	end
 	
 	def find(args={}, &block)
-		where = []
-		if nick = args[:nick] then
-			where << field_equals_values('nick', nick)
-		end
-		if channel = args[:channel] then
-			where << field_equals_values('channel', channel)
-		end
-		if time = args[:time] then
-			where << "time >= #{SQLite3::Database.quote(time.begin.to_i)} AND time <= #{SQLite3::Database.quote(time.end.to_i)}"
+		select(where(args), &block)
+	end
+	
+	def find_first(*args)
+		case args.length
+			when 0, 1
+				if Integer === args.first then
+					select("LIMIT #{args.first}")
+				else
+					select(where(args.first)+" LIMIT 1").first
+				end
+			when 2
+				select(where(args.last)+" LIMIT #{args.first}")
+			else
+				raise ArgumentError, "0, 1 or 2 arguments accepted"
 		end
-		if types = args[:type] then
-			where << field_equals_values('type', types)
+	end
+	
+	def find_last(*args)
+		case args.length
+			when 0, 1
+				if Integer === args.first then
+					select("ORDER BY time DESC LIMIT #{args.first}").reverse
+				else
+					select(where(args.first)+" ORDER BY time DESC LIMIT 1").first
+				end
+			when 2
+				select(	where(args.last)+" ORDER BY time DESC LIMIT #{args.first}").reverse
+			else
+				raise ArgumentError, "0, 1 or 2 arguments accepted"
 		end
-		if text = args[:text] then
-			field_contains_all_values('text', text)
+	end
+	
+	def where(args=nil, connected='AND')
+		where = sub_where(args || {}, connected)
+		where.empty? ? "" : 'WHERE '+where.join(' AND ')
+	end
+	
+	def sub_where(args={}, connected='AND')
+		where = []
+		where << field_equals_values('nick', args[:nick]) if args[:nick]
+		where << field_equals_values('channel', args[:channel]) if args[:channel]
+		where << field_within('time', args[:time].begin.to_i, args[:time].end.to_i) if args[:time]
+		if args[:type] then
+			if Array === args[:type] then
+				args[:type] = args[:type].map { |e| MessageTypes.index(e).to_s }
+			else
+				args[:type] = MessageTypes.index(args[:type]).to_s
+			end
+			where << field_equals_values('type', args[:type])
 		end
-		select(where.empty? ? nil : 'WHERE '+where.join(' AND '), &block)
+		where << field_like_values('text', args[:text]) if args[:text]
+		where
 	end
 	
-	def field_equals_values(field, values)
+	def field_within(field, lower, upper)
+		"(#{field} >= #{SQLite3::Database.quote(lower)} AND " \
+		"#{field} <= #{SQLite3::Database.quote(upper)})" 
+	end
+
+	def field_like_values(field, values)
 		if Array === values then
 			values.map { |e| "#{field} LIKE '#{SQLite3::Database.quote(e)}'" }.join(" AND ")
 		else
@@ -111,12 +163,12 @@ class IRCLogger
 		if Array === values then
 			is_in(field, values)
 		else
-			"#{field} = '#{SQLite3::Database.quote(values)}'"
+			"#{field} == '#{SQLite3::Database.quote(values)}'"
 		end
 	end
 	
 	def is_in(field, values)
-		"#{field} IN ('#{values.map { |e| SQLite3::Database.quote(text) }.join('\', \'') }')"
+		"#{field} IN ('#{values.map { |e| SQLite3::Database.quote(e) }.join('\', \'') }')"
 	end
 end
 
@@ -124,75 +176,103 @@ def self.on_load
 	logger = IRCLogger.new(@path.base+'/log.sqlite', @path.base+'/channels.yaml')
 
 	subscribe(:PRIVMSG, -10, MessageTypes.index(:PRIVMSG)) { |listener, message, type|
-		next unless logger.logged?(message.channel.to_str)
+		next unless message.channel and logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => message.identified? ? 1 : 0
 		)
 	}
 	subscribe(:NOTICE, -10, MessageTypes.index(:NOTICE)) { |listener, message, type|
-		next unless logger.logged?(message.channel.to_str)
+		next unless message.channel and logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => message.identified? ? 1 : 0
 		)
 	}
 	subscribe(:JOIN, -10, MessageTypes.index(:JOIN)) { |listener, message, type|
 		next unless logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => nil
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => nil,
+			:identified => 0
 		)
 	}
 	subscribe(:PART, -10, MessageTypes.index(:PART)) { |listener, message, type|
 		next unless logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => 0
 		)
 	}
 	subscribe(:QUIT, -10, MessageTypes.index(:QUIT)) { |listener, message, type|
-		next unless logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => "",
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => 0
 		)
 	}
 	subscribe(:KICK, -10, MessageTypes.index(:KICK)) { |listener, message, type|
 		next unless logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => 0
 		)
 	}
 	subscribe(:KILL, -10, MessageTypes.index(:KILL)) { |listener, message, type|
 		next unless logger.logged?(message.channel.to_str)
 		logger.insert(
-			:time    => Time.now.to_i,
-			:channel => message.channel.to_str,
-			:nick    => message.from.nick,
-			:type    => type,
-			:text    => message.text
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => 0
+		)
+	}
+	subscribe(:NICK, -10, MessageTypes.index(:NICK)) { |listener, message, type|
+		logger.insert(
+			:time       => Time.now.to_i,
+			:channel    => "",
+			:nick       => message.old_nick,
+			:type       => type,
+			:text       => message.from.nick,
+			:identified => 0
+		)
+	}
+	subscribe(:TOPIC, -10, MessageTypes.index(:TOPIC)) { |listener, message, type|
+		next unless logger.logged?(message.channel.to_str)
+		logger.insert(
+			:time       => Time.now.to_i,
+			:channel    => message.channel.to_str,
+			:nick       => message.from.nick,
+			:type       => type,
+			:text       => message.text,
+			:identified => 0
 		)
 	}
 
+
 	register(logger)
 end