butler 1.8.0

data/lib/butler/bot.rb

@@ -0,0 +1,247 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler'
+require 'butler/irc/client'
+require 'configuration'
+require 'log'
+require 'butler/plugins'
+require 'ruby/string/arguments'
+require 'ruby/string/post_arguments'
+require 'scheduler'
+require 'set'
+require 'thread'
+
+
+
+# FIXME: credits @ daemonize lib
+class Butler
+	class Bot < IRC::Client
+		include Log::Comfort
+
+		attr_reader :access
+		attr_reader :base
+		attr_reader :config
+		attr_reader :log_device
+		attr_reader :path
+		attr_reader :plugins
+		attr_reader :scheduler
+
+		# FIXME, raise if selftest fails
+		def initialize(path, name, opts={})
+			path      ||= Butler.path
+			@irc        = nil # early inspects
+			@name       = name
+			@base       = "#{path.bots}/#{name}"
+			@path       = OpenStruct.new(
+				:access     => @base+'/access',
+				:base       => @base,
+				:config     => @base+'/config',
+				:log        => @base+'/log',
+				:plugins    => @base+'/plugins',
+				:strings    => @base+'/strings'
+			)
+			@log_device = $stderr
+			@config     = Configuration.new(@base+'/config')
+			@scheduler  = Scheduler.new
+			@access     = Access.new(
+				Access::YAMLBase.new(Access::User::Base,      @base+'/access/user'),
+				Access::YAMLBase.new(Access::Role::Base,      @base+'/access/role'),
+				Access::YAMLBase.new(Access::Privilege::Base, @base+'/access/privilege')
+				#:channel => Access::YAMLBase.new("#{TestDir}/channel", Access::Location)
+			)
+			@on_disconnect   = nil
+			@on_reconnect    = nil
+			@reconnect       = [
+				opts.delete(:reconnect_delay) || 60,
+				opts.delete(:reconnect_tries) || -1
+			]
+
+			super(@config["connections.main.server"], {
+				:port => @config["connections.main.port"],
+				:host => @config["connections.main.host"]
+			}.merge(opts))
+
+			# { lang => { trigger => SortedSet[ *commands ] } }
+			@commands  = {}
+			@plugins   = Plugins.new(self, @base+'/plugins')
+			
+			subscribe(:PRIVMSG, -10, &method(:invoke_commands))
+			subscribe(:NOTICE,  -10, &method(:invoke_commands))
+
+			selftest
+		end
+		
+		def invoke_commands(listener, message)
+			return unless ((sequence = invocation(message.text)) || message.realm == :private)
+			message.invocation = sequence || ""
+			message.language   = "en"
+			trigger            = message.arguments.first
+			access             = message.from && message.from.access.method(:authorized?)
+			return unless access and trigger
+			
+			trigger  = trigger.downcase
+			commands = []
+			if @commands[message.language] && @commands[message.language][trigger] then
+				commands.concat(@commands[message.language][trigger].to_a)
+			end
+			if message.language != "en" && @commands["en"] && @commands["en"][trigger] then
+				commands.concat(@commands["en"][trigger].to_a)
+			end
+
+			commands.each { |command|
+				if args = (command.invoked_by?(message)) then
+					if !command.authorization || access.call(command.authorization) then
+						Thread.new {
+							begin
+								command.call(message, *args)
+							rescue Exception => e
+								exception(e)
+							end
+						}
+						break if command.abort_invocations?
+					else
+						info("#{message.from} (#{message.from.access.id}) had no authorization for 'plugin/#{command.plugin.base}'")
+					end
+				end
+			}
+		end
+		
+		def add_command(command)
+			@commands[command.language] ||= {}
+			@commands[command.language][command.trigger] ||= SortedSet.new
+			@commands[command.language][command.trigger].add(command)
+		end
+		
+		def delete_command(command)
+			@commands[command.language][command.trigger].delete(command)
+			if @commands[command.language][command.trigger].empty? then
+				@commands[command.language].delete(command.trigger)
+				@commands.delete(command.language) if @commands[command.language].empty?
+			end
+		end
+		
+		# returns the rest of the sequence if it was an invocation, nil else
+		def invocation(sequence)
+			@myself && sequence[/^(?:!?#{@myself.nick}[:;,])\s+/i]
+		end
+		
+		# runs a diagnose, will collect all wrongs and raise if it finds any
+		def selftest
+			
+		end
+		
+		def login
+			@access.default_user = @access["default_user"]
+			@access.default_user.login
+
+			nick = @config["connections.main.nick"]
+			pass = @config["connections.main.password"]
+			super(
+				nick,
+				@config["connections.main.user"],
+				@config["connections.main.real"]
+			)
+			info("Logged in")
+			# FIXME, use #same_nick?
+			if pass && @myself.nick.downcase != nick.downcase then
+				@irc.ghost(nick, pass)
+				sleep(1) # FIXME, do a wait_for or similar
+				@irc.nick(nick)
+			end
+			@irc.identify(pass) if pass
+			join(*@config["connections.main.channels"])
+		end
+		
+		def on_disconnect(reason)
+			return if reason == :quit
+			unless @reconnect[1].zero? then
+				@reconnect[1] -= 1
+				sleep(@reconnect[0])
+				login
+			end
+		end
+					
+		
+		def output_to_logfiles
+			# Errors still go to $stderr, $stdin handles puts as "info" level $stderr prints
+			@log_device = Log.file(@path.log+'/error.log')
+			$stdout     = Log.forward(@log_device, :warn)
+			$stderr     = Log.forward(@log_device, :info)
+		end
+
+		def inspect # :nodoc:
+			"#<%s:0x%08x %s (in %s) irc=%s>" %  [
+				self.class,
+				object_id << 1,
+				@name,
+				@base,
+				@irc.inspect
+			]
+		end
+	end # Bot
+	
+	class IRC::Users
+		attr_reader :client
+	end
+
+	class IRC::User
+		attr_accessor :access
+
+		def authorized?(*args)
+			@access.authorized?(*args)
+		end
+		
+		alias butler_initialize initialize unless method_defined? :butler_initialize
+		def initialize(users, *args, &block)
+			butler_initialize(users, *args, &block)
+			@access = users.client.access.default_user
+		end
+	end # IRC::User
+
+	class IRC::Message
+		# the language of this message, as determined by butler
+		attr_accessor :language
+
+		# the invocation-sequence (e.g. "butler, "), nil if none was used (e.g. in
+		# private messages)
+		attr_accessor :invocation
+
+		alias butler_initialize initialize unless method_defined? :butler_initialize
+		def initialize(*args, &block)
+			butler_initialize(*args, &block)
+			@language       = nil
+			@invocation     = nil
+			@arguments      = nil
+			@post_arguments = nil
+		end
+	
+		# parses a given string into argument-tokens. a token is either a word or a quoted string. escapes are respected.
+		# e.g. 'Hallo "this is token2" "and this \"token\" is token3"'
+		# would be parsed into: ["hallo", "this is token2", "and this \"token\" is token3"]
+		def arguments
+			return [] unless text # only messages with text can be tokenized to parameters
+			@arguments ||= begin # don't do double-work
+				text[@invocation.length..-1].arguments
+			rescue String::SingleQuoteException => ex
+				ex.pre+[ex.post.join(" ")]
+			end
+		end
+	
+		# FIXME due to it's current working, post_arguments will strip formatting
+		# Returns the rest of message text after argument
+		# == Synopsis
+		#   "foo bar baz".post_arguments[0] # => "foo bar baz"
+		#   "foo bar baz".post_arguments[1] # => "bar baz"
+		#   "foo bar baz".post_arguments[2] # => "baz"
+		def post_arguments
+			return [] unless text # only messages with text can be tokenized to parameters
+			@post_arguments ||= text[@invocation.length..-1].post_arguments # don't do double-work
+		end
+	end # IRC::Message
+end # Butler

data/lib/butler/control.rb

@@ -0,0 +1,93 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'ruby/file/write'
+
+
+
+class Butler
+	IsGem = true # REPLACE: IsGem = false
+
+	# this module provides services to botcontrol
+	# for gems, this module uses the Gem module to get information on the where-
+	# abouts of data. If installed using rake from tarball, it is hard-coded.
+	class Control
+		attr_reader :dialog
+		attr_reader :config
+		attr_reader :path
+
+		def initialize
+			@path = OpenStruct.new({
+				:template => Gem.datadir("butler")+'/config_template.yaml', # DELETE
+				:config   => Gem.datadir("butler")+'/config.yaml',          # REPLACE: :config   => %CONFIG_DIR%+'/config.yaml',
+				:dialogs  => Gem.datadir("butler")+'/dialogs',              # REPLACE: :dialogs  => %DIALOGS_DIR%,
+				:plugins  => Gem.datadir("butler")+'/plugins',              # REPLACE: :plugins  => %PLUGINS_DIR%,
+				:strings  => Gem.datadir("butler")+'/strings',              # REPLACE: :strings  => %STRINGS_DIR%,
+				:man      => Gem.datadir("butler")+'/man1',                 # DELETE
+			})
+			File.write(@path.config, File.read(@path.template)) unless File.exist?(@path.config)
+			@config = OpenStruct.new(YAML.load_file(@path.config))
+			@dialog = DialogLine.new(@path.dialogs, @config.language)
+		end
+		
+		def user(name=nil)
+			# use Etc.getlogin?
+			name || ENV['SUDO_USER'] || ENV['USER'] || @dialog.discuss("username", false)[:name]
+		end
+
+		def configured?(user=nil)
+			path = @config.users[user(user)]
+			path && File.exist?(path)
+		end
+
+		def configure_user(user=nil)
+			raise Errno::EACCES unless File.writable?(@path.config)
+			user      ||= user()
+			installer   = Installer.new("butler")
+			user_config = @dialog.discuss(:botcontrol, false,
+				:installer  => installer,
+				:user       => user,
+				:path       => path
+			)
+			path = @config.users[user] = user_config.delete(:config)+"/config.yaml"
+			user_config[:language] = "en" # FIXME multilingualize
+			update_config
+			FileUtils.mkdir_p(File.dirname(path))
+			FileUtils.chown(user, nil, File.dirname(path))
+			File.write(path, user_config.to_yaml)
+			FileUtils.chown(user, nil, path)
+			OpenStruct.new(@config.users[user])
+		end
+		
+		def update_config
+			File.write(@path.config, @config.to_hash.to_yaml)
+		end
+
+		def user_config(user=nil)
+			path        = @config.users[user(user)]
+			user_config = OpenStruct.new(YAML.load_file(path))
+			user_config.plugin_repository = @path.plugins
+			user_config
+		end
+
+		def butler_path(user=nil)
+			path        = @config.users[user(user)]
+			user_config = OpenStruct.new(YAML.load_file(path))
+			user_config.plugin_repository = @path.plugins
+			user_config
+		end
+		
+		def discuss(dir, lang=nil, variables={}, &block)
+			@dialog.discuss(dir, lang, variables.merge(:botcontrol => self), &block)
+		end
+		
+		def language
+			"en"
+		end
+	end
+end

data/lib/butler/dialog.rb

@@ -0,0 +1,64 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'durations'
+
+
+
+class Butler
+	# A message can be converted to a dialog, this will open a query to the
+	# originator of the query and intercept every message there
+	class Dialog
+		@timeout  = 5.minutes, :timeout
+		@reminder = 3.minutes, :reminder
+
+		class <<self
+			def timeout(after, string)
+				@timeout = after, string
+			end
+
+			def reminder(after, string)
+				@reminder = after, string
+			end
+		end
+
+		def initialize(plugin)
+			@plugin = plugin
+			@plugin.butler.subscribe(:PRIVMSG, 0, true) { |listener, message|
+				if message.private? then
+					postpone
+					dialog(listener, message)
+					:block
+				else
+					:pass
+				end
+			}
+		end
+		
+		def postpone
+			@reminder.postpone
+			@timeout.postpone
+		end
+		
+		def dialog(listener, message)
+			
+		end
+		
+		def timeout(timer, string)
+		end
+		
+		def localize(*args)
+			@plugin.localize(*args)
+		end
+		alias _ localize
+		
+		def method_missing(*args)
+			@plugin.__send__(*args)
+		end
+	end
+end

data/lib/butler/initialvalues.rb

@@ -0,0 +1,40 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler
+	Structure = %w[
+		BOTPATH
+		BOTPATH/access
+		BOTPATH/access/privilege
+		BOTPATH/access/role
+		BOTPATH/access/user
+		BOTPATH/log
+		BOTPATH/plugins
+		BOTPATH/strings
+	].map { |e| [e, 0755] }
+	# first one is the base-directory
+	ConfigurationStructure = %w[
+		BOTPATH/config
+		connections
+		channels
+		plugin
+	]
+	EmptyConfig = {
+		'remote' => {
+			'host'   => 'localhost',
+			'port'   => 7666,
+			'active' => false,
+		},
+		'logging' => {
+		},
+		'owner' => {
+			'username' => nil, # no owner
+			'contact'  => 'unknown',
+		},
+	}
+end

data/lib/butler/irc/channel.rb

@@ -0,0 +1,135 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler/irc/topic'
+require 'thread'
+
+
+
+class Butler
+	module IRC
+		class Channel
+			include Comparable
+			include Enumerable
+	
+			#the name of the channel (immutable)
+			attr_reader :name
+			#the current topic of the channel
+			attr_reader :topic
+			
+			# the value used for comparison/sorting
+			attr_reader :compare
+			
+			# :nodoc:
+			attr_reader :hash
+	
+			# Create a Butler::IRC::Channel-object.
+			# Use Channel.create(<channelname>) if you can.
+			def initialize(all_users, name, topic=nil, topic_set_by=nil, topic_set_at=nil)
+				name          = name.to_str.strip_user_prefixes
+				raise "Invalid channelname '#{name}'" unless name.valid_channelname?
+				@all_users    = all_users
+				@name         = name.freeze
+				@compare      = name.downcase.freeze
+				@hash         = @compare.hash
+				@users        = {}
+				@topic        = Topic.new(topic || "", topic_set_by, topic_set_at)
+				@lock         = Mutex.new
+			end
+
+			# Looks up if there are clones in the list of users
+			# min defines how many users need to have the same host (+user if strong)
+			# to appear in the list.
+			def clones(strong=false, min=2)
+				sieve	= Hash.new { |h,k| h[k] = [] }
+				if strong then
+					users.each { |user|
+						sieve["#{user.user}@#{user.host}"] << user if (user.user && user.host)
+					}
+				else
+					users = users()
+					users.each { |user|
+						sieve[user.host] << user if user.host
+					}
+				end
+				sieve.select { |host, users| users.length >= min }
+			end
+			
+			#List of users (Butler::IRC::User objects) in this channel
+			def users
+				@all_users.map_nicks(*@users.keys)
+			end
+			
+			# List of normalized (lowercased and flag-stripped) nicknames in this channel
+			def nicks
+				@users.keys
+			end
+
+			# Iterate over all users in this channel
+			def each
+				@users.each_value { |user| yield @all_users[user] }
+			end
+	
+			# Returns amount of users
+			def length
+				@users.length
+			end
+	
+			# Comparison based on lowercase channelname
+			def ==(other)
+				@compare == other.to_str.downcase
+			end
+	
+			# Comparison based on lowercase channelname, -1, 0 or 1
+			def <=>(other)
+				@compare <=> other.to_str.downcase
+			end
+			
+			# Add a user to the channel, see Butler::IRC::CHANNEL_SIGNALS for possible
+			# reasons (should only be used by IRC::Parser)
+			def add_user(user, reason) #:nodoc:
+				@users[user.to_str.downcase] ||= 0
+			end
+			
+			# Get user by nick if or nil if that user is not in this channel
+			def [](nick)
+				nick = nick.to_str.downcase
+				@users.has_key?(nick) ? @all_users[nick] : nil
+			end
+			
+			# Test if user with nick is in this channel (also works with IRC::User objects)
+			def include?(nick)
+				@users.has_key?(nick.to_str.downcase)
+			end
+			
+			# Remove a user from the channel, see Butler::IRC::CHANNEL_SIGNALS for
+			# possible reasons (should only be used by Butler::IRC::Parser)
+			def delete_user(user, reason) #:nodoc:
+				@users.delete(user.to_str.downcase)
+			end
+	
+			def inspect # :nodoc:
+				"#<%s:0x%x %s (%d users)" %  [self.class, object_id, @name, length]
+			end
+			
+			# Returns the (frozen!) name of the channel
+			def to_s
+				@name
+			end
+
+			# Returns the normalized name of the channel
+			def to_str #:nodoc:
+				@compare
+			end
+	
+			def eql?(other) #:nodoc:
+				self.class == other.class && @compare == other.compare
+			end
+		end
+	end
+end