extlib 0.9.3 → 0.9.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sam Smoot.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.txt

@@ -1,3 +1,3 @@
 = extlib
 
-A support library for DataMapper and DataObjects.
+A support library for DataMapper, DataObjects and Merb.

data/Rakefile

@@ -2,31 +2,66 @@
 require 'pathname'
 require 'rubygems'
 require 'rake'
+require "rake/clean"
+require "rake/gempackagetask"
+require "fileutils"
 require Pathname('spec/rake/spectask')
 require Pathname('lib/extlib/version')
 
 ROOT = Pathname(__FILE__).dirname.expand_path
 
+##############################################################################
+# Package && release
+##############################################################################
+RUBY_FORGE_PROJECT  = "extlib"
+PROJECT_URL         = "http://extlib.rubyforge.org"
+PROJECT_SUMMARY     = "Support library for DataMapper and Merb."
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
 AUTHOR = "Sam Smoot"
 EMAIL  = "ssmoot@gmail.com"
-GEM_NAME = "extlib"
-GEM_VERSION = Extlib::VERSION
-GEM_DEPENDENCIES = [["english", ">=0.2.0"]]
-GEM_CLEAN = "*.gem", "**/.DS_Store"
-GEM_EXTRAS = { :has_rdoc => false }
 
-PROJECT_NAME = "extlib"
-PROJECT_URL  = "http://extlib.rubyforge.org"
-PROJECT_DESCRIPTION = PROJECT_SUMMARY = "Support Library for DataMapper and DataObjects"
+GEM_NAME    = "extlib"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = Extlib::VERSION + PKG_BUILD
 
-require ROOT + 'tasks/hoe'
+RELEASE_NAME    = "REL #{GEM_VERSION}"
 
-task :default => 'extlib:spec'
-task :spec    => 'extlib:spec'
+require "lib/extlib/tasks/release"
+
+spec = Gem::Specification.new do |s|
+  s.name         = GEM_NAME
+  s.version      = GEM_VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.author       = AUTHOR
+  s.email        = EMAIL
+  s.homepage     = PROJECT_URL
+  s.summary      = PROJECT_SUMMARY
+  s.description  = PROJECT_DESCRIPTION
+  s.require_path = "lib"
+  s.files        = ["LICENSE", "README.txt", "Rakefile"] + Dir["lib/**/*"]
+
+  # rdoc
+  s.has_rdoc         = false
+  s.extra_rdoc_files = ["LICENSE", "README.txt"]
+
+  # Dependencies
+  s.add_dependency "english", ">=0.2.0"
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
 
 desc 'Remove all package, docs and spec products'
 task :clobber_all => %w[ clobber_package clobber_doc extlib:clobber_spec ]
 
+##############################################################################
+# Specs and continous integration
+##############################################################################
+task :default => 'extlib:spec'
+task :spec    => 'extlib:spec'
+
 namespace :extlib do
   Spec::Rake::SpecTask.new(:spec) do |t|
     t.spec_opts << '--format' << 'specdoc' << '--colour'
@@ -44,6 +79,10 @@ namespace :extlib do
   end
 end
 
+
+##############################################################################
+# Documentation
+##############################################################################
 desc "Generate documentation"
 task :doc do
   begin
@@ -58,6 +97,7 @@ end
 WINDOWS = (RUBY_PLATFORM =~ /win32|mingw|bccwin|cygwin/) rescue nil
 SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
 
+
 desc "Install #{GEM_NAME}"
 task :install => :package do
   sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}
@@ -143,3 +183,18 @@ namespace :ci do
 end
 
 task :ci => ["ci:spec", "ci:doc", "ci:saikuro", :install, :publish]
+
+##############################################################################
+# Benchmarks
+##############################################################################
+
+namespace :benchmark do
+  desc "Runs benchmarks"
+  task :run do
+    files = Dir["benchmarks/**/*.rb"]
+    
+    files.each do |f|
+      system "ruby #{f}"
+    end
+  end  
+end

data/lib/extlib.rb

@@ -1,19 +1,32 @@
 require 'pathname'
 require 'rubygems'
 
+__DIR__ = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift(__DIR__) unless $LOAD_PATH.include?(__DIR__)
+
 # for Pathname /
-require File.expand_path(File.join(File.dirname(__FILE__), 'extlib', 'pathname'))
+require File.expand_path(File.join(__DIR__, 'extlib', 'pathname'))
 
 dir = Pathname(__FILE__).dirname.expand_path / 'extlib'
 
+require dir / "class.rb"
+require dir / "object"
+require dir / "object_space"
+
+require dir / "string"
+require dir / "hash"
+require dir / "mash"
+require dir / "virtual_file"
+require dir / "logger"
+require dir / "time"
+
 require dir / 'assertions'
 require dir / 'blank'
 require dir / 'inflection'
 require dir / 'lazy_array'
-require dir / 'object'
 require dir / 'module'
 require dir / 'blank'
 require dir / 'pooling'
-require dir / 'string'
+require dir / 'simple_set'
 require dir / 'struct'
 require dir / 'hook'

data/lib/extlib/blank.rb

@@ -1,5 +1,10 @@
-# blank? methods for several different class types
 class Object
+  # @return <TrueClass, FalseClass>
+  #
+  # @example [].blank?         #=>  true
+  # @example [1].blank?        #=>  false
+  # @example [nil].blank?      #=>  false
+  # 
   # Returns true if the object is nil or empty (if applicable)
   def blank?
     nil? || (respond_to?(:empty?) && empty?)
@@ -7,6 +12,8 @@ class Object
 end # class Object
 
 class Numeric
+  # @return <TrueClass, FalseClass>
+  # 
   # Numerics can't be blank
   def blank?
     false
@@ -14,6 +21,8 @@ class Numeric
 end # class Numeric
 
 class NilClass
+  # @return <TrueClass, FalseClass>
+  # 
   # Nils are always blank
   def blank?
     true
@@ -21,7 +30,9 @@ class NilClass
 end # class NilClass
 
 class TrueClass
-  # True is not blank.
+  # @return <TrueClass, FalseClass>
+  # 
+  # True is not blank.  
   def blank?
     false
   end
@@ -35,6 +46,12 @@ class FalseClass
 end # class FalseClass
 
 class String
+  # @example "".blank?         #=>  true
+  # @example "     ".blank?    #=>  true
+  # @example " hey ho ".blank? #=>  false
+  # 
+  # @return <TrueClass, FalseClass>
+  # 
   # Strips out whitespace then tests if the string is empty.
   def blank?
     strip.empty?

data/lib/extlib/class.rb

@@ -0,0 +1,175 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+      
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+    
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self == #{self} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+  
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it 
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj        
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+  
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to 
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end

data/lib/extlib/hash.rb

@@ -0,0 +1,410 @@
+require 'base64'
+
+class Hash
+  class << self
+    # Converts valid XML into a Ruby Hash structure.
+    #
+    # @param xml<String> A string representation of valid XML.
+    #
+    # @note Mixed content is treated as text and any tags in it are left unparsed
+    # @note Any attributes other than type on a node containing a text node will be
+    #   discarded
+    #
+    # @details [Typecasting]
+    #   Typecasting is performed on elements that have a +type+ attribute:
+    #   integer::
+    #   boolean:: Anything other than "true" evaluates to false.
+    #   datetime::
+    #     Returns a Time object. See Time documentation for valid Time strings.
+    #   date::
+    #     Returns a Date object. See Date documentation for valid Date strings.
+    #
+    # Keys are automatically converted to +snake_case+
+    #
+    # @example [Simple]
+    #   <user gender='m'>
+    #     <age type='integer'>35</age>
+    #     <name>Home Simpson</name>
+    #     <dob type='date'>1988-01-01</dob>
+    #     <joined-at type='datetime'>2000-04-28 23:01</joined-at>
+    #     <is-cool type='boolean'>true</is-cool>
+    #   </user>
+    #
+    #   evaluates to
+    #
+    #   { "user" => {
+    #       "gender"    => "m",
+    #       "age"       => 35,
+    #       "name"      => "Home Simpson",
+    #       "dob"       => DateObject( 1998-01-01 ),
+    #       "joined_at" => TimeObject( 2000-04-28 23:01),
+    #       "is_cool"   => true
+    #     }
+    #   }
+    #
+    # @example [Mixed Content]
+    #   <story>
+    #     A Quick <em>brown</em> Fox
+    #   </story>
+    #
+    #   evaluates to
+    #
+    #   { "story" => "A Quick <em>brown</em> Fox" }
+    #
+    # @details [Attributes other than type on a node containing text]
+    #   <story is-good='false'>
+    #     A Quick <em>brown</em> Fox
+    #   </story>
+    #
+    #   evaluates to
+    #
+    #   { "story" => "A Quick <em>brown</em> Fox" }
+    #
+    #   <bicep unit='inches' type='integer'>60</bicep>
+    #
+    #   evaluates with a typecast to an integer. But unit attribute is ignored.
+    #
+    #   { "bicep" => 60 }
+    def from_xml( xml )
+      ToHashParser.from_xml(xml)
+    end
+  end
+  
+  # This class has semantics of ActiveSupport's HashWithIndifferentAccess
+  # and we only have it so that people can write
+  # params[:key] instead of params['key'].
+  #
+  # @return <Mash> This hash as a Mash for string or symbol key access.
+  def to_mash
+    hash = Mash.new(self)
+    hash.default = default
+    hash
+  end
+
+  # @return <String> This hash as a query string
+  #
+  # @example
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #     #=> "name=Bob&address[city]=Ruby Central&address[phones]=111-111-1111222-222-2222&address[street]=111 Ruby Ave."
+  def to_params
+    params = ''
+    stack = []
+
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      else
+        params << "#{k}=#{v}&"
+      end
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+
+    params.chop! # trailing &
+    params
+  end
+
+  # @param *allowed<Array[(String, Symbol)]> The hash keys to include.
+  #
+  # @return <Hash> A new hash with only the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)
+  #     #=> { :one => 1 }
+  def only(*allowed)
+    hash = {}
+    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
+  # @param *rejected<Array[(String, Symbol)] The hash keys to exclude.
+  #
+  # @return <Hash> A new hash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { :two => 2, :three => 3 }
+  def except(*rejected)
+    hash = self.dup
+    rejected.each {|k| hash.delete(k) }
+    hash
+  end
+
+  # @return <String> The hash as attributes for an XML tag.
+  #
+  # @example
+  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+  #     #=> 'one="1" two="TWO"'
+  def to_xml_attributes
+    map do |k,v|
+      %{#{k.to_s.camel_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+    end.join(' ')
+  end
+
+  alias_method :to_html_attributes, :to_xml_attributes
+
+  # @param html_class<#to_s>
+  #   The HTML class to add to the :class key. The html_class will be
+  #   concatenated to any existing classes.
+  #
+  # @example hash[:class] #=> nil
+  # @example hash.add_html_class!(:selected)
+  # @example hash[:class] #=> "selected"
+  # @example hash.add_html_class!("class1 class2")
+  # @example hash[:class] #=> "selected class1 class2"
+  def add_html_class!(html_class)
+    if self[:class]
+      self[:class] = "#{self[:class]} #{html_class}"
+    else
+      self[:class] = html_class.to_s
+    end
+  end
+
+  # Converts all keys into string values. This is used during reloading to
+  # prevent problems when classes are no longer declared.
+  #
+  # @return <Array> An array of they hash's keys
+  #
+  # @example 
+  #   hash = { One => 1, Two => 2 }.proctect_keys!
+  #   hash # => { "One" => 1, "Two" => 2 }
+  def protect_keys!
+    keys.each {|key| self[key.to_s] = delete(key) }
+  end
+
+  # Attempts to convert all string keys into Class keys. We run this after
+  # reloading to convert protected hashes back into usable hashes.
+  #
+  # @example
+  #   # Provided that classes One and Two are declared in this scope:
+  #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
+  #   hash # => { One => 1, Two => 2 }
+  def unprotect_keys!
+    keys.each do |key|
+      (self[Object.full_const_get(key)] = delete(key)) rescue nil
+    end
+  end
+
+  # Destructively and non-recursively convert each key to an uppercase string,
+  # deleting nil values along the way.
+  #
+  # @return <Hash> The newly environmentized hash.
+  #
+  # @example
+  #   { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
+  #     #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }
+  def environmentize_keys!
+    keys.each do |key|
+      val = delete(key)
+      next if val.nil?
+      self[key.to_s.upcase] = val
+    end
+    self
+  end
+end
+
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the
+# underlying parser.
+class REXMLUtilityNode
+  attr_accessor :name, :attributes, :children, :type
+  cattr_accessor :typecasts, :available_typecasts
+
+  self.typecasts = {}
+  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
+  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
+  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
+  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
+  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
+  self.typecasts["string"]        = lambda{|v| v.to_s}
+  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| Base64.decode64(v)}
+
+  self.available_typecasts = self.typecasts.keys
+
+  def initialize(name, attributes = {})
+    @name         = name.tr("-", "_")
+    # leave the type alone if we don't know what it is
+    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+    @nil_element  = attributes.delete("nil") == "true"
+    @attributes   = undasherize_keys(attributes)
+    @children     = []
+    @text         = false
+  end
+
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+
+  def to_hash
+    if @type == "file"
+      f = StringIO.new(::Base64.decode64(@children.first || ""))
+      class << f
+        attr_accessor :original_filename, :content_type
+      end
+      f.original_filename = attributes['name'] || 'untitled'
+      f.content_type = attributes['content_type'] || 'application/octet-stream'
+      return {name => f}
+    end
+
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #change repeating groups into an array
+      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+      out = nil
+      if @type == "array"
+        out = []
+        groups.each do |k, v|
+          if v.size == 1
+            out << v.first.to_hash.entries.first.last
+          else
+            out << v.map{|e| e.to_hash[k]}
+          end
+        end
+        out = out.flatten
+
+      else # If Hash
+        out = {}
+        groups.each do |k,v|
+          if v.size == 1
+            out.merge!(v.first)
+          else
+            out.merge!( k => v.map{|e| e.to_hash[k]})
+          end
+        end
+        out.merge! attributes unless attributes.empty?
+        out = out.empty? ? nil : out
+      end
+
+      if @type && out.nil?
+        { name => typecast_value(out) }
+      else
+        { name => out }
+      end
+    end
+  end
+
+  # Typecasts a value based upon its type. For instance, if
+  # +node+ has #type == "integer",
+  # {{[node.typecast_value("12") #=> 12]}}
+  #
+  # @param value<String> The value that is being typecast.
+  #
+  # @details [:type options]
+  #   "integer"::
+  #     converts +value+ to an integer with #to_i
+  #   "boolean"::
+  #     checks whether +value+, after removing spaces, is the literal
+  #     "true"
+  #   "datetime"::
+  #     Parses +value+ using Time.parse, and returns a UTC Time
+  #   "date"::
+  #     Parses +value+ using Date.parse
+  #
+  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+  #   The result of typecasting +value+.
+  #
+  # @note
+  #   If +self+ does not have a "type" key, or if it's not one of the
+  #   options specified above, the raw +value+ will be returned.
+  def typecast_value(value)
+    return value unless @type
+    proc = self.class.typecasts[@type]
+    proc.nil? ? value : proc.call(value)
+  end
+
+  # Convert basic XML entities into their literal values.
+  #
+  # @param value<#gsub> An XML fragment.
+  #
+  # @return <#gsub> The XML fragment after converting entities.
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
+  end
+
+  # Take keys of the form foo-bar and convert them to foo_bar
+  def undasherize_keys(params)
+    params.keys.each do |key, value|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+
+  # Get the inner_html of the REXML node.
+  def inner_html
+    @children.join
+  end
+
+  # Converts the node into a readable HTML node.
+  #
+  # @return <String> The HTML node in text form.
+  def to_html
+    attributes.merge!(:type => @type ) if @type
+    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+  end
+
+  # @alias #to_html #to_s
+  def to_s
+    to_html
+  end
+end
+
+class ToHashParser
+
+  def self.from_xml(xml)
+    stack = []
+    parser = REXML::Parsers::BaseParser.new(xml)
+
+    while true
+      event = parser.pull
+      case event[0]
+      when :end_document
+        break
+      when :end_doctype, :start_doctype
+        # do nothing
+      when :start_element
+        stack.push REXMLUtilityNode.new(event[1], event[2])
+      when :end_element
+        if stack.size > 1
+          temp = stack.pop
+          stack.last.add_node(temp)
+        end
+      when :text, :cdata
+        stack.last.add_node(event[1]) unless event[1].strip.length == 0
+      end
+    end
+    stack.pop.to_hash
+  end
+end