activesupport 3.2.22.5 → 4.0.0

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

@@ -1,16 +1,19 @@
 class Array
-  # Returns an unique array based on the criteria given as a +Proc+.
+  # *DEPRECATED*: Use <tt>Array#uniq</tt> instead.
   #
-  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
+  # Returns a unique array based on the criteria in the block.
   #
-  def uniq_by
-    hash, array = {}, []
-    each { |i| hash[yield(i)] ||= (array << i) }
-    array
+  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
+  def uniq_by(&block)
+    ActiveSupport::Deprecation.warn 'uniq_by is deprecated. Use Array#uniq instead'
+    uniq(&block)
   end
 
-  # Same as uniq_by, but modifies self.
-  def uniq_by!
-    replace(uniq_by{ |i| yield(i) })
+  # *DEPRECATED*: Use <tt>Array#uniq!</tt> instead.
+  #
+  # Same as +uniq_by+, but modifies +self+.
+  def uniq_by!(&block)
+    ActiveSupport::Deprecation.warn 'uniq_by! is deprecated. Use Array#uniq! instead'
+    uniq!(&block)
   end
 end

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

@@ -7,35 +7,32 @@ class Array
   # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
   # * Otherwise, returns an array with the argument as its single element.
   #
-  #   Array.wrap(nil)       # => []
-  #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
-  #   Array.wrap(0)         # => [0]
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
   #
   # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
   #
   # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  # such a +nil+ right away.
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   +nil+ right away.
   # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
-  # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, but returns an empty array if argument is +nil+.
   #
-  # The last point is particularly worth comparing for some enumerables:
+  # The second point is easily explained with some enumerables:
   #
-  #   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"]
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
   #
   # There's also a related idiom that uses the splat operator:
   #
   #   [*object]
   #
-  # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
+  # which returns <tt>[]</tt> for +nil+, but calls to <tt>Array(object)</tt> otherwise.
   #
-  # Thus, in this case the behavior is different for +nil+, and the differences with
-  # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
+  # The differences with <tt>Kernel#Array</tt> explained above
+  # apply to the rest of <tt>object</tt>s.
   def self.wrap(object)
     if object.nil?
       []

data/lib/active_support/core_ext/array.rb

@@ -4,5 +4,4 @@ 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/prepend_and_append'

data/lib/active_support/core_ext/benchmark.rb

@@ -1,6 +1,13 @@
 require 'benchmark'
 
 class << Benchmark
+  # Benchmark realtime in milliseconds.
+  #
+  #   Benchmark.realtime { User.all }
+  #   # => 8.0e-05
+  #
+  #   Benchmark.ms { User.all }
+  #   # => 0.074
   def ms
     1000 * realtime { yield }
   end

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

@@ -1,31 +1,10 @@
 require 'bigdecimal'
-
-begin
-  require 'psych'
-rescue LoadError
-end
-
+require 'bigdecimal/util'
 require 'yaml'
 
 class BigDecimal
-  YAML_TAG = 'tag:yaml.org,2002:float'
   YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
 
-  # 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 = {})
-    return super if
-      (defined?(YAML::ENGINE) && !YAML::ENGINE.syck?) ||
-      (defined?(Psych) && YAML == Psych)
-
-    YAML.quick_emit(nil, opts) do |out|
-      string = to_s
-      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
-    end
-  end
-
   def encode_with(coder)
     string = to_s
     coder.represent_scalar(nil, YAML_MAPPING[string] || string)
@@ -39,8 +18,13 @@ class BigDecimal
   end
 
   DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
-    _original_to_s(format)
+  def to_formatted_s(*args)
+    if args[0].is_a?(Symbol)
+      super
+    else
+      format = args[0] || DEFAULT_STRING_FORMAT
+      _original_to_s(format)
+    end
   end
   alias_method :_original_to_s, :to_s
   alias_method :to_s, :to_formatted_s

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

@@ -44,7 +44,8 @@ class Class
   #   Base.setting               # => []
   #   Subclass.setting           # => [:foo]
   #
-  # For convenience, a query method is defined as well:
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
   #
   #   Subclass.setting?       # => false
   #
@@ -57,61 +58,68 @@ class Class
   #   object.setting          # => false
   #   Base.setting            # => true
   #
-  # To opt out of the instance reader method, pass :instance_reader => false.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   object.setting          # => NoMethodError
   #   object.setting?         # => NoMethodError
   #
-  # To opt out of the instance writer method, pass :instance_writer => false.
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
   #
   #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
   def class_attribute(*attrs)
     options = attrs.extract_options!
-    instance_reader = instance_reader = options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_writer, true)
+    # double assignment is used to avoid "assigned but unused variable" warning
+    instance_reader = instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
 
     attrs.each do |name|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{name}() nil end
-        def self.#{name}?() !!#{name} end
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
 
-        def self.#{name}=(val)
-          singleton_class.class_eval do
-            remove_possible_method(:#{name})
-            define_method(:#{name}) { val }
-          end
+      ivar = "@#{name}"
 
-          if singleton_class?
-            class_eval do
-              remove_possible_method(:#{name})
-              def #{name}
-                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
               end
             end
           end
-          val
         end
+        val
+      end
 
-        if instance_reader
-          remove_possible_method :#{name}
-          def #{name}
-            defined?(@#{name}) ? @#{name} : self.class.#{name}
-          end
-
-          def #{name}?
-            !!#{name}
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
           end
         end
-      RUBY
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
 
       attr_writer name if instance_writer
     end
   end
 
   private
-    unless respond_to?(:singleton_class?)
-      def singleton_class?
-        ancestors.first != self
-      end
+    def singleton_class?
+      ancestors.first != self
     end
 end

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

@@ -21,17 +21,18 @@ class Class
   #   end
   #   # => NameError: invalid attribute name
   #
-  # If you want to opt out the instance reader method, you can pass <tt>:instance_reader => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
+  # If you want to opt out the instance reader method, you can pass <tt>instance_reader: false</tt>
+  # or <tt>instance_accessor: false</tt>.
   #
   #   class Person
-  #     cattr_reader :hair_colors, :instance_reader => false
+  #     cattr_reader :hair_colors, instance_reader: false
   #   end
   #
   #   Person.new.hair_colors # => NoMethodError
   def cattr_reader(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new("invalid class attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil
@@ -71,11 +72,11 @@ class Class
   #   end
   #   # => NameError: invalid attribute name
   #
-  # If you want to opt out the instance writer method, pass <tt>:instance_writer => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
+  # If you want to opt out the instance writer method, pass <tt>instance_writer: false</tt>
+  # or <tt>instance_accessor: false</tt>.
   #
   #   class Person
-  #     cattr_writer :hair_colors, :instance_writer => false
+  #     cattr_writer :hair_colors, instance_writer: false
   #   end
   #
   #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
@@ -92,6 +93,7 @@ class Class
   def cattr_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new("invalid class attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil
@@ -109,7 +111,7 @@ class Class
           end
         EOS
       end
-      self.send("#{sym}=", yield) if block_given?
+      send("#{sym}=", yield) if block_given?
     end
   end
 
@@ -133,20 +135,20 @@ class Class
   #   Male.hair_colors << :blue
   #   Person.hair_colors # => [:brown, :black, :blonde, :red, :blue]
   #
-  # To opt out of the instance writer method, pass <tt>:instance_writer => false</tt>.
-  # To opt out of the instance reader method, pass <tt>:instance_reader => false</tt>.
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   class Person
-  #     cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
+  #     cattr_accessor :hair_colors, instance_writer: false, instance_reader: false
   #   end
   #
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Or pass <tt>:instance_accessor => false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
   #
   #   class Person
-  #     cattr_accessor :hair_colors, :instance_accessor => false
+  #     cattr_accessor :hair_colors, instance_accessor: false
   #   end
   #
   #   Person.new.hair_colors = [:brown]  # => NoMethodError

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

@@ -1,5 +1,3 @@
-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'
 
@@ -22,23 +20,21 @@ class Class
     define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
   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(name, options = {})
-    singleton_class.send(:define_method, "#{name}=") do |value|
-      _stash_object_in_method(value, name, options[:instance_reader] != false)
+  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
-    send("#{name}=", nil)
-  end
 
+    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

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

@@ -1,19 +1,19 @@
 require 'active_support/core_ext/module/anonymous'
 require 'active_support/core_ext/module/reachable'
 
-class Class #:nodoc:
+class Class
   begin
     ObjectSpace.each_object(Class.new) {}
 
-    def descendants
+    def descendants # :nodoc:
       descendants = []
-      ObjectSpace.each_object(class << self; self; end) do |k|
+      ObjectSpace.each_object(singleton_class) do |k|
         descendants.unshift k unless k == self
       end
       descendants
     end
   rescue StandardError # JRuby
-    def descendants
+    def descendants # :nodoc:
       descendants = []
       ObjectSpace.each_object(Class) do |k|
         descendants.unshift k if k < self
@@ -25,7 +25,13 @@ class Class #:nodoc:
 
   # Returns an array with the direct children of +self+.
   #
-  #   Integer.subclasses # => [Bignum, Fixnum]
+  #   Integer.subclasses # => [Fixnum, Bignum]
+  #
+  #   class Foo; end
+  #   class Bar < Foo; end
+  #   class Baz < Bar; end
+  #
+  #   Foo.subclasses # => [Bar]
   def subclasses
     subclasses, chain = [], descendants
     chain.each do |k|