butler 1.8.0 → 1.8.1

data/lib/butler/irc/parser/rfc2812.rb

@@ -0,0 +1,328 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# A list with RFC2812 compatible IRC-Commands and it's parsing instructions
+# Currently many of them are still in generic.rb
+
+
+
+# --- Text based ----------------------------------------
+add("error",   :ERROR)		# ERROR :<error-message>
+add("invite",  :INVITE, /^(\S*) :(.*)/, [:invited, :channel])
+add("join",    :JOIN,   /^:(.*)/,          [:channel]) { |message, parser|
+	if message.from && message.channel then
+		message.from.add_channel(message.channel, :join)
+		message.channel.add_user(message.from, :join)
+	end
+}
+add("kick",    :KICK,   /^(\S*) (\S*) :(.*)/, [:channel, :for, :text]) { |message, parser|
+	parser.leave_channel(message, :kick, :kicked)
+}
+add("kill",    :KILL,   /^(\S*) (\S*) (.*)/, [:channel, :for, :text]) { |message, parser|
+	if message.for then
+		message.for.kill
+		parser.channels.delete_user(message.for, :kill)
+	end
+}
+# FIXME, really ':?' or just plain ':'?
+add("mode",    :MODE,   /^(\S*) :?(.*)/, [:for, :arguments]) { |message, parser|
+	modifiers				= message[:arguments].split(" ")
+	modes					= modifiers.shift.split("")
+	flags					= {"o" => User::Flags::OP, "v" => User::Flags::VOICE, "u" => User::Flags::UOP}
+	message.create_member(:modes, [])
+	argumentIndex			= 0
+	direction				= "+"
+
+	modes.each { |mode|
+		# MODEs direction
+		if (["+", "-"].include?(mode)) then
+			direction	= mode
+		# MODEs taking an argument
+		elsif (["k", "o", "v", "u"].include?(mode) || (mode == "l" && direction == "+")) then
+			if ["o", "v", "u"].include?(mode) then
+				if (direction == "+") then
+					parser.users[modifiers[argumentIndex]].add_flags(message.channel, flags[mode]) #adding flags to user
+				else
+					parser.users[modifiers[argumentIndex]].delete_flags(message.channel, flags[mode]) #removing flags from user
+				end
+			end
+			message.modes << [direction, mode, modifiers[argumentIndex]]
+			argumentIndex	= argumentIndex+1
+		# MODEs without argument
+		else
+			message.modes << [direction, mode, nil]
+		end
+	}
+}
+add("nick",    :NICK,    /^:(.*)/, [:nick]) { |message, parser|
+	message.create_member(:old_nick, message.from.nick)
+	message.from.nick = message.nick if message.from
+}
+add("notice",  :NOTICE,  /(\S+) :(.*)/, [:for, :text]) { |message, parser|
+	if message.channel then
+		message.create_member(:realm, :public)
+		message.create_method(:private?) { false }
+		message.create_method(:public?) { true }
+	else
+		message.create_member(:realm, :private)
+		message.create_method(:private?) { true }
+		message.create_method(:public?) { false }
+	end
+}
+add("part",    :PART,    /^([^\x00\x07\x10\x0D\x20,:]+)(?: :(.*))?/, [:channel, :reason]) { |message, parser|
+	parser.leave_channel(message, :part, :parted)
+}
+add("ping",    :PING,    /:(.*)/, [:pong])
+add("pong",    :PONG)
+add("privmsg", :PRIVMSG, /(\S+) :(.*)/, [:for, :text]) { |message, parser|
+	if message.channel then
+		message.create_member(:realm, :public)
+		message.create_method(:private?) { false }
+		message.create_method(:public?) { true }
+	else
+		message.create_member(:realm, :private)
+		message.create_method(:private?) { true }
+		message.create_method(:public?) { false }
+	end
+}
+add("quit",    :QUIT,    /(.*)/, [:text]) { |message, parser|
+	if message.from then
+		message.from.quit
+		parser.channels.delete_user(message.from, :quit)
+		parser.users.delete(message.from, :quit)
+	end
+}
+add("topic",   :TOPIC, /(\S+) :(.*)/, [:channel, :text])
+
+
+
+# --- 0** Codes ----------------------------------------
+add("001", :RPL_WELCOME)
+add("002", :RPL_YOURHOST)
+add("003", :RPL_CREATED)
+add("004", :RPL_MYINFO)
+add("005", :RPL_ISUPPORT)
+
+
+
+
+# --- 2** Codes ----------------------------------------
+add("200", :RPL_TRACELINK)
+add("201", :RPL_TRACECONNECTING)
+add("202", :RPL_TRACEHANDSHAKE)
+add("203", :RPL_TRACEUNKNOWN)
+add("204", :RPL_TRACEOPERATOR)
+add("205", :RPL_TRACEUSER)
+add("206", :RPL_TRACESERVER)
+add("207", :RPL_TRACESERVICE)
+add("208", :RPL_TRACENEWTYPE)
+add("209", :RPL_TRACECLASS)
+add("210", :RPL_TRACERECONNECT)
+add("211", :RPL_STATSLINKINFO)
+add("212", :RPL_STATSCOMMANDS)
+add("213", :RPL_STATSCLINE)
+add("214", :RPL_STATSNLINE)
+add("215", :RPL_STATSILINE)
+add("216", :RPL_STATSKLINE)
+add("217", :RPL_STATSQLINE)
+add("218", :RPL_STATSYLINE)
+add("219", :RPL_ENDOFSTATS)
+
+add("221", :RPL_UMODEIS)
+
+add("231", :RPL_SERVICEINFO)
+add("232", :RPL_ENDOFSERVICES)
+add("233", :RPL_SERVICE)
+add("234", :RPL_SERVLIST)
+add("235", :RPL_SERVLISTEND)
+
+add("240", :RPL_STATSVLINE)
+add("241", :RPL_STATSLLINE)
+add("242", :RPL_STATSUPTIME)
+add("243", :RPL_STATSOLINE)
+add("244", :RPL_STATSHLINE)
+add("245", :RPL_STATSSLINE)	# RFC 2812 seems to be erroneous, it assigns 244 double
+add("246", :RPL_STATSPING)
+add("247", :RPL_STATSBLINE)
+add("250", :RPL_STATSCONN)
+add("251", :RPL_LUSERCLIENT)
+add("252", :RPL_LUSEROP)
+add("253", :RPL_LUSERUNKNOWN)
+add("254", :RPL_LUSERCHANNELS)
+add("255", :RPL_LUSERME)
+add("256", :RPL_ADMINME)
+add("257", :RPL_ADMINLOC1)
+add("258", :RPL_ADMINLOC2)
+add("259", :RPL_ADMINEMAIL)
+
+add("261", :RPL_TRACELOG)
+add("262", :RPL_TRACEEND)
+
+add("263", :RPL_TRYAGAIN)
+
+
+
+# --- 3** Codes ----------------------------------------
+add("300", :RPL_NONE)
+add("301", :RPL_AWAY)
+add("302", :RPL_USERHOST)
+add("303", :RPL_ISON)
+add("305", :RPL_UNAWAY)
+add("306", :RPL_NOWAWAY)
+add("311", :RPL_WHOISUSER, /^(\S+) (\S+) (\S+) (\S+) \* :(.*)/, [:for, :nick, :user, :host, :real])
+add("312", :RPL_WHOISSERVER)
+add("313", :RPL_WHOISOPERATOR)
+add("314", :RPL_WHOWASUSER)
+add("315", :RPL_ENDOFWHO)
+add("316", :RPL_WHOISCHANOP)
+add("317", :RPL_WHOISIDLE, /^(\S+) (\S+) ([^:]+) :(.*)/, [:for, :nick, :values, :descriptions]) { |message, parser|
+	values			= message[:values].split(" ");
+	descriptions	= message[:descriptions].split(", ").map { |desc| desc.gsub(" ", "_").to_sym };
+	message.delete(:values)
+	message.delete(:descriptions)
+	0.upto([values.length, descriptions.length].min-1) { |index|
+		message[descriptions[index]]	= values[index]
+	}
+}
+add("318", :RPL_ENDOFWHOIS)
+add("319", :RPL_WHOISCHANNELS, /^(\S+) (\S+) :(.*)/, [:for, :nick, :channels]) { |message, parser|
+	# FIXME
+	message.alter_member(:channels, message.channels.split(" ").map { |channel| parser.channels.create(channel) })
+}
+add("321", :RPL_LISTSTART)
+add("322", :RPL_LIST, /^(\S+) (\S+) (\d+) :(.*)/, [:for, :channelname, :usercount, :topic])
+add("323", :RPL_LISTEND)
+add("324", :RPL_CHANNELMODEIS)
+add("325", :RPL_UNIQOPIS)
+add("331", :RPL_NOTOPIC)
+		# :irc.server.net 332 YourNickname #channel :Topic
+add("332", :RPL_TOPIC, /^(\S+) (\S+) :(.*)/, [:for, :channel, :topic]) { |message, parser|
+	message.channel.topic.text = message[:topic]
+}
+add("341", :RPL_INVITING)
+add("342", :RPL_SUMMONING)
+add("346", :RPL_INVITELIST)
+add("347", :RPL_ENDOFINVITELIST)
+add("348", :RPL_EXCEPTLIST)
+add("349", :RPL_ENDOFEXCEPTLIST)
+add("351", :RPL_VERSION)
+		# :irc.server.net 352 YourNickname <channel> <user> <host> <server> <nick> ( "H" / "G" > ["*"] [ ( "@" / "+" ) ] :<hopcount> <real name>
+add("352", :RPL_WHOREPLY,
+			/(\S+) (\S+) (\S+) (\S+) (\S+) (\S+) ([HG])[*%]{0,2}([@+-]{0,3}) :(\d+) (.*)/,
+			[:for, :channel, :user, :host, :server, :nick, :status, :flags, :hopcount, :real]) { |message, parser|
+#"for", "channel", "user", "host", "server", "nick", "status", "flags", "hopcount", "real"
+	user	= parser.users.create(message[:nick])
+	user.update(message[:user], message[:host], message[:real])
+	user.away	= message[:status] == "G"
+	user.add_channel(message.channel, :joined)
+	message.channel.add_user(user, :joined)
+	user.add_flags(message.channel, message[:flags].to_flags)
+}
+add("353", :RPL_NAMEREPLY, /(\S+) [=@] (\S+) :(.*)/, [:for, :channel, :users]) { |message, parser|
+	users	= message[:users]
+	message.alter_member(:users, [])
+	users.split(/ /).each { |nick|
+		user	= parser.users.create(nick)
+		message[:users]	<< user
+		user.add_channel(message.channel, :joined)
+		message.channel.add_user(user, :joined)
+	}
+}
+add("361", :RPL_KILLDONE)
+add("362", :RPL_CLOSING)
+add("363", :RPL_CLOSEEND)
+add("364", :RPL_LINKS)
+add("365", :RPL_ENDOFLINKS)
+add("366", :RPL_ENDOFNAMES)
+add("367", :RPL_BANLIST,
+			/(\S+) (\S+) (\S+) (\S+) (\d+)/,
+			[:for, :channel, :banmask, :banned_by, :bantime]
+) { |message, parser| #367 nickname #channel nick!user@host nickname 1140125288
+	message[:bantime]	= Time.at(message[:bantime].to_i)
+	message[:banmask]	= Hostmask.new(message[:banmask])
+}
+add("369", :RPL_ENDOFWHOWAS)
+
+add("368", :RPL_ENDOFBANLIST)
+add("371", :RPL_INFO)
+add("372", :RPL_MOTD)
+add("373", :RPL_INFOSTART)
+add("374", :RPL_ENDOFINFO)
+add("375", :RPL_MOTDSTART)
+add("376", :RPL_ENDOFMOTD)
+add("381", :RPL_YOUREOPER)
+add("382", :RPL_REHASHING)
+add("383", :RPL_YOURESERVICE)
+add("384", :RPL_MYPORTIS)
+add("391", :RPL_TIME)
+add("392", :RPL_USERSSTART)
+add("393", :RPL_USERS)
+add("394", :RPL_ENDOFUSERS)
+add("395", :RPL_NOUSERS)
+
+
+
+# --- 4** Codes ----------------------------------------
+add("401", :ERR_NOSUCHNICK)
+add("402", :ERR_NOSUCHSERVER)
+add("403", :ERR_NOSUCHCHANNEL)
+add("404", :ERR_CANNOTSENDTOCHAN)
+add("405", :ERR_TOOMANYCHANNELS)
+add("406", :ERR_WASNOSUCHNICK)
+add("407", :ERR_TOOMANYTARGETS)
+add("408", :ERR_NOSUCHSERVICE)
+add("409", :ERR_NOORIGIN)
+add("411", :ERR_NORECIPIENT)
+add("412", :ERR_NOTEXTTOSEND)
+add("413", :ERR_NOTOPLEVEL)
+add("414", :ERR_WILDTOPLEVEL)
+add("415", :ERR_BADMASK)
+add("421", :ERR_UNKNOWNCOMMAND)
+add("422", :ERR_NOMOTD)
+add("423", :ERR_NOADMININFO)
+add("424", :ERR_FILEERROR)
+add("431", :ERR_NONICKNAMEGIVEN)
+add("432", :ERR_ERRONEUSNICKNAME)
+add("433", :ERR_NICKNAMEINUSE)
+add("436", :ERR_NICKCOLLISION)
+add("437", :ERR_UNAVAILRESOURCE)
+add("441", :ERR_USERNOTINCHANNEL)
+add("442", :ERR_NOTONCHANNEL)
+add("443", :ERR_USERONCHANNEL)
+add("444", :ERR_NOLOGIN)
+add("445", :ERR_SUMMONDISABLED)
+add("446", :ERR_USERSDISABLED)
+add("451", :ERR_NOTREGISTERED)
+add("461", :ERR_NEEDMOREPARAMS)
+add("462", :ERR_ALREADYREGISTRED)
+add("463", :ERR_NOPERMFORHOST)
+add("464", :ERR_PASSWDMISMATCH)
+add("465", :ERR_YOUREBANNEDCREEP)
+add("466", :ERR_YOUWILLBEBANNED)
+add("467", :ERR_KEYSET)
+add("471", :ERR_CHANNELISFULL)
+add("472", :ERR_UNKNOWNMODE)
+add("473", :ERR_INVITEONLYCHAN)
+add("474", :ERR_BANNEDFROMCHAN)
+add("475", :ERR_BADCHANNELKEY)
+add("476", :ERR_BADCHANMASK)
+add("477", :ERR_NOCHANMODES)
+add("478", :ERR_BANLISTFULL)
+add("481", :ERR_NOPRIVILEGES)
+add("482", :ERR_CHANOPRIVSNEEDED)
+add("483", :ERR_CANTKILLSERVER)
+add("484", :ERR_RESTRICTED)
+add("485", :ERR_UNIQOPPRIVSNEEDED)
+add("491", :ERR_NOOPERHOST)
+add("492", :ERR_NOSERVICEHOST)
+
+
+
+# --- 5** Codes ----------------------------------------
+add("501", :ERR_UMODEUNKNOWNFLAG)
+add("502", :ERR_USERSDONTMATCH)

data/lib/butler/irc/socket.rb

@@ -87,7 +87,7 @@ class Butler
 			#
 			def initialize(server, options={})
 				options       = OptionsDefault.merge(options)
-				@log_device   = options.delete(:log)
+				@logger       = options.delete(:log)
 				@server       = server # options.delete(:server)
 				@port         = options.delete(:port)
 				@eol          = options.delete(:eol).dup.freeze

data/lib/butler/irc/user.rb

@@ -87,6 +87,19 @@ class Butler
 				@real = real.freeze if real
 				self
 			end
+			
+			# :nodoc:
+			# DO NOT USE THIS METHOD
+			# This method is intended to be used by IRC::Parser or IRC::Client
+			# in case the server alters parts about 'myself'
+			# examples: some ircd's change the 'user' part (prefix it), some
+			# ircd's allow hiding the host, ...
+			def force_update(user=nil, host=nil, real=nil)
+				@user = user.freeze if user
+				@host = host.freeze if host
+				@real = real.freeze if real
+				self
+			end
 	
 			# set users nickname (should only be used by Butler::IRC::Parser)
 			def nick=(nick) #:nodoc:

data/lib/butler/plugin.rb

@@ -41,7 +41,7 @@ class Butler
 				@name      = File.basename(base).freeze
 				@commands  = []
 				@listener  = []
-				@config    = ConfigProxy.new(@butler.config, "plugin.#{name}")
+				@config    = ConfigProxy.new(@butler.config, "plugin/#{name}")
 	
 				if File.directory?(path) then
 					raise "Not supported yet" # FIXME

data/lib/butler/plugin/configproxy.rb

@@ -15,20 +15,20 @@ class Butler
 			end
 			
 			def []=(key, value)
-				@config[key.empty? ? @base : "#{@base}.#{key}"] = value
+				@config[key.empty? ? @base : "#{@base}/#{key}"] = value
 			end
 			
 			def [](key, *args)
-				@config[(key.empty? ? @base : "#{@base}.#{key}"), *args]
+				@config[(key.empty? ? @base : "#{@base}/#{key}"), *args]
 			end
 
 			def exist?(key)
-				@config.exist?(key.empty? ? @base : "#{@base}.#{key}")
+				@config.exist?(key.empty? ? @base : "#{@base}/#{key}")
 			end
 			alias has_key? exist?
 			
 			def delete(key)
-				@config.delete(key.empty? ? @base : "#{@base}.#{key}")
+				@config.delete(key.empty? ? @base : "#{@base}/#{key}")
 			end
 		end
 	end

data/lib/butler/plugins.rb

@@ -114,7 +114,7 @@ class Butler
 				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
+			plugin.logger = @butler.logger
 			begin
 				plugin.load_plugin(@butler, base, path)
 				plugin.class_eval(File.read(codefile), codefile)

data/lib/butler/version.rb

@@ -10,7 +10,7 @@ class Butler #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 8
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/configuration.rb

@@ -13,10 +13,24 @@ require 'yaml'
 
 class String
 	def config_key # FIXME %2e instead of . is just ugly...
-		gsub(/\./, '%2e')
+		gsub(/\//, '%2f')
 	end
 end
 
+# == Indexing
+# Author:  Stefan Rusterholz
+# Contact: apeiros@gmx.net>
+# Version: 1.0.0
+# Date:    2007-10-12
+#
+# == About
+# Map configuration keys/data to files
+# 
+# == Synopsis
+#   config = Configuration.new("my/config")
+#   config["some/key"] = "Some value"
+#   config["some/key"] = config["some/key"].upcase # can't use upcase!
+# 
 class Configuration
 	module VERSION
 		MAJOR  = 0
@@ -28,7 +42,7 @@ class Configuration
 		attr_reader :key
 		def initialize(key)
 			@key = key
-			super("Keys must not be empty nor contain '.'.")
+			super("Keys must not be empty")
 		end
 	end	
 
@@ -105,25 +119,26 @@ class Configuration
 	def setup(dirs)
 		FileUtils.mkdir_p(dirs.map { |dir| "#@base/#{dir}" })
 	end
-
+	
 	private
 	def key_exist?(file, key)
 		File.exist?(file) && (!key || load(file).has_key?(key))
 	end
 	
 	def split(key)
-		keys      = Array === key ? key.map { |k| String(k) } : key.split(/\./)
+		keys      = Array === key ? key.map { |k| String(k) } : key.split(/\//)
 		file      = @base.dup
-		raise InvalidKey.new(key) if (keys.empty? || keys.join.include?("."))
+		raise InvalidKey.new(key) if keys.empty?
 		file << "/#{encode_filename(keys.shift)}" while (File.directory?(file) && keys.first)
 		file << ".yaml"
 		return [file, keys.empty? ? nil : keys.join(".")]
 	end
 	
 	def encode_filename(name)
-		name.gsub(/[\x00-\x1f%\x7f]/) { |m| "%%%02x"%m[0] } # {}()\[\]~
+		# FIXME: {}()\[\]~ what about those?
+		name.gsub(/[\x00-\x1f%\x2f\x7f]/) { |m| "%%%02x"%m[0] }.sub(/^\x2e/, '%2e')
 	end
-	
+
 	def decode_filename(name)
 		name.gsub(/%[a-f\d]{2}/) { |m| m[1,2].to_i(16).chr }
 	end
@@ -157,67 +172,3 @@ class Configuration
 		end
 	end
 end
-
-if $0 == __FILE__ then
-	require 'test/unit'
-	class TestConfiguration < Test::Unit::TestCase
-		def setup
-			@conf = Configuration.new("./test")
-		end
-		
-		def test_setup
-			assert(@conf)
-			assert(@conf.base)
-			assert(File.directory?(@conf.base))
-		end
-		
-		def test_accessor
-			assert(@conf["file1"] = "bar")
-			assert_equal(@conf[[:file1]], "bar")
-			assert_equal(@conf[["file1"]], "bar")
-			assert_equal(@conf["file1"], "bar")
-			assert(File.exist?("#{@conf.base}/file1.yaml"))
-
-			assert(@conf["file2"] = "foo")
-			assert_equal(@conf[:file2], "foo")
-			assert_equal(@conf["file2"], "foo")
-			assert(File.exist?("#{@conf.base}/file2.yaml"))
-
-			assert(@conf[[:file3, :sub]] = "baz")
-			assert_equal(@conf[[:file3, :sub]], "baz")
-			assert_equal(@conf["file3", "sub"], "baz")
-			assert(File.exist?("#{@conf.base}/file3.yaml"))
-			assert(!File.exist?("#{@conf.base}/file3"))
-			
-			assert(@conf.exist?(:file3))
-			assert(!@conf.exist?(:file))
-			#assert_raise { @conf
-		end
-
-		def test_nesting
-		end
-		
-		def xtest_common_usecase
-			@conf.setup(%w(
-				main
-				plugins
-				plugins/demo
-			))
-			@conf.merge(
-				"main.language"      => "de",
-				"main.channels"      => %w(foo bar baz),
-				"plugins.demo.value" => 42
-			)
-			@conf["plugins.demo.other"] = 24
-			@conf["main.language"].replace("en")
-			@conf.update
-			file, key = @conf.send(:split, "main.language")
-			File.open(file, "w") { |fh| fh.write({"language" => "en"}.to_yaml) }
-			@conf.rehash
-		end
-
-		def teardown
-			FileUtils.rm_r(@conf.base)
-		end
-	end
-end