multi_xml 0.0.1 → 0.1.0

data/.gitignore

@@ -1,3 +1,4 @@
-pkg/*
 *.gem
 .bundle
+pkg/*
+rdoc/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=nested

data/Gemfile

@@ -1,9 +1,8 @@
 source "http://rubygems.org"
 
 group :development, :test do
-  gem 'hpricot', "~> 0.8.2", :require => nil
-  gem 'libxml-ruby', "~> 1.1.4", :require => nil
-  gem 'nokogiri', "~> 1.4.3", :require => nil
+  gem 'libxml-ruby', "~> 1.1", :require => nil
+  gem 'nokogiri', "~> 1.4", :require => nil
 end
 
 gemspec

data/Gemfile.lock

@@ -1,25 +1,33 @@
 PATH
   remote: .
   specs:
-    multi_xml (0.0.1)
+    multi_xml (0.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    hpricot (0.8.2)
+    diff-lcs (1.1.2)
     libxml-ruby (1.1.4)
     nokogiri (1.4.3.1)
     rake (0.8.7)
-    rspec (1.3.0)
+    rspec (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+      rspec-mocks (= 2.0.0)
+    rspec-core (2.0.0)
+    rspec-expectations (2.0.0)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0.2)
-  hpricot (~> 0.8.2)
-  libxml-ruby (~> 1.1.4)
+  bundler (~> 1.0)
+  libxml-ruby (~> 1.1)
   multi_xml!
-  nokogiri (~> 1.4.3)
-  rake (~> 0.8.7)
-  rspec (~> 1.3.0)
+  nokogiri (~> 1.4)
+  rake (~> 0.8)
+  rspec (~> 2.0)

data/README.rdoc

@@ -4,18 +4,18 @@ Lots of Ruby libraries utilize XML parsing in some form, and everyone has their
 
   require 'multi_xml'
   
-  MultiXml.engine = :nokogiri
+  MultiXml.parser = :nokogiri
   MultiXml.parse('<tag>This is the contents</tag>') # parsed using Nokogiri
   
-  MultiXml.engine = :rexml
-  MultiXml.engine = MultiJson::Engines::Rexml # equivalent to previous line
+  MultiXml.parser = :rexml
+  MultiXml.parser = MultiJson::Parser::Rexml # equivalent to previous line
   MultiXml.parse('<tag>This is the contents</tag>') # parsed using REXML
 
-The <tt>engine</tt> setter takes either a symbol or a class (to allow for custom XML parsers) that responds to <tt>.parse</tt> at the class level.
+The <tt>parser</tt> setter takes either a symbol or a class (to allow for custom XML parsers) that responds to <tt>.parse</tt> at the class level.
 
-MultiXML tries to have intelligent defaulting. That is, if you have any of the supported engines already loaded, it will utilize them before attempting to load any. When loading, libraries are ordered by speed. First LibXML, then Nokogiri, then Hpricot, then REXML.
+MultiXML tries to have intelligent defaulting. That is, if you have any of the supported parsers already loaded, it will utilize them before attempting to load any. When loading, libraries are ordered by speed. First LibXML, then Nokogiri, then REXML.
 
-== Inspriation
+== Inspiration
 
 MultiXML was inspired by MultiJSON[http://github.com/intridea/multi_json/].
 

data/Rakefile

@@ -1,28 +1,18 @@
-require 'rubygems'
-require 'bundler'
-require 'rake'
-require 'rake/rdoctask'
-require 'spec/rake/spectask'
+require "bundler"
+require "rake/rdoctask"
+require "rspec/core/rake_task"
 
 Bundler::GemHelper.install_tasks
 
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "multi_xml #{version}"
+  rdoc.title = "multi_xml #{MultiXml::VERSION}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
 end
 
 task :default => :spec

data/lib/multi_xml.rb

@@ -1,65 +1,229 @@
+require 'base64'
+require 'bigdecimal'
+require 'date'
+require 'time'
+require 'yaml'
+
 module MultiXml
-  module_function
+  class << self
 
-  # Get the current engine class.
-  def engine
-    return @engine if @engine
-    self.engine = self.default_engine
-    @engine
-  end
+    REQUIREMENT_MAP = [
+      ['libxml', :libxml],
+      ['nokogiri', :nokogiri],
+      ['rexml/document', :rexml]
+    ]
+
+    CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+
+    # TODO: use Time.xmlschema instead of Time.parse;
+    #       use regexp instead of Date.parse
+    unless defined?(PARSING)
+      PARSING = {
+        'symbol'       => Proc.new{|symbol| symbol.to_sym},
+        'date'         => Proc.new{|date| ::Date.parse(date)},
+        'datetime'     => Proc.new{|time| ::Time.parse(time).utc rescue ::DateTime.parse(time).utc},
+        'integer'      => Proc.new{|integer| integer.to_i},
+        'float'        => Proc.new{|float| float.to_f},
+        'decimal'      => Proc.new{|number| BigDecimal(number)},
+        'boolean'      => Proc.new{|boolean| !%w(0 false).include?(boolean.strip)},
+        'string'       => Proc.new{|string| string.to_s},
+        'yaml'         => Proc.new{|yaml| YAML::load(yaml) rescue yaml},
+        'base64Binary' => Proc.new{|binary| binary.unpack('m').first},
+        'binary'       => Proc.new{|binary, entity| parse_binary(binary, entity)},
+        'file'         => Proc.new{|file, entity| parse_file(file, entity)}
+      }
+
+      PARSING.update(
+        'double'   => PARSING['float'],
+        'dateTime' => PARSING['datetime']
+      )
+    end
 
-  REQUIREMENT_MAP = [
-    ['libxml', :libxml],
-    ['nokogiri', :nokogiri],
-    ['hpricot', :hpricot],
-    ['rexml/document', :rexml]
-  ]
-
-  # The default engine based on what you currently
-  # have loaded and installed. First checks to see
-  # if any engines are already loaded, then checks
-  # to see which are installed if none are loaded.
-  def default_engine
-    return :libxml if defined?(::LibXML)
-    return :nokogiri if defined?(::Nokogiri)
-    return :hpricot if defined?(::Hpricot)
-
-    REQUIREMENT_MAP.each do |(library, engine)|
-      begin
-        require library
-        return engine
-      rescue LoadError
-        next
+    # Get the current parser class.
+    def parser
+      return @parser if @parser
+      self.parser = self.default_parser
+      @parser
+    end
+
+    # The default parser based on what you currently
+    # have loaded and installed. First checks to see
+    # if any parsers are already loaded, then checks
+    # to see which are installed if none are loaded.
+    def default_parser
+      return :libxml if defined?(::LibXML)
+      return :nokogiri if defined?(::Nokogiri)
+
+      REQUIREMENT_MAP.each do |(library, parser)|
+        begin
+          require library
+          return parser
+        rescue LoadError
+          next
+        end
+      end
+    end
+
+    # Set the XML parser utilizing a symbol, string, or class.
+    # Supported by default are:
+    #
+    # * <tt>:libxml</tt>
+    # * <tt>:nokogiri</tt>
+    # * <tt>:rexml</tt>
+    def parser=(new_parser)
+      case new_parser
+        when String, Symbol
+          require "multi_xml/parsers/#{new_parser.to_s.downcase}"
+          @parser = MultiXml::Parsers.const_get("#{new_parser.to_s.split('_').map{|s| s.capitalize}.join('')}")
+        when Class, Module
+          @parser = new_parser
+        else
+          raise "Did not recognize your parser specification. Please specify either a symbol or a class."
+      end
+    end
+
+    # Parse an XML string into Ruby.
+    #
+    # <b>Options</b>
+    #
+    # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
+    def parse(xml, options={})
+      xml.strip!
+      hash = typecast_xml_value(undasherize_keys(parser.parse(xml)))
+      hash = symbolize_keys(hash) if options[:symbolize_keys]
+      hash = {} if hash.nil?
+      hash
+    end
+
+    # This module decorates files with the <tt>original_filename</tt>
+    # and <tt>content_type</tt> methods.
+    module FileLike #:nodoc:
+      attr_writer :original_filename, :content_type
+
+      def original_filename
+        @original_filename || 'untitled'
+      end
+
+      def content_type
+        @content_type || 'application/octet-stream'
       end
     end
-  end
 
-  # Set the XML parser utilizing a symbol, string, or class.
-  # Supported by default are:
-  #
-  # * <tt>:libxml</tt>
-  # * <tt>:nokogiri</tt>
-  # * <tt>:hpricot</tt>
-  # * <tt>:rexml</tt>
-  def engine=(new_engine)
-    case new_engine
-      when String, Symbol
-        require "multi_xml/engines/#{new_engine}"
-        @engine = MultiXml::Engines.const_get("#{new_engine.to_s.split('_').map{|s| s.capitalize}.join('')}")
-      when Class
-        @engine = new_engine
+    private
+
+    # TODO: Add support for other encodings
+    def self.parse_binary(binary, entity) #:nodoc:
+      case entity['encoding']
+      when 'base64'
+        Base64.decode64(binary)
       else
-        raise "Did not recognize your engine specification. Please specify either a symbol or a class."
+        binary
+      end
     end
-  end
 
-  # Parse a XML string into Ruby.
-  #
-  # <b>Options</b>
-  #
-  # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
-  def parse(string, options = {})
-    engine.parse(string, options)
-  end
+    def self.parse_file(file, entity)
+      f = StringIO.new(Base64.decode64(file))
+      f.extend(FileLike)
+      f.original_filename = entity['name']
+      f.content_type = entity['content_type']
+      f
+    end
 
+    def symbolize_keys(hash)
+      hash.inject({}) do |result, (key, value)|
+        new_key = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+        new_value = case value
+        when Hash
+          symbolize_keys(value)
+        else
+          value
+        end
+        result[new_key] = new_value
+        result
+      end
+    end
+
+    def undasherize_keys(params)
+      case params
+      when Hash
+        params.inject({}) do |hash, (key, value)|
+          hash[key.to_s.tr('-', '_')] = undasherize_keys(value)
+          hash
+        end
+      when Array
+        params.map{|value| undasherize_keys(value)}
+      else
+        params
+      end
+    end
+
+    def wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
+    end
+
+    def typecast_xml_value(value)
+      case value
+      when Hash
+        if value['type'] == 'array'
+          _, entries = wrap(value.detect{|key, value| key != 'type'})
+          if entries.nil? || entries.strip == '' || (c = value[CONTENT_ROOT] && c.nil?)
+            []
+          else
+            case entries
+            when Array
+              entries.map{|value| typecast_xml_value(value)}
+            when Hash
+              [typecast_xml_value(entries)]
+            else
+              raise "can't typecast #{entries.class.name}: #{entries.inspect}"
+            end
+          end
+        elsif value.has_key?(CONTENT_ROOT)
+          content = value[CONTENT_ROOT]
+          if block = PARSING[value['type']]
+            block.arity == 1 ? block.call(content) : block.call(content, value)
+          else
+            content
+          end
+        elsif value['type'] == 'string' && value['nil'] != 'true'
+          ''
+        # blank or nil parsed values are represented by nil
+        elsif value.nil? || value.empty? || value['nil'] == 'true'
+          nil
+        # If the type is the only element which makes it then
+        # this still makes the value nil, except if type is
+        # a XML node(where type['value'] is a Hash)
+        elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
+          nil
+        else
+          xml_value = value.inject({}) do |hash, (key, value)|
+            hash[key] = typecast_xml_value(value)
+            hash
+          end
+
+          # Turn {:files => {:file => #<StringIO>} into {:files => #<StringIO>} so it is compatible with
+          # how multipart uploaded files from HTML appear
+          xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
+        end
+      when Array
+        value.map!{|i| typecast_xml_value(i)}
+        value.length > 1 ? value : value.first
+      when String
+        value
+      else
+        raise "can't typecast #{value.class.name}: #{value.inspect}"
+      end
+    end
+  end
 end

data/lib/multi_xml/parsers/libxml.rb

@@ -0,0 +1,79 @@
+require 'libxml' unless defined?(LibXML)
+
+module MultiXml
+  module Parsers
+    # Use LibXML to parse XML.
+    module Libxml #:nodoc:
+      extend self
+
+      # Parse an XML Document string or IO into a simple hash using libxml.
+      # data::
+      #   XML Document string or IO to parse
+      def parse(data)
+        if !data.respond_to?(:read)
+          data = StringIO.new(data || '')
+        end
+
+        char = data.getc
+        if char.nil?
+          {}
+        else
+          data.ungetc(char)
+          LibXML::XML::Parser.io(data).parse.to_hash
+        end
+      end
+    end
+  end
+end
+
+module LibXML #:nodoc:
+  module Conversions #:nodoc:
+    module Document #:nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node #:nodoc:
+      CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+
+      # Convert XML document to hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def to_hash(hash={})
+        node_hash = {}
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+          when Array then hash[name] << node_hash
+          when Hash  then hash[name] = [hash[name], node_hash]
+          when nil   then hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child do |c|
+          if c.element?
+            c.to_hash(node_hash)
+          elsif c.text? || c.cdata?
+            node_hash[CONTENT_ROOT] ||= ''
+            node_hash[CONTENT_ROOT] << c.content
+          end
+        end
+
+        # Remove content node if it is blank
+        if node_hash.length > 1 && (node_hash[CONTENT_ROOT].nil? || node_hash[CONTENT_ROOT].empty?)
+          node_hash.delete(CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr { |a| node_hash[a.name] = a.value }
+
+        hash
+      end
+    end
+  end
+end
+
+LibXML::XML::Document.send(:include, LibXML::Conversions::Document)
+LibXML::XML::Node.send(:include, LibXML::Conversions::Node)