activesupport 1.3.1 → 1.4.0

data/lib/active_support/core_ext/bigdecimal.rb

@@ -0,0 +1,3 @@
+require 'bigdecimal'
+
+require File.dirname(__FILE__) + '/bigdecimal/formatting.rb'

data/lib/active_support/core_ext/bigdecimal/formatting.rb

@@ -0,0 +1,7 @@
+class BigDecimal #:nodoc:
+  
+  alias :_original_to_s :to_s
+  def to_s(format="F")
+    _original_to_s(format)
+  end
+end

data/lib/active_support/core_ext/class/inheritable_attributes.rb

@@ -107,7 +107,12 @@ class Class # :nodoc:
   private 
     def inherited_with_inheritable_attributes(child)
       inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-      child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
+      
+      new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+        memo.update(key => (value.dup rescue value))
+      end
+      
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
     end
 
     alias inherited_without_inheritable_attributes inherited

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

@@ -7,14 +7,14 @@ module ActiveSupport #:nodoc:
           :short => "%e %b",
           :long  => "%B %e, %Y"
         }
-        
+
         def self.included(klass) #:nodoc:
           klass.send(:alias_method, :to_default_s, :to_s)
           klass.send(:alias_method, :to_s, :to_formatted_s)
         end
-        
+
         def to_formatted_s(format = :default)
-          DATE_FORMATS[format] ? strftime(DATE_FORMATS[format]).strip : to_default_s   
+          DATE_FORMATS[format] ? strftime(DATE_FORMATS[format]).strip : to_default_s
         end
 
         # To be able to keep Dates and Times interchangeable on conversions
@@ -23,11 +23,17 @@ module ActiveSupport #:nodoc:
         end
 
         def to_time(form = :local)
-          ::Time.send(form, year, month, day)
+          if respond_to?(:hour)
+            ::Time.send(form, year, month, day, hour, min, sec)
+          else
+            ::Time.send(form, year, month, day)
+          end
+        end
+
+        def xmlschema
+          to_time.xmlschema
         end
-        
-        alias :xmlschema :to_s
       end
     end
   end
-end
+end

data/lib/active_support/core_ext/enumerable.rb

@@ -1,12 +1,4 @@
-module Enumerable #:nodoc:
-  def first_match
-    match = nil
-    each do |items|
-      break if match = yield(items)
-    end
-    match
-  end
-
+module Enumerable
   # Collect an enumerable into sets, grouped by the result of a block. Useful,
   # for example, for grouping records by date.
   #
@@ -27,5 +19,44 @@ module Enumerable #:nodoc:
       (groups[yield(element)] ||= []) << element
       groups
     end
-  end 
+  end if RUBY_VERSION < '1.9'
+
+  # Calculates a sum from the elements. Examples:
+  #
+  #  payments.sum { |p| p.price * p.tax_rate }
+  #  payments.sum(&:price)
+  #
+  # This is instead of payments.inject { |sum, p| sum + p.price }
+  #
+  # Also calculates sums without the use of a block:
+  #   [5, 15, 10].sum # => 30
+  #
+  # The default identity (sum of an empty list) is zero. 
+  # However, you can override this default:
+  #
+  # [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  #
+  def sum(identity = 0, &block)
+    return identity unless size > 0
+    if block_given?
+      map(&block).sum
+    else
+      inject { |sum, element| sum + element }
+    end
+  end
+
+  # Convert an enumerable to a hash. Examples:
+  # 
+  #   people.index_by(&:login)
+  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
+  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  # 
+  def index_by
+    inject({}) do |accum, elem|
+      accum[yield(elem)] = elem
+      accum
+    end
+  end
+  
 end

data/lib/active_support/core_ext/exception.rb

@@ -28,6 +28,6 @@ class Exception # :nodoc:
   end
   
   def framework_backtrace
-    clean_backtrace.select {|line| line =~ FrameworkRegexp}
+    clean_backtrace.grep FrameworkRegexp
   end
-end
+end

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

@@ -1,42 +1,153 @@
+require 'date'
+require 'xml_simple'
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
       module Conversions
         XML_TYPE_NAMES = {
           "Fixnum"     => "integer",
+          "Bignum"     => "integer",
+          "BigDecimal" => "numeric",
+          "Float"      => "float",
           "Date"       => "date",
+          "DateTime"   => "datetime",
           "Time"       => "datetime",
           "TrueClass"  => "boolean",
           "FalseClass" => "boolean"
-        }
-        
+        } unless defined? XML_TYPE_NAMES
+
         XML_FORMATTING = {
           "date"     => Proc.new { |date| date.to_s(:db) },
-          "datetime" => Proc.new { |time| time.xmlschema }
-        }
-        
+          "datetime" => Proc.new { |time| time.xmlschema },
+          "binary"   => Proc.new { |binary| Base64.encode64(binary) }
+        } unless defined? XML_FORMATTING
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
         def to_xml(options = {})
           options[:indent] ||= 2
-          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]), :root => "hash" })
+          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
+                                   :root => "hash" })
           options[:builder].instruct! unless options.delete(:skip_instruct)
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
 
-          options[:builder].__send__(options[:root].to_s.dasherize) do
+          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
-                  type_name = XML_TYPE_NAMES[value.class.to_s]
+                  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]
+
+                    key = dasherize ? key.to_s.dasherize : key.to_s
 
-                  options[:builder].tag!(key.to_s.dasherize, 
-                    XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
-                    options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
-                  )
+                    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
           end
+
+        end
+
+        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(xml,
+              'forcearray'   => false,
+              'forcecontent' => true,
+              'keeproot'     => true,
+              'contentkey'   => '__content__')
+            ))            
+          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
+                    end
+                  else
+                    (value.blank? || value['type'] || value['nil'] == 'true') ? nil : value.inject({}) do |h,(k,v)|
+                      h[k] = typecast_xml_value(v)
+                      h
+                    end
+                  end
+                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"
+                  value
+                else
+                  raise "can't typecast #{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"
+                  params.inject({}) do |h,(k,v)|
+                    h[k.to_s.tr("-", "_")] = undasherize_keys(v)
+                    h
+                  end
+                when "Array"
+                  params.map { |v| undasherize_keys(v) }
+                else
+                  params
+              end
+            end
         end
       end
     end

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

@@ -10,14 +10,18 @@ class HashWithIndifferentAccess < Hash
       super(constructor)
     end
   end
- 
-  def default(key)
-    self[key.to_s] if key.is_a?(Symbol)
-  end  
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
 
   alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
   alias_method :regular_update, :update unless method_defined?(:regular_update)
-  
+
   def []=(key, value)
     regular_writer(convert_key(key), convert_value(value))
   end
@@ -26,7 +30,7 @@ class HashWithIndifferentAccess < Hash
     other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
     self
   end
-  
+
   alias_method :merge!, :update
 
   def key?(key)
@@ -48,7 +52,7 @@ class HashWithIndifferentAccess < Hash
   def dup
     HashWithIndifferentAccess.new(self)
   end
-  
+
   def merge(hash)
     self.dup.update(hash)
   end
@@ -56,7 +60,10 @@ class HashWithIndifferentAccess < Hash
   def delete(key)
     super(convert_key(key))
   end
-    
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+
   protected
     def convert_key(key)
       key.kind_of?(Symbol) ? key.to_s : key
@@ -71,7 +78,9 @@ module ActiveSupport #:nodoc:
     module Hash #:nodoc:
       module IndifferentAccess #:nodoc:
         def with_indifferent_access
-          HashWithIndifferentAccess.new(self)
+          hash = HashWithIndifferentAccess.new(self)
+          hash.default = self.default
+          hash
         end
       end
     end

data/lib/active_support/core_ext/integer/inflections.rb

@@ -1,11 +1,17 @@
-require File.dirname(__FILE__) + '/../../inflector' unless defined? Inflector
+require 'active_support/inflector'
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Integer #:nodoc:
       module Inflections
-        # 1.ordinalize  # => "1st"
-        # 3.ordinalize  # => "3rd"
-        # 10.ordinalize # => "10th"
+        # Ordinalize turns a number into an ordinal string used to denote the
+        # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+        #
+        # Examples
+        #   1.ordinalize    # => "1st"
+        #   2.ordinalize    # => "2nd"
+        #   1002.ordinalize # => "1002nd"
+        #   1003.ordinalize # => "1003rd"
         def ordinalize
           Inflector.ordinalize(self)
         end

data/lib/active_support/core_ext/load_error.rb

@@ -8,7 +8,7 @@ class MissingSourceFile < LoadError #:nodoc:
   def is_missing?(path)
     path.gsub(/\.rb$/, '') == self.path.gsub(/\.rb$/, '')
   end
-  
+
   def self.from_message(message)
     REGEXPS.each do |regexp, capture|
       match = regexp.match(message)
@@ -16,12 +16,12 @@ class MissingSourceFile < LoadError #:nodoc:
     end
     nil
   end
-  
+
   REGEXPS = [
     [/^no such file to load -- (.+)$/i, 1],
     [/^Missing \w+ (file\s*)?([^\s]+.rb)$/i, 2],
     [/^Missing API definition file in (.+)$/i, 1]
-  ]
+  ] unless defined?(REGEXPS)
 end
 
 module ActiveSupport #:nodoc:

data/lib/active_support/core_ext/module.rb

@@ -1,5 +1,7 @@
 require File.dirname(__FILE__) + '/module/inclusion'
 require File.dirname(__FILE__) + '/module/attribute_accessors'
+require File.dirname(__FILE__) + '/module/attr_internal'
 require File.dirname(__FILE__) + '/module/delegation'
 require File.dirname(__FILE__) + '/module/introspection'
 require File.dirname(__FILE__) + '/module/loading'
+require File.dirname(__FILE__) + '/module/aliasing'

data/lib/active_support/core_ext/module/aliasing.rb

@@ -0,0 +1,58 @@
+class Module
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  #
+  # Query and bang methods (foo?, foo!) keep the same punctuation:
+  #
+  #   alias_method_chain :foo?, :feature
+  #
+  # is equivalent to
+  #
+  #   alias_method :foo_without_feature?, :foo?
+  #   alias_method :foo?, :foo_with_feature?
+  #
+  # so you can safely chain foo, foo?, and foo! with the same feature.
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+  end
+
+  # Allows you to make aliases for attributes, which includes 
+  # getter, setter, and query methods.
+  #
+  # Example:
+  #
+  #   class Content < ActiveRecord::Base
+  #     # has a title attribute
+  #   end
+  #
+  #   class Email < ActiveRecord::Base
+  #     alias_attribute :subject, :title
+  #   end
+  #
+  #   e = Email.find(1)
+  #   e.title    # => "Superstars"
+  #   e.subject  # => "Superstars"
+  #   e.subject? # => true
+  #   e.subject = "Megastars"
+  #   e.title    # => "Megastars"
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__+1
+      def #{new_name}; #{old_name}; end
+      def #{new_name}?; #{old_name}?; end
+      def #{new_name}=(v); self.#{old_name} = v; end
+    STR
+  end
+end