activesupport 3.0.0.beta4 → 3.0.pre

data/lib/active_support/version.rb

@@ -2,9 +2,8 @@ module ActiveSupport
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 0
-    BUILD = "beta4"
+    TINY  = "pre"
 
-    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
+    STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/lib/active_support/whiny_nil.rb

@@ -11,7 +11,7 @@
 # classes in NilClass::WHINERS the error message suggests which could be the
 # actual intended class:
 #
-#   $ rails runner nil.destroy
+#   $ script/runner nil.destroy 
 #   ...
 #   You might have expected an instance of ActiveRecord::Base.
 #   ...
@@ -25,16 +25,17 @@
 # By default it is on in development and test modes, and it is off in production
 # mode.
 class NilClass
+  WHINERS = [::Array]
+  WHINERS << ::ActiveRecord::Base if defined? ::ActiveRecord
+
   METHOD_CLASS_MAP = Hash.new
 
-  def self.add_whiner(klass)
+  WHINERS.each do |klass|
     methods = klass.public_instance_methods - public_instance_methods
     class_name = klass.name
     methods.each { |method| METHOD_CLASS_MAP[method.to_sym] = class_name }
   end
 
-  add_whiner ::Array
-
   # Raises a RuntimeError when you attempt to call +id+ on +nil+.
   def id
     raise RuntimeError, "Called id for nil, which would mistakenly be 4 -- if you really wanted the id of nil, use object_id", caller
@@ -42,11 +43,7 @@ class NilClass
 
   private
     def method_missing(method, *args, &block)
-      if klass = METHOD_CLASS_MAP[method]
-        raise_nil_warning_for klass, method, caller
-      else
-        super
-      end
+      raise_nil_warning_for METHOD_CLASS_MAP[method], method, caller
     end
 
     # Raises a NoMethodError when you attempt to call a method on +nil+.
@@ -58,3 +55,4 @@ class NilClass
       raise NoMethodError, message, with_caller || caller
     end
 end
+

data/lib/active_support/xml_mini.rb

@@ -9,71 +9,6 @@ module ActiveSupport
   module XmlMini
     extend self
 
-    # This module exists to decorate 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?(TYPE_NAMES)
-
-    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| ActiveSupport::Base64.encode64(binary) },
-      "yaml"     => Proc.new { |yaml| yaml.to_yaml }
-    } unless defined?(FORMATTING)
-
-    # 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(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|     ActiveSupport::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
     delegate :parse, :to => :backend
 
@@ -81,7 +16,7 @@ module ActiveSupport
       if name.is_a?(Module)
         @backend = name
       else
-        require "active_support/xml_mini/#{name.to_s.downcase}"
+        require "active_support/xml_mini/#{name.to_s.downcase}.rb"
         @backend = ActiveSupport.const_get("XmlMini_#{name}")
       end
     end
@@ -92,66 +27,6 @@ module ActiveSupport
     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
-
-        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.has_key?(:camelize) && options[:camelize]
-      dasherize = !options.has_key?(:dasherize) || options[:dasherize]
-      key = key.camelize  if camelize
-      key = key.dasherize if dasherize
-      key
-    end
-
-    protected
-
-	  # TODO: Add support for other encodings
-    def _parse_binary(bin, entity) #:nodoc:
-      case entity['encoding']
-      when 'base64'
-        ActiveSupport::Base64.decode64(bin)
-      else
-        bin
-      end
-    end
-
-    def _parse_file(file, entity)
-      f = StringIO.new(ActiveSupport::Base64.decode64(file))
-      f.extend(FileLike)
-      f.original_filename = entity['name']
-      f.content_type = entity['content_type']
-      f
-    end
   end
 
   XmlMini.backend = 'REXML'

data/lib/active_support/xml_mini/jdom.rb

@@ -3,8 +3,6 @@ raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFO
 require 'jruby'
 include Java
 
-require 'active_support/core_ext/object/blank'
-
 import javax.xml.parsers.DocumentBuilder unless defined? DocumentBuilder
 import javax.xml.parsers.DocumentBuilderFactory unless defined? DocumentBuilderFactory
 import java.io.StringReader unless defined? StringReader

data/lib/active_support/xml_mini/libxml.rb

@@ -1,6 +1,4 @@
 require 'libxml'
-require 'active_support/core_ext/object/returning'
-require 'active_support/core_ext/object/blank'
 
 # = XmlMini LibXML implementation
 module ActiveSupport
@@ -14,7 +12,7 @@ module ActiveSupport
       if !data.respond_to?(:read)
         data = StringIO.new(data || '')
       end
-
+      
       char = data.getc
       if char.nil?
         {}
@@ -36,42 +34,106 @@ module LibXML #:nodoc:
     end
 
     module Node #:nodoc:
-      CONTENT_ROOT = '__content__'.freeze
+      CONTENT_ROOT = '__content__'
+      LIB_XML_LIMIT = 30000000 # Hardcoded LibXML limit
 
       # Convert XML document to hash
       #
       # hash::
       #   Hash to merge the converted element into.
       def to_hash(hash={})
-        node_hash = {}
+        if text? || cdata?
+          raise LibXML::XML::Error if hash[CONTENT_ROOT].to_s.length + content.length >= LIB_XML_LIMIT
+          hash[CONTENT_ROOT] = hash[CONTENT_ROOT].to_s + 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
 
-        # 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
+      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
 
-        # 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
+        # Insert children into hash
+        #
+        # hash::
+        #   Hash to merge the children into.
+        def children_to_hash(hash={})
+          each { |child| child.to_hash(hash) }
+
+          if hash.length > 1 && hash[CONTENT_ROOT].blank?
+            hash.delete(CONTENT_ROOT)
           end
+
+          attributes_to_hash(hash)
+          hash
         end
 
-        # Remove content node if it is blank
-        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
-          node_hash.delete(CONTENT_ROOT)
+        # 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
         end
 
-        # Handle attributes
-        each_attr { |a| node_hash[a.name] = a.value }
+        # 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) }
+          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
+        end
+
+        # Check if child is of type yaml
+        def yaml?
+          attributes.collect{|x| x.value}.include?('yaml')
+        end
 
-        hash
-      end
     end
   end
 end

data/lib/active_support/xml_mini/nokogiri.rb

@@ -1,5 +1,4 @@
 require 'nokogiri'
-require 'active_support/core_ext/object/blank'
 
 # = XmlMini Nokogiri implementation
 module ActiveSupport
@@ -13,13 +12,13 @@ module ActiveSupport
       if !data.respond_to?(:read)
         data = StringIO.new(data || '')
       end
-
+      
       char = data.getc
       if char.nil?
         {}
       else
         data.ungetc(char)
-        doc = Nokogiri::XML(data)
+        doc = Nokogiri::XML(data) { |cfg| cfg.noblanks }
         raise doc.errors.first if doc.errors.length > 0
         doc.to_hash
       end
@@ -33,42 +32,40 @@ module ActiveSupport
       end
 
       module Node #:nodoc:
-        CONTENT_ROOT = '__content__'.freeze
+        CONTENT_ROOT = '__content__'
 
         # 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
+        def to_hash(hash = {})
+          attributes = attributes_as_hash
+          if hash[name]
+            hash[name] = [hash[name]].flatten
+            hash[name] << attributes
+          else
+            hash[name] ||= attributes
           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
+          children.each { |child|
+            next if child.blank? && 'file' != self['type']
 
-          # 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
+            if child.text? || child.cdata?
+              (attributes[CONTENT_ROOT] ||= '') << child.content
+              next
+            end
 
-          # Handle attributes
-          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+            child.to_hash attributes
+          }
 
           hash
         end
+
+        def attributes_as_hash
+          Hash[*(attribute_nodes.map { |node|
+            [node.node_name, node.value]
+          }.flatten)]
+        end
       end
     end
 

data/lib/active_support/xml_mini/rexml.rb

@@ -27,13 +27,7 @@ module ActiveSupport
         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
+        merge_element!({}, doc.root)
       end
     end