butler 1.8.0

data/lib/butler/version.rb

@@ -0,0 +1,17 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class Butler #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 8
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/cloptions.rb

@@ -0,0 +1,217 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'cloptions/adapters'
+require 'cloptions/switch'
+
+
+
+# a class for simple command line option parsing
+class CLOptions
+	EmptyARGV = Struct.new('EmptyARGV')
+
+	class Result
+		attr_reader :argv
+		
+		def initialize(options, argv, flags={}, hash={})
+			@options = options
+			@argv    = argv
+			@flags   = flags
+			@hash    = hash
+		end
+		
+		def to_hash
+			@hash.dup
+		end
+		
+		def [](key)
+			@flags[key] && @flags[key].parameters
+		end
+		
+		def flag(*key)
+			return @flags if key.empty?
+			@flags[key.first]
+		end
+		
+		# Run the block if given flag is set
+		# :yields: flag
+		def on(flag)
+			yield @flag[key] if flag
+		end
+
+		def process(argv)
+			@argv_processing = argv
+			while arg = argv.shift
+				case arg
+					when Switch::Short: add_flag($~, @options.short)
+					when Switch::Long:  add_flag($~, @options.long)
+					else
+						argv.unshift(arg)
+						break
+				end
+			end
+
+			min = (@options.arity[0] < 0 ? -1-@options.arity[0] : @options.arity[0])+(@options.arity[2] < 0 ? -1-@options.arity[2] : @options.arity[2])
+			max = (@options.arity[0] < 0 || @options.arity[1] < 0) ? nil : min+@options.arity[1]
+			argv_index = -1
+			3.times { |i|
+				process_args(i, @argv_processing).each { |arg|
+					@argv[argv_index+=1] = arg
+				}
+			}
+			self
+		end
+		
+		private
+		def add_flag(match, from)
+			name, data = match.captures
+			raise "Unknown switch -#{name}" unless switch = from[name]
+			flag       = switch.process(data, @argv_processing)
+			switch.mappings.each { |mapping|
+				@flags[mapping] = flag
+			}
+			@hash[switch.hash_key] = flag.parameters if switch.hash_key
+		end
+	
+		def process_args(n, params)
+			if @options.arity[n] > 0 then
+				params.slice!(0,@options.arity[n]) || []
+			elsif @options.arity[n] < 0 then
+				(params.slice!(0,-1-@options.arity[n]) || [])+[params]
+			else
+				[]
+			end
+		end
+		private :process_args
+	end
+	
+	def self.parse(*args, &block)
+		options = new(*args, &block)
+		options.parse(ARGV)
+	end
+	
+	attr_reader :arity
+	attr_reader :switch
+	attr_reader :short
+	attr_reader :long
+	attr_reader :argstruct
+	def initialize(arguments, opts={}, &description)
+		@switch    = []
+		@short     = {}
+		@long      = {}
+		@arguments, @arity = *analyze_args(arguments)
+		@str_args  = arguments
+		@argstruct = (@arguments.empty? ? EmptyARGV : ::Struct.new(*@arguments.map { |a| a.to_sym }))
+		@appname   = $0
+		instance_eval(&description) if description
+	end
+	
+	def parse(argv=ARGV)
+		result = Result.new(self, @argstruct.new)
+		result.process(argv)
+		result
+	end
+	
+	# figure from argument string the arity and what args
+	def analyze_args(argstr)
+		current = 0
+		arity   = [0, 0, 0]
+		args    = []
+		return [args, arity] if argstr.nil?
+
+		argstr.split(/\s+/).each { |param|
+			raise "Invalid argument format '#{argstr}'" if current == 2
+			if param == "..." || param == "…" then
+				arity[current] = -(arity[current]+1)
+				current = 2
+			elsif param[0] == ?[ && param[-1] == ?] then
+				raise "Invalid parameter format '#{argstr}'" if current == 2
+				current = 1
+				arity[2] += 1
+				args << param[1..-2].freeze
+			else
+				current = 2 if current == 1
+				arity[current] += 1
+				args << param.dup.freeze
+			end
+		}
+		[args, arity]
+	end
+	private :analyze_args
+
+
+	# arguments are positional, starting from 2 arguments, the last argument is considered
+	# to be the description/help:
+	#   0: short switch
+	#   1: long switch (optional)
+	#   2: arguments (optional)
+	#   3: hash-mapping (optional)
+	#  -1: description (-1 == the last)
+	# option('-s', '--long', :mapping, "Description of flag") { |value| adapt }
+	# option('-p', '--port', true, "Description of flag", &CLOptions::Integer)
+	def option(short, *rest, &adapter)
+		switch = Switch.new(short, *rest, &adapter)
+		@short[switch.short] = switch if switch.short
+		@long[switch.long]   = switch if switch.long
+		if switch.short || switch.long then
+			@switch              << switch
+		else
+			raise "Neither short nor long in option declaration."
+		end
+	end
+	alias o option
+	
+	def application_name(name)
+		@appname = name
+	end
+	
+	# an automatically generated help string
+	# see #application_name
+	def help
+		out = "#{@appname}#{' '+@str_args if @str_args}\n\n"
+		@switch.inject(out) { |out, switch| out << "#{switch}\n\t#{switch.help}\n" }
+	end
+
+	# an automatically generated usage string
+	def usage(include_long_opts=false)
+		out = "Usage:\n\t#@appname"
+		short = ""
+		long  = ""
+		collected = []
+		if include_long_opts then
+	 		@switch.each { |s|
+	 			if s.short then
+					if s.params.empty? then
+						collected << s.short[1,1]
+					else
+						short << " #{s.short}#{' '+s.str_params if s.str_params}"
+					end
+				end
+				long << " #{s.long}#{' '+s.str_params if s.str_params}" if s.long
+			}
+		else
+	 		@switch.each { |s|
+ 				if s.short.nil? then
+					long << " #{s.long}#{' '+s.str_params if s.str_params}"
+				elsif s.params.empty? then
+					collected << s.short[1,1]
+				else
+					short << " #{s.short}#{' '+s.str_params if s.str_params}"
+				end
+			}
+		end
+		out << (collected.empty? ? "" : " -#{collected.join('')}") << short << long << (@str_args ? " #@str_args\n" :  "\n")
+		out
+	end
+end
+
+# Developer notes:
+# arity is an array, negative numbers mean infinite, where -1 means 0..Inf, -2 means 1..Inf etc
+# positive numbers mean exactly that many
+# the first number is mandatory head, the last number is mandatory tail, the middle number
+# is optional args

data/lib/cloptions/adapters.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class CLOptions
+	module Adapters
+		Integer = Kernel.method(:Integer)
+		Octal   = proc { |value|
+			raise ArgumentError, "Not Octal" unless value =~ /\A(-?)([0-7]+)\z/
+			Integer("#{$1}0#{$2}")
+		}
+		Hex     = proc { |value|
+			raise ArgumentError, "Not Hex" unless value =~ /\A(-?)(?:0[Xx])?([\dA-Fa-f]+)\z/
+			Integer("#{$1}0x#{$2}")
+		}
+		Float   = Kernel.method(:Float)
+		String  = proc { |value| value }
+	end
+	include Adapters
+end

data/lib/cloptions/switch.rb

@@ -0,0 +1,132 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+class CLOptions
+	Flag      = Struct.new(:switch, :parameters, :errors)	
+	class Flag
+		def inspect
+			"#<%s:0x%x switch=#<CLOptions::Switch %s> parameters=%s errors=%s>" %  [
+				self.class,
+				object_id << 1,
+				switch.to_s,
+				parameters.inspect,
+				errors.inspect
+			]
+		end
+	end
+
+	# VALID:
+	# --foo                    => [ 0,  0,  0]
+	# --foo [PARAM]            => [ 0,  1,  0]
+	# --foo PARAM              => [ 1,  0,  0]
+	# --foo PARAM, ...         => [-2,  0,  0]
+	# --foo [PARAM], ...       => [ 0, -1,  0]
+	# --foo P1, P2, P3         => [ 3,  0,  0]
+	# --foo P1, P2, [P3]       => [ 2,  1,  0]
+	# --foo P1, P2, ...        => [-3,  0,  0]
+	#
+	# POSSIBLE:
+	# --foo P1, [P2], P3       => [ 1,  1,  1]
+	# --foo P1, ..., P3        => [-2,  0,  1]
+	# --foo P1, [P2], ..., P3  => [ 1, -1,  1]
+	#
+	# IMPOSSIBLE:
+	# --foo P1, [P2], P3, [P4] => [ 0,  0,  0]
+	class Switch
+		Match = /\A(?:-\w|--[\w-]+)(?:=.*)?\z/
+		Short = /\A(-\w)(?:=([^,]+(?:(?:,[^,]+)*)|,))?\z/
+		Long  = /\A(--[\w-]+)(?:=([^,]+(?:(?:,[^,]+)*)|,))?\z/
+
+		attr_reader :short
+		attr_reader :long
+		attr_reader :hash_key
+		attr_reader :mappings
+		attr_reader :help
+		attr_reader :str_params
+		attr_reader :to_s
+		attr_reader :params
+		attr_reader :arity
+
+		def initialize(short, *rest, &adapter)
+			@help           = (::String === rest.last ? rest.pop : "").freeze
+			@short          = short
+			@long           = rest.shift
+			@str_params     = rest.shift
+			@params, @arity = *analyze_param(@str_params)
+			@hash_key       = rest.shift
+			@hash_key       = @long ? @long[2..-1].to_sym : @short[1,1].to_sym if @hash_key == true
+			@mappings       = [@short, @long, @hash_key].compact
+			@adapter        = adapter
+			@to_s           = ("#{short}#{', ' if short and long}#{long}#{' '+@str_params if @str_params}")
+		end
+		
+		def analyze_param(param)
+			current = 0
+			arity   = [0, 0, 0]
+			params  = []
+			return [params, arity] if param.nil?
+
+			param.split(/,\s*/).each { |param|
+				raise "Invalid parameter format '#{param}'" if current == 2
+				if param == "..." || param == "…" then
+					arity[current] = -(arity[current]+1)
+					current = 2
+				elsif param[0] == ?[ && param[-1] == ?] then
+					raise "Invalid parameter format '#{param}'" if current == 2
+					current = 1
+					arity[2] += 1
+					params << param[1..-2].freeze
+				else
+					current = 2 if current == 1
+					arity[current] += 1
+					params << param.dup.freeze
+				end
+			}
+			
+			[params, arity]
+		end
+		private :analyze_param
+		
+		def process(data, args)
+			flag    = Flag.new(self, true, nil)
+			min     = (@arity[0] < 0 ? -1-@arity[0] : @arity[0])+(@arity[2] < 0 ? -1-@arity[2] : @arity[2])
+			max     = (@arity[0] < 0 || @arity[1] < 0) ? nil : min+@arity[1]
+			return flag if max == 0
+
+			flag[1] = []
+			params  = []
+			args.unshift(*data.split(/,/)) if data
+			while args.first !~ Match
+				params << (@adapter ? @adapter.call(args.shift) : args.shift)
+				break unless args.first and args.first[-1] == ?,
+			end
+			raise "Invalid parameter count for flag #{self}" if ((max && !params.length.between?(min, max)) || params.length < min)
+			if max == 0 then
+				flag[1] = nil
+			elsif min == 1 && max == 1 then
+				flag[1] = params.first
+			else
+				3.times { |i| process_params(flag, i, params) }
+			end
+			flag
+		end
+		
+		def process_params(flag, n, params)
+			#p [:process_params, flag, n, params]
+			#pp self
+			return if @arity[n] == 0
+			if @arity[n] > 0 then
+				flag[1].concat(params.slice!(0,@arity[n]))
+			else
+				flag[1].concat(params.slice!(0,-1-@arity[n]))
+				#flag[1].push(params) -- FIXME why is that in again? write tests, for lobsters sake :-S
+			end
+		end
+		private :process_params
+	end
+end

data/lib/configuration.rb

@@ -0,0 +1,223 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'fileutils'
+require 'yaml'
+
+
+
+class String
+	def config_key # FIXME %2e instead of . is just ugly...
+		gsub(/\./, '%2e')
+	end
+end
+
+class Configuration
+	module VERSION
+		MAJOR  = 0
+		MINOR  = 0
+		TINY   = 1
+		STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+	end
+	class InvalidKey < StandardError
+		attr_reader :key
+		def initialize(key)
+			@key = key
+			super("Keys must not be empty nor contain '.'.")
+		end
+	end	
+
+	ConfFile = Struct.new(:data, :path, :mtime)
+	
+	attr_reader :base
+
+	def initialize(base, dir_tree=[])
+		# make it resistant against Dir.chdir
+		@base  = File.expand_path(base).freeze
+		@files = {}
+
+		unless File.directory?(@base) && File.exist?("#@base/.configdir.yaml") then
+			if File.file?(@base) then
+				raise "Can't create directory #@base because of existing file #@base"
+			end
+			if File.exist?(@base) then
+				raise "Directory #@base already exists and is not a configuration directory"
+			end
+		end
+		unless File.exist?(@base) then
+			FileUtils.mkdir_p(@base)
+			File.open("#@base/.configdir.yaml", "w") { |fh|
+				fh.write({
+					:created  => Time.now,
+					:modified => Time.now,
+					:revision => 1,
+				}.to_yaml)
+			}
+		end
+		setup(dir_tree)
+	end
+	
+	def [](key)
+		file, key = split(key)
+		return nil unless key_exist?(file, key)
+		key ? @files[file][key] : @files[file]
+	end
+	
+	def []=(key, value)
+		file, key = split(key)
+		load(file)
+		if key then
+			if Hash === @files[file] then
+				@files[file][key] = value
+			else
+				@files[file] = {key => value}
+			end
+		else
+			@files[file] = value
+		end
+		store(file)
+		value
+	end
+
+	def exist?(key)
+		file, key = split(key)
+		key_exist?(file, key)
+	end
+	alias has_key? exist?
+	
+	def delete(key)
+		file, key = split(key)
+		return nil unless key_exist?(file, key) and File.exist?(file)
+		if key.empty? then
+			File.delete(file)
+		else
+			load(file)
+			@files[file].delete(key)
+			store(file)
+		end
+	end
+
+	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(/\./)
+		file      = @base.dup
+		raise InvalidKey.new(key) if (keys.empty? || keys.join.include?("."))
+		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] } # {}()\[\]~
+	end
+	
+	def decode_filename(name)
+		name.gsub(/%[a-f\d]{2}/) { |m| m[1,2].to_i(16).chr }
+	end
+	
+	def load(file, force=false)
+		if force || !@files.has_key?(file) then
+			@files[file] = nil
+			@files[file] = YAML.load_file(file) if File.exist?(file)
+		else
+			@files[file]
+		end
+	end
+	
+	def store(file)
+		bak = nil
+		if File.exist?(file) then
+			bak = "#{file}.bak"
+			FileUtils.cp(file, bak)
+		end
+		begin
+			File.open(file, "w") { |fh| fh.write(@files[file].to_yaml) }
+		rescue
+			if bak then
+				FileUtils.rm(file)
+				FileUtils.mv(bak, file)
+				FileUtils.rm(bak)
+			end
+			raise
+		else
+			FileUtils.rm(bak) if bak # not in the ensure because the rescue might fail too
+		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