activesupport 3.0.0.beta4 → 3.0.pre

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

@@ -1,6 +1,6 @@
-require 'date'
 require 'active_support/inflector'
-require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date_time/conversions'
 
 class Date
   DATE_FORMATS = {

data/lib/active_support/core_ext/date_time.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date_time/acts_like'
+require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/date_time/zones'

data/lib/active_support/core_ext/date_time/calculations.rb

@@ -1,5 +1,4 @@
-require 'rational' unless RUBY_VERSION >= '1.9.2'
-require 'active_support/core_ext/object/acts_like'
+require 'rational'
 
 class DateTime
   class << self

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

@@ -1,6 +1,4 @@
 require 'active_support/inflector'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/date_time/calculations'
 
 class DateTime
   # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows
@@ -60,7 +58,7 @@ class DateTime
   # Converts self to a Ruby Date object; time portion is discarded
   def to_date
     ::Date.new(year, month, day)
-  end unless instance_methods(false).include?(:to_date)
+  end unless method_defined?(:to_date)
 
   # Attempts to convert self to a Ruby Time object; returns self if out of range of Ruby Time class
   # If self has an offset other than 0, self will just be returned unaltered, since there's no clean way to map it to a Time
@@ -71,32 +69,16 @@ class DateTime
   # To be able to keep Times, Dates and DateTimes interchangeable on conversions
   def to_datetime
     self
-  end unless instance_methods(false).include?(:to_datetime)
-
-  def self.civil_from_format(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0)
-    offset = utc_or_local.to_sym == :local ? local_offset : 0
-    civil(year, month, day, hour, min, sec, offset)
-  end
+  end unless method_defined?(:to_datetime)
 
   # Converts datetime to an appropriate format for use in XML
   def xmlschema
     strftime("%Y-%m-%dT%H:%M:%S%Z")
-  end unless instance_methods(false).include?(:xmlschema)
+  end unless method_defined?(:xmlschema)
   
   # Converts self to a floating-point number of seconds since the Unix epoch 
   def to_f
-    seconds_since_unix_epoch.to_f
-  end
-
-  # Converts self to an integer number of seconds since the Unix epoch
-  def to_i
-    seconds_since_unix_epoch.to_i
-  end
-
-  private
-
-  def seconds_since_unix_epoch
-    seconds_per_day = 86_400
-    (self - ::DateTime.civil(1970)) * seconds_per_day
+    days_since_unix_epoch = self - ::DateTime.civil(1970)
+    (days_since_unix_epoch * 86_400).to_f
   end
 end

data/lib/active_support/core_ext/enumerable.rb

@@ -101,11 +101,15 @@ module Enumerable
     size = block_given? ? select(&block).size : self.size
     size > 1
   end
-  
-  # The negative of the Enumerable#include?. Returns true if the collection does not include the object.
-  def exclude?(object)
-    !include?(object)
-  end
+
+  # Returns true if none of the elements match the given block.
+  #
+  #   success = responses.none? {|r| r.status / 100 == 5 }
+  #
+  # This is a builtin method in Ruby 1.8.7 and later.
+  def none?(&block)
+    !any?(&block)
+  end unless [].respond_to?(:none?)
 end
 
 class Range #:nodoc:

data/lib/active_support/core_ext/exception.rb

@@ -1,3 +1,50 @@
 module ActiveSupport
   FrozenObjectError = RUBY_VERSION < '1.9' ? TypeError : RuntimeError
 end
+
+# TODO: Turn all this into using the BacktraceCleaner.
+class Exception # :nodoc:
+  # Clean the paths contained in the message.
+  def self.clean_paths(string)
+    require 'pathname' unless defined? Pathname
+    string.gsub(%r{[\w. ]+(/[\w. ]+)+(\.rb)?(\b|$)}) do |path|
+      Pathname.new(path).cleanpath
+    end
+  end
+
+  def clean_message
+    Exception.clean_paths(message)
+  end
+
+  TraceSubstitutions = []
+  FrameworkStart = /action_controller\/dispatcher\.rb/.freeze
+  FrameworkRegexp = /generated|vendor|dispatch|ruby|script\/\w+/.freeze
+
+  def clean_backtrace
+    backtrace.collect do |line|
+      substituted = TraceSubstitutions.inject(line) do |result, (regexp, sub)|
+        result.gsub regexp, sub
+      end
+      Exception.clean_paths(substituted)
+    end
+  end
+
+  def application_backtrace
+    before_framework_frame = nil
+    before_application_frame = true
+
+    trace = clean_backtrace.reject do |line|
+      before_framework_frame ||= (line =~ FrameworkStart)
+      non_app_frame = (line =~ FrameworkRegexp)
+      before_application_frame = false unless non_app_frame
+      before_framework_frame || (non_app_frame && !before_application_frame)
+    end
+
+    # If we didn't find any application frames, return an empty app trace.
+    before_application_frame ? [] : trace
+  end
+
+  def framework_backtrace
+    clean_backtrace.grep FrameworkRegexp
+  end
+end

data/lib/active_support/core_ext/file.rb

@@ -1,2 +1 @@
 require 'active_support/core_ext/file/atomic'
-require 'active_support/core_ext/file/path'

data/lib/active_support/core_ext/file/atomic.rb

@@ -9,12 +9,11 @@ class File
   # 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.important", "/data/tmp") do |file|
+  #   File.atomic_write("/data/something.important", "/data/tmp") do |f|
   #     file.write("hello")
   #   end
   def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
     require 'tempfile' unless defined?(Tempfile)
-    require 'fileutils' unless defined?(FileUtils)
 
     temp_file = Tempfile.new(basename(file_name), temp_dir)
     yield temp_file
@@ -32,7 +31,7 @@ class File
     end
 
     # Overwrite original file with temp file
-    FileUtils.mv(temp_file.path, file_name)
+    rename(temp_file.path, file_name)
 
     # Set correct permissions on new file
     chown(old_stat.uid, old_stat.gid, file_name)

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

@@ -1,6 +1,5 @@
 class Float
-  alias precisionless_round round
-  private :precisionless_round
+  remove_method :round
 
   # Rounds the float with the specified precision.
   #
@@ -13,7 +12,7 @@ class Float
       magnitude = 10.0 ** precision
       (self * magnitude).round / magnitude
     else
-      precisionless_round
+      super()
     end
   end
 end

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

@@ -1,76 +1,148 @@
-require 'active_support/xml_mini'
 require 'active_support/time'
-require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/string/inflections'
 
 class Hash
-  # Returns a string containing an XML representation of its receiver:
-  # 
-  #   {"foo" => 1, "bar" => 2}.to_xml
-  #   # =>
-  #   # <?xml version="1.0" encoding="UTF-8"?>
-  #   # <hash>
-  #   #   <foo type="integer">1</foo>
-  #   #   <bar type="integer">2</bar>
-  #   # </hash>
-  # 
-  # To do so, the method loops over the pairs and builds nodes that depend on
-  # the _values_. Given a pair +key+, +value+:
-  # 
-  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
-  # 
-  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
-  #   and +key+ singularized as <tt>:children</tt>.
-  # 
-  # * If +value+ is a callable object it must expect one or two arguments. Depending
-  #   on the arity, the callable is invoked with the +options+ hash as first argument
-  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. Its
-  #   return value becomes a new node.
-  # 
-  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
-  # 
-  # * Otherwise, a node with +key+ as tag is created with a string representation of
-  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
-  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
-  #   added as well according to the following mapping:
+  # 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
+
+  XML_TYPE_NAMES = {
+    "Symbol"     => "symbol",
+    "Fixnum"     => "integer",
+    "Bignum"     => "integer",
+    "BigDecimal" => "decimal",
+    "Float"      => "float",
+    "TrueClass"  => "boolean",
+    "FalseClass" => "boolean",
+    "Date"       => "date",
+    "DateTime"   => "datetime",
+    "Time"       => "datetime"
+  } 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| ActiveSupport::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 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) },
+      "file"         => Proc.new do |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
+    }
+
+    XML_PARSING.update(
+      "double"   => XML_PARSING["float"],
+      "dateTime" => XML_PARSING["datetime"]
+    )
+  end
+
+  # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
+  # passed to enclose the param names (see example below).
   #
-  #     XML_TYPE_NAMES = {
-  #       "Symbol"     => "symbol",
-  #       "Fixnum"     => "integer",
-  #       "Bignum"     => "integer",
-  #       "BigDecimal" => "decimal",
-  #       "Float"      => "float",
-  #       "TrueClass"  => "boolean",
-  #       "FalseClass" => "boolean",
-  #       "Date"       => "date",
-  #       "DateTime"   => "datetime",
-  #       "Time"       => "datetime"
-  #     }
-  # 
-  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
-  # 
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
-  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
-  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
+  # ==== Examples
+  #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
+  #
+  #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+  def to_query(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort * '&'
+  end
+  
+  alias_method :to_param, :to_query
+
   def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
+    require 'builder' unless defined?(Builder)
 
     options = options.dup
-    options[:indent]  ||= 2
-    options[:root]    ||= "hash"
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    options[:indent] ||= 2
+    options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
+                             :root => "hash" })
+    options[:builder].instruct! unless options.delete(:skip_instruct)
+    root = rename_key(options[:root].to_s, options)
 
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
+    options[:builder].__send__(:method_missing, root) do
+      each do |key, value|
+        case value
+          when ::Hash
+            value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+          when ::Array
+            value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
+          when ::Method, ::Proc
+            # If the Method or Proc takes two arguments, then
+            # pass the suggested child element name.  This is
+            # used if the Method or Proc will be operating over
+            # multiple records and needs to create an containing
+            # element that will contain the objects being
+            # serialized.
+            if 1 == value.arity
+              value.call(options.merge({ :root => key, :skip_instruct => true }))
+            else
+              value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
+            end
+          else
+            if value.respond_to?(:to_xml)
+              value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+            else
+              type_name = XML_TYPE_NAMES[value.class.name]
 
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
+              key = rename_key(key.to_s, options)
 
-    builder.__send__(:method_missing, root) do
-      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
-      yield builder if block_given?
+              attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
+              if value.nil?
+                attributes[:nil] = true
+              end
+
+              options[:builder].tag!(key,
+                XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
+                attributes
+              )
+            end
+        end
+      end
+      
+      yield options[:builder] if block_given?
     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
+    dasherize ? key.dasherize : key
   end
 
   class << self
@@ -83,7 +155,7 @@ class Hash
         case value.class.to_s
           when 'Hash'
             if value['type'] == 'array'
-              child_key, entries = Array.wrap(value.detect { |k,v| k != 'type' })   # child_key is throwaway
+              child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
               if entries.nil? || (c = value['__content__'] && c.blank?)
                 []
               else
@@ -98,8 +170,12 @@ class Hash
               end
             elsif value.has_key?("__content__")
               content = value["__content__"]
-              if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
-                parser.arity == 1 ? parser.call(content) : parser.call(content, value)
+              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
@@ -125,7 +201,11 @@ class Hash
             end
           when 'Array'
             value.map! { |i| typecast_xml_value(i) }
-            value.length > 1 ? value : value.first
+            case value.length
+              when 0 then nil
+              when 1 then value.first
+              else value
+            end
           when 'String'
             value
           else

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

@@ -1,16 +1,17 @@
 class Hash
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   def deep_merge(other_hash)
-    dup.deep_merge!(other_hash)
+    target = dup
+    other_hash.each_pair do |k,v|
+      tv = target[k]
+      target[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+    end
+    target
   end
 
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   # Modifies the receiver in place.
   def deep_merge!(other_hash)
-    other_hash.each_pair do |k,v|
-      tv = self[k]
-      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
-    end
-    self
+    replace(deep_merge(other_hash))
   end
 end