xml_mini 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p194@xml_mini --create

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xml_mini.gemspec
+gemspec
+
+gem 'bundler'
+gem 'rake'
+
+
+group :development, :test do
+  gem 'minitest' 
+  gem 'libxml-ruby'
+  gem 'nokogiri'
+end
+  
+group :test do
+  gem 'guard'
+  gem 'guard-minitest', github: 'mpouleijn/guard-minitest'
+  gem 'guard-bundler'
+end

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'minitest' do
+  # with Minitest::Unit
+  watch(%r|^test/(.*)\/?(.*)\_test.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/lib/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r|^lib/core_ext/(.*)([^/]+)\.rb|)     { |m| "test/lib/core_ext/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michel Pouleijn
+
+MIT License
+
+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.md

@@ -0,0 +1,31 @@
+[![Build Status](https://secure.travis-ci.org/Pouleijn/xml_mini.png?branch=master)](http://travis-ci.org/Pouleijn/xml_mini) | [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/Pouleijn/xml_mini)
+
+# XmlMini
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xml_mini'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xml_mini
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = '**/*_test.rb'
+end
+
+desc "Default Task"
+task :default => "test"

data/lib/core_ext/array.rb

@@ -0,0 +1,45 @@
+class Array
+  # Wraps its argument in an array unless it is already an array (or array-like).
+  #
+  # Specifically:
+  #
+  # * If the argument is +nil+ an empty list is returned.
+  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+  # * Otherwise, returns an array with the argument as its single element.
+  #
+  #   Array.wrap(nil)       # => []
+  #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #   Array.wrap(0)         # => [0]
+  #
+  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+  #
+  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  # such a +nil+ right away.
+  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+  # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
+  #
+  # The last point is particularly worth comparing for some enumerables:
+  #
+  #   Array(:foo => :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
+  #
+  # There's also a related idiom that uses the splat operator:
+  #
+  #   [*object]
+  #
+  # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
+  #
+  # Thus, in this case the behavior is different for +nil+, and the differences with
+  # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/core_ext/blank.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies:
+  #
+  #   if address.nil? || address.empty?
+  #
+  # ...to:
+  #
+  #   if address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not <tt>blank?</tt>.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all. For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   {:key => 'value'}.blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class String
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?                 # => true
+  #   '   '.blank?              # => true
+  #   '　'.blank?               # => true
+  #   ' something here '.blank? # => false
+  #
+  def blank?
+    self !~ /[^[:space:]]/
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  def blank?
+    false
+  end
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,72 @@
+class Hash
+  class << self
+    def from_minixml(xml)
+      typecast_xml_value(unrename_keys(XmlMini.parse(xml)))
+    end
+    
+    private
+    
+    def typecast_xml_value(value)
+      case value.class.to_s
+        when 'Hash'
+          if value['type'] == 'array'
+            _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
+            if entries.nil? || (c = value['__content__'] && c.blank?)
+              []
+            else
+              case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
+              when 'Array'
+                entries.collect { |v| typecast_xml_value(v) }
+              when 'Hash'
+                [typecast_xml_value(entries)]
+              else
+                raise "can't typecast #{entries.inspect}"
+              end
+            end
+          elsif value['type'] == 'file' ||
+             (value['__content__'] && (value.keys.size == 1 || !value['__content__'].present? ))
+            content = value['__content__']
+            if parser = XmlMini::PARSING[value['type']]
+              parser.arity == 1 ? parser.call(content) : parser.call(content, value)
+            else
+              content
+            end
+          elsif value['type'] == 'string' && value['nil'] != 'true'
+            ''
+          # blank or nil parsed values are represented by nil
+          elsif value.blank? || 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 = Hash[value.map { |k,v| [k, typecast_xml_value(v)] }]
+
+            # 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
+
+    def unrename_keys(params)
+      case params.class.to_s
+        when 'Hash'
+          Hash[params.map { |k,v| [k.to_s.tr('-', '_'), unrename_keys(v)] } ]
+        when 'Array'
+          params.map { |v| unrename_keys(v) }
+        else
+          params
+      end
+      end
+  end
+end

data/lib/xml_mini.rb

@@ -0,0 +1,160 @@
+require 'base64'
+require "xml_mini/version"
+require "core_ext/array"
+require "core_ext/blank"
+require "core_ext/hash"
+
+module XmlMini
+  extend Forwardable
+  extend self
+
+  # This module decorates files deserialized using Hash.from_minixml 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
+
+  DEFAULT_ENCODINGS = {
+      "binary" => "base64"
+  } unless defined?(DEFAULT_ENCODINGS)
+
+  TYPE_NAMES = {
+      "Symbol" => "symbol",
+      "Fixnum" => "integer",
+      "Bignum" => "integer",
+      "BigDecimal" => "decimal",
+      "Float" => "float",
+      "TrueClass" => "boolean",
+      "FalseClass" => "boolean",
+      "Date" => "date",
+      "DateTime" => "dateTime",
+      "Time" => "dateTime",
+      "Array" => "array",
+      "Hash" => "hash"
+  } unless defined?(TYPE_NAMES)
+
+  FORMATTING = {
+      "symbol" => Proc.new { |symbol| symbol.to_s },
+      "date" => Proc.new { |date| date.to_s(:db) },
+      "dateTime" => Proc.new { |time| time.xmlschema },
+      "binary" => Proc.new { |binary| ::Base64.encode64(binary) },
+      "yaml" => Proc.new { |yaml| yaml.to_yaml }
+  } unless defined?(FORMATTING)
+
+  # TODO 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.xmlschema(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(1 true).include?(boolean.strip) },
+        "string" => Proc.new { |string| string.to_s },
+        "yaml" => Proc.new { |yaml| YAML::load(yaml) rescue yaml },
+        "base64Binary" => Proc.new { |bin| ::Base64.decode64(bin) },
+        "binary" => Proc.new { |bin, entity| _parse_binary(bin, entity) },
+        "file" => Proc.new { |file, entity| _parse_file(file, entity) }
+    }
+
+    PARSING.update(
+        "double" => PARSING["float"],
+        "dateTime" => PARSING["datetime"]
+    )
+  end
+
+  attr_reader :backend
+  def_delegator :@backend, :parse
+
+  def backend=(name)
+    if name.is_a?(Module)
+      @backend = name
+    else
+      require "xml_mini/#{name.downcase}"
+      @backend = XmlMini.const_get("XmlMini_#{name}")
+    end
+  end
+
+  def with_backend(name)
+    old_backend, self.backend = backend, name
+    yield
+  ensure
+    self.backend = old_backend
+  end
+
+  def to_tag(key, value, options)
+    type_name = options.delete(:type)
+    merged_options = options.merge(:root => key, :skip_instruct => true)
+
+    if value.is_a?(::Method) || value.is_a?(::Proc)
+      if value.arity == 1
+        value.call(merged_options)
+      else
+        value.call(merged_options, key.to_s.singularize)
+      end
+    elsif value.respond_to?(:to_xml)
+      value.to_xml(merged_options)
+    else
+      type_name ||= TYPE_NAMES[value.class.name]
+      type_name ||= value.class.name if value && !value.respond_to?(:to_str)
+      type_name = type_name.to_s if type_name
+      type_name = "dateTime" if type_name == "datetime"
+
+      key = rename_key(key.to_s, options)
+
+      attributes = options[:skip_types] || type_name.nil? ? {} : {:type => type_name}
+      attributes[:nil] = true if value.nil?
+
+      encoding = options[:encoding] || DEFAULT_ENCODINGS[type_name]
+      attributes[:encoding] = encoding if encoding
+
+      formatted_value = FORMATTING[type_name] && !value.nil? ?
+          FORMATTING[type_name].call(value) : value
+
+      options[:builder].tag!(key, formatted_value, attributes)
+    end
+  end
+
+  def rename_key(key, options = {})
+    dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+    key = _dasherize(key) if dasherize
+    key
+  end
+
+  protected
+
+  def _dasherize(key)
+    # $2 must be a non-greedy regex for this to work
+    left, middle, right = /\A(_*)(.*?)(_*)\Z/.match(key.strip)[1, 3]
+    "#{left}#{middle.tr('_ ', '--')}#{right}"
+  end
+
+  # TODO: Add support for other encodings
+  def _parse_binary(bin, entity) #:nodoc:
+    case entity['encoding']
+      when 'base64'
+        ::Base64.decode64(bin)
+      else
+        bin
+    end
+  end
+
+  def _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
+end
+
+XmlMini.backend = 'REXML'