merb-core 0.9.2

data/lib/merb-core/controller/template.rb

@@ -0,0 +1,205 @@
+module Merb::InlineTemplates
+end
+
+module Merb::Template
+  
+  EXTENSIONS  = {} unless defined?(EXTENSIONS)
+  METHOD_LIST = {} unless defined?(METHOD_LIST)
+  MTIMES      = {} unless defined?(MTIMES)
+  
+  class << self
+    # Get the template's method name from a full path. This replaces
+    # non-alphanumeric characters with __ and "." with "_"
+    #
+    # Collisions are potentially possible with something like:
+    # ~foo.bar and __foo.bar or !foo.bar.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to convert to a valid Ruby method name
+    #
+    # ==== Returns
+    # String:: The template name.
+    #
+    #---
+    # We might want to replace this with something that varies the
+    # character replaced based on the non-alphanumeric character
+    # to avoid edge-case collisions.
+    def template_name(path)
+      path = File.expand_path(path)      
+      path.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_")
+    end
+
+    # Get the name of the template method for a particular path.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to find a template method for.
+    # template_stack<Array>:: The template stack. Not used.
+    #
+    # ==== Returns
+    # DOC
+    #---
+    # @semipublic
+    def template_for(path, template_stack = [])
+      path = File.expand_path(path)
+      
+      ret = 
+      if Merb::Config[:reload_templates]
+        file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first
+        METHOD_LIST[path] = file ? inline_template(file) : nil
+      else
+        METHOD_LIST[path] ||= begin
+          file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first          
+          file ? inline_template(file) : nil
+        end
+      end
+      
+      ret
+    end
+    
+    # Takes a template at a particular path and inlines it into a module and
+    # adds it to the METHOD_LIST table to speed lookup later.
+    # 
+    # ==== Parameters
+    # path<String>::
+    #   The full path of the template (minus the templating specifier) to
+    #   inline.
+    # mod<Module>::
+    #   The module to put the compiled method into. Defaults to
+    #   Merb::InlineTemplates
+    #
+    # ==== Note
+    # Even though this method supports inlining into any module, the method
+    # must be available to instances of AbstractController that will use it.
+    #---
+    # @public
+    def inline_template(path, mod = Merb::InlineTemplates)
+      path = File.expand_path(path)
+      METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
+        engine_for(path).compile_template(path, template_name(path), mod)
+    end
+    
+    # Finds the engine for a particular path.
+    # 
+    # ==== Parameters
+    # path<String>:: The path of the file to find an engine for.
+    #
+    # ==== Returns
+    # Class:: The engine.
+    #---
+    # @semipublic
+    def engine_for(path)
+      path = File.expand_path(path)      
+      EXTENSIONS[path.match(/\.([^\.]*)$/)[1]]
+    end
+    
+    # Registers the extensions that will trigger a particular templating
+    # engine.
+    # 
+    # ==== Parameters
+    # engine<Class>:: The class of the engine that is being registered
+    # extensions<Array[String]>:: 
+    #   The list of extensions that will be registered with this templating
+    #   language
+    #
+    # ==== Raises
+    # ArgumentError:: engine does not have a compile_template method.
+    #
+    # ==== Example
+    #   Merb::Template.register_extensions(Merb::Template::Erubis, ["erb"])
+    #---
+    # @public
+    def register_extensions(engine, extensions) 
+      raise ArgumentError, "The class you are registering does not have a compile_template method" unless
+        engine.respond_to?(:compile_template)
+      extensions.each{|ext| EXTENSIONS[ext] = engine }
+      Merb::AbstractController.class_eval <<-HERE
+        include #{engine}::Mixin
+      HERE
+    end
+  end
+  
+  require 'erubis'
+
+  class Erubis    
+    # ==== Parameters
+    # path<String>:: A full path to the template.
+    # name<String>:: The name of the method that will be created.
+    # mod<Module>:: The module that the compiled method will be placed into.
+    def self.compile_template(path, name, mod)
+      template = ::Erubis::Eruby.new(File.read(path))
+      template.def_method(mod, name, path) 
+      name
+    end
+
+    module Mixin
+      
+      # Provides direct acccess to the buffer for this view context
+      #
+      # ==== Parameters
+      # the_binding<Binding>:: The binding to pass to the buffer.
+      #
+      # ==== Returns
+      # DOC
+      def _erb_buffer( the_binding )
+        @_buffer = eval( "_buf", the_binding, __FILE__, __LINE__)
+      end
+
+      # ==== Parameters
+      # *args:: Arguments to pass to the block.
+      # &block:: The template block to call.
+      #
+      # ==== Returns
+      # String:: The output of the block.
+      #
+      # ==== Examples
+      # Capture being used in a .html.erb page:
+      # 
+      #   <% @foo = capture do %>
+      #     <p>Some Foo content!</p> 
+      #   <% end %>
+      def capture_erb(*args, &block)
+        # get the buffer from the block's binding
+        buffer = _erb_buffer( block.binding ) rescue nil
+
+        # If there is no buffer, just call the block and get the contents
+        if buffer.nil?
+          block.call(*args)
+        # If there is a buffer, execute the block, then extract its contents
+        else
+          pos = buffer.length
+          block.call(*args)
+
+          # extract the block
+          data = buffer[pos..-1]
+
+          # replace it in the original with empty string
+          buffer[pos..-1] = ''
+
+          data
+        end
+      end
+
+      # DOC
+      def concat_erb(string, binding)
+        _erb_buffer(binding) << string
+      end
+            
+    end
+  
+    Merb::Template.register_extensions(self, %w[erb])    
+  end
+  
+end
+
+module Erubis
+  module RubyEvaluator
+
+    # DOC
+    def def_method(object, method_name, filename=nil)
+      m = object.is_a?(Module) ? :module_eval : :instance_eval
+      setup = "@_engine = 'erb'"
+      object.__send__(m, "def #{method_name}(locals={}); #{setup}; #{@src}; end", filename || @filename || '(erubis)')
+    end
+   
+  end
+end

data/lib/merb-core/core_ext.rb

@@ -0,0 +1,12 @@
+corelib = File.join(File.dirname(__FILE__), "core_ext")
+
+require "#{corelib}/string"
+require corelib/:class
+require corelib/:hash
+require corelib/:kernel
+require corelib/:mash
+require corelib/:object
+require corelib/:object_space
+require corelib/:rubygems
+require corelib/:set
+

data/lib/merb-core/core_ext/class.rb

@@ -0,0 +1,192 @@
+# 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 # :nodoc:
+
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS, __FILE__, __LINE__
+
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+  
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => (value.dup rescue value))
+        end
+      end
+      
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/merb-core/core_ext/hash.rb

@@ -0,0 +1,422 @@
+require 'base64'
+
+class Hash
+  class << self
+    # Converts valid XML into a Ruby Hash structure.
+    #
+    # ==== Paramters
+    # xml<String>:: A string representation of valid XML.
+    #
+    # ==== Notes
+    # * Mixed content is treated as text and any tags in it are left unparsed
+    # * Any attributes other than type on a node containing a text node will be
+    #   discarded
+    #
+    # ===== 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+
+    #
+    # ==== Examples
+    #
+    # ===== Standard
+    #   <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 
+    #     }
+    #   }
+    #
+    # ===== Mixed Content
+    #   <story>
+    #     A Quick <em>brown</em> Fox
+    #   </story>
+    #
+    # evaluates to
+    #
+    #   { "story" => "A Quick <em>brown</em> Fox" }
+    # 
+    # ====== 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
+  
+  # ==== Returns
+  # Mash:: This hash as a Mash for string or symbol key access.
+  def to_mash
+    hash = Mash.new(self)
+    hash.default = default
+    hash
+  end
+  
+  # ==== Returns
+  # String:: This hash as a query string
+  #
+  # ==== Examples
+  #   { :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
+  
+  # ==== Parameters
+  # *allowed:: The hash keys to include.
+  #
+  # ==== Returns
+  # Hash:: A new hash with only the selected keys.
+  #
+  # ==== Examples
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)
+  #     #=> { :one => 1 }
+  def only(*allowed) 
+    reject { |k,v| !allowed.include?(k) }
+  end
+  
+  # ==== Parameters
+  # *rejected:: The hash keys to exclude.
+  #
+  # ==== Returns
+  # Hash:: A new hash without the selected keys.
+  #
+  # ==== Examples
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { :two => 2, :three => 3 }
+  def except(*rejected) 
+    reject { |k,v| rejected.include?(k) }
+  end
+  
+  # ==== Returns
+  # String:: The hash as attributes for an XML tag.
+  #
+  # ==== Examples
+  #   { :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
+  
+  # ==== Parameters
+  # html_class<~to_s>::
+  #   The HTML class to add to the :class key. The html_class will be
+  #   concatenated to any existing classes.
+  #
+  # ==== Examples
+  #   hash[:class] #=> nil
+  #   hash.add_html_class!(:selected)
+  #   hash[:class] #=> "selected"
+  #   hash.add_html_class!("class1 class2")
+  #   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.
+  #
+  # === Examples
+  #   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.
+  #
+  # === Examples
+  #   # 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.
+  #
+  # ==== Returns
+  # Hash:: The newly environmentized hash.
+  #
+  # ==== Examples
+  #   { :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 # :nodoc:
+  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]}}
+  #
+  # ==== Parameters
+  # value<String>:: The value that is being typecast.
+  # 
+  # ==== :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
+  #
+  # ==== Returns
+  # Integer, true, false, 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.
+  #
+  # ==== Parameters
+  # value<~gsub>::
+  #   An XML fragment.
+  #
+  # ==== Returns
+  # ~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.
+  #
+  # ==== Returns
+  # 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
+  def to_s 
+    to_html
+  end
+end
+
+class ToHashParser # :nodoc:
+
+  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