monetra-ruby 0.0.6

data/lib/monetra/active_support/vendor/flexmock.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004 by Jim Weirich (jim@weriichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+require 'test/unit'
+
+# FlexMock is a flexible mock object suitable for using with Ruby's
+# Test::Unit unit test framework.  FlexMock has a simple interface
+# that's easy to remember, and leaves the hard stuff to all those
+# other mock object implementations.
+#
+# Usage:  See TestSamples for example usage.
+
+class FlexMock
+  include Test::Unit::Assertions
+
+  # Create a FlexMock object.
+  def initialize
+    @handlers = Hash.new
+    @counts   = Hash.new(0)
+    @expected_counts = Hash.new
+  end
+  
+  # Handle all messages denoted by +sym+ by calling the given block
+  # and passing any parameters to the block.  If we know exactly how
+  # many calls are to be made to a particular method, we may check
+  # that by passing in the number of expected calls as a second
+  # paramter.
+  def mock_handle(sym, expected_count=nil, &block)
+    if block_given?
+      @handlers[sym] = block
+    else
+      @handlers[sym] = proc { }
+    end
+    @expected_counts[sym] = expected_count  if expected_count
+  end
+
+  # Verify that each method that had an explicit expected count was
+  # actually called that many times.
+  def mock_verify
+    @expected_counts.keys.each do |key|
+      assert_equal @expected_counts[key], @counts[key],
+	"Expected method #{key} to be called #{@expected_counts[key]} times, " +
+	"got #{@counts[key]}"
+    end
+  end
+
+  # Report how many times a method was called.
+  def mock_count(sym)
+    @counts[sym]
+  end
+
+  # Ignore all undefined (missing) method calls.
+  def mock_ignore_missing
+    @ignore_missing = true
+  end
+
+  # Handle missing methods by attempting to look up a handler.
+  def method_missing(sym, *args, &block)
+    if handler = @handlers[sym]
+      @counts[sym] += 1
+      args << block  if block_given?
+      handler.call(*args)
+    else
+      super(sym, *args, &block)  unless @ignore_missing
+    end
+  end
+
+  # Class method to make sure that verify is called at the end of a
+  # test.
+  def self.use
+    mock = new
+    yield mock
+  ensure
+    mock.mock_verify
+  end
+end

data/lib/monetra/active_support/vendor/xml_simple.rb

@@ -0,0 +1,1019 @@
+# = XmlSimple
+#
+# Author::    Maik Schmidt <contact@maik-schmidt.de>
+# Copyright:: Copyright (c) 2003 Maik Schmidt
+# License::   Distributes under the same terms as Ruby.
+#
+require 'rexml/document'
+
+# Easy API to maintain XML (especially configuration files).
+class XmlSimple #:nodoc:
+  include REXML
+
+  @@VERSION = '1.0.2'
+
+  # A simple cache for XML documents that were already transformed
+  # by xml_in.
+  class Cache #:nodoc:
+    # Creates and initializes a new Cache object.
+    def initialize
+      @mem_share_cache = {}
+      @mem_copy_cache  = {}
+    end
+
+    # Saves a data structure into a file.
+    # 
+    # data::
+    #   Data structure to be saved.
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def save_storable(data, filename)
+      cache_file = get_cache_filename(filename)
+      File.open(cache_file, "w+") { |f| Marshal.dump(data, f) }
+    end
+
+    # Restores a data structure from a file. If restoring the data
+    # structure failed for any reason, nil will be returned.
+    #
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def restore_storable(filename)
+      cache_file = get_cache_filename(filename)
+      return nil unless File::exist?(cache_file)
+      return nil unless File::mtime(cache_file).to_i > File::mtime(filename).to_i
+      data = nil
+      File.open(cache_file) { |f| data = Marshal.load(f) }
+      data
+    end
+
+    # Saves a data structure in a shared memory cache.
+    #
+    # data::
+    #   Data structure to be saved.
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def save_mem_share(data, filename)
+      @mem_share_cache[filename] = [Time::now.to_i, data]
+    end
+
+    # Restores a data structure from a shared memory cache. You
+    # should consider these elements as "read only". If restoring
+    # the data structure failed for any reason, nil will be
+    # returned.
+    #
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def restore_mem_share(filename)
+      get_from_memory_cache(filename, @mem_share_cache)
+    end
+
+    # Copies a data structure to a memory cache.
+    #
+    # data::
+    #   Data structure to be copied.
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def save_mem_copy(data, filename)
+      @mem_share_cache[filename] = [Time::now.to_i, Marshal.dump(data)]
+    end
+
+    # Restores a data structure from a memory cache. If restoring
+    # the data structure failed for any reason, nil will be
+    # returned.
+    #
+    # filename::
+    #   Name of the file belonging to the data structure.
+    def restore_mem_copy(filename)
+      data = get_from_memory_cache(filename, @mem_share_cache)
+      data = Marshal.load(data) unless data.nil?
+      data
+    end
+
+    private
+
+    # Returns the "cache filename" belonging to a filename, i.e.
+    # the extension '.xml' in the original filename will be replaced
+    # by '.stor'. If filename does not have this extension, '.stor'
+    # will be appended.
+    #
+    # filename::
+    #   Filename to get "cache filename" for.
+    def get_cache_filename(filename)
+      filename.sub(/(\.xml)?$/, '.stor')
+    end
+
+    # Returns a cache entry from a memory cache belonging to a
+    # certain filename. If no entry could be found for any reason,
+    # nil will be returned.
+    #
+    # filename::
+    #   Name of the file the cache entry belongs to.
+    # cache::
+    #   Memory cache to get entry from.
+    def get_from_memory_cache(filename, cache)
+      return nil unless cache[filename]
+      return nil unless cache[filename][0] > File::mtime(filename).to_i
+      return cache[filename][1]
+    end
+  end
+
+  # Create a "global" cache.
+  @@cache = Cache.new
+
+  # Creates and intializes a new XmlSimple object.
+  # 
+  # defaults::
+  #   Default values for options.
+  def initialize(defaults = nil)
+    unless defaults.nil? || defaults.instance_of?(Hash)
+      raise ArgumentError, "Options have to be a Hash."
+    end
+    @default_options = normalize_option_names(defaults, KNOWN_OPTIONS['in'] & KNOWN_OPTIONS['out'])
+    @options = Hash.new
+    @_var_values = nil
+  end
+
+  # Converts an XML document in the same way as the Perl module XML::Simple.
+  #
+  # string::
+  #   XML source. Could be one of the following:
+  #
+  #   - nil: Tries to load and parse '<scriptname>.xml'.
+  #   - filename: Tries to load and parse filename.
+  #   - IO object: Reads from object until EOF is detected and parses result.
+  #   - XML string: Parses string.
+  #   
+  # options::
+  #   Options to be used.
+  def xml_in(string = nil, options = nil)
+    handle_options('in', options)
+
+    # If no XML string or filename was supplied look for scriptname.xml.
+    if string.nil?
+      string = File::basename($0)
+      string.sub!(/\.[^.]+$/, '')
+      string += '.xml'
+
+      directory = File::dirname($0)
+      @options['searchpath'].unshift(directory) unless directory.nil?
+    end
+
+    if string.instance_of?(String)
+      if string =~ /<.*?>/m
+        @doc = parse(string)
+      elsif string == '-'
+        @doc = parse($stdin.readlines.to_s)
+      else
+        filename = find_xml_file(string, @options['searchpath'])
+
+        if @options.has_key?('cache')
+          @options['cache'].each { |scheme|
+            case(scheme)
+            when 'storable'
+              content = @@cache.restore_storable(filename)
+            when 'mem_share'
+              content = @@cache.restore_mem_share(filename)
+            when 'mem_copy'
+              content = @@cache.restore_mem_copy(filename)
+            else
+              raise ArgumentError, "Unsupported caching scheme: <#{scheme}>."
+            end
+            return content if content
+          }
+        end
+        
+        @doc = load_xml_file(filename)
+      end
+    elsif string.kind_of?(IO)
+      @doc = parse(string.readlines.to_s)
+    else
+      raise ArgumentError, "Could not parse object of type: <#{string.type}>."
+    end
+
+    result = collapse(@doc.root)
+    result = @options['keeproot'] ? merge({}, @doc.root.name, result) : result
+    put_into_cache(result, filename)
+    result
+  end
+
+  # This is the functional version of the instance method xml_in.
+  def XmlSimple.xml_in(string = nil, options = nil)
+    xml_simple = XmlSimple.new
+    xml_simple.xml_in(string, options)
+  end
+  
+  # Converts a data structure into an XML document.
+  #
+  # ref::
+  #   Reference to data structure to be converted into XML.
+  # options::
+  #   Options to be used.
+  def xml_out(ref, options = nil)
+    handle_options('out', options)
+    if ref.instance_of?(Array)
+      ref = { @options['anonymoustag'] => ref }
+    end
+
+    if @options['keeproot']
+      keys = ref.keys
+      if keys.size == 1
+        ref = ref[keys[0]]
+        @options['rootname'] = keys[0]
+      end
+    elsif @options['rootname'] == ''
+      if ref.instance_of?(Hash)
+        refsave = ref
+        ref = {}
+        refsave.each { |key, value|
+          if !scalar(value)
+            ref[key] = value
+          else
+            ref[key] = [ value.to_s ]
+          end
+        }
+      end
+    end
+
+    @ancestors = []
+    xml = value_to_xml(ref, @options['rootname'], '')
+    @ancestors = nil
+
+    if @options['xmldeclaration']
+      xml = @options['xmldeclaration'] + "\n" + xml
+    end
+
+    if @options.has_key?('outputfile')
+      if @options['outputfile'].kind_of?(IO)
+        return @options['outputfile'].write(xml)
+      else
+        File.open(@options['outputfile'], "w") { |file| file.write(xml) }
+      end
+    end
+    xml
+  end
+
+  # This is the functional version of the instance method xml_out.
+  def XmlSimple.xml_out(hash, options = nil)
+    xml_simple = XmlSimple.new
+    xml_simple.xml_out(hash, options)
+  end
+  
+  private
+
+  # Declare options that are valid for xml_in and xml_out.
+  KNOWN_OPTIONS = {
+    'in'  => %w(
+      keyattr keeproot forcecontent contentkey noattr
+      searchpath forcearray suppressempty anonymoustag
+      cache grouptags normalisespace normalizespace
+      variables varattr
+    ),
+    'out' => %w(
+      keyattr keeproot contentkey noattr rootname
+      xmldeclaration outputfile noescape suppressempty
+      anonymoustag indent grouptags noindent
+    )
+  }
+
+  # Define some reasonable defaults.
+  DEF_KEY_ATTRIBUTES  = []
+  DEF_ROOT_NAME       = 'opt'
+  DEF_CONTENT_KEY     = 'content'
+  DEF_XML_DECLARATION = "<?xml version='1.0' standalone='yes'?>"
+  DEF_ANONYMOUS_TAG   = 'anon'
+  DEF_FORCE_ARRAY     = true
+  DEF_INDENTATION     = '  '
+  
+  # Normalizes option names in a hash, i.e., turns all
+  # characters to lower case and removes all underscores.
+  # Additionally, this method checks, if an unknown option
+  # was used and raises an according exception.
+  #
+  # options::
+  #   Hash to be normalized.
+  # known_options::
+  #   List of known options.
+  def normalize_option_names(options, known_options)
+    return nil if options.nil?
+    result = Hash.new
+    options.each { |key, value|
+      lkey = key.downcase
+      lkey.gsub!(/_/, '')
+      if !known_options.member?(lkey)
+        raise ArgumentError, "Unrecognised option: #{lkey}."
+      end
+      result[lkey] = value
+    }
+    result
+  end
+  
+  # Merges a set of options with the default options.
+  # 
+  # direction::
+  #  'in':  If options should be handled for xml_in.
+  #  'out': If options should be handled for xml_out.
+  # options::
+  #   Options to be merged with the default options.
+  def handle_options(direction, options)
+    @options = options || Hash.new
+
+    raise ArgumentError, "Options must be a Hash!" unless @options.instance_of?(Hash)
+
+    unless KNOWN_OPTIONS.has_key?(direction)
+      raise ArgumentError, "Unknown direction: <#{direction}>."
+    end
+
+    known_options = KNOWN_OPTIONS[direction]
+    @options = normalize_option_names(@options, known_options)
+
+    unless @default_options.nil?
+      known_options.each { |option|
+        unless @options.has_key?(option)
+          if @default_options.has_key?(option)
+            @options[option] = @default_options[option]
+          end
+        end
+      }
+    end
+
+    unless @options.has_key?('noattr')
+        @options['noattr'] = false
+    end
+
+    if @options.has_key?('rootname')
+      @options['rootname'] = '' if @options['rootname'].nil?
+    else
+      @options['rootname'] = DEF_ROOT_NAME
+    end
+
+    if @options.has_key?('xmldeclaration') && @options['xmldeclaration'] == true
+      @options['xmldeclaration'] = DEF_XML_DECLARATION
+    end
+
+    if @options.has_key?('contentkey')
+      if @options['contentkey'] =~ /^-(.*)$/
+        @options['contentkey']    = $1
+        @options['collapseagain'] = true
+      end
+    else
+      @options['contentkey'] = DEF_CONTENT_KEY
+    end
+
+    unless @options.has_key?('normalisespace')
+      @options['normalisespace'] = @options['normalizespace']
+    end
+    @options['normalisespace'] = 0 if @options['normalisespace'].nil?
+
+    if @options.has_key?('searchpath')
+      unless @options['searchpath'].instance_of?(Array)
+        @options['searchpath'] = [ @options['searchpath'] ]
+      end
+    else
+      @options['searchpath'] = []
+    end
+
+    if @options.has_key?('cache') && scalar(@options['cache'])
+      @options['cache'] = [ @options['cache'] ]
+    end
+
+    @options['anonymoustag'] = DEF_ANONYMOUS_TAG unless @options.has_key?('anonymoustag')
+
+    if !@options.has_key?('indent') || @options['indent'].nil?
+      @options['indent'] = DEF_INDENTATION
+    end
+
+    @options['indent'] = '' if @options.has_key?('noindent')
+
+    # Special cleanup for 'keyattr' which could be an array or
+    # a hash or left to default to array.
+    if @options.has_key?('keyattr')
+      if !scalar(@options['keyattr'])
+        # Convert keyattr => { elem => '+attr' }
+        #      to keyattr => { elem => ['attr', '+'] }
+        if @options['keyattr'].instance_of?(Hash)
+          @options['keyattr'].each { |key, value|
+            if value =~ /^([-+])?(.*)$/
+              @options['keyattr'][key] = [$2, $1 ? $1 : '']
+            end
+          }
+        elsif !@options['keyattr'].instance_of?(Array)
+          raise ArgumentError, "'keyattr' must be String, Hash, or Array!"
+        end
+      else
+        @options['keyattr'] = [ @options['keyattr'] ]
+      end
+    else
+      @options['keyattr'] = DEF_KEY_ATTRIBUTES
+    end
+
+    if @options.has_key?('forcearray')
+      if @options['forcearray'].instance_of?(Regexp)
+        @options['forcearray'] = [ @options['forcearray'] ]
+      end
+
+      if @options['forcearray'].instance_of?(Array)
+        force_list = @options['forcearray']
+        unless force_list.empty?
+          @options['forcearray'] = {}
+          force_list.each { |tag|
+            if tag.instance_of?(Regexp)
+              unless @options['forcearray']['_regex'].instance_of?(Array)
+                @options['forcearray']['_regex'] = []
+              end
+              @options['forcearray']['_regex'] << tag
+            else
+              @options['forcearray'][tag] = true
+            end
+          }
+        else
+          @options['forcearray'] = false
+        end
+      else
+        @options['forcearray'] = @options['forcearray'] ? true : false
+      end
+    else
+      @options['forcearray'] = DEF_FORCE_ARRAY
+    end
+
+    if @options.has_key?('grouptags') && !@options['grouptags'].instance_of?(Hash)
+      raise ArgumentError, "Illegal value for 'GroupTags' option - expected a Hash."
+    end
+
+    if @options.has_key?('variables') && !@options['variables'].instance_of?(Hash)
+      raise ArgumentError, "Illegal value for 'Variables' option - expected a Hash."
+    end
+
+    if @options.has_key?('variables')
+      @_var_values = @options['variables']
+    elsif @options.has_key?('varattr')
+      @_var_values = {}
+    end
+  end
+
+  # Actually converts an XML document element into a data structure.
+  #
+  # element::
+  #   The document element to be collapsed.
+  def collapse(element)
+    result = @options['noattr'] ? {} : get_attributes(element)
+
+    if @options['normalisespace'] == 2
+      result.each { |k, v| result[k] = normalise_space(v) }
+    end
+
+    if element.has_elements?
+      element.each_element { |child|
+        value = collapse(child)
+        if empty(value) && (element.attributes.empty? || @options['noattr'])
+          next if @options.has_key?('suppressempty') && @options['suppressempty'] == true
+        end
+        result = merge(result, child.name, value)
+      }
+      if has_mixed_content?(element)
+        # normalisespace?
+        content = element.texts.map { |x| x.to_s }
+        content = content[0] if content.size == 1
+        result[@options['contentkey']] = content
+      end
+    elsif element.has_text? # i.e. it has only text.
+      return collapse_text_node(result, element)
+    end
+
+    # Turn Arrays into Hashes if key fields present.
+    count = fold_arrays(result)
+
+    # Disintermediate grouped tags.
+    if @options.has_key?('grouptags')
+      result.each { |key, value|
+        next unless (value.instance_of?(Hash) && (value.size == 1))
+        child_key, child_value = value.to_a[0]
+        if @options['grouptags'][key] == child_key
+          result[key] = child_value
+        end
+      }
+    end
+    
+    # Fold Hases containing a single anonymous Array up into just the Array.
+    if count == 1 
+      anonymoustag = @options['anonymoustag']
+      if result.has_key?(anonymoustag) && result[anonymoustag].instance_of?(Array)
+        return result[anonymoustag]
+      end
+    end
+
+    if result.empty? && @options.has_key?('suppressempty')
+      return @options['suppressempty'] == '' ? '' : nil
+    end
+
+    result
+  end
+
+  # Collapses a text node and merges it with an existing Hash, if
+  # possible.
+  # Thanks to Curtis Schofield for reporting a subtle bug.
+  #
+  # hash::
+  #   Hash to merge text node value with, if possible.
+  # element::
+  #   Text node to be collapsed.
+  def collapse_text_node(hash, element)
+    value = node_to_text(element)
+    if empty(value) && !element.has_attributes?
+      return {}
+    end
+
+    if element.has_attributes? && !@options['noattr']
+      return merge(hash, @options['contentkey'], value)
+    else
+      if @options['forcecontent']
+        return merge(hash, @options['contentkey'], value)
+      else
+        return value
+      end
+    end
+  end
+
+  # Folds all arrays in a Hash.
+  # 
+  # hash::
+  #   Hash to be folded.
+  def fold_arrays(hash)
+    fold_amount = 0
+    keyattr = @options['keyattr']
+    if (keyattr.instance_of?(Array) || keyattr.instance_of?(Hash))
+      hash.each { |key, value|
+        if value.instance_of?(Array)
+          if keyattr.instance_of?(Array)
+            hash[key] = fold_array(value)
+          else
+            hash[key] = fold_array_by_name(key, value)
+          end
+          fold_amount += 1
+        end
+      }
+    end
+    fold_amount
+  end
+
+  # Folds an Array to a Hash, if possible. Folding happens
+  # according to the content of keyattr, which has to be
+  # an array.
+  #
+  # array::
+  #   Array to be folded.
+  def fold_array(array)
+    hash = Hash.new
+    array.each { |x|
+      return array unless x.instance_of?(Hash)
+      key_matched = false
+      @options['keyattr'].each { |key|
+        if x.has_key?(key)
+          key_matched = true
+          value = x[key]
+          return array if value.instance_of?(Hash) || value.instance_of?(Array)
+          value = normalise_space(value) if @options['normalisespace'] == 1
+          x.delete(key)
+          hash[value] = x
+          break
+        end
+      }
+      return array unless key_matched
+    }
+    hash = collapse_content(hash) if @options['collapseagain']
+    hash
+  end
+  
+  # Folds an Array to a Hash, if possible. Folding happens
+  # according to the content of keyattr, which has to be
+  # a Hash.
+  #
+  # name::
+  #   Name of the attribute to be folded upon.
+  # array::
+  #   Array to be folded.
+  def fold_array_by_name(name, array)
+    return array unless @options['keyattr'].has_key?(name)
+    key, flag = @options['keyattr'][name]
+
+    hash = Hash.new
+    array.each { |x|
+      if x.instance_of?(Hash) && x.has_key?(key)
+        value = x[key]
+        return array if value.instance_of?(Hash) || value.instance_of?(Array)
+        value = normalise_space(value) if @options['normalisespace'] == 1
+        hash[value] = x
+        hash[value]["-#{key}"] = hash[value][key] if flag == '-'
+        hash[value].delete(key) unless flag == '+'
+      else
+        $stderr.puts("Warning: <#{name}> element has no '#{key}' attribute.")
+        return array
+      end
+    }
+    hash = collapse_content(hash) if @options['collapseagain']
+    hash
+  end
+
+  # Tries to collapse a Hash even more ;-)
+  #
+  # hash::
+  #   Hash to be collapsed again.
+  def collapse_content(hash)
+    content_key = @options['contentkey']
+    hash.each_value { |value|
+      return hash unless value.instance_of?(Hash) && value.size == 1 && value.has_key?(content_key)
+      hash.each_key { |key| hash[key] = hash[key][content_key] }
+    }
+    hash
+  end
+  
+  # Adds a new key/value pair to an existing Hash. If the key to be added
+  # does already exist and the existing value associated with key is not
+  # an Array, it will be converted into an Array. Then the new value is
+  # appended to that Array.
+  #
+  # hash::
+  #   Hash to add key/value pair to.
+  # key::
+  #   Key to be added.
+  # value::
+  #   Value to be associated with key.
+  def merge(hash, key, value)
+    if value.instance_of?(String)
+      value = normalise_space(value) if @options['normalisespace'] == 2
+
+      # do variable substitutions
+      unless @_var_values.nil? || @_var_values.empty?
+        value.gsub!(/\$\{(\w+)\}/) { |x| get_var($1) }
+      end
+      
+      # look for variable definitions
+      if @options.has_key?('varattr')
+        varattr = @options['varattr']
+        if hash.has_key?(varattr)
+          set_var(hash[varattr], value)
+        end
+      end
+    end
+    if hash.has_key?(key)
+      if hash[key].instance_of?(Array)
+        hash[key] << value
+      else
+        hash[key] = [ hash[key], value ]
+      end
+    elsif value.instance_of?(Array) # Handle anonymous arrays.
+      hash[key] = [ value ]
+    else
+      if force_array?(key)
+        hash[key] = [ value ]
+      else
+        hash[key] = value
+      end
+    end
+    hash
+  end
+  
+  # Checks, if the 'forcearray' option has to be used for
+  # a certain key.
+  def force_array?(key)
+    return false if key == @options['contentkey']
+    return true if @options['forcearray'] == true
+    forcearray = @options['forcearray']
+    if forcearray.instance_of?(Hash)
+      return true if forcearray.has_key?(key) 
+      return false unless forcearray.has_key?('_regex')
+      forcearray['_regex'].each { |x| return true if key =~ x }
+    end
+    return false
+  end
+  
+  # Converts the attributes array of a document node into a Hash.
+  # Returns an empty Hash, if node has no attributes.
+  #
+  # node::
+  #   Document node to extract attributes from.
+  def get_attributes(node)
+    attributes = {}
+    node.attributes.each { |n,v| attributes[n] = v }
+    attributes
+  end
+  
+  # Determines, if a document element has mixed content.
+  #
+  # element::
+  #   Document element to be checked.
+  def has_mixed_content?(element)
+    if element.has_text? && element.has_elements?
+      return true if element.texts.join('') !~ /^\s*$/s
+    end
+    false
+  end
+  
+  # Called when a variable definition is encountered in the XML.
+  # A variable definition looks like
+  #    <element attrname="name">value</element>
+  # where attrname matches the varattr setting.
+  def set_var(name, value)
+    @_var_values[name] = value
+  end
+
+  # Called during variable substitution to get the value for the
+  # named variable.
+  def get_var(name)
+    if @_var_values.has_key?(name)
+      return @_var_values[name]
+    else
+      return "${#{name}}"
+    end
+  end
+  
+  # Recurses through a data structure building up and returning an
+  # XML representation of that structure as a string.
+  #
+  # ref::
+  #   Reference to the data structure to be encoded.
+  # name::
+  #   The XML tag name to be used for this item.
+  # indent::
+  #   A string of spaces for use as the current indent level.
+  def value_to_xml(ref, name, indent)
+    named = !name.nil? && name != ''
+    nl    = @options.has_key?('noindent') ? '' : "\n"
+
+    if !scalar(ref)
+      if @ancestors.member?(ref)
+        raise ArgumentError, "Circular data structures not supported!"
+      end
+      @ancestors << ref
+    else
+      if named
+        return [indent, '<', name, '>', @options['noescape'] ? ref.to_s : escape_value(ref.to_s), '</', name, '>', nl].join('')
+      else
+        return ref.to_s + nl
+      end
+    end
+
+    # Unfold hash to array if possible.
+    if ref.instance_of?(Hash) && !ref.empty? && !@options['keyattr'].empty? && indent != ''
+      ref = hash_to_array(name, ref)
+    end
+
+    result = []
+    if ref.instance_of?(Hash)
+      # Reintermediate grouped values if applicable.
+      if @options.has_key?('grouptags')
+        ref.each { |key, value|
+          if @options['grouptags'].has_key?(key)
+            ref[key] = { @options['grouptags'][key] => value }
+          end
+        }
+      end
+      
+      nested = []
+      text_content = nil
+      if named
+        result << indent << '<' << name
+      end
+
+      if !ref.empty?
+        ref.each { |key, value|
+          next if !key.nil? && key[0, 1] == '-'
+          if value.nil?
+            unless @options.has_key?('suppressempty') && @options['suppressempty'].nil?
+              raise ArgumentError, "Use of uninitialized value!"
+            end
+            value = {}
+          end
+
+          if !scalar(value) || @options['noattr']
+            nested << value_to_xml(value, key, indent + @options['indent'])
+          else
+            value = value.to_s
+            value = escape_value(value) unless @options['noescape']
+            if key == @options['contentkey']
+              text_content = value
+            else
+              result << ' ' << key << '="' << value << '"'
+            end
+          end
+        }
+      else
+        text_content = ''
+      end
+
+      if !nested.empty? || !text_content.nil?
+        if named
+          result << '>'
+          if !text_content.nil?
+            result << text_content
+            nested[0].sub!(/^\s+/, '') if !nested.empty?
+          else
+            result << nl
+          end
+          if !nested.empty?
+            result << nested << indent
+          end
+          result << '</' << name << '>' << nl
+        else
+          result << nested
+        end
+      else
+        result << ' />' << nl
+      end
+    elsif ref.instance_of?(Array)
+      ref.each { |value|
+        if scalar(value)
+          result << indent << '<' << name << '>'
+          result << (@options['noescape'] ? value.to_s : escape_value(value.to_s))
+          result << '</' << name << '>' << nl
+        elsif value.instance_of?(Hash)
+          result << value_to_xml(value, name, indent)
+        else
+          result << indent << '<' << name << '>' << nl
+          result << value_to_xml(value, @options['anonymoustag'], indent + @options['indent'])
+          result << indent << '</' << name << '>' << nl
+        end
+      }
+    else
+      # Probably, this is obsolete.
+      raise ArgumentError, "Can't encode a value of type: #{ref.type}."
+    end
+    @ancestors.pop if !scalar(ref)
+    result.join('')
+  end
+  
+  # Checks, if a certain value is a "scalar" value. Whatever
+  # that will be in Ruby ... ;-)
+  # 
+  # value::
+  #   Value to be checked.
+  def scalar(value)
+    return false if value.instance_of?(Hash) || value.instance_of?(Array)
+    return true
+  end
+
+  # Attempts to unfold a hash of hashes into an array of hashes. Returns
+  # a reference to th array on success or the original hash, if unfolding
+  # is not possible.
+  # 
+  # parent::
+  #   
+  # hashref::
+  #   Reference to the hash to be unfolded.
+  def hash_to_array(parent, hashref)
+    arrayref = []
+    hashref.each { |key, value|
+      return hashref unless value.instance_of?(Hash)
+
+      if @options['keyattr'].instance_of?(Hash)
+        return hashref unless @options['keyattr'].has_key?(parent)
+        arrayref << { @options['keyattr'][parent][0] => key }.update(value)
+      else
+        arrayref << { @options['keyattr'][0] => key }.update(value)
+      end
+    }
+    arrayref
+  end
+  
+  # Replaces XML markup characters by their external entities.
+  #
+  # data::
+  #   The string to be escaped.
+  def escape_value(data)
+    return data if data.nil? || data == ''
+    result = data.dup
+    result.gsub!('&', '&amp;')
+    result.gsub!('<', '&lt;')
+    result.gsub!('>', '&gt;')
+    result.gsub!('"', '&quot;')
+    result.gsub!("'", '&apos;')
+    result
+  end
+  
+  # Removes leading and trailing whitespace and sequences of
+  # whitespaces from a string.
+  #
+  # text::
+  #   String to be normalised.
+  def normalise_space(text)
+    text.sub!(/^\s+/, '')
+    text.sub!(/\s+$/, '')
+    text.gsub!(/\s\s+/, ' ')
+    text
+  end
+
+  # Checks, if an object is nil, an empty String or an empty Hash.
+  # Thanks to Norbert Gawor for a bugfix.
+  #
+  # value::
+  #   Value to be checked for emptyness.
+  def empty(value)
+    case value
+      when Hash
+        return value.empty?
+      when String
+        return value !~ /\S/m
+      else
+        return value.nil?
+    end
+  end
+  
+  # Converts a document node into a String.
+  # If the node could not be converted into a String
+  # for any reason, default will be returned.
+  #
+  # node::
+  #   Document node to be converted.
+  # default::
+  #   Value to be returned, if node could not be converted.
+  def node_to_text(node, default = nil)
+    if node.instance_of?(Element) 
+      return node.texts.join('')
+    elsif node.instance_of?(Attribute)
+      return node.value.nil? ? default : node.value.strip
+    elsif node.instance_of?(Text)
+      return node.to_s.strip
+    else
+      return default
+    end
+  end
+
+  # Parses an XML string and returns the according document.
+  #
+  # xml_string::
+  #   XML string to be parsed.
+  #
+  # The following exception may be raised:
+  #
+  # REXML::ParseException::
+  #   If the specified file is not wellformed.
+  def parse(xml_string)
+    Document.new(xml_string)
+  end
+  
+  # Searches in a list of paths for a certain file. Returns
+  # the full path to the file, if it could be found. Otherwise,
+  # an exception will be raised.
+  #
+  # filename::
+  #   Name of the file to search for.
+  # searchpath::
+  #   List of paths to search in.
+  def find_xml_file(file, searchpath)
+    filename = File::basename(file)
+
+    if filename != file
+      return file if File::file?(file)
+    else
+      searchpath.each { |path|
+        full_path = File::join(path, filename)
+        return full_path if File::file?(full_path)
+      }
+    end
+
+    if searchpath.empty?
+      return file if File::file?(file)
+      raise ArgumentError, "File does not exist: #{file}."
+    end
+    raise ArgumentError, "Could not find <#{filename}> in <#{searchpath.join(':')}>"
+  end
+  
+  # Loads and parses an XML configuration file.
+  #
+  # filename::
+  #   Name of the configuration file to be loaded.
+  #
+  # The following exceptions may be raised:
+  # 
+  # Errno::ENOENT::
+  #   If the specified file does not exist.
+  # REXML::ParseException::
+  #   If the specified file is not wellformed.
+  def load_xml_file(filename)
+    parse(File.readlines(filename).to_s)
+  end
+
+  # Caches the data belonging to a certain file.
+  #
+  # data::
+  #   Data to be cached.
+  # filename::
+  #   Name of file the data was read from.
+  def put_into_cache(data, filename)
+    if @options.has_key?('cache')
+      @options['cache'].each { |scheme|
+        case(scheme)
+        when 'storable'
+          @@cache.save_storable(data, filename)
+        when 'mem_share'
+          @@cache.save_mem_share(data, filename)
+        when 'mem_copy'
+          @@cache.save_mem_copy(data, filename)
+        else
+          raise ArgumentError, "Unsupported caching scheme: <#{scheme}>."
+        end
+      }
+    end
+  end
+end
+
+# vim:sw=2