butler 1.8.0 → 1.8.1

data/lib/log/fakeio.rb

@@ -7,6 +7,7 @@
 
 
 module Log
+
 	# == Description
 	# Fakes most IO methods and forwards the converted data to #process
 	#

data/lib/log/splitter.rb

@@ -4,14 +4,18 @@ module Log
 			@receivers = receivers
 		end
 		
-		def delete(receiver)
+		def __delete__(receiver)
 			@receivers.delete(receiver)
 		end
 		
-		def add(receiver)
+		def __add__(receiver)
 			@receivers << receiver
 		end
 		
+		def each(&block)
+			@receivers.each(&block)
+		end
+		
 		def method_missing(*a, &b)
 			@receivers.each { |r| r.__send__(*a, &b)
 		end

data/lib/ostructfixed.rb

@@ -11,15 +11,20 @@ require 'ostruct'
 
 
 class OpenStruct
+	# Get the field by its name, faster than #send and with
+	# dynamic field names more convenient.
 	def [](field)
 		@table[field.to_sym]
 	end
 	
+	# Assign a field by its name, faster than #send and with
+	# dynamic fields more convenient
 	def []=(field,value)
 		new_ostruct_member(field)
 		@table[field.to_sym] = value
 	end
 	
+	# Get a copy of the table with the members.
 	def to_hash
 		@table.dup
 	end

data/lib/ruby/exception/detailed.rb

@@ -10,15 +10,15 @@ class Exception
 		end
 
 		def prepend(string)
-			@prepend.unshift string
+			(@prepend ||= []).unshift string
 		end
 
 		def append(string)
-			@append.unshift string
+			(@append ||= []).unshift string
 		end
 
 		def to_s
-			(@prepend+[super]+@append).join(' ')
+			((@prepend||[])+[super]+(@append||[])).join(' ')
 		end
 	end
 end

data/lib/scheduler.rb

@@ -13,6 +13,15 @@ require 'log/comfort'
 
 
 
+# == Indexing
+# Author:  Stefan Rusterholz
+# Contact: apeiros@gmx.net>
+# Version: 1.0.0
+# Date:    2007-10-12
+#
+# == About
+# Provides methods to execute scheduled Events
+# 
 # == Synopsis
 #   scheduler = Dispatcher::Scheduled.new(*events)
 #   scheduler.every 5.minutes do puts "Another 5 minutes wasted!" end
@@ -22,12 +31,13 @@ require 'log/comfort'
 #   scheduler.resume
 #   scheduler.terminate # important, else you'll have a forever sleeping thread left
 #
-# == Description
-# Provides methods to execute scheduled Events
-#
 class Scheduler
 	include Log::Comfort
+	include Enumerable
 
+	# ==== Arguments
+	# * delete_finished: if true, it will remove elements from #events once they're done
+	# * *events:         events to schedule
 	def initialize(delete_finished=true, *events)
 		events.each { |event| event.scheduler = self }
 		@terminated   = false
@@ -42,7 +52,8 @@ class Scheduler
 		add(*events)
 	end
 
-	def sleeper
+	# Handles the events and invokes them when due.
+	def sleeper # :nodoc:
 		while instr = @instructions.shift
 			@alarm.kill # just overkill...
 
@@ -86,9 +97,13 @@ class Scheduler
 	def restart
 	end
 	
+	# not yet implemented
 	def terminate
 	end
 	
+	# Tell the Scheduler to update its scheduling regardings this event
+	# This should not be necessary if your event is properly linked to the
+	# scheduler (the event is supposed to do that by itself).
 	def reschedule(event)
 		@mutex.synchronize {
 			#first = @events.first

data/lib/scriptfile.rb

@@ -35,10 +35,12 @@ class ScriptFile < File
 	(IO.instance_methods(false)+File.instance_methods(false) - %w[see tell pos truncate]).each { |m| private m }
 
 	class <<self
+		# Like File::read, slurp the whole files DATA at once.
 		def read(file)
 			open(file) { |fh| fh.read }
 		end
 	
+		# Like File::read, slurp the whole files DATA at once.
 		def open(file, mode="r")
 			fh = new(file, mode)
 			block_given? ? yield(fh) : fh
@@ -46,7 +48,8 @@ class ScriptFile < File
 			fh.close if fh and block_given?
 		end
 	end
-		
+
+	# Same as File::new
 	def initialize(file, mode="r")
 		super(file, "r+") # "r#{'+' unless mode=='r'}"
 		@offset = 0
@@ -76,23 +79,27 @@ class ScriptFile < File
 	
 	alias file_seek seek unless method_defined?(:file_seek)
 	private :file_seek
-	
+
+	# See File#seek
 	def seek(offset=0, type=IO::SEEK_SET)
 		raise ArgumentError, "negative seeks currently not supported" if offset < 0
 		raise ArgumentError, "no type but IO::SEEK_SET supported at the moment" if type != IO::SEEK_SET
 		super(offset+@offset)
 	end
 
+	# See File#truncate
 	def truncate(bytes=0)
 		super(bytes+@offset)
 		seek(bytes)
 		0
 	end
 	
+	# See File#tell
 	def tell
 		super-@offset
 	end
 
+	# See File#pos
 	def pos
 		super-@offset
 	end

data/lib/string.rb

@@ -0,0 +1,176 @@
+$KCODE ||= 'utf8'
+
+# Extend String class to integrate nicely
+require 'string/ascii'
+
+# SBEncodedString handles singlebyte encoded strings with collation
+require 'string/sbencoded'
+
+# MBEncodedString handles multibyte encoded strings with collation
+require 'string/mbencoded'
+
+# UTF8String is slightly faster than EncodedString
+require 'string/utf8'
+
+# Iconv to allow charset conversions
+begin
+	require 'iconv'
+rescue LoadError
+	warn "Iconv is not installed on this machinge, charset translation of Strings won't work."
+	class Iconv
+		def initialize(*args)
+		end
+		def iconv(text)
+			text
+		end
+	end
+end
+
+# Unicode to have universal uppercase/lowercase/capitalize methods
+begin
+	require 'unicode'
+rescue LoadError
+	warn "Unicode is not installed on this machine, universal upper-, lowercase, capitalize and length method won't work."
+	module Unicode
+		class <<self
+			def upcase(string)
+				string.ascii_upcase
+			end
+			def downcase(string)
+				string.ascii_downcase
+			end
+			def capitalize(string)
+				string.ascii_capitalize
+			end
+			def strcmp(string1, string2)
+				string1.ascii_cmp(string2)
+			end
+		end
+	end
+end
+
+module Kernel
+	# Short for creating a utf8 string
+	#    u"Stringy"
+	def u(string, collation=nil)
+		String::UTF8.new(string, String::UTF8::UTF8, collation)
+	end
+	private :u
+end
+
+def Iconv.charsets
+	`Iconv -l`.split("\n").map { |l| l.split(" ") }
+end
+
+class String
+	def self.encodings
+		Encodings.keys
+	end
+
+	# encoding -> singlebyte
+	Encodings = {
+		'binary'         => ASCII, # only with collation, else it's ::String
+		'ascii'          => ASCII,
+		'utf-8'          => UTF8,
+
+		'iso-8859-1'     => SBEncoded,
+		'iso-8859-2'     => SBEncoded,
+		'iso-8859-3'     => SBEncoded,
+		'iso-8859-4'     => SBEncoded,
+		'iso-8859-5'     => SBEncoded,
+		'iso-8859-6'     => SBEncoded,
+		'iso-8859-7'     => SBEncoded,
+		'iso-8859-8'     => SBEncoded,
+		'iso-8859-9'     => SBEncoded,
+		'iso-8859-10'    => SBEncoded,
+		'iso-8859-11'    => SBEncoded,
+		'iso-8859-12'    => SBEncoded,
+		'iso-8859-13'    => SBEncoded,
+		'iso-8859-14'    => SBEncoded,
+		'iso-8859-15'    => SBEncoded,
+		'macroman'       => SBEncoded,
+		'macroman'       => SBEncoded,
+		
+		'utf-8-mac'      => MBEncoded,
+		'utf-16'         => MBEncoded,
+		'utf-16be'       => MBEncoded,
+		'utf-16le'       => MBEncoded,
+		'utf-32'         => MBEncoded,
+		'utf-32be'       => MBEncoded,
+		'utf-32le'       => MBEncoded,
+		'ucs-2be'        => MBEncoded,
+		'ucs-2le'        => MBEncoded,
+		'ucs-4be'        => MBEncoded,
+		'ucs-4le'        => MBEncoded,
+		'ucs-2-internal' => MBEncoded,
+		'ucs-2-swapped'  => MBEncoded,
+		'ucs-4-internal' => MBEncoded,
+		'ucs-4-swapped'  => MBEncoded,
+	}
+
+	# UNICODE_ is used for strip/strip!
+	UNICODE_WHITESPACE = [
+		(0x0009..0x000D).to_a,  # White_Space # Cc   [5] <control-0009>..<control-000D>
+		0x0020,          # White_Space # Zs       SPACE
+		0x0085,          # White_Space # Cc       <control-0085>
+		0x00A0,          # White_Space # Zs       NO-BREAK SPACE
+		0x1680,          # White_Space # Zs       OGHAM SPACE MARK
+		0x180E,          # White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
+		(0x2000..0x200A).to_a, # White_Space # Zs  [11] EN QUAD..HAIR SPACE
+		0x2028,          # White_Space # Zl       LINE SEPARATOR
+		0x2029,          # White_Space # Zp       PARAGRAPH SEPARATOR
+		0x202F,          # White_Space # Zs       NARROW NO-BREAK SPACE
+		0x205F,          # White_Space # Zs       MEDIUM MATHEMATICAL SPACE
+		0x3000,          # White_Space # Zs       IDEOGRAPHIC SPACE
+	].flatten  #:nodoc:
+	UNICODE_LEADERS_AND_TRAILERS = UNICODE_WHITESPACE + [65279] # ZERO-WIDTH NO-BREAK SPACE aka BOM  #:nodoc:
+	UNICODE_LT_PAT = /#{UNICODE_LEADERS_AND_TRAILERS.pack("U*").gsub(/.(?=.)/u, '\0|')}/u
+	UNICODE_T_PAT  = /#{UNICODE_LT_PAT}+$/
+	UNICODE_L_PAT  = /^#{UNICODE_LT_PAT}+/
+
+	Binary      = 'binary'.freeze
+
+	alias ascii_upcase     upcase
+	alias ascii_downcase   downcase
+	alias ascii_capitalize capitalize
+	alias byte_cmp         <=>
+	alias byte_insert      insert
+	alias byte_reverse     reverse
+	alias byte_slice       slice
+	alias byte_index       index
+	alias byte_rindex      rindex
+	alias jlength          length
+	alias jcount           count
+	
+	def encoding
+		Binary
+	end
+
+	def collation
+		Binary
+	end
+	
+	def to_s(encoding=nil, collation=nil)
+		encoding  = nil if encoding  == Binary
+		collation = nil if collation == Binary
+		return String.new(self) unless (encoding || collation)
+		data = if encoding == self.encoding || self.encoding == Binary || self.encoding == ASCII::ASCII then
+			self
+		else
+			Iconv.iconv(encoding, self.encoding, self).first
+		end
+		Encodings[encoding].new(data, encoding, collation)
+	end
+	
+	def ascii(collation=nil)
+		String::ASCII.new(self, String::ASCII::ASCII, collation)
+	end
+	
+	def utf8(collation=nil)
+		String::UTF8.new(self, String::UTF8::UTF8, collation)
+	end
+
+	def binary
+		String.new(self)
+	end
+end

data/lib/string/ascii.rb

@@ -0,0 +1,31 @@
+require 'string'
+
+# deal with ascii-strings
+class String::ASCII < String
+	ASCII     = 'ascii'.freeze
+	Collation = 'ascii'.freeze
+
+	def self.new(string, encoding, collation=nil)
+		unless encoding == String::Binary or encoding == String::ASCII::ASCII then
+			raise "Encoding must be 'ascii' or 'binary'"
+		end
+		unless collation.nil? or collation == Collation then
+			raise "Collation must be 'ascii' or nil"
+		end
+		obj = allocate
+		obj.send(:initialize, string)
+		obj
+	end
+
+	def encoding
+		String::ASCII::ASCII
+	end
+	
+	def collation
+		Collation
+	end
+
+	def inspect
+		"#{encoding}(#{collation||'none'}):#{super}"
+	end
+end

data/lib/string/mbencoded.rb

@@ -0,0 +1,79 @@
+require 'string'
+
+class String::MBEncoded < String
+	def self.new(string, encoding, collation=nil)
+		raise "No encoding given" unless encoding
+		if encoding == 'utf-8' then
+			String::UTF8.new(string, collation)
+		else
+			obj = allocate
+			obj.send(:initialize, string, encoding, collation)
+			obj
+		end
+	end
+
+	attr_reader :encoding
+	
+	attr_reader :collation
+
+	def initialize(string, encoding, collation=nil)
+		super(string)
+		@encoding  = encoding.freeze
+		@collation = collation.freeze
+	end
+
+	def <=>(other)
+		unless other.collation == @collation
+			raise ArgumentError, "Collations don't match: #{@collation} <=> #{other.collation}"
+		end
+		unless other.encoding == @encoding
+			raise ArgumentError.new("Encodings don't match: #{@encoding} <=> #{other.encoding}")
+		end
+		self.utf8(@collation) <=> other.utf8(@collation)
+	end
+
+# all methods delegated to utf8-ified strings (and if necessary it's reconversion)
+	def length;      utf8.length; end
+	def upcase;      utf8.upcase.to_s(@encoding, @collation);   end
+	def downcase;    utf8.downcase.to_s(@encoding, @collation); end
+	def capitalize;  utf8.capitalize.to_s(@encoding, @collation); end
+	def chop;        utf8.chop.to_s(@encoding, @collation); end
+	def index(*a);   utf8.index(*a); end
+	def rindex(*a);  utf8.rindex(*a); end
+	def strip;       utf8.strip.to_s(@encoding, @collation);   end
+	def lstrip;      utf8.lstrip.to_s(@encoding, @collation);   end
+	def rstrip;      utf8.rstrip.to_s(@encoding, @collation);   end
+	def [](*a);      utf8[*a].to_s(@encoding, @collation); end
+	alias slice []
+	def []=(*args)
+		value    = args.pop
+		a        = self.utf8
+		a[*args] = value
+		self.replace(a.to_s(@encoding, @collation))
+	end
+
+# ! variants, using self.replace
+	def upcase!;     replace(upcase); end
+	def downcase!;   replace(downcase); end
+	def capitalize!; replace(capitalize); end
+	def lstrip!;     replace(lstrip); end
+	def rstrip!;     replace(rstrip); end
+	def strip!;      replace(strip); end
+	def chop!;       replace(chop); end
+
+	def dup
+		String::MBEncoded.new(self, @encoding, @collation)
+	end
+
+	def utf8(collation=nil)
+		String::UTF8.new(
+			Iconv.iconv(String::UTF8::UTF8, @encoding, self).first,
+			String::UTF8::UTF8,
+			collation || @collation
+		)
+	end
+
+	def inspect
+		"#{encoding}(#{collation||'none'}):#{super}"
+	end
+end