core_ext 0.0.1

data/lib/core_ext/xml_mini/libxml.rb

@@ -0,0 +1,79 @@
+require 'libxml'
+require 'core_ext/object/blank'
+require 'stringio'
+
+module CoreExt
+  module XmlMini_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
+
+module LibXML #:nodoc:
+  module Conversions #:nodoc:
+    module Document #:nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node #:nodoc:
+      CONTENT_ROOT = '__content__'.freeze
+
+      # 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].blank?
+          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.include(LibXML::Conversions::Document)
+LibXML::XML::Node.include(LibXML::Conversions::Node)

data/lib/core_ext/xml_mini/libxmlsax.rb

@@ -0,0 +1,85 @@
+require 'libxml'
+require 'core_ext/object/blank'
+require 'stringio'
+
+module CoreExt
+  module XmlMini_LibXMLSAX #:nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder
+
+      include LibXML::XML::SaxParser::Callbacks
+
+      CONTENT_KEY   = '__content__'.freeze
+      HASH_SIZE_KEY = '__hash_size__'.freeze
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def on_start_document
+        @hash = { CONTENT_KEY => '' }
+        @hash_stack = [@hash]
+      end
+
+      def on_end_document
+        @hash = @hash_stack.pop
+        @hash.delete(CONTENT_KEY)
+      end
+
+      def on_start_element(name, attrs = {})
+        new_hash = { CONTENT_KEY => '' }.merge!(attrs)
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+          when Array then current_hash[name] << new_hash
+          when Hash  then current_hash[name] = [current_hash[name], new_hash]
+          when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def on_end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def on_characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :on_cdata_block, :on_characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    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::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
+        parser = LibXML::XML::SaxParser.io(data)
+        document = self.document_class.new
+
+        parser.callbacks = document
+        parser.parse
+        document.hash
+      end
+    end
+  end
+end

data/lib/core_ext/xml_mini/nokogiri.rb

@@ -0,0 +1,83 @@
+begin
+  require 'nokogiri'
+rescue LoadError => e
+  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require 'core_ext/object/blank'
+require 'stringio'
+
+module CoreExt
+  module XmlMini_Nokogiri #:nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
+    # 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)
+        doc = Nokogiri::XML(data)
+        raise doc.errors.first if doc.errors.length > 0
+        doc.to_hash
+      end
+    end
+
+    module Conversions #:nodoc:
+      module Document #:nodoc:
+        def to_hash
+          root.to_hash
+        end
+      end
+
+      module Node #:nodoc:
+        CONTENT_ROOT = '__content__'.freeze
+
+        # 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
+          children.each 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 and there are child tags
+          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+            node_hash.delete(CONTENT_ROOT)
+          end
+
+          # Handle attributes
+          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+
+          hash
+        end
+      end
+    end
+
+    Nokogiri::XML::Document.include(Conversions::Document)
+    Nokogiri::XML::Node.include(Conversions::Node)
+  end
+end

data/lib/core_ext/xml_mini/nokogirisax.rb

@@ -0,0 +1,87 @@
+begin
+  require 'nokogiri'
+rescue LoadError => e
+  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require 'core_ext/object/blank'
+require 'stringio'
+
+module CoreExt
+  module XmlMini_NokogiriSAX #:nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder < Nokogiri::XML::SAX::Document
+
+      CONTENT_KEY   = '__content__'.freeze
+      HASH_SIZE_KEY = '__hash_size__'.freeze
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def start_document
+        @hash = {}
+        @hash_stack = [@hash]
+      end
+
+      def end_document
+        raise "Parse stack not empty!" if @hash_stack.size > 1
+      end
+
+      def error(error_message)
+        raise error_message
+      end
+
+      def start_element(name, attrs = [])
+        new_hash = { CONTENT_KEY => '' }.merge!(Hash[attrs])
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+          when Array then current_hash[name] << new_hash
+          when Hash  then current_hash[name] = [current_hash[name], new_hash]
+          when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :cdata_block, :characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || '')
+      end
+
+      char = data.getc
+      if char.nil?
+        {}
+      else
+        data.ungetc(char)
+        document = self.document_class.new
+        parser = Nokogiri::XML::SAX::Parser.new(document)
+        parser.parse(data)
+        document.hash
+      end
+    end
+  end
+end

data/lib/core_ext/xml_mini/rexml.rb

@@ -0,0 +1,130 @@
+require 'core_ext/kernel/reporting'
+require 'core_ext/object/blank'
+require 'stringio'
+
+module CoreExt
+  module XmlMini_REXML #:nodoc:
+    extend self
+
+    CONTENT_KEY = '__content__'.freeze
+
+    # Parse an XML Document string or IO into a simple hash.
+    #
+    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
+    # and uses the defaults from Active Support.
+    #
+    # 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)
+        silence_warnings { require 'rexml/document' } unless defined?(REXML::Document)
+        doc = REXML::Document.new(data)
+
+        if doc.root
+          merge_element!({}, doc.root, XmlMini.depth)
+        else
+          raise REXML::ParseException,
+            "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
+    end
+
+    private
+      # Convert an XML element and merge into the hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      # element::
+      #   XML element to merge into hash
+      def merge_element!(hash, element, depth)
+        raise REXML::ParseException, "The document is too deep" if depth == 0
+        merge!(hash, element.name, collapse(element, depth))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element, depth)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element {|child| merge_element!(hash, child, depth - 1) }
+          merge_texts!(hash, element) unless empty_content?(element)
+          hash
+        else
+          merge_texts!(hash, element)
+        end
+      end
+
+      # Merge all the texts of an element into the hash
+      #
+      # hash::
+      #   Hash to add the converted element to.
+      # element::
+      #   XML element whose texts are to me merged into the hash
+      def merge_texts!(hash, element)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, CONTENT_KEY, texts)
+        end
+      end
+
+      # Adds a new key/value pair to an existing Hash. If the key to be added
+      # already exists and the existing value associated with key is not
+      # an Array, it will be wrapped in an Array. Then the new value is
+      # appended to that Array.
+      #
+      # hash::
+      #   Hash to add key/value pair to.
+      # key::
+      #   Key to be added.
+      # value::
+      #   Value to be associated with key.
+      def merge!(hash, key, value)
+        if hash.has_key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Converts the attributes array of an XML element into a hash.
+      # Returns an empty Hash if node has no attributes.
+      #
+      # element::
+      #   XML element to extract attributes from.
+      def get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n,v| attributes[n] = v }
+        attributes
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        element.texts.join.blank?
+      end
+  end
+end

data/lib/core_ext/xml_mini.rb

@@ -0,0 +1,194 @@
+require 'time'
+require 'base64'
+require 'bigdecimal'
+require 'core_ext/module/delegation'
+require 'core_ext/string/inflections'
+require 'core_ext/date_time/calculations'
+
+module CodeExt
+  # = XmlMini
+  #
+  # To use the much faster libxml parser:
+  #   gem 'libxml-ruby', '=0.9.7'
+  #   XmlMini.backend = 'LibXML'
+  module XmlMini
+    extend self
+
+    # This module decorates files deserialized using Hash.from_xml 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_s.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.to_s.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_accessor :depth
+    self.depth = 100
+
+    delegate :parse, :to => :backend
+
+    def backend
+      current_thread_backend || @backend
+    end
+
+    def backend=(name)
+      backend = name && cast_backend_name_to_module(name)
+      self.current_thread_backend = backend if current_thread_backend
+      @backend = backend
+    end
+
+    def with_backend(name)
+      old_backend = current_thread_backend
+      self.current_thread_backend = name && cast_backend_name_to_module(name)
+      yield
+    ensure
+      self.current_thread_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 = {})
+      camelize  = options[:camelize]
+      dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+      if camelize
+        key = true == camelize ? key.camelize : key.camelize(camelize)
+      end
+      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
+
+    private
+
+      def current_thread_backend
+        Thread.current[:xml_mini_backend]
+      end
+
+      def current_thread_backend=(name)
+        Thread.current[:xml_mini_backend] = name && cast_backend_name_to_module(name)
+      end
+
+      def cast_backend_name_to_module(name)
+        if name.is_a?(Module)
+          name
+        else
+          require "core_ext/xml_mini/#{name.downcase}"
+          CoreExt.const_get("XmlMini_#{name}")
+        end
+      end
+  end
+
+  XmlMini.backend = 'REXML'
+end

data/lib/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].each do |path|
+  require path
+end