butler 1.8.0 → 1.8.1

data/lib/string/sbencoded.rb

@@ -0,0 +1,77 @@
+require 'string'
+
+# SingleByte encoded Strings, more speed than MBEncoded for operations like
+# length, index, [] and []= (predefined length of characters)
+class String::SBEncoded < String
+	def self.new(string, encoding, collation=nil)
+		raise "No encoding given" unless Encodings[encoding]
+		obj = allocate
+		obj.send(:initialize, string, encoding, collation)
+		obj
+	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 <=> other.utf8
+	end
+
+# all methods delegated to utf8-ified strings (and if necessary it's reconversion)
+	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 [](*args)
+		String::SBEncoded.new(super, @encoding, @collation)
+	end
+	alias slice []
+	
+	def chop
+		String::SBEncoded.new(super, @encoding, @collation)
+	end
+	def strip
+		String::SBEncoded.new(super, @encoding, @collation)
+	end
+	def lstrip
+		String::SBEncoded.new(super, @encoding, @collation)
+	end
+	def rstrip
+		String::SBEncoded.new(super, @encoding, @collation)
+	end
+
+
+# ! variants, using self.replace
+	def upcase!;     replace(upcase);     end
+	def downcase!;   replace(downcase);   end
+	def capitalize!; replace(capitalize); end
+
+	def dup
+		String::SBEncoded.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

data/lib/string/utf8.rb

@@ -0,0 +1,157 @@
+require 'string'
+
+class String::UTF8 < String
+	unless method_defined?(:byte_insert)
+		UTF8        = 'utf-8'
+		alias byte_insert insert
+		alias original_succ! succ!
+		alias original_succ succ
+		private :original_succ!
+		private :original_succ
+	end
+	
+	def self.new(string, encoding, collation=nil)
+		raise "Encoding must be 'utf-8' but is '#{encoding}'" unless encoding == UTF8
+		obj = allocate
+		obj.send(:initialize, string, collation)
+		obj
+	end
+
+	attr_reader :collation
+
+	def initialize(string, collation=nil)
+		super(Unicode::normalize_KC(string))
+		@collation = collation
+	end
+	
+	def encoding
+		String::UTF8::UTF8
+	end
+
+	# See String#[].
+	# May return an integer > 255 when used like "\342\210\205"[0] # => 8709
+	def [](arg1, arg2=nil) #:nodoc:
+		if arg2 then
+			unpack("U*").slice(arg1, arg2).pack("U*").utf8
+		elsif Range === arg1 then
+			unpack("U*").slice(arg1).pack("U*").utf8
+		else
+			unpack("U*").slice(*args)
+		end
+	end
+	alias slice []
+	
+	def []=(*args)
+		value = args.pop
+		codepoints = unpack("U*")
+		codepoints[*args] = value.utf8.unpack("U*")
+		replace(codepoints.pack("U*"))
+		self
+	end
+
+	def ==(other)
+		super(other.utf8)
+	end
+
+	def <=>(other)
+		raise "Can't compare strings with different collation" unless @collation == other.collation
+		Unicode.strcmp(self, other)
+	end
+
+	def length;     @length||=unpack("U*").size; end
+	def upcase;     Unicode::upcase(self).utf8; end
+	def downcase;   Unicode::downcase(self).utf8; end
+	def capitalize; Unicode::capitalize(self).utf8; end
+	def swapcase
+		up   = Unicode::upcase(self)
+		down = Unicode::downcase(self)
+		unpack("U*").zip(up.unpack("U*"), down.unpack("U*")).map { |n,u,d|
+			n == u ? d : u
+		}.pack("U*")
+	end
+	def reverse;    unpack("U*").reverse.pack("U*").utf8; end
+	def strip;      gsub(UNICODE_L_PAT, '').gsub(UNICODE_L_PAT, '').utf8; end
+	def lstrip;     gsub(UNICODE_L_PAT, '').utf8; end
+	def rstrip;     gsub(UNICODE_T_PAT, '').utf8; end
+
+	def index(item, offset=0)
+		case item
+			when Regexp
+				mb = unpack("U*")[offset..-1].pack("U*")
+				bi = mb.byte_index(item)
+				bi && mb.byte_slice(0,bi).unpack("U*").size+offset
+			when Integer
+				# sucks, but Array#index does not accept an offset-arg
+				unpack("U*")[offset..-1].index(item)+offset
+			else
+				raise "Must be of same encoding" if String === item and encoding != item.encoding
+				if offset.zero? then
+					bi = byte_index(item)
+					bi && byte_slice(0,bi).unpack("U*").size
+				else
+					index(Regexp.new(Regexp.escape(item)), offset)
+				end
+		end
+	end
+
+	def rindex(item, offset=-1)
+		case item
+			when Integer
+				unpack("U*")[0..offset].rindex(item)
+			else
+				raise "Must be of same encoding" if String === item and encoding != item.encoding
+				bi = byte_rindex(item, offset)
+				bi && byte_slice(0,bi).unpack("U*").size
+		end
+	end
+
+	# Inserts the string at codepoint offset specified in offset.
+	def insert(offset, fragment)  #:nodoc:
+		replace(unpack("U*").insert(offset, fragment.unpack("U*")).flatten.pack("U*"))
+	end
+	
+	def chop!
+		gsub!(/(?:.|\r?\n)\z/u, '')
+	end
+
+	def chop
+		gsub(/(?:.|\r?\n)\z/u, '')
+	end
+
+	def each_char(&block)
+		scan(/./um, &block)
+		self
+	end
+	
+	def utf8(collation=nil)
+		String::UTF8.new(self, String::UTF8::UTF8, collation)
+	end
+	
+	def dup
+		String::UTF8.new(self, String::UTF8::UTF8, @collation)
+	end
+
+	# Decomposes the string and returns the decomposed string
+	def decompose #:nodoc:
+		Unicode::decompose(self)
+	end
+
+	# Normalizes the string to form C and returns the result
+	def normalize_C #:nodoc:
+		Unicode::normalize_C(self)
+	end
+
+	# Normalizes the string to form D and returns the result
+	def normalize_D #:nodoc:
+		Unicode::normalize_D(self)
+	end
+
+	# Normalizes the string to form KC and returns the result
+	def normalize_KC #:nodoc:
+		Unicode::normalize_KC(self)
+	end
+
+	def inspect
+		"#{encoding}(#{collation||'none'}):#{super}"
+	end
+end

data/lib/templater.rb

@@ -11,22 +11,66 @@ require 'ostruct'
 
 
 
+# = Indexing
+# Author:  Stefan Rusterholz
+# Contact: apeiros@gmx.net>
+# Version: 0.0.1
+# Date:    2007-10-12
+#
+# = About
+# A helper class for ERB, allows constructs like the one in the Synopsis to
+# enable simple use of variables/methods in templates.
+# 
+# = Synopsis
+#   tmpl = Templater.new("Hello <%= name %>!")
+#   tmpl.result(self, :name => 'world') # => 'Hello World!'
+# 
 class Templater
+	module VERSION
+		STRING = "0.0.2"
+	end
+
+	# A proc for &on_error in Templater::Variables.new or Templater#result.
+	# Raises the error further on.
 	Raiser = proc { |e|
 		raise
 	}
+
+	# A proc for &on_error in Templater::Variables.new or Templater#result.
+	# Inserts <<error_class: error_message>> in the place where the error
+	# occurred.
 	Teller = proc { |e|
 		"<<#{e.class}: #{e}>>"
 	}
 
+	# = Indexing
+	# Author:  Stefan Rusterholz
+	# Contact: apeiros@gmx.net>
+	# Version: 0.0.1
+	# Date:    2007-10-12
+	#
+	# = About
+	# Used by Templater to resolve variables.
+	# 
+	# = Synopsis
+	#   tmpl = Variables.new(delegator, :variable => "content") { |exception|
+	#     do_something_with_exception
+	#   }
+	# 
 	class Variables < OpenStruct
+
+		# === Arguments
+		# * delegator: All method calls and undefined variables are delegated to this object as method call.
+		# * variables: A hash with variables in it, keys must be Symbols.
+		# * &on_error: The block is yielded in case of an exception with the exception as argument
+		#
 		def initialize(delegator=nil, variables={}, &on_error)
 			super(variables)
 			@delegator = delegator
 			@on_error  = on_error || RaiseExceptions
 		end
 		
-		def method_missing(m, *a, &b)
+		def method_missing(m, *a, &b) # :nodoc:
 			if @table.key?(m) || m.to_s =~ /=$/ then
 				super
 			elsif @delegator && @delegator.respond_to?(m) then
@@ -38,7 +82,7 @@ class Templater
 			@on_error.call(e)
 		end
 		
-		def inspect
+		def inspect # :nodoc:
 			@table.inspect
 		end
 	end
@@ -49,24 +93,38 @@ class Templater
 		:trim_mode  => '%<>',
 		:eoutvar    => '_erbout'
 	}
+
 	# binding method
 	Binder = Object.instance_method(:binding)
 
+	# The template string
 	attr_reader :string
+	
+	# Like Templater.new, but instead of a template string, the path to the file
+	# containing the template. Sets :filename.
+	def self.file(path, opt=nil)
+		new(File.read, (opt || {}).merge(:filename => path))
+	end
+	
+	# ==== Arguments
+	# * string: The template string, it becomes frozen
+	# * opt:    Option hash, keys:
+	#   * :filename:   The filename used for the evaluation (useful for error messages)
+	#   * :safe_level: see ERB.new
+	#   * :trim_mode:  see ERB.new
+	#   * :eoutvar:    see ERB.new
 	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
+		file          = opt.delete(:filename)
+		@string       = string.freeze
 		@erb          = ERB.new(@string, *opt.values_at(:safe_level, :trim_mode, :eoutvar))
 		@erb.filename = file if file
 	end
 	
+	# See Templater::Variables.new
+	# Returns the evaluated template. Default &on_error is the Templater::Raiser
+	# proc.
 	def result(delegator=nil, variables={}, &on_error)
 		variables ||= {}
 		on_error  ||= Raiser
@@ -75,7 +133,7 @@ class Templater
 	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,

data/lib/w3validator.rb

@@ -0,0 +1,86 @@
+require 'mechanize'
+
+class W3Validator
+	attr_reader :glob
+	attr_reader :files
+	
+	def initialize(glob, cache=nil)
+		@glob  = glob.freeze
+		@files = glob ? Dir.glob(glob).freeze : [].freeze
+		@agent = WWW::Mechanize.new
+		# bug in current implementation? unpredictably raises EOF exceptions without this
+		@agent.keep_alive = false
+		@cache      = cache ? Marshal.load(File.read(cache)) : nil
+		@cache_file = cache
+		require 'zlib' if @cache
+	end
+	
+	def cache
+		data = {}
+		@files.each { |file| data[file] = Zlib.crc32(File.read(file)) }
+		File.open(cache, "w") { |fh| fh.write(Marshal.dump(data)) }
+		@cache = data
+	end
+	
+	def cache_file(file)
+		require 'zlib'
+		data = Marshal.load(File.read(cache))
+		data[file] = Zlib.crc32(File.read(file))
+		File.open(cache, "w") { |fh| fh.write(Marshal.dump(data)) }
+		data
+	end
+	
+	def validate_changed(cachefile, delay=2)
+		require 'zlib'
+		crcs = File.exist?(cachefile) ? Marshal.load(File.read(cachefile)) {}
+		warn "No cachefile." unless File.exist?(cachefile)
+		orig_files = @files.dup
+		@files     = @files.reject { |file| Zlib.crc32(File.read(file)) == crcs[file] }
+		puts "Validating files:", *@files
+		result     = validate(delay, &block)
+		@files     = orig_files.freeze
+		result
+	end
+	
+	# returns whether all are valid, yields file, valid if a block was given.
+	def validate(delay=2)
+		@files.map { |file|
+			valid = valid?(file)
+			yield(file, valid) if block_given?
+			sleep(delay)
+			valid
+		}.all?
+	end
+	
+	def rehash
+		@files = @glob ? Dir.glob(@glob).freeze : [].freeze
+	end
+	
+	def glob=(glob)
+		@glob = glob
+		rehash
+	end
+	
+	def valid?(file, tries=3, delay=3)
+		rescued = 0
+		form = @agent.get('http://validator.w3.org/').forms[1]
+		form.file_uploads.first.file_name = file
+		result = form.submit
+		cache_file(file) if @cache_file
+		case (result/"title").first.inner_text[/\[([^\/]+)\]/, 1]
+			when "Valid": true
+			when "Invalid": false
+			else raise "Title #{(result/"title").first.inner_text.gsub(/\s+/m, ' ')} not recognized"
+		end
+	rescue Exception => e
+		warn e
+		tries -= 1
+		raise "could not validate" if tries.zero?
+		sleep(delay)
+		retry
+	end
+	
+	def inspect
+		"#<%s:0x%08x glob=%s>" %  [self.class, object_id<<1, @glob.inspect]
+	end
+end