activesupport 2.3.5 → 3.0.0.beta3

data/lib/active_support/xml_mini/libxml.rb

@@ -1,130 +1,77 @@
 require 'libxml'
+require 'active_support/core_ext/object/returning'
+require 'active_support/core_ext/object/blank'
 
 # = XmlMini LibXML implementation
 module ActiveSupport
   module XmlMini_LibXML #:nodoc:
     extend self
 
-    # Parse an XML Document string into a simple hash using libxml.
-    # string::
-    #   XML Document string to parse
-    def parse(string)
-      LibXML::XML.default_keep_blanks = false
+    # 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
 
-      if string.blank?
+      char = data.getc
+      if char.nil?
         {}
       else
-        LibXML::XML::Parser.string(string.strip).parse.to_hash
+        data.ungetc(char)
+        LibXML::XML::Parser.io(data).parse.to_hash
       end
     end
 
   end
 end
 
-module LibXML
-  module Conversions
-    module Document
+module LibXML #:nodoc:
+  module Conversions #:nodoc:
+    module Document #:nodoc:
       def to_hash
         root.to_hash
       end
     end
 
-    module Node
-      CONTENT_ROOT = '__content__'
-      LIB_XML_LIMIT = 30000000 # Hardcoded LibXML limit
+    module Node #:nodoc:
+      CONTENT_ROOT = '__content__'.freeze
 
       # Convert XML document to hash
       #
       # hash::
       #   Hash to merge the converted element into.
       def to_hash(hash={})
-        if text?
-          raise LibXML::XML::Error if content.length >= LIB_XML_LIMIT
-          hash[CONTENT_ROOT] = content
-        else
-          sub_hash = insert_name_into_hash(hash, name)
-          attributes_to_hash(sub_hash)
-          if array?
-            children_array_to_hash(sub_hash)
-          elsif yaml?
-            children_yaml_to_hash(sub_hash)
-          else
-            children_to_hash(sub_hash)
-          end
-        end
-        hash
-      end
-
-      protected
-
-        # Insert name into hash
-        #
-        # hash::
-        #   Hash to merge the converted element into.
-        # name::
-        #   name to to merge into hash
-        def insert_name_into_hash(hash, name)
-          sub_hash = {}
-          if hash[name]
-            if !hash[name].kind_of? Array
-              hash[name] = [hash[name]]
-            end
-            hash[name] << sub_hash
-          else
-            hash[name] = sub_hash
-          end
-          sub_hash
-        end
-
-        # Insert children into hash
-        #
-        # hash::
-        #   Hash to merge the children into.
-        def children_to_hash(hash={})
-          each { |child| child.to_hash(hash) }
-          attributes_to_hash(hash)
-          hash
-        end
+        node_hash = {}
 
-        # Convert xml attributes to hash
-        #
-        # hash::
-        #   Hash to merge the attributes into
-        def attributes_to_hash(hash={})
-          each_attr { |attr| hash[attr.name] = attr.value }
-          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
 
-        # Convert array into hash
-        #
-        # hash::
-        #   Hash to merge the array into
-        def children_array_to_hash(hash={})
-          hash[child.name] = map do |child|
-            returning({}) { |sub_hash| child.children_to_hash(sub_hash) }
+        # 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
-          hash
-        end
-
-        # Convert yaml into hash
-        #
-        # hash::
-        #   Hash to merge the yaml into
-        def children_yaml_to_hash(hash = {})
-          hash[CONTENT_ROOT] = content unless content.blank?
-          hash
         end
 
-        # Check if child is of type array
-        def array?
-          child? && child.next? && child.name == child.next.name
+        # Remove content node if it is blank
+        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+          node_hash.delete(CONTENT_ROOT)
         end
 
-        # Check if child is of type yaml
-        def yaml?
-          attributes.collect{|x| x.value}.include?('yaml')
-        end
+        # Handle attributes
+        each_attr { |a| node_hash[a.name] = a.value }
 
+        hash
+      end
     end
   end
 end

data/lib/active_support/xml_mini/libxmlsax.rb

@@ -0,0 +1,85 @@
+require 'libxml'
+require 'active_support/core_ext/object/blank'
+
+# = XmlMini LibXML implementation using a SAX-based parser
+module ActiveSupport
+  module XmlMini_LibXMLSAX
+    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/active_support/xml_mini/nokogiri.rb

@@ -1,64 +1,73 @@
 require 'nokogiri'
+require 'active_support/core_ext/object/blank'
 
 # = XmlMini Nokogiri implementation
 module ActiveSupport
   module XmlMini_Nokogiri #:nodoc:
     extend self
 
-    # Parse an XML Document string into a simple hash using libxml / nokogiri.
-    # string::
-    #   XML Document string to parse
-    def parse(string)
-      if string.blank?
+    # 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
-        doc = Nokogiri::XML(string) { |cfg| cfg.noblanks }
+        data.ungetc(char)
+        doc = Nokogiri::XML(data)
         raise doc.errors.first if doc.errors.length > 0
         doc.to_hash
       end
     end
 
-    module Conversions
-      module Document
+    module Conversions #:nodoc:
+      module Document #:nodoc:
         def to_hash
           root.to_hash
         end
       end
 
-      module Node
-        CONTENT_ROOT = '__content__'
+      module Node #:nodoc:
+        CONTENT_ROOT = '__content__'.freeze
 
         # Convert XML document to hash
         #
         # hash::
         #   Hash to merge the converted element into.
-        def to_hash(hash = {})
-          attributes = attributes_as_hash
-          if hash[name]
-            hash[name] = [hash[name]].flatten
-            hash[name] << attributes
-          else
-            hash[name] ||= attributes
-          end
+        def to_hash(hash={})
+          node_hash = {}
 
-          children.each { |child|
-            next if child.blank? && 'file' != self['type']
+          # 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
 
-            if child.text? || child.cdata?
-              (attributes[CONTENT_ROOT] ||= '') << child.content
-              next
+          # 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
 
-            child.to_hash attributes
-          }
+          # 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
 
-          hash
-        end
+          # Handle attributes
+          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
 
-        def attributes_as_hash
-          Hash[*(attribute_nodes.map { |node|
-            [node.node_name, node.value]
-          }.flatten)]
+          hash
         end
       end
     end

data/lib/active_support/xml_mini/nokogirisax.rb

@@ -0,0 +1,83 @@
+require 'nokogiri'
+require 'active_support/core_ext/object/blank'
+
+# = XmlMini Nokogiri implementation using a SAX-based parser
+module ActiveSupport
+  module XmlMini_NokogiriSAX
+    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 => '' }
+        new_hash[attrs.shift] = attrs.shift while attrs.length > 0
+        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/active_support/xml_mini/rexml.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/object/blank'
+
 # = XmlMini ReXML implementation
 module ActiveSupport
   module XmlMini_REXML #:nodoc:
@@ -5,17 +8,33 @@ module ActiveSupport
 
     CONTENT_KEY = '__content__'.freeze
 
-    # Parse an XML Document string into a simple hash
+    # 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 ActiveSupport
     #
-    # string::
-    #   XML Document string to parse
-    def parse(string)
-      require 'rexml/document' unless defined?(REXML::Document)
-      doc = REXML::Document.new(string)
-      merge_element!({}, doc.root)
+    # 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)
+        else
+          raise REXML::ParseException,
+            "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
     end
 
     private
@@ -48,7 +67,7 @@ module ActiveSupport
       # Merge all the texts of an element into the hash
       #
       # hash::
-      #   Hash to add the converted emement to.
+      #   Hash to add the converted element to.
       # element::
       #   XML element whose texts are to me merged into the hash
       def merge_texts!(hash, element)
@@ -56,7 +75,9 @@ module ActiveSupport
           hash
         else
           # must use value to prevent double-escaping
-          merge!(hash, CONTENT_KEY, element.texts.sum(&:value))
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, CONTENT_KEY, texts)
         end
       end
 

data/lib/active_support/xml_mini.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActiveSupport
   # = XmlMini
   #

data/lib/active_support.rb

@@ -22,38 +22,54 @@
 #++
 
 module ActiveSupport
-  def self.load_all!
-    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom, TimeWithZone]
+  class << self
+    attr_accessor :load_all_hooks
+    def on_load_all(&hook) load_all_hooks << hook end
+    def load_all!; load_all_hooks.each { |hook| hook.call } end
   end
+  self.load_all_hooks = []
 
-  autoload :BacktraceCleaner, 'active_support/backtrace_cleaner'
-  autoload :Base64, 'active_support/base64'
-  autoload :BasicObject, 'active_support/basic_object'
-  autoload :BufferedLogger, 'active_support/buffered_logger'
-  autoload :Cache, 'active_support/cache'
-  autoload :Callbacks, 'active_support/callbacks'
-  autoload :Deprecation, 'active_support/deprecation'
-  autoload :Duration, 'active_support/duration'
-  autoload :Gzip, 'active_support/gzip'
-  autoload :Inflector, 'active_support/inflector'
-  autoload :Memoizable, 'active_support/memoizable'
-  autoload :MessageEncryptor, 'active_support/message_encryptor'
-  autoload :MessageVerifier, 'active_support/message_verifier'
-  autoload :Multibyte, 'active_support/multibyte'
-  autoload :OptionMerger, 'active_support/option_merger'
-  autoload :OrderedHash, 'active_support/ordered_hash'
-  autoload :OrderedOptions, 'active_support/ordered_options'
-  autoload :Rescuable, 'active_support/rescuable'
-  autoload :SecureRandom, 'active_support/secure_random'
-  autoload :StringInquirer, 'active_support/string_inquirer'
-  autoload :TimeWithZone, 'active_support/time_with_zone'
-  autoload :TimeZone, 'active_support/values/time_zone'
-  autoload :XmlMini, 'active_support/xml_mini'
+  on_load_all do
+    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom]
+  end
 end
 
-require 'active_support/vendor'
-require 'active_support/core_ext'
-require 'active_support/dependencies'
-require 'active_support/json'
+require "active_support/dependencies/autoload"
+
+module ActiveSupport
+  extend ActiveSupport::Autoload
+
+  # TODO: Narrow this list down
+  eager_autoload do
+    autoload :BacktraceCleaner
+    autoload :Base64
+    autoload :BasicObject
+    autoload :Benchmarkable
+    autoload :BufferedLogger
+    autoload :Cache
+    autoload :Callbacks
+    autoload :Concern
+    autoload :Configurable
+    autoload :Deprecation
+    autoload :Gzip
+    autoload :Inflector
+    autoload :JSON
+    autoload :Memoizable
+    autoload :MessageEncryptor
+    autoload :MessageVerifier
+    autoload :Multibyte
+    autoload :OptionMerger
+    autoload :OrderedHash
+    autoload :OrderedOptions
+    autoload :Notifications
+    autoload :Rescuable
+    autoload :SecureRandom
+    autoload :StringInquirer
+    autoload :XmlMini
+  end
+
+  autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
+  autoload :TestCase
+end
 
-I18n.load_path << "#{File.dirname(__FILE__)}/active_support/locale/en.yml"
+autoload :I18n, "active_support/i18n"