activesupport 2.3.5 → 3.0.0.beta3

data/lib/active_support/core_ext/array/grouping.rb

@@ -1,106 +1,100 @@
 require 'enumerator'
 
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Array #:nodoc:
-      module Grouping
-        # Splits or iterates over the array in groups of size +number+,
-        # padding any remaining slots with +fill_with+ unless it is +false+.
-        # 
-        #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
-        #   ["1", "2", "3"]
-        #   ["4", "5", "6"]
-        #   ["7", nil, nil]
-        #
-        #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
-        #   ["1", "2"]
-        #   ["3", " "]
-        #
-        #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
-        #   ["1", "2"]
-        #   ["3"]
-        def in_groups_of(number, fill_with = nil)
-          if fill_with == false
-            collection = self
-          else
-            # size % number gives how many extra we have;
-            # subtracting from number gives how many to add;
-            # modulo number ensures we don't add group of just fill.
-            padding = (number - size % number) % number
-            collection = dup.concat([fill_with] * padding)
-          end
-
-          if block_given?
-            collection.each_slice(number) { |slice| yield(slice) }
-          else
-            returning [] do |groups|
-              collection.each_slice(number) { |group| groups << group }
-            end
-          end
-        end
+class Array
+  # Splits or iterates over the array in groups of size +number+,
+  # padding any remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5", "6"]
+  #   ["7", nil, nil]
+  #
+  #   %w(1 2 3).in_groups_of(2, '&nbsp;') {|group| p group}
+  #   ["1", "2"]
+  #   ["3", "&nbsp;"]
+  #
+  #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
+  #   ["1", "2"]
+  #   ["3"]
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
 
-        # Splits or iterates over the array in +number+ of groups, padding any
-        # remaining slots with +fill_with+ unless it is +false+.
-        #
-        #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
-        #   ["1", "2", "3", "4"]
-        #   ["5", "6", "7", nil]
-        #   ["8", "9", "10", nil]
-        #
-        #   %w(1 2 3 4 5 6 7).in_groups(3, '&nbsp;') {|group| p group}
-        #   ["1", "2", "3"]
-        #   ["4", "5", "&nbsp;"]
-        #   ["6", "7", "&nbsp;"]
-        #
-        #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
-        #   ["1", "2", "3"]
-        #   ["4", "5"]
-        #   ["6", "7"]
-        def in_groups(number, fill_with = nil)
-          # size / number gives minor group size;
-          # size % number gives how many objects need extra accomodation;
-          # each group hold either division or division + 1 items.
-          division = size / number
-          modulo = size % number
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      groups = []
+      collection.each_slice(number) { |group| groups << group }
+      groups
+    end
+  end
 
-          # create a new array avoiding dup
-          groups = []
-          start = 0
+  # Splits or iterates over the array in +number+ of groups, padding any
+  # remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", nil]
+  #   ["8", "9", "10", nil]
+  #
+  #   %w(1 2 3 4 5 6 7).in_groups(3, '&nbsp;') {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5", "&nbsp;"]
+  #   ["6", "7", "&nbsp;"]
+  #
+  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5"]
+  #   ["6", "7"]
+  def in_groups(number, fill_with = nil)
+    # size / number gives minor group size;
+    # size % number gives how many objects need extra accomodation;
+    # each group hold either division or division + 1 items.
+    division = size / number
+    modulo = size % number
 
-          number.times do |index|
-            length = division + (modulo > 0 && modulo > index ? 1 : 0)
-            padding = fill_with != false &&
-              modulo > 0 && length == division ? 1 : 0
-            groups << slice(start, length).concat([fill_with] * padding)
-            start += length
-          end
+    # create a new array avoiding dup
+    groups = []
+    start = 0
 
-          if block_given?
-            groups.each{|g| yield(g) }
-          else
-            groups
-          end
-        end
+    number.times do |index|
+      length = division + (modulo > 0 && modulo > index ? 1 : 0)
+      padding = fill_with != false &&
+        modulo > 0 && length == division ? 1 : 0
+      groups << slice(start, length).concat([fill_with] * padding)
+      start += length
+    end
 
-        # Divides the array into one or more subarrays based on a delimiting +value+
-        # or the result of an optional block.
-        #
-        #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
-        #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
-        def split(value = nil)
-          using_block = block_given?
+    if block_given?
+      groups.each { |g| yield(g) }
+    else
+      groups
+    end
+  end
 
-          inject([[]]) do |results, element|
-            if (using_block && yield(element)) || (value == element)
-              results << []
-            else
-              results.last << element
-            end
+  # Divides the array into one or more subarrays based on a delimiting +value+
+  # or the result of an optional block.
+  #
+  #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
+  #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
+  def split(value = nil)
+    using_block = block_given?
 
-            results
-          end
-        end
+    inject([[]]) do |results, element|
+      if (using_block && yield(element)) || (value == element)
+        results << []
+      else
+        results.last << element
       end
+
+      results
     end
   end
 end

data/lib/active_support/core_ext/array/random_access.rb

@@ -1,12 +1,6 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Array #:nodoc:
-      module RandomAccess
-        # Returns a random element from the array.
-        def rand
-          self[Kernel.rand(length)]
-        end
-      end
-    end
+class Array
+  # Returns a random element from the array.
+  def rand
+    self[Kernel.rand(length)]
   end
 end

data/lib/active_support/core_ext/array/uniq_by.rb

@@ -0,0 +1,17 @@
+class Array
+  # Return an unique array based on the criteria given as a proc.
+  #
+  #   [1, 2, 3, 4].uniq_by { |i| i.odd? }
+  #   #=> [1, 2]
+  #
+  def uniq_by
+    hash, array = {}, []
+    each { |i| hash[yield(i)] ||= (array << i) }
+    array
+  end
+
+  # Same as uniq_by, but modifies self.
+  def uniq_by!
+    replace(uniq_by{ |i| yield(i) })
+  end
+end

data/lib/active_support/core_ext/array/wrap.rb

@@ -0,0 +1,22 @@
+class Array
+  # Wraps the object in an Array unless it's an Array.  Converts the
+  # object to an Array using #to_ary if it implements that.
+  #
+  # It differs with Array() in that it does not call +to_a+ on
+  # the argument:
+  #
+  #   Array(:foo => :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
+  #
+  #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
+  #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary
+    else
+      [object]
+    end
+  end
+end

data/lib/active_support/core_ext/array.rb

@@ -1,15 +1,7 @@
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/array/uniq_by'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/grouping'
 require 'active_support/core_ext/array/random_access'
-require 'active_support/core_ext/array/wrapper'
-
-class Array #:nodoc:
-  include ActiveSupport::CoreExtensions::Array::Access
-  include ActiveSupport::CoreExtensions::Array::Conversions
-  include ActiveSupport::CoreExtensions::Array::ExtractOptions
-  include ActiveSupport::CoreExtensions::Array::Grouping
-  include ActiveSupport::CoreExtensions::Array::RandomAccess
-  extend ActiveSupport::CoreExtensions::Array::Wrapper
-end

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

@@ -0,0 +1,27 @@
+require 'bigdecimal'
+require 'yaml'
+
+class BigDecimal
+  YAML_TAG = 'tag:yaml.org,2002:float'
+  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
+
+  yaml_as YAML_TAG
+
+  # This emits the number without any scientific notation.
+  # This is better than self.to_f.to_s since it doesn't lose precision.
+  #
+  # Note that reconstituting YAML floats to native floats may lose precision.
+  def to_yaml(opts = {})
+    YAML.quick_emit(nil, opts) do |out|
+      string = to_s
+      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
+    end
+  end
+
+  DEFAULT_STRING_FORMAT = 'F'
+  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
+    _original_to_s(format)
+  end
+  alias_method :_original_to_s, :to_s
+  alias_method :to_s, :to_formatted_s
+end

data/lib/active_support/core_ext/big_decimal.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/big_decimal/conversions'

data/lib/active_support/core_ext/cgi/escape_skipping_slashes.rb

@@ -1,23 +1,19 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module CGI #:nodoc:
-      module EscapeSkippingSlashes #:nodoc:
-        if RUBY_VERSION >= '1.9'
-          def escape_skipping_slashes(str)
-            str = str.join('/') if str.respond_to? :join
-            str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
-              "%#{$1.unpack('H2' * $1.bytesize).join('%').upcase}"
-            end.tr(' ', '+')
-          end
-        else
-          def escape_skipping_slashes(str)
-            str = str.join('/') if str.respond_to? :join
-            str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
-              "%#{$1.unpack('H2').first.upcase}"
-            end.tr(' ', '+')
-          end
-        end
-      end
+require 'cgi'
+
+class CGI #:nodoc:
+  if RUBY_VERSION >= '1.9'
+    def self.escape_skipping_slashes(str)
+      str = str.join('/') if str.respond_to? :join
+      str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
+        "%#{$1.unpack('H2' * $1.bytesize).join('%').upcase}"
+      end.tr(' ', '+')
+    end
+  else
+    def self.escape_skipping_slashes(str)
+      str = str.join('/') if str.respond_to? :join
+      str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
+        "%#{$1.unpack('H2').first.upcase}"
+      end.tr(' ', '+')
     end
   end
 end

data/lib/active_support/core_ext/cgi.rb

@@ -1,5 +1 @@
 require 'active_support/core_ext/cgi/escape_skipping_slashes'
-
-class CGI #:nodoc:
-  extend ActiveSupport::CoreExtensions::CGI::EscapeSkippingSlashes
-end

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

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/remove_method'
+
+class Class
+  # Declare a class-level attribute whose value is inheritable and
+  # overwritable by subclasses:
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method.
+  #
+  # For convenience, a query method is defined as well:
+  #
+  #   Subclass.setting?           # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance writer method, pass :instance_writer => false.
+  #
+  #   object.setting = false  # => NoMethodError
+  def class_attribute(*attrs)
+    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
+
+    attrs.each do |name|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{name}() nil end
+        def self.#{name}?() !!#{name} end
+
+        def self.#{name}=(val)
+          singleton_class.class_eval do
+            remove_possible_method(:#{name})
+            define_method(:#{name}) { val }
+          end
+        end
+
+        def #{name}
+          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+        end
+
+        def #{name}?
+          !!#{name}
+        end
+      RUBY
+
+      if instance_writer
+        body = "def #{name}=(value) @#{name} = value end"
+        class_eval body, __FILE__, __LINE__ - 1
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/extract_options'
+
 # Extends the class object with class and instance accessors for class attributes,
 # just like the native attr* accessors for instance attributes.
 #
@@ -8,47 +10,54 @@
 #  Person.hair_colors = [:brown, :black, :blonde, :red]
 class Class
   def cattr_reader(*syms)
-    syms.flatten.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}  # unless defined? @@hair_colors
-          @@#{sym} = nil          #   @@hair_colors = nil
-        end                       # end
-                                  #
-        def self.#{sym}           # def self.hair_colors
-          @@#{sym}                #   @@hair_colors
-        end                       # end
-                                  #
-        def #{sym}                # def hair_colors
-          @@#{sym}                #   @@hair_colors
-        end                       # end
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
       EOS
+
+      unless options[:instance_reader] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
     end
   end
 
   def cattr_writer(*syms)
     options = syms.extract_options!
-    syms.flatten.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}                       # unless defined? @@hair_colors
-          @@#{sym} = nil                               #   @@hair_colors = nil
-        end                                            # end
-                                                       #
-        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
-          @@#{sym} = obj                               #   @@hair_colors = obj
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def hair_colors=(obj)
-          @@#{sym} = obj                               #   @@hair_colors = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
       EOS
+
+      unless options[:instance_writer] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+      end
+      self.send("#{sym}=", yield) if block_given?
     end
   end
 
-  def cattr_accessor(*syms)
+  def cattr_accessor(*syms, &blk)
     cattr_reader(*syms)
-    cattr_writer(*syms)
+    cattr_writer(*syms, &blk)
   end
 end

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

@@ -1,47 +1,44 @@
-# These class attributes behave something like the class
-# inheritable accessors.  But instead of copying the hash over at
-# the time the subclass is first defined,  the accessors simply
-# delegate to their superclass unless they have been given a 
-# specific value.  This stops the strange situation where values 
-# set after class definition don't get applied to subclasses.
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/remove_method'
+
 class Class
-  def superclass_delegating_reader(*names)
-    class_name_to_stop_searching_on = self.superclass.name.blank? ? "Object" : self.superclass.name
-    names.each do |name|
-      class_eval <<-EOS
-      def self.#{name}                                            # def self.only_reader
-        if defined?(@#{name})                                     #   if defined?(@only_reader)
-          @#{name}                                                #     @only_reader
-        elsif superclass < #{class_name_to_stop_searching_on} &&  #   elsif superclass < Object &&
-              superclass.respond_to?(:#{name})                    #         superclass.respond_to?(:only_reader)
-          superclass.#{name}                                      #     superclass.only_reader
-        end                                                       #   end
-      end                                                         # end
-      def #{name}                                                 # def only_reader
-        self.class.#{name}                                        #   self.class.only_reader
-      end                                                         # end
-      def self.#{name}?                                           # def self.only_reader?
-        !!#{name}                                                 #   !!only_reader
-      end                                                         # end
-      def #{name}?                                                # def only_reader?
-        !!#{name}                                                 #   !!only_reader
-      end                                                         # end
-      EOS
-    end
+  def superclass_delegating_accessor(name, options = {})
+    # Create private _name and _name= methods that can still be used if the public
+    # methods are overridden. This allows
+    _superclass_delegating_accessor("_#{name}")
+
+    # Generate the public methods name, name=, and name?
+    # These methods dispatch to the private _name, and _name= methods, making them
+    # overridable
+    singleton_class.send(:define_method, name) { send("_#{name}") }
+    singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
+    singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
+
+    # If an instance_reader is needed, generate methods for name and name= on the
+    # class itself, so instances will be able to see them
+    define_method(name) { send("_#{name}") } if options[:instance_reader] != false
+    define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
   end
 
-  def superclass_delegating_writer(*names)
-    names.each do |name|
-      class_eval <<-EOS
-        def self.#{name}=(value)  # def self.only_writer=(value)
-          @#{name} = value        #   @only_writer = value
-        end                       # end
-      EOS
-    end
+private
+
+  # Take the object being set and store it in a method. This gives us automatic
+  # inheritance behavior, without having to store the object in an instance
+  # variable and look up the superclass chain manually.
+  def _stash_object_in_method(object, method, instance_reader = true)
+    singleton_class.remove_possible_method(method)
+    singleton_class.send(:define_method, method) { object }
+    remove_possible_method(method)
+    define_method(method) { object } if instance_reader
   end
 
-  def superclass_delegating_accessor(*names)
-    superclass_delegating_reader(*names)
-    superclass_delegating_writer(*names)
+  def _superclass_delegating_accessor(name, options = {})
+    singleton_class.send(:define_method, "#{name}=") do |value|
+      _stash_object_in_method(value, name, options[:instance_reader] != false)
+    end
+    send("#{name}=", nil)
   end
+
 end