activesupport 1.4.4 → 2.0.0

data/lib/active_support/core_ext/duplicable.rb

@@ -0,0 +1,37 @@
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, and numbers; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end

data/lib/active_support/core_ext/enumerable.rb

@@ -38,6 +38,7 @@ module Enumerable
   #
   def sum(identity = 0, &block)
     return identity unless size > 0
+
     if block_given?
       map(&block).sum
     else

data/lib/active_support/core_ext/exception.rb

@@ -8,8 +8,8 @@ class Exception # :nodoc:
   
   def clean_backtrace
     backtrace.collect do |line|
-      Pathname.clean_within(TraceSubstitutions.inject(line) do |line, (regexp, sub)|
-        line.gsub regexp, sub
+      Pathname.clean_within(TraceSubstitutions.inject(line) do |result, (regexp, sub)|
+        result.gsub regexp, sub
       end)
     end
   end

data/lib/active_support/core_ext/file.rb

@@ -0,0 +1,21 @@
+require 'tempfile'
+
+# Write to a file atomically.  Useful for situations where you don't
+# want other processes or threads to see half-written files.
+#
+#  File.atomic_write("important.file") do |file|
+#    file.write("hello")
+#  end
+#
+# If your temp directory is not on the same filesystem as the file you're 
+# trying to write, you can provide a different temporary directory.
+# 
+# File.atomic_write("/data/something.imporant", "/data/tmp") do |f|
+#   file.write("hello")
+# end
+def File.atomic_write(file_name, temp_dir = Dir.tmpdir)
+  temp_file = Tempfile.new(File.basename(file_name), temp_dir)
+  yield temp_file
+  temp_file.close
+  File.rename(temp_file.path, file_name)
+end

data/lib/active_support/core_ext/float.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/float/rounding'
+
+class Float #:nodoc:
+  include ActiveSupport::CoreExtensions::Float::Rounding
+end

data/lib/active_support/core_ext/float/rounding.rb

@@ -0,0 +1,24 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Float #:nodoc:
+      module Rounding
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method :round_without_precision, :round
+            alias_method :round, :round_with_precision
+          end
+        end
+
+        # Rounds the float with the specified precision.
+        #
+        #   x = 1.337
+        #   x.round    # => 1
+        #   x.round(1) # => 1.3
+        #   x.round(2) # => 1.34
+        def round_with_precision(precision = nil)
+          precision.nil? ? round_without_precision : (self * (10 ** precision)).round / (10 ** precision).to_f
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/hash.rb

@@ -1,8 +1,6 @@
-require File.dirname(__FILE__) + '/hash/keys'
-require File.dirname(__FILE__) + '/hash/indifferent_access'
-require File.dirname(__FILE__) + '/hash/reverse_merge'
-require File.dirname(__FILE__) + '/hash/conversions'
-require File.dirname(__FILE__) + '/hash/diff'
+%w(keys indifferent_access reverse_merge conversions diff slice except).each do |ext|
+  require "active_support/core_ext/hash/#{ext}"
+end
 
 class Hash #:nodoc:
   include ActiveSupport::CoreExtensions::Hash::Keys
@@ -10,4 +8,6 @@ class Hash #:nodoc:
   include ActiveSupport::CoreExtensions::Hash::ReverseMerge
   include ActiveSupport::CoreExtensions::Hash::Conversions
   include ActiveSupport::CoreExtensions::Hash::Diff
+  include ActiveSupport::CoreExtensions::Hash::Slice
+  include ActiveSupport::CoreExtensions::Hash::Except
 end

data/lib/active_support/core_ext/hash/conversions.rb

@@ -1,7 +1,9 @@
 require 'date'
-require 'xml_simple'
 require 'cgi'
- 
+require 'base64'
+require 'builder'
+require 'xmlsimple'
+
 # Extensions needed for Hash#to_query
 class Object
   def to_param #:nodoc:
@@ -15,7 +17,7 @@ end
 
 class Array
   def to_query(key) #:nodoc:
-    collect { |value| value.to_query("#{key}[]") }.sort * '&'
+    collect { |value| value.to_query("#{key}[]") } * '&'
   end
 end
 
@@ -45,22 +47,54 @@ module ActiveSupport #:nodoc:
     module Hash #:nodoc:
       module Conversions
         XML_TYPE_NAMES = {
+          "Symbol"     => "symbol",
           "Fixnum"     => "integer",
           "Bignum"     => "integer",
-          "BigDecimal" => "numeric",
+          "BigDecimal" => "decimal",
           "Float"      => "float",
           "Date"       => "date",
           "DateTime"   => "datetime",
           "Time"       => "datetime",
           "TrueClass"  => "boolean",
           "FalseClass" => "boolean"
-        } unless defined? XML_TYPE_NAMES
+        } unless defined?(XML_TYPE_NAMES)
 
         XML_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) }
-        } unless defined? XML_FORMATTING
+          "binary"   => Proc.new { |binary| Base64.encode64(binary) },
+          "yaml"     => Proc.new { |yaml| yaml.to_yaml }
+        } unless defined?(XML_FORMATTING)
+
+        # TODO: use Time.xmlschema instead of Time.parse;
+        #       use regexp instead of Date.parse
+        unless defined?(XML_PARSING)
+          XML_PARSING = {
+            "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
+            "date"         => Proc.new  { |date|    ::Date.parse(date) },
+            "datetime"     => Proc.new  { |time|    ::Time.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) },
+            # FIXME: Get rid of eval and institute a proper decorator here
+            "file"         => Proc.new do |file, entity|
+              f = StringIO.new(Base64.decode64(file))
+              eval "def f.original_filename() '#{entity["name"]}' || 'untitled' end"
+              eval "def f.content_type()      '#{entity["content_type"]}' || 'application/octet-stream' end"
+              f
+            end
+          }
+
+          XML_PARSING.update(
+            "double"   => XML_PARSING["float"],
+            "dateTime" => XML_PARSING["datetime"]
+          )
+        end
 
         def self.included(klass)
           klass.extend(ClassMethods)
@@ -119,6 +153,8 @@ module ActiveSupport #:nodoc:
                 end
               end
             end
+            
+            yield options[:builder] if block_given?
           end
 
         end
@@ -126,7 +162,7 @@ module ActiveSupport #:nodoc:
         module ClassMethods
           def from_xml(xml)
             # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
-            undasherize_keys(typecast_xml_value(XmlSimple.xml_in_string(xml,
+            typecast_xml_value(undasherize_keys(XmlSimple.xml_in_string(xml,
               'forcearray'   => false,
               'forcecontent' => true,
               'keeproot'     => true,
@@ -134,52 +170,68 @@ module ActiveSupport #:nodoc:
             ))
           end
 
-          def create_from_xml(xml)
-            ActiveSupport::Deprecation.warn("Hash.create_from_xml has been renamed to Hash.from_xml", caller)
-            from_xml(xml)
-          end
-
           private
             def typecast_xml_value(value)
               case value.class.to_s
-                when "Hash"
-                  if value.has_key?("__content__")
-                    content = translate_xml_entities(value["__content__"])
-                    case value["type"]
-                      when "integer"  then content.to_i
-                      when "boolean"  then content.strip == "true"
-                      when "datetime" then ::Time.parse(content).utc
-                      when "date"     then ::Date.parse(content)
-                      else                 content
+                when 'Hash'
+                  if value['type'] == 'array'
+                    child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
+                    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.has_key?("__content__")
+                    content = value["__content__"]
+                    if parser = XML_PARSING[value["type"]]
+                      if parser.arity == 2
+                        XML_PARSING[value["type"]].call(content, value)
+                      else
+                        XML_PARSING[value["type"]].call(content)
+                      end
+                    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
+                  elsif value['type'] && value.size == 1
+                    nil
                   else
-                    (value.blank? || value['type'] || value['nil'] == 'true') ? nil : value.inject({}) do |h,(k,v)|
+                    xml_value = value.inject({}) do |h,(k,v)|
                       h[k] = typecast_xml_value(v)
                       h
                     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"
+                when 'Array'
                   value.map! { |i| typecast_xml_value(i) }
                   case value.length
                     when 0 then nil
                     when 1 then value.first
                     else value
                   end
-                when "String"
+                when 'String'
                   value
                 else
-                  raise "can't typecast #{value.inspect}"
+                  raise "can't typecast #{value.class.name} - #{value.inspect}"
               end
             end
 
-            def translate_xml_entities(value)
-              value.gsub(/&lt;/,   "<").
-                    gsub(/&gt;/,   ">").
-                    gsub(/&quot;/, '"').
-                    gsub(/&apos;/, "'").
-                    gsub(/&amp;/,  "&")
-            end
-
             def undasherize_keys(params)
               case params.class.to_s
                 when "Hash"

data/lib/active_support/core_ext/hash/diff.rb

@@ -2,6 +2,14 @@ module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
       module Diff
+        # Returns a hash that represents the difference between two hashes.
+        #
+        # Examples:
+        #
+        #   {1 => 2}.diff(1 => 2)         # => {}
+        #   {1 => 2}.diff(1 => 3)         # => {1 => 2}
+        #   {}.diff(1 => 2)               # => {1 => 2}
+        #   {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
         def diff(h2)
           self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) })
         end

data/lib/active_support/core_ext/hash/except.rb

@@ -0,0 +1,24 @@
+require 'set'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # Return a hash that includes everything but the given keys. This is useful for
+      # limiting a set of parameters to everything but a few known toggles:
+      #
+      #   @person.update_attributes(params[:person].except(:admin))
+      module Except
+        # Returns a new hash without the given keys.
+        def except(*keys)
+          rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+          reject { |key,| rejected.include?(key) }
+        end
+
+        # Replaces the hash without only the given keys.
+        def except!(*keys)
+          replace(except(*keys))
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -1,4 +1,4 @@
-# this class has dubious semantics and we only have it so that
+# This class has dubious semantics and we only have it so that
 # people can write params[:key] instead of params['key']
 
 class HashWithIndifferentAccess < Hash
@@ -64,12 +64,25 @@ class HashWithIndifferentAccess < Hash
   def stringify_keys!; self end
   def symbolize_keys!; self end
 
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
   protected
     def convert_key(key)
       key.kind_of?(Symbol) ? key.to_s : key
     end
+
     def convert_value(value)
-      value.is_a?(Hash) ? value.with_indifferent_access : value
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
     end
 end
 

data/lib/active_support/core_ext/hash/keys.rb

@@ -24,7 +24,7 @@ module ActiveSupport #:nodoc:
         # Return a new hash with all keys converted to symbols.
         def symbolize_keys
           inject({}) do |options, (key, value)|
-            options[key.to_sym] = value
+            options[key.to_sym || key] = value
             options
           end
         end
@@ -32,8 +32,8 @@ module ActiveSupport #:nodoc:
         # Destructively convert all keys to symbols.
         def symbolize_keys!
           keys.each do |key|
-            unless key.is_a?(Symbol)
-              self[key.to_sym] = self[key]
+            unless key.is_a?(Symbol) || (new_key = key.to_sym).nil?
+              self[new_key] = self[key]
               delete(key)
             end
           end
@@ -43,6 +43,13 @@ module ActiveSupport #:nodoc:
         alias_method :to_options,  :symbolize_keys
         alias_method :to_options!, :symbolize_keys!
 
+        # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+        # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbol
+        # as keys, this will fail.
+        # examples:
+        #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): years, name"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
         def assert_valid_keys(*valid_keys)
           unknown_keys = keys - [valid_keys].flatten
           raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?

data/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -18,8 +18,8 @@ module ActiveSupport #:nodoc:
           replace(reverse_merge(other_hash))
         end
 
-        alias_method :reverse_update, :reverse_merge
+        alias_method :reverse_update, :reverse_merge!
       end
     end
   end
-end
+end

data/lib/active_support/core_ext/hash/slice.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # Slice a hash to include only the given keys. This is useful for
+      # limiting an options hash to valid keys before passing to a method:
+      #
+      #   def search(criteria = {})
+      #     assert_valid_keys(:mass, :velocity, :time)
+      #   end
+      #
+      #   search(options.slice(:mass, :velocity, :time))
+      module Slice
+        # Returns a new hash with only the given keys.
+        def slice(*keys)
+          allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+          reject { |key,| !allowed.include?(key) }
+        end
+
+        # Replaces the hash with only the given keys.
+        def slice!(*keys)
+          replace(slice(*keys))
+        end
+      end
+    end
+  end
+end