Narnach-libxml_rails 0.0.2.5

data/CHANGELOG

@@ -0,0 +1,3 @@
+v0.0.2. Port ActiveSupport Test::Unit tests to RSpec.
+
+v0.0.1. Initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Brandon Mitchell
+
+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.rdoc

@@ -0,0 +1,40 @@
+= libxml_rails
+
+libxml_rails is a gem/rails plugin by Brandon Mitchell. It is designed to replace the default XML processor in Rails (XmlSimple) with the C-based libxml. It requires the libxml-ruby gem.
+
+This fork is maintained by Wes 'Narnach' Oldenbeuving.
+
+Changes from the Brandon's version are:
+* Don't rely on echoe to build the gem.
+* Added Hash#to_xml_with_libxml and Array#to_xml_with_libxml
+* ActiveResource::Base#to_xml uses libxml.
+* ActiveResource::Formats::XmlFormat#encode uses libxml
+
+=== Installation
+
+libxml_rails can be installed as a rails plugin or as a stand-alone gem.
+
+=== Gem Installation
+
+From PROJECT_ROOT:
+
+  gem install libxml-ruby
+  rake install
+
+=== Plugin Installation
+
+From RAILS_ROOT:
+
+  script/plugin install git://github.com/Narnach/libxml_rails.git
+
+Add the following to the configuration block in config/environment.rb:
+
+  config.gem 'libxml-ruby'
+  
+=== Gem Installation
+
+Add the following to the configuration block in config/environment.rb:
+
+  config.gem 'Narnach-libxml_rails', :source => 'http://gems.github.com'
+
+Copyright (c) 2008 Brandon Mitchell, released under the MIT license

data/Rakefile

@@ -0,0 +1,28 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require 'rubygems'
+
+################################################################################
+### Gem
+################################################################################
+
+begin
+  # Parse gemspec using the github safety level.
+  file = Dir['*.gemspec'].first
+  data = File.read(file)
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3\n%s" % data)}.join
+
+  # Create the gem tasks
+  Rake::GemPackageTask.new(spec) do |package|
+    package.gem_spec = spec
+  end
+rescue Exception => e
+  printf "WARNING: Error caught (%s): %s\n%s", e.class.name, e.message, e.backtrace[0...5].map {|l| '  %s' % l}.join("\n")
+end
+
+desc 'Package and install the gem for the current version'
+task :install => :gem do
+  system "sudo gem install -l pkg/%s-%s.gem" % [spec.name, spec.version]
+end

data/init.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'libxml_rails'))

data/lib/bitbckt/core_ext/hash/conversions.rb

@@ -0,0 +1,91 @@
+module Bitbckt #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Conversions
+        
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+          def from_xml(xml)
+            result = LibXML::XML::Parser.string(xml).parse
+            if result.root.attributes['type'] == 'array'
+              { result.root.name.to_s.gsub(/-/,'_') => array_from_node(result.root) }
+            else
+              { result.root.name.to_s.gsub(/-/,'_') => xml_node_to_hash(result.root) }
+            end
+          end     
+
+          private
+            def xml_node_to_hash(node)              
+              # If we are at an XML::Node, build the Hash
+              if node.element?
+                result_hash = {}
+                if node.children?
+                  
+                  node.each_child do |child|
+                    next if child.empty?
+                  
+                    if child.attributes['type'] == 'array'
+                      result = array_from_node(child)
+                    elsif child.attributes['type'] == 'string' and child.children.empty?
+                      # NOTE: Odd issue with libxml - XML::Node#empty? returns false and
+                      #       XML::Node#children? returns true when the Node contains just
+                      #       an empty string (#children == []), but has attributes.
+                      result = ''
+                    elsif child.attributes['type'] == 'file'
+                      result = Object::Hash::XML_PARSING['file'].call(child.content.to_s, child.attributes)
+                    elsif Object::Hash::XML_PARSING.include? child.attributes['type'] and not child.content.to_s.chomp.blank?
+                      result = Object::Hash::XML_PARSING[child.attributes['type']].call(child.content.to_s)
+                    else
+                      result = xml_node_to_hash(child)
+                      result['type'] = child.attributes['type'] if child.attributes['type'] and result
+                    end
+                    
+                    return result if child.name == 'text'
+                    
+                    key = child.name.gsub(/-/, '_')
+                    if result_hash[key]
+                      if result_hash[key].is_a?(Object::Array)
+                        result_hash[key] << result
+                      else
+                        result_hash[key] = [result_hash[key]] << result
+                      end
+                    else
+                      result_hash[key] = result
+                    end
+                  end
+                
+                else
+                  if node.attributes['type'] || node.attributes.length == 0 || node.attributes['nil'] == 'true'
+                    result_hash = nil
+                  else
+                    node.each_attr do |attribute|
+                      result_hash[attribute.name] = attribute.value.to_s
+                    end
+                  end
+                end
+                
+                return result_hash
+              else
+                return node.content.to_s
+              end              
+            end
+          
+            def array_from_node(node)
+              returning([]) do |collection|
+                node.each_child do |child|
+                  next if child.empty?
+                  collection << xml_node_to_hash(child)
+                end
+              end
+            end
+        end
+        
+      end
+    end
+  end
+end
+
+Hash.class_eval { include Bitbckt::CoreExtensions::Hash::Conversions }

data/lib/libxml_rails.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'active_support'
+require 'libxml'
+require 'bitbckt/core_ext/hash/conversions'
+require 'narnach/core_ext/hash/conversions'
+require 'narnach/core_ext/array/conversions'

data/lib/libxml_rails/active_resource.rb

@@ -0,0 +1,2 @@
+# Convenience file to make it easy to load 'libxml_rails/active_resource'
+require 'narnach/rails_ext/active_resource'

data/lib/narnach/core_ext/array/conversions.rb

@@ -0,0 +1,64 @@
+module Narnach #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module Conversions
+        # Version of #to_xml copy-adjusted from ActiveSupport to work with libxml.
+        # 
+        # Options not supported:
+        # - :indent
+        def to_xml_with_libxml(options = {})
+          raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml_with_libxml }
+          options.reverse_merge!({:to_string => true, :skip_instruct => false })
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+          options[:root]     = options[:root].to_s.dasherize if dasherize
+          options[:children] ||= options[:root].singularize
+          to_string = options.delete(:to_string)
+          skip_instruct = options.delete(:skip_instruct)
+          root     = options.delete(:root).to_s
+          doc = nil
+          if skip_instruct
+            node = LibXML::XML::Node.new(root)
+            doc = node
+            case options[:builder]
+            when LibXML::XML::Document
+              options[:builder].root << node
+            when nil
+              options[:builder] = node
+            else
+              options[:builder] << node
+            end
+          else
+            options[:builder] = LibXML::XML::Document.new
+            options[:builder].encoding = 'UTF-8'
+            options[:builder].root = LibXML::XML::Node.new(root)
+            doc = options[:builder].root
+          end
+          doc['type'] = 'array' unless options[:skip_types]
+
+
+          children = options.delete(:children)
+          opts = options.merge({ :root => children })
+
+          unless empty?
+            yield doc if block_given?
+            each do |e|
+              e.to_xml_with_libxml(opts.merge!({ :skip_instruct => true, :to_string => false, :builder => doc }))
+            end
+          end
+          if to_string
+            string = options[:builder].to_s
+            string << "\n" if skip_instruct # Emulate Builder behaviour
+            return string
+          else
+            return options[:builder]
+          end
+        end # to_xml_with_libxml
+      end # module Conversions
+    end # module Hash
+  end # module CoreExtensions
+end # module Narnach
+
+class Array
+  include Narnach::CoreExtensions::Array::Conversions
+end

data/lib/narnach/core_ext/hash/conversions.rb

@@ -0,0 +1,91 @@
+module Narnach #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Conversions
+        XML_TYPE_NAMES = ActiveSupport::CoreExtensions::Hash::Conversions::XML_TYPE_NAMES unless defined?(XML_TYPE_NAMES)
+        XML_FORMATTING = ActiveSupport::CoreExtensions::Hash::Conversions::XML_FORMATTING unless defined?(XML_FORMATTING)
+
+        # Version of #to_xml copy-adjusted from ActiveSupport to work with libxml.
+        # 
+        # Options supported in XMLBuilder that are/will be supported here:
+        # - :root, name of root node. Default to hash
+        # - :children, name of child nodes. Default to singular of root.
+        # - :skip_types
+        #
+        # Options supported in a different way:
+        # - :builder. Holds the active LibXML::XML::Document or LibXML::XML::Node.
+        # - :skip_instruct. Determine if the document encoding needs to be set. When false, a new Document is created and used as :builder. When true a new Node is created when no :builder is specified.
+        # - :dasherize, dasherize the node names or keep them as-is.
+        #
+        # Options known but not (yet) supported:
+        # - :indent, default to level 2
+        #
+        # Uses Builder's String#to_xs for escaping
+        def to_xml_with_libxml(options = {})
+          options.reverse_merge!({:root => "hash", :to_string => true })
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
+          to_string = options.delete(:to_string)
+          skip_instruct = options.delete(:skip_instruct)
+          doc = nil
+          if skip_instruct
+            node = LibXML::XML::Node.new(root)
+            doc = node
+            case options[:builder]
+            when LibXML::XML::Document
+              options[:builder].root << node
+            when nil
+              options[:builder] = node
+            else
+              options[:builder] << node
+            end
+          else
+            options[:builder] = LibXML::XML::Document.new
+            options[:builder].encoding = 'UTF-8'
+            options[:builder].root = LibXML::XML::Node.new(root)
+            doc = options[:builder].root
+          end
+          self.each do |key, value|
+            case value
+            when ::Hash
+              value.to_xml_with_libxml(options.merge({ :root => key, :skip_instruct => true, :to_string => false, :builder => doc }))
+            when ::Array
+              value.to_xml_with_libxml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true, :to_string => false, :builder => doc}))
+            # when ::Method, ::Proc
+            else
+              if value.respond_to?(:to_xml_with_libxml)
+                value.to_xml_with_libxml(options.merge({ :root => key, :skip_instruct => true, :to_string => false, :builder => doc }))
+              else
+                type_name = XML_TYPE_NAMES[value.class.name]
+                key = dasherize ? key.to_s.dasherize : key.to_s
+                attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
+                if value.nil?
+                  attributes[:nil] = true
+                end
+
+                content = XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value
+                child = LibXML::XML::Node.new(key, content.to_s.to_xs)
+                attributes.stringify_keys.each do |akey, avalue|
+                  child[akey] = String(avalue).to_s.to_xs
+                end
+                doc << child
+              end # if
+            end # case
+          end # each
+          yield options[:builder] if block_given?
+          if to_string
+            string = options[:builder].to_s
+            string << "\n" if skip_instruct # Emulate Builder behaviour
+            return string
+          else
+            return options[:builder]
+          end
+        end # to_xml_with_libxml
+      end # module Conversions
+    end # module Hash
+  end # module CoreExtensions
+end # module Narnach
+
+class Hash
+  include Narnach::CoreExtensions::Hash::Conversions
+end

data/lib/narnach/rails_ext/active_resource.rb

@@ -0,0 +1,64 @@
+gem 'activeresource'
+require 'active_resource'
+require 'active_resource/formats/xml_format'
+
+module Narnach
+  module RailsExt
+    module ActiveResource
+      module Base
+        # A method to convert the the resource to an XML string.
+        #
+        # This is a copy-adjusted version of ActiveResource's #to_xml, but
+        # it uses libxml for serialization instead of builder.
+        #
+        # ==== Options
+        # The +options+ parameter is handed off to the +to_xml_with_libxml+ method on each
+        # attribute, so it has the same options as the +to_xml_with_libxml+ methods in
+        # Active Support.
+        #
+        # * <tt>:dasherize</tt> - Boolean option to determine whether or not element names should
+        #   replace underscores with dashes (default is <tt>false</tt>).
+        # * <tt>:skip_instruct</tt> - Toggle skipping the +instruct!+ call on the XML builder
+        #   that generates the XML declaration (default is <tt>false</tt>).
+        #
+        # ==== Examples
+        #   my_group = SubsidiaryGroup.find(:first)
+        #   my_group.to_xml
+        #   # => <?xml version="1.0" encoding="UTF-8"?>
+        #   #    <subsidiary_group> [...] </subsidiary_group>
+        #
+        #   my_group.to_xml(:dasherize => true)
+        #   # => <?xml version="1.0" encoding="UTF-8"?>
+        #   #    <subsidiary-group> [...] </subsidiary-group>
+        #
+        #   my_group.to_xml(:skip_instruct => true)
+        #   # => <subsidiary_group> [...] </subsidiary_group>
+        def to_xml(options={})
+          attributes.to_xml_with_libxml({:root => self.class.element_name}.merge(options))
+        end
+      end
+
+      module Formats
+        module XmlFormat
+          def encode(hash, options={})
+            hash.to_xml_with_libxml(options)
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveResource
+  module Formats
+    XmlFormat.class_eval do
+      remove_method :encode
+      include Narnach::RailsExt::ActiveResource::Formats::XmlFormat
+    end
+  end
+  
+  Base.class_eval do
+    remove_method :to_xml
+    include Narnach::RailsExt::ActiveResource::Base
+  end
+end

data/libxml_rails.gemspec

@@ -0,0 +1,34 @@
+Gem::Specification.new do |s|
+  # Project
+  s.name         = 'libxml_rails'
+  s.description  = "Libxml_rails replaces ActiveSupport's XmlSimple XML parsing with libxml-ruby. Original gem by Brandon Mitchell, this fork is by Wes 'Narnach' Oldenbeuving."
+  s.summary      = s.description
+  s.version      = '0.0.2.5'
+  s.date         = '2009-01-06'
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Brandon Mitchell", "Wes Oldenbeuving"]
+  s.email        = "narnach@gmail.com"
+  s.homepage     = "http://www.github.com/Narnach/libxml_rails"
+
+  # Files
+  root_files     = %w[CHANGELOG init.rb libxml_rails.gemspec MIT-LICENSE Rakefile README.rdoc]
+  lib_files      = %w[bitbckt/core_ext/hash/conversions narnach/core_ext/hash/conversions narnach/core_ext/array/conversions narnach/rails_ext/active_resource libxml_rails libxml_rails/active_resource]
+  spec_files     = %w[from_xml] + lib_files.select{|f| f[0...7] == 'narnach'}
+  other_files    = %w[spec/spec_helper.rb]
+  s.require_path = "lib"
+  s.executables  = []
+  s.test_files   = spec_files.map {|f| 'spec/%s_spec.rb' % f}
+  s.files        = root_files + s.test_files + other_files + lib_files.map {|f| 'lib/%s.rb' % f}
+
+  # rdoc
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README.rdoc MIT-LICENSE]
+  s.rdoc_options << '--inline-source' << '--line-numbers' << '--main' << 'README.rdoc'
+
+  # Dependencies
+  s.add_dependency 'activesupport', '>= 2.1.0'
+  s.add_dependency 'libxml-ruby', '>= 0.8.3'
+
+  # Requirements
+  s.required_ruby_version = ">= 1.8.0"
+end

data/spec/from_xml_spec.rb

@@ -0,0 +1,328 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Hash, '.from_xml' do
+  
+  before(:each) do
+    @xml_options = { :root => :person, :skip_instruct => true, :indent => 0 }
+  end
+  
+  it 'parses a single record' do
+    topic_xml = <<-EOT
+      <topic>
+        <title>The First Topic</title>
+        <author-name>David</author-name>
+        <id type="integer">1</id>
+        <approved type="boolean"> true </approved>
+        <replies-count type="integer">0</replies-count>
+        <replies-close-in type="integer">2592000000</replies-close-in>
+        <written-on type="date">2003-07-16</written-on>
+        <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
+        <content type="yaml">--- \n1: should be an integer\n:message: Have a nice day\narray: \n- should-have-dashes: true\n  should_have_underscores: true\n</content>
+        <author-email-address>david@loudthinking.com</author-email-address>
+        <parent-id></parent-id>
+        <ad-revenue type="decimal">1.5</ad-revenue>
+        <optimum-viewing-angle type="float">135</optimum-viewing-angle>
+        <resident type="symbol">yes</resident>
+      </topic>
+    EOT
+
+    expected_topic_hash = {
+      :title => "The First Topic",
+      :author_name => "David",
+      :id => 1,
+      :approved => true,
+      :replies_count => 0,
+      :replies_close_in => 2592000000,
+      :written_on => Date.new(2003, 7, 16),
+      :viewed_at => Time.utc(2003, 7, 16, 9, 28),
+      :content => { :message => "Have a nice day", 1 => "should be an integer", "array" => [{ "should-have-dashes" => true, "should_have_underscores" => true }] },
+      :author_email_address => "david@loudthinking.com",
+      :parent_id => nil,
+      :ad_revenue => BigDecimal("1.50"),
+      :optimum_viewing_angle => 135.0,
+      :resident => :yes
+    }.stringify_keys
+ 
+    Hash.from_xml(topic_xml)["topic"].should == expected_topic_hash
+  end
+  
+  it 'parses a single record with nil values' do
+    topic_xml = <<-EOT
+      <topic>
+        <title></title>
+        <id type="integer"></id>
+        <approved type="boolean"></approved>
+        <written-on type="date"></written-on>
+        <viewed-at type="datetime"></viewed-at>
+        <content type="yaml"></content>
+        <parent-id></parent-id>
+      </topic>
+    EOT
+    
+    expected_topic_hash = {
+      :title      => nil, 
+      :id         => nil,
+      :approved   => nil,
+      :written_on => nil,
+      :viewed_at  => nil,
+      :content    => nil, 
+      :parent_id  => nil
+    }.stringify_keys
+    
+    Hash.from_xml(topic_xml)["topic"].should == expected_topic_hash
+  end
+  
+  it 'parses multiple records' do
+    topics_xml = <<-EOT
+      <topics type="array">
+        <topic>
+          <title>The First Topic</title>
+          <author-name>David</author-name>
+          <id type="integer">1</id>
+          <approved type="boolean">false</approved>
+          <replies-count type="integer">0</replies-count>
+          <replies-close-in type="integer">2592000000</replies-close-in>
+          <written-on type="date">2003-07-16</written-on>
+          <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
+          <content>Have a nice day</content>
+          <author-email-address>david@loudthinking.com</author-email-address>
+          <parent-id nil="true"></parent-id>
+        </topic>
+        <topic>
+          <title>The Second Topic</title>
+          <author-name>Jason</author-name>
+          <id type="integer">1</id>
+          <approved type="boolean">false</approved>
+          <replies-count type="integer">0</replies-count>
+          <replies-close-in type="integer">2592000000</replies-close-in>
+          <written-on type="date">2003-07-16</written-on>
+          <viewed-at type="datetime">2003-07-16T09:28:00+0000</viewed-at>
+          <content>Have a nice day</content>
+          <author-email-address>david@loudthinking.com</author-email-address>
+          <parent-id></parent-id>
+        </topic>
+      </topics>
+    EOT
+    
+    expected_topic_hash = {
+      :title => "The First Topic",
+      :author_name => "David",
+      :id => 1,
+      :approved => false,
+      :replies_count => 0,
+      :replies_close_in => 2592000000,
+      :written_on => Date.new(2003, 7, 16),
+      :viewed_at => Time.utc(2003, 7, 16, 9, 28),
+      :content => "Have a nice day",
+      :author_email_address => "david@loudthinking.com",
+      :parent_id => nil
+    }.stringify_keys
+    
+    Hash.from_xml(topics_xml)["topics"].first.should == expected_topic_hash
+  end
+  
+  it 'parses a single record with attributes *other* than "type"' do
+    topic_xml = <<-EOT
+    <rsp stat="ok">
+      <photos page="1" pages="1" perpage="100" total="16">
+        <photo id="175756086" owner="55569174@N00" secret="0279bf37a1" server="76" title="Colored Pencil PhotoBooth Fun" ispublic="1" isfriend="0" isfamily="0"/>
+      </photos>
+    </rsp>
+    EOT
+    
+    expected_topic_hash = {
+      :id => "175756086",
+      :owner => "55569174@N00",
+      :secret => "0279bf37a1",
+      :server => "76",
+      :title => "Colored Pencil PhotoBooth Fun",
+      :ispublic => "1",
+      :isfriend => "0",
+      :isfamily => "0",
+    }.stringify_keys
+    
+    Hash.from_xml(topic_xml)["rsp"]["photos"]["photo"].should == expected_topic_hash
+  end
+  
+  it 'parses an empty array' do
+   blog_xml = <<-XML
+     <blog>
+       <posts type="array"></posts>
+     </blog>
+   XML
+   expected_blog_hash = {"blog" => {"posts" => []}}
+   Hash.from_xml(blog_xml).should == expected_blog_hash
+  end
+  
+  it 'parses an empty array with whitespace' do
+    blog_xml = <<-XML
+      <blog>
+        <posts type="array">
+        </posts>
+      </blog>
+    XML
+    expected_blog_hash = {"blog" => {"posts" => []}}
+    Hash.from_xml(blog_xml).should == expected_blog_hash
+  end
+  
+  it 'parses an array with one entry' do
+    blog_xml = <<-XML
+      <blog>
+        <posts type="array">
+          <post>a post</post>
+        </posts>
+      </blog>
+    XML
+    expected_blog_hash = {"blog" => {"posts" => ["a post"]}}
+    Hash.from_xml(blog_xml).should == expected_blog_hash
+  end
+  
+  it 'parses an array with multiple entries' do
+    blog_xml = <<-XML
+      <blog>
+        <posts type="array">
+          <post>a post</post>
+          <post>another post</post>
+        </posts>
+      </blog>
+    XML
+    expected_blog_hash = {"blog" => {"posts" => ["a post", "another post"]}}
+    Hash.from_xml(blog_xml).should == expected_blog_hash
+  end
+  
+  it 'parses a file' do
+    blog_xml = <<-XML
+      <blog>
+        <logo type="file" name="logo.png" content_type="image/png">
+        </logo>
+      </blog>
+    XML
+    hash = Hash.from_xml(blog_xml)
+    hash.has_key?('blog').should be_true
+    hash['blog'].has_key?('logo').should be_true
+    
+    file = hash['blog']['logo']
+    file.original_filename.should == 'logo.png'
+    file.content_type.should == 'image/png'
+  end
+  
+  it 'parses a file with defaults' do
+    blog_xml = <<-XML
+      <blog>
+        <logo type="file">
+        </logo>
+      </blog>
+    XML
+    file = Hash.from_xml(blog_xml)['blog']['logo']
+    file.original_filename.should == 'untitled'
+    file.content_type.should == 'application/octet-stream'
+  end
+  
+  it 'parses XSD-like types' do
+    bacon_xml = <<-EOT
+    <bacon>
+      <weight type="double">0.5</weight>
+      <price type="decimal">12.50</price>
+      <chunky type="boolean"> 1 </chunky>
+      <expires-at type="dateTime">2007-12-25T12:34:56+0000</expires-at>
+      <notes type="string"></notes>
+      <illustration type="base64Binary">YmFiZS5wbmc=</illustration>
+    </bacon>
+    EOT
+    
+    expected_bacon_hash = {
+      :weight => 0.5,
+      :chunky => true,
+      :price => BigDecimal("12.50"),
+      :expires_at => Time.utc(2007,12,25,12,34,56),
+      :notes => "",
+      :illustration => "babe.png"
+    }.stringify_keys
+    
+    Hash.from_xml(bacon_xml)["bacon"].should == expected_bacon_hash
+  end
+  
+  it 'trickles the "type" attribute through, when unknown' do
+    product_xml = <<-EOT
+    <product>
+      <weight type="double">0.5</weight>
+      <image type="ProductImage"><filename>image.gif</filename></image>
+      
+    </product>
+    EOT
+    
+    expected_product_hash = {
+      :weight => 0.5,
+      :image => {'type' => 'ProductImage', 'filename' => 'image.gif' },
+    }.stringify_keys
+    
+    Hash.from_xml(product_xml)["product"].should == expected_product_hash
+  end
+  
+  it 'unescapes text nodes' do
+    xml_string = '<person><bare-string>First &amp; Last Name</bare-string><pre-escaped-string>First &amp;amp; Last Name</pre-escaped-string></person>'
+    expected_hash = { 
+      :bare_string        => 'First & Last Name', 
+      :pre_escaped_string => 'First &amp; Last Name'
+    }.stringify_keys
+    Hash.from_xml(xml_string)['person'].should == expected_hash
+  end
+  
+  it 'parses Hash.to_xml output' do
+    hash = { 
+      :bare_string        => 'First & Last Name', 
+      :pre_escaped_string => 'First &amp; Last Name'
+    }.stringify_keys
+    
+    Hash.from_xml(hash.to_xml(@xml_options))['person'].should == hash
+  end
+  
+  it 'parses a datetime with UTC time' do
+    alert_xml = <<-XML
+      <alert>
+        <alert_at type="datetime">2008-02-10T15:30:45Z</alert_at>
+      </alert>
+    XML
+    alert_at = Hash.from_xml(alert_xml)['alert']['alert_at']
+    alert_at.utc?.should be_true
+    alert_at.should == Time.utc(2008, 2, 10, 15, 30, 45)
+  end
+  
+  it 'parses a datetime with non-UTC time' do
+    alert_xml = <<-XML
+      <alert>
+        <alert_at type="datetime">2008-02-10T10:30:45-05:00</alert_at>
+      </alert>
+    XML
+    alert_at = Hash.from_xml(alert_xml)['alert']['alert_at']
+    alert_at.utc?.should be_true
+    alert_at.should == Time.utc(2008, 2, 10, 15, 30, 45)
+  end
+  
+  it 'parses a datetime with a far-future date' do
+     alert_xml = <<-XML
+       <alert>
+         <alert_at type="datetime">2050-02-10T15:30:45Z</alert_at>
+       </alert>
+     XML
+     alert_at = Hash.from_xml(alert_xml)['alert']['alert_at']
+     alert_at.utc?.should be_true
+     alert_at.year.should   == 2050
+     alert_at.month.should  == 2
+     alert_at.day.should    == 10
+     alert_at.hour.should   == 15
+     alert_at.min.should    == 30
+     alert_at.sec.should    == 45
+  end
+
+  it 'undasherizes the root node name' do
+    xml = <<-EOT
+<?xml version="1.0" encoding="UTF-8"?>
+<with-dash>
+  <another-dash>text</another-dash>
+</with-dash>
+    EOT
+    expected_hash = { "with_dash" => {"another_dash"=>"text"} }
+    Hash.from_xml(xml).should == expected_hash
+  end
+end

data/spec/narnach/core_ext/array/conversions_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'narnach/core_ext/array/conversions'
+
+describe Array, '#to_xml' do
+  describe 'ActiveSupport tests' do
+    before(:each) do
+      @builder_xml_options = {:skip_instruct => true }
+      @libxml_options = {:skip_instruct => true }
+    end
+
+    def compare_with_rails_for(hash, options = {})
+      builder_xml = hash.to_xml(@builder_xml_options.merge(options))
+      libxml_xml = hash.to_xml_with_libxml(@libxml_options.merge(options))
+      libxml_xml.should == builder_xml
+    end
+
+    it 'should pass test_to_xml' do
+      compare_with_rails_for([
+        { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+        { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+      ])
+    end
+    
+    it 'should pass test_to_xml_with_dedicated_name' do
+      compare_with_rails_for([
+        { :name => "David", :age => 26, :age_in_millis => 820497600000 }, { :name => "Jason", :age => 31 }
+      ],{:root => "people"})
+    end
+    
+    it 'should pass test_to_xml_with_options' do
+      compare_with_rails_for([
+        { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+      ], {:skip_types => true})
+    end
+
+    it 'should pass test_to_xml_with_dasherize_false' do
+      compare_with_rails_for([
+        { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+      ], {:skip_types => true, :dasherize => false})
+    end
+
+    it 'should pass test_to_xml_with_dasherize_true' do
+      compare_with_rails_for([
+        { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+      ], {:skip_types => true, :dasherize => true})
+    end
+
+    it 'should pass test_to_with_instruct' do
+      compare_with_rails_for([
+        { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+        { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+      ], {:skip_instruct => false})
+    end
+
+    it 'should pass test_to_xml_with_block' do
+      ary = [
+        { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+        { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+      ]
+      builder_xml = ary.to_xml(@builder_xml_options) do |builder|
+        builder.count 2
+      end
+      libxml_xml = ary.to_xml_with_libxml(@libxml_options) do |libxml|
+        libxml << LibXML::XML::Node.new('count', 2)
+      end
+      libxml_xml.should == builder_xml
+    end
+    
+    it 'should pass test_to_xml_with_empty' do
+      compare_with_rails_for([])
+    end
+  end
+end

data/spec/narnach/core_ext/hash/conversions_spec.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Hash, '#from_xml' do
+  it "should undasherize the Hash keys" do
+    xml = <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<post>
+  <post-id type="integer">1</post-id>
+</post>
+    XML
+    Hash.from_xml(xml).should == {'post' => {'post_id' => 1}}
+  end
+  
+  # # libxml will not break, but it takes about 140MB and 60 seconds on a 2.4GHz Core2 Duo Macbook to succeed.
+  # # It would be nice if entity expansion could be disabled if you don't plan to use it.
+  # it 'should pass test_expansion_count_is_limited' do
+  #   attack_xml = <<-EOT
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <!DOCTYPE member [
+  #     <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+  #     <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+  #     <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+  #     <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+  #     <!ENTITY e "&f;&f;&f;&f;&f;&f;&f;&f;&f;&f;">
+  #     <!ENTITY f "&g;&g;&g;&g;&g;&g;&g;&g;&g;&g;">
+  #     <!ENTITY g "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
+  #   ]>
+  #   <member>
+  #   &a;
+  #   </member>
+  #   EOT
+  #   lambda {
+  #     Hash.from_xml(attack_xml)
+  #   }.should_not raise_error
+  # end
+end
+
+class IWriteMyOwnXML
+  def to_xml(options = {})
+    options[:indent] ||= 2
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+    xml.level_one do
+      xml.tag!(:second_level, 'content')
+    end
+  end
+  
+  def to_xml_with_libxml(options = {})
+    {:second_level => 'content'}.to_xml_with_libxml(options.merge(:root => 'level_one', :dasherize => false))
+  end
+end
+
+describe Hash, "#to_xml_with_libxml" do
+  it "should convert a Hash with one element" do
+    hsh = {:one => 1}
+    libxml_xml = hsh.to_xml_with_libxml.to_s
+    builder_xml = hsh.to_xml
+    libxml_xml.should == builder_xml
+  end
+
+  it "should convert a Hash with nested Hash" do
+    hsh = {:one => 1, 'two' => { :three => 3}}
+    libxml_xml = hsh.to_xml_with_libxml.to_s
+    builder_xml = hsh.to_xml
+    libxml_xml.should == builder_xml
+  end
+
+  # These tests are adapted from the Rails ActiveSupport tests, so test to_xml_with_libxml in the same situations as to_xml
+  describe 'ActiveSupport tests' do
+    before(:each) do
+      @builder_xml_options = { :root => :person, :skip_instruct => true }
+      @libxml_options = { :root => :person, :skip_instruct => true }
+    end
+
+    def compare_with_rails_for(hash, custom_builder_options={}, custom_libxml_options={})
+      builder_xml = hash.to_xml(@builder_xml_options.merge(custom_builder_options))
+      libxml_xml = hash.to_xml_with_libxml(@libxml_options.merge(custom_libxml_options))
+      libxml_xml.should == builder_xml
+    end
+
+    it 'should pass test_one_level' do
+      compare_with_rails_for({ :name => "David", :street => "Paulina" })
+    end
+
+    it 'should pass test_one_level_dasherize_false' do
+      compare_with_rails_for({ :name => "David", :street_name => "Paulina" }, {:dasherize => false}, {:dasherize => false})
+    end
+
+    it 'should pass test_one_level_dasherize_true' do
+      compare_with_rails_for({ :name => "David", :street_name => "Paulina" }, {:dasherize => true}, {:dasherize => true})
+    end
+    
+    it 'should pass test_one_level_with_types' do
+      compare_with_rails_for({ :name => "David", :street => "Paulina", :age => 26, :age_in_millis => 820497600000, :moved_on => Date.new(2005, 11, 15), :resident => :yes })
+    end
+
+    it 'should pass test_one_level_with_nils' do
+      compare_with_rails_for({ :name => "David", :street => "Paulina", :age => nil })
+    end
+
+    it 'should pass test_one_level_with_skipping_types' do
+      compare_with_rails_for({ :name => "David", :street => "Paulina", :age => nil }, {:skip_types => true}, {:skip_types => true})
+    end
+    
+    it 'should pass test_one_level_with_yielding' do
+      hash = { :name => "David", :street => "Paulina" }
+      builder_xml = hash.to_xml(@builder_xml_options) do |x|
+        x.creator("Rails")
+      end
+      libxml_xml = hash.to_xml_with_libxml(@libxml_options) do |x|
+        x << LibXML::XML::Node.new('creator', 'Rails')
+      end
+      libxml_xml.should == builder_xml
+    end
+
+    it 'should pass test_two_levels' do
+      compare_with_rails_for({ :name => "David", :address => { :street => "Paulina" } })
+    end
+
+    it 'should pass test_two_levels_with_second_level_overriding_to_xml' do
+      compare_with_rails_for({ :name => "David", :address => { :street => "Paulina" }, :child => IWriteMyOwnXML.new })
+    end
+    
+    it 'should pass test_two_levels_with_array' do
+      compare_with_rails_for({ :name => "David", :addresses => [{ :street => "Paulina" }, { :street => "Evergreen" }] })
+    end
+
+    it 'should test_three_levels_with_array' do
+      compare_with_rails_for({ :name => "David", :addresses => [{ :streets => [ { :name => "Paulina" }, { :name => "Paulina" } ] } ] })
+    end
+
+    # The XML builder seems to fail miserably when trying to tag something
+    # with the same name as a Kernel method (throw, test, loop, select ...)
+    it 'should pass test_kernel_method_names_to_xml' do
+      compare_with_rails_for({ :throw => { :ball => 'red' } })
+    end
+
+    it 'should pass test_escaping_to_xml' do
+      compare_with_rails_for({ 
+        :bare_string        => 'First & Last Name', 
+        :pre_escaped_string => 'First &amp; Last Name'
+      }.stringify_keys)
+    end
+
+    it 'should pass test_roundtrip_to_xml_from_xml' do
+      hash = { 
+        :bare_string        => 'First & Last Name', 
+        :pre_escaped_string => 'First &amp; Last Name'
+      }.stringify_keys
+
+      Hash.from_xml(hash.to_xml_with_libxml(@libxml_options))['person'].should == hash
+    end
+  end
+end

data/spec/narnach/rails_ext/active_resource_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'libxml_rails/active_resource'
+
+class SomePerson < ActiveResource::Base
+  self.site = 'http://example.org'
+end
+
+describe ActiveResource, '#to_xml' do
+  before(:each) do
+    @sp = SomePerson.new(:name => 'Wes', :last_name => 'Oldenbeuving', :age => 22)
+  end
+
+  it "should return the resource as XML" do
+    @sp.to_xml(:libxml=>false).should == @sp.to_xml(:libxml=>true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+$LOAD_PATH.unshift(lib_dir)
+
+require 'libxml_rails'

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: Narnach-libxml_rails
+version: !ruby/object:Gem::Version 
+  version: 0.0.2.5
+platform: ruby
+authors: 
+- Brandon Mitchell
+- Wes Oldenbeuving
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-06 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.3
+    version: 
+description: Libxml_rails replaces ActiveSupport's XmlSimple XML parsing with libxml-ruby. Original gem by Brandon Mitchell, this fork is by Wes 'Narnach' Oldenbeuving.
+email: narnach@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- CHANGELOG
+- init.rb
+- libxml_rails.gemspec
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- spec/from_xml_spec.rb
+- spec/narnach/core_ext/hash/conversions_spec.rb
+- spec/narnach/core_ext/array/conversions_spec.rb
+- spec/narnach/rails_ext/active_resource_spec.rb
+- spec/spec_helper.rb
+- lib/bitbckt/core_ext/hash/conversions.rb
+- lib/narnach/core_ext/hash/conversions.rb
+- lib/narnach/core_ext/array/conversions.rb
+- lib/narnach/rails_ext/active_resource.rb
+- lib/libxml_rails.rb
+- lib/libxml_rails/active_resource.rb
+has_rdoc: true
+homepage: http://www.github.com/Narnach/libxml_rails
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Libxml_rails replaces ActiveSupport's XmlSimple XML parsing with libxml-ruby. Original gem by Brandon Mitchell, this fork is by Wes 'Narnach' Oldenbeuving.
+test_files: 
+- spec/from_xml_spec.rb
+- spec/narnach/core_ext/hash/conversions_spec.rb
+- spec/narnach/core_ext/array/conversions_spec.rb
+- spec/narnach/rails_ext/active_resource_spec.rb