butler 1.8.0

data/lib/ruby/string/unescaped.rb

@@ -0,0 +1,17 @@
+class String	
+	# convert \" to " and similar
+	Escapes = Hash.new{|h,k|k}.update({
+		'\\\\' => '\\',
+		'\\"'  => '"',
+		"\\'"  => "'",
+		'\e'   => "\e",
+		'\r'   => "\r",
+		'\n'   => "\n",
+		'\f'   => "\f",
+		'\t'   => "\t",
+		'\ '   => " ",
+	})
+	def unescaped
+		gsub(/\\.|[^\\]/) { |m| Escapes[m] }
+	end
+end

data/lib/scheduler.rb

@@ -0,0 +1,164 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'durations'
+require 'event'
+require 'thread'
+require 'log/comfort'
+
+
+
+# == Synopsis
+#   scheduler = Dispatcher::Scheduled.new(*events)
+#   scheduler.every 5.minutes do puts "Another 5 minutes wasted!" end
+#   scheduler.add(event)
+#   scheduler.delete(event)
+#   scheduler.suspend
+#   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
+
+	def initialize(delete_finished=true, *events)
+		events.each { |event| event.scheduler = self }
+		@terminated   = false
+		@instructions = Queue.new
+		@mutex        = Mutex.new
+		@events       = []
+		@alarm        = Thread.new {} # dead thread
+		@min_sleep    = 0.1
+		@execute      = method(:execute)
+		@sleeper      = Thread.new(&method(:sleeper))
+		@auto_delete  = delete_finished
+		add(*events)
+	end
+
+	def sleeper
+		while instr = @instructions.shift
+			@alarm.kill # just overkill...
+
+			now = Time.now+@min_sleep
+			@mutex.synchronize {
+				i = nil
+				@events.each_with_index { |event,i|
+					break unless event.due?(now)
+					event.one_done
+					Thread.new(event, &@execute)
+				}
+				@events.first(i+1).each { |event|
+					@events.delete(event) if event.finished?
+				} if (@auto_delete && i)
+				unless @events.empty?
+					@events.sort!
+					if seconds = @events.first.seconds_left then
+						if seconds < @min_sleep then
+							@instructions.push(:wakeup)
+						else
+							@alarm = Thread.new {
+								sleep(seconds)
+								@instructions.push(:wakeup)
+							}
+						end
+					end
+				end
+			}
+		end
+	end
+	
+	# not yet implemented
+	def suspend
+	end
+	
+	# not yet implemented
+	def resume
+	end
+	
+	# not yet implemented
+	def restart
+	end
+	
+	def terminate
+	end
+	
+	def reschedule(event)
+		@mutex.synchronize {
+			#first = @events.first
+			@events.sort!
+			#first != @events.first
+		}
+		@instructions.push(:reschedule)
+		self
+	end
+
+	# Adds the events to the scheduler
+	def add(*events)
+		events.each { |event| event.scheduler = self }
+		@instructions.push(:reschedule) if @mutex.synchronize {
+			first = @events.first
+			@events.push(*events)
+			@events.sort!
+			first != @events.first
+		}
+		self
+	end
+	alias << add
+
+	def delete(event)
+		wakeup = false
+		@mutex.synchronize {
+			wakeup = @events.first == event
+			@events.delete(event)
+		}
+		@instructions.push(:reschedule) if wakeup
+	end
+
+	def reject!(&block)
+		@instructions.push(:reschedule) if @mutex.synchronize {
+			first = @events.first
+			@events.reject!(&block)
+			@events.min
+			first != @events.first
+		}
+	end
+
+	def execute(event)
+		event.call(event)
+	rescue Exception => e
+		exception(e) # log it
+	end
+	
+	# Creates a new Dispatcher::Event.every, adds it and
+	# returns the event
+	def every(*args, &block)
+		add(event = Event::Every.new(*args, &block))
+		event
+	end
+
+	# Creates a new Dispatcher::Event.timed, adds it and
+	# returns the event
+	def timed(*args, &block)
+		add(event = Event::Timed.new(*args, &block))
+		event
+	end
+
+	# Creates a new Dispatcher::Event.timed, adds it and
+	# returns the event
+	def at(*args, &block)
+		add(event = Event::At.new(*args, &block))
+		event
+	end
+
+	# The amount of scheduled events
+	def length
+		@events.length
+	end
+end

data/lib/scriptfile.rb

@@ -0,0 +1,101 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'ruby/kernel/non_verbose'
+
+# use data after __END__ in .rb files like normal files
+# WARNING:
+# - if you have an __END__ alone in a multiline comment or string
+#   your .rb file will be damaged.
+# - Current implementation *will* append an __END__ to the file, regardeless
+#   of what you do (that will change)
+# 
+# Example:
+# 	require 'scriptfile'
+# 	ScriptFile.open(__FILE__) { |fh|
+# 		p [:tell, fh.tell]
+# 		p [:read, fh.read]
+# 		p [:tell, fh.tell]
+# 		p [:truncate, fh.truncate]
+# 		p [:tell, fh.tell]
+# 		p [:read, fh.read]
+# 		p [:tell, fh.tell]
+# 		p [:seek, fh.seek]
+# 		p [:puts, fh.puts("ScriptFile rocks")]
+# 		p [:seek, fh.seek]
+# 		p [:read, fh.read]
+# 	}
+#
+class ScriptFile < File
+	(IO.instance_methods(false)+File.instance_methods(false) - %w[see tell pos truncate]).each { |m| private m }
+
+	class <<self
+		def read(file)
+			open(file) { |fh| fh.read }
+		end
+	
+		def open(file, mode="r")
+			fh = new(file, mode)
+			block_given? ? yield(fh) : fh
+		ensure
+			fh.close if fh and block_given?
+		end
+	end
+		
+	def initialize(file, mode="r")
+		super(file, "r+") # "r#{'+' unless mode=='r'}"
+		@offset = 0
+		while line = gets
+			@offset += line.size
+			break if line =~ /^__END__$/
+		end
+		unless line then
+			file_seek(-1, IO::SEEK_CUR)
+			unless read(1) == "\n" then
+				puts
+				@offset += 1
+			end
+			print "__END__\n"
+			@offset += 8
+		end
+		case mode
+			when /^w/: truncate
+			when /^a/: read
+		end
+	end
+
+	public :each, :each_byte, :each_line
+	public :gets, :getc, :read, :readchar, :readline, :readlines
+	public :puts, :putc, :print, :printf, :write
+	public :ctime, :atime, :mtime
+	
+	alias file_seek seek unless method_defined?(:file_seek)
+	private :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
+
+	def truncate(bytes=0)
+		super(bytes+@offset)
+		seek(bytes)
+		0
+	end
+	
+	def tell
+		super-@offset
+	end
+
+	def pos
+		super-@offset
+	end
+
+	public :close
+end

data/lib/templater.rb

@@ -0,0 +1,86 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'erb'
+require 'ostruct'
+
+
+
+class Templater
+	Raiser = proc { |e|
+		raise
+	}
+	Teller = proc { |e|
+		"<<#{e.class}: #{e}>>"
+	}
+
+	class Variables < OpenStruct
+		def initialize(delegator=nil, variables={}, &on_error)
+			super(variables)
+			@delegator = delegator
+			@on_error  = on_error || RaiseExceptions
+		end
+		
+		def method_missing(m, *a, &b)
+			if @table.key?(m) || m.to_s =~ /=$/ then
+				super
+			elsif @delegator && @delegator.respond_to?(m) then
+				@delegator.send(m, *a, &b) if @delegator
+			else
+				raise NameError, "undefined local variable or method `#{m}'"
+			end
+		rescue Exception => e
+			@on_error.call(e)
+		end
+		
+		def inspect
+			@table.inspect
+		end
+	end
+
+	# Option defaults
+	Opt = {
+		:safe_level => nil,
+		:trim_mode  => '%<>',
+		:eoutvar    => '_erbout'
+	}
+	# binding method
+	Binder = Object.instance_method(:binding)
+
+	attr_reader :string
+	def initialize(string, opt={})
+		opt, string   = string, nil if string.kind_of?(Hash)
+		opt           = Opt.merge(opt)
+		file          = nil
+		if !string || File.exist?(string) then
+			string ||= opt[:filename]
+			file     = string
+			string   = File.read(string)
+		end
+		@string       = string.dup.freeze
+		@erb          = ERB.new(@string, *opt.values_at(:safe_level, :trim_mode, :eoutvar))
+		@erb.filename = file if file
+	end
+	
+	def result(delegator=nil, variables={}, &on_error)
+		variables ||= {}
+		on_error  ||= Raiser
+		variables = Variables.new(delegator, variables, &on_error) unless variables.kind_of?(Variables)
+		@erb.result(Binder.bind(variables).call)
+	rescue NameError => e
+		raise NameError, e.message+" for #{self.inspect} with #{variables.inspect}", e.backtrace
+	end
+	
+	def inspect # :nodoc:
+		"#<%s:0x%x string=%s>" %  [
+			self.class,
+			object_id << 1,
+			@string.inspect
+		]
+	end
+end

data/test/cloptions.rb

@@ -0,0 +1,134 @@
+require 'pp'
+require 'test/unit'
+
+class TestCLOptions < Test::Unit::TestCase
+	def setup
+		# if you prefer methods over bullet lists, o is just an alias to option
+		@options       = CLOptions.new("file1 file2 [file3]") {
+			application_name 'app'  # optional, defaults to $0
+			#required_options %w(-p) # optional (obviously)
+		
+			o nil,  '--help',			           "Display this help."
+			o '-i', '--interactive',         "Don't deamonize, lets process run interactively in Terminal."
+			o '-p', '--port',        'PORT', "On what port to run the server."
+			o '-v', '--version',             "Prints the version and quits."
+		}
+	end
+	
+	def test_flags
+		flag1 = CLOptions::Switch.new('-p')
+		flag2 = CLOptions::Switch.new('-p', 'Help')
+		flag3 = CLOptions::Switch.new('-p', '--port', 'Help')
+		flag4 = CLOptions::Switch.new('-p', '--port', nil, 'Help')
+		flag5 = CLOptions::Switch.new('-p', '--port', 'INTEGER', 'Help')
+		flag6 = CLOptions::Switch.new('-p', '--port', 'INTEGER', true, 'Help')
+		flag7 = CLOptions::Switch.new('-p', '--port', 'INTEGER', :portmap, 'Help')
+		flag8 = CLOptions::Switch.new('-p', '--port', 'INTEGER', :portmap, 'Help', &CLOptions::Integer)
+
+		assert_equal('-p',   flag1.short)
+		assert_equal(nil,    flag1.long)
+		assert_equal([],     flag1.params)
+		assert_equal(%w(-p), flag1.mappings)
+		assert_equal(nil,    flag1.hash_key)
+		assert_equal('',     flag1.help)
+		assert_equal('-p',   flag1.to_s)
+
+		assert_equal('-p',   flag2.short)
+		assert_equal(nil,    flag2.long)
+		assert_equal([],     flag2.params)
+		assert_equal(%w(-p), flag2.mappings)
+		assert_equal(nil,    flag2.hash_key)
+		assert_equal('Help', flag2.help)
+		assert_equal('-p',   flag2.to_s)
+
+		assert_equal('-p',          flag3.short)
+		assert_equal('--port',      flag3.long)
+		assert_equal([],            flag3.params)
+		assert_equal(%w(-p --port), flag3.mappings)
+		assert_equal(nil,           flag3.hash_key)
+		assert_equal('Help',        flag3.help)
+		assert_equal('-p, --port',  flag3.to_s)
+
+		assert_equal('-p',                 flag5.short)
+		assert_equal('--port',             flag5.long)
+		assert_equal(['INTEGER'],          flag5.params)
+		assert_equal(%w(-p --port),        flag5.mappings)
+		assert_equal(nil,                  flag5.hash_key)
+		assert_equal('Help',               flag5.help)
+		assert_equal('-p, --port INTEGER', flag5.to_s)
+
+		assert_equal('-p',                    flag6.short)
+		assert_equal('--port',                flag6.long)
+		assert_equal(['INTEGER'],             flag6.params)
+		assert_equal(['-p', '--port', :port], flag6.mappings)
+		assert_equal(:port,                   flag6.hash_key)
+		assert_equal('Help',                  flag6.help)
+		assert_equal('-p, --port INTEGER',    flag6.to_s)
+
+		assert_equal('-p',                       flag7.short)
+		assert_equal('--port',                   flag7.long)
+		assert_equal(['INTEGER'],                flag7.params)
+		assert_equal(['-p', '--port', :portmap], flag7.mappings)
+		assert_equal(:portmap,                   flag7.hash_key)
+		assert_equal('Help',                     flag7.help)
+		assert_equal('-p, --port INTEGER',       flag7.to_s)
+
+		assert_equal('-p',                       flag8.short)
+		assert_equal('--port',                   flag8.long)
+		assert_equal(['INTEGER'],                flag8.params)
+		assert_equal(['-p', '--port', :portmap], flag8.mappings)
+		assert_equal(:portmap,                   flag8.hash_key)
+		assert_equal('Help',                     flag8.help)
+		assert_equal('-p, --port INTEGER',       flag8.to_s)
+		
+		flag = flag8.process(nil, ["1234"])
+		assert_equal(1234, flag.parameters)
+	end
+
+	def test_parsing1
+		result = nil
+		assert_nothing_raised { result = @options.parse(%w(-p 1234 --interactive fubu fubar)) }
+		
+		assert_equal("fubu",  result.argv.file1)
+		assert_equal("fubu",  result.argv[0])
+		assert_equal("fubar", result.argv.file2)
+		assert_equal("fubar", result.argv[1])
+		assert_equal(nil,     result.argv.file3)
+
+		assert_equal("1234",  result['-p'])
+		assert_equal("1234",  result['--port'])
+		assert_equal(true,    result['-i'])
+		assert_equal(true,    result['--interactive'])
+		assert_equal(nil,     result['-v'])
+		assert_equal(nil,     result['--version'])
+	end
+
+	def test_usage
+		assert_equal(<<EOUSAGE, @options.usage(false))
+Usage:
+	app -iv -p PORT --help file1 file2 [file3]
+EOUSAGE
+		assert_equal(<<EOUSAGE, @options.usage(true))
+Usage:
+	app -iv -p PORT --help --interactive --port PORT --version file1 file2 [file3]
+EOUSAGE
+	end
+
+	def test_help
+		assert_equal(<<EOUSAGE, @options.help)
+app file1 file2 [file3]
+
+--help
+	Display this help.
+-i, --interactive
+	Don't deamonize, lets process run interactively in Terminal.
+-p, --port PORT
+	On what port to run the server.
+-v, --version
+	Prints the version and quits.
+EOUSAGE
+	end
+	
+	def test_options
+	end
+end