activesupport 3.2.22.5 → 4.0.0

data/lib/active_support/concern.rb

@@ -1,5 +1,3 @@
-require 'active_support/deprecation'
-
 module ActiveSupport
   # A typical module looks like this:
   #
@@ -7,7 +5,7 @@ module ActiveSupport
   #     def self.included(base)
   #       base.extend ClassMethods
   #       base.class_eval do
-  #         scope :disabled, where(:disabled => true)
+  #         scope :disabled, -> { where(disabled: true) }
   #       end
   #     end
   #
@@ -16,7 +14,8 @@ module ActiveSupport
   #     end
   #   end
   #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
   #
   #   require 'active_support/concern'
   #
@@ -24,7 +23,7 @@ module ActiveSupport
   #     extend ActiveSupport::Concern
   #
   #     included do
-  #       scope :disabled, where(:disabled => true)
+  #       scope :disabled, -> { where(disabled: true) }
   #     end
   #
   #     module ClassMethods
@@ -32,8 +31,9 @@ module ActiveSupport
   #     end
   #   end
   #
-  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
-  # module which depends on the former, we would typically write the following:
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
   #
   #   module Foo
   #     def self.included(base)
@@ -56,11 +56,11 @@ module ActiveSupport
   #     include Bar # Bar is the module that Host really needs
   #   end
   #
-  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
-  # these from +Host+ directly including +Foo+ in +Bar+:
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
   #
   #   module Bar
-  #     include Foo 
+  #     include Foo
   #     def self.included(base)
   #       base.method_injected_by_foo
   #     end
@@ -70,18 +70,17 @@ module ActiveSupport
   #     include Bar
   #   end
   #
-  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
-  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
   #
   #   require 'active_support/concern'
   #
   #   module Foo
   #     extend ActiveSupport::Concern
   #     included do
-  #       class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
+  #       def self.method_injected_by_foo
+  #         ...
   #       end
   #     end
   #   end
@@ -98,9 +97,8 @@ module ActiveSupport
   #   class Host
   #     include Bar # works, Bar takes care now of its dependencies
   #   end
-  #
   module Concern
-    def self.extended(base)
+    def self.extended(base) #:nodoc:
       base.instance_variable_set("@_dependencies", [])
     end
 
@@ -113,11 +111,6 @@ module ActiveSupport
         @_dependencies.each { |dep| base.send(:include, dep) }
         super
         base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
-        if const_defined?("InstanceMethods")
-          base.send :include, const_get("InstanceMethods")
-          ActiveSupport::Deprecation.warn "The InstanceMethods module inside ActiveSupport::Concern will be " \
-            "no longer included automatically. Please define instance methods directly in #{self} instead.", caller
-        end
         base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
       end
     end

data/lib/active_support/concurrency/latch.rb

@@ -0,0 +1,27 @@
+require 'thread'
+require 'monitor'
+
+module ActiveSupport
+  module Concurrency
+    class Latch
+      def initialize(count = 1)
+        @count = count
+        @lock = Monitor.new
+        @cv = @lock.new_cond
+      end
+
+      def release
+        @lock.synchronize do
+          @count -= 1 if @count > 0
+          @cv.broadcast if @count.zero?
+        end
+      end
+
+      def await
+        @lock.synchronize do
+          @cv.wait_while { @count > 0 }
+        end
+      end
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -1,7 +1,5 @@
 require 'active_support/concern'
 require 'active_support/ordered_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
@@ -15,7 +13,7 @@ module ActiveSupport
         self.class.compile_methods!(keys)
       end
 
-      # compiles reader methods so we don't have to go through method_missing
+      # Compiles reader methods so we don't have to go through method_missing.
       def self.compile_methods!(keys)
         keys.reject { |m| method_defined?(m) }.each do |key|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -39,29 +37,89 @@ module ActiveSupport
         yield config
       end
 
-      # Allows you to add shortcut so that you don't have to refer to attribute through config.
-      # Also look at the example for config to contrast.
+      # Allows you to add shortcut so that you don't have to refer to attribute
+      # through config. Also look at the example for config to contrast.
+      #
+      # Defines both class and instance config accessors.
       #
       #   class User
       #     include ActiveSupport::Configurable
       #     config_accessor :allowed_access
       #   end
       #
+      #   User.allowed_access # => nil
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
       #   user = User.new
+      #   user.allowed_access # => false
       #   user.allowed_access = true
       #   user.allowed_access # => true
       #
+      #   User.allowed_access # => false
+      #
+      # The attribute name must be a valid method name in Ruby.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :"1_Badname"
+      #   end
+      #   # => NameError: invalid config attribute name
+      #
+      # 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 User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :allowed_access, instance_reader: false, instance_writer: false
+      #   end
+      #
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
+      #   User.new.allowed_access = true # => NoMethodError
+      #   User.new.allowed_access        # => NoMethodError
+      #
+      # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :allowed_access, instance_accessor: false
+      #   end
+      #
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
+      #   User.new.allowed_access = true # => NoMethodError
+      #   User.new.allowed_access        # => NoMethodError
+      #
+      # Also you can pass a block to set up the attribute with a default value.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :hair_colors do
+      #       [:brown, :black, :blonde, :red]
+      #     end
+      #   end
+      #
+      #   User.hair_colors # => [:brown, :black, :blonde, :red]
       def config_accessor(*names)
         options = names.extract_options!
 
         names.each do |name|
-          reader, line = "def #{name}; config.#{name}; end", __LINE__
-          writer, line = "def #{name}=(value); config.#{name} = value; end", __LINE__
+          raise NameError.new('invalid config attribute name') unless name =~ /^[_A-Za-z]\w*$/
 
-          singleton_class.class_eval reader, __FILE__, line
-          singleton_class.class_eval writer, __FILE__, line
-          class_eval reader, __FILE__, line unless options[:instance_reader] == false
-          class_eval writer, __FILE__, line unless options[:instance_writer] == false
+          reader, reader_line = "def #{name}; config.#{name}; end", __LINE__
+          writer, writer_line = "def #{name}=(value); config.#{name} = value; end", __LINE__
+
+          singleton_class.class_eval reader, __FILE__, reader_line
+          singleton_class.class_eval writer, __FILE__, writer_line
+
+          unless options[:instance_accessor] == false
+            class_eval reader, __FILE__, reader_line unless options[:instance_reader] == false
+            class_eval writer, __FILE__, writer_line unless options[:instance_writer] == false
+          end
+          send("#{name}=", yield) if block_given?
         end
       end
     end
@@ -81,7 +139,6 @@ module ActiveSupport
     #
     #   user.config.allowed_access # => true
     #   user.config.level          # => 1
-    #
     def config
       @_config ||= self.class.config.inheritable_copy
     end

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

@@ -1,40 +1,48 @@
 class Array
   # Returns the tail of the array from +position+.
   #
-  #   %w( a b c d ).from(0)  # => %w( a b c d )
-  #   %w( a b c d ).from(2)  # => %w( c d )
-  #   %w( a b c d ).from(10) # => %w()
-  #   %w().from(0)           # => %w()
+  #   %w( a b c d ).from(0)  # => ["a", "b", "c", "d"]
+  #   %w( a b c d ).from(2)  # => ["c", "d"]
+  #   %w( a b c d ).from(10) # => []
+  #   %w().from(0)           # => []
   def from(position)
     self[position, length] || []
   end
 
   # Returns the beginning of the array up to +position+.
   #
-  #   %w( a b c d ).to(0)  # => %w( a )
-  #   %w( a b c d ).to(2)  # => %w( a b c )
-  #   %w( a b c d ).to(10) # => %w( a b c d )
-  #   %w().to(0)           # => %w()
+  #   %w( a b c d ).to(0)  # => ["a"]
+  #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
+  #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
+  #   %w().to(0)           # => []
   def to(position)
-    self.first position + 1
+    first position + 1
   end
 
   # Equal to <tt>self[1]</tt>.
+  #
+  #   %w( a b c d e ).second # => "b"
   def second
     self[1]
   end
 
   # Equal to <tt>self[2]</tt>.
+  #
+  #   %w( a b c d e ).third # => "c"
   def third
     self[2]
   end
 
   # Equal to <tt>self[3]</tt>.
+  #
+  #   %w( a b c d e ).fourth # => "d"
   def fourth
     self[3]
   end
 
   # Equal to <tt>self[4]</tt>.
+  #
+  #   %w( a b c d e ).fifth # => "e"
   def fifth
     self[4]
   end

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

@@ -1,41 +1,99 @@
 require 'active_support/xml_mini'
 require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/object/to_query'
 
 class Array
-  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
-  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
-  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
-  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  # Converts the array to a comma-separated sentence where the last element is
+  # joined by the connector word.
+  #
+  # You can pass the following options to change the default behavior. If you
+  # pass an option key that doesn't exist in the list below, it will raise an
+  # <tt>ArgumentError</tt>.
+  #
+  # ==== Options
+  #
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements
+  #   in arrays with two or more elements (default: ", ").
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
+  #   in arrays with two elements (default: " and ").
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
+  #   in arrays with three or more elements (default: ", and ").
+  # * <tt>:locale</tt> - If +i18n+ is available, you can set a locale and use
+  #   the connector options defined on the 'support.array' namespace in the
+  #   corresponding dictionary file.
+  #
+  # ==== Examples
+  #
+  #   [].to_sentence                      # => ""
+  #   ['one'].to_sentence                 # => "one"
+  #   ['one', 'two'].to_sentence          # => "one and two"
+  #   ['one', 'two', 'three'].to_sentence # => "one, two, and three"
+  #
+  #   ['one', 'two'].to_sentence(passing: 'invalid option')
+  #   # => ArgumentError: Unknown key :passing
+  #
+  #   ['one', 'two'].to_sentence(two_words_connector: '-')
+  #   # => "one-two"
+  #
+  #   ['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
+  #   # => "one or two or at least three"
+  #
+  # Using <tt>:locale</tt> option:
+  #
+  #   # Given this locale dictionary:
+  #   #
+  #   #   es:
+  #   #     support:
+  #   #       array:
+  #   #         words_connector: " o "
+  #   #         two_words_connector: " y "
+  #   #         last_word_connector: " o al menos "
+  #
+  #   ['uno', 'dos'].to_sentence(locale: :es)
+  #   # => "uno y dos"
+  #
+  #   ['uno', 'dos', 'tres'].to_sentence(locale: :es)
+  #   # => "uno o dos o al menos tres"
   def to_sentence(options = {})
+    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+
+    default_connectors = {
+      :words_connector     => ', ',
+      :two_words_connector => ' and ',
+      :last_word_connector => ', and '
+    }
     if defined?(I18n)
-      default_words_connector     = I18n.translate(:'support.array.words_connector',     :locale => options[:locale])
-      default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
-      default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
-    else
-      default_words_connector     = ", "
-      default_two_words_connector = " and "
-      default_last_word_connector = ", and "
+      i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
+      default_connectors.merge!(i18n_connectors)
     end
-
-    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
-    options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
+    options = default_connectors.merge!(options)
 
     case length
-      when 0
-        ""
-      when 1
-        self[0].to_s.dup
-      when 2
-        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
-      else
-        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    when 0
+      ''
+    when 1
+      self[0].to_s.dup
+    when 2
+      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+    else
+      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
     end
   end
 
   # Converts a collection of elements into a formatted string by calling
-  # <tt>to_s</tt> on all elements and joining them:
+  # <tt>to_s</tt> on all elements and joining them. Having this model:
+  #
+  #   class Blog < ActiveRecord::Base
+  #     def to_s
+  #       title
+  #     end
+  #   end
+  #
+  #   Blog.all.map(&:title) #=> ["First Post", "Second Post", "Third post"]
+  #
+  # <tt>to_formatted_s</tt> shows us:
   #
   #   Blog.all.to_formatted_s # => "First PostSecond PostThird Post"
   #
@@ -45,14 +103,14 @@ class Array
   #   Blog.all.to_formatted_s(:db) # => "1,2,3"
   def to_formatted_s(format = :default)
     case format
-      when :db
-        if respond_to?(:empty?) && self.empty?
-          "null"
-        else
-          collect { |element| element.id }.join(",")
-        end
+    when :db
+      if empty?
+        'null'
       else
-        to_default_s
+        collect { |element| element.id }.join(',')
+      end
+    else
+      to_default_s
     end
   end
   alias_method :to_default_s, :to_s
@@ -86,20 +144,20 @@ class Array
   #     </project>
   #   </projects>
   #
-  # Otherwise the root element is "records":
+  # Otherwise the root element is "objects":
   #
-  #   [{:foo => 1, :bar => 2}, {:baz => 3}].to_xml
+  #   [{ foo: 1, bar: 2}, { baz: 3}].to_xml
   #
   #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <records type="array">
-  #     <record>
+  #   <objects type="array">
+  #     <object>
   #       <bar type="integer">2</bar>
   #       <foo type="integer">1</foo>
-  #     </record>
-  #     <record>
+  #     </object>
+  #     <object>
   #       <baz type="integer">3</baz>
-  #     </record>
-  #   </records>
+  #     </object>
+  #   </objects>
   #
   # If the collection is empty the root element is "nil-classes" by default:
   #
@@ -110,7 +168,7 @@ class Array
   #
   # To ensure a meaningful root element use the <tt>:root</tt> option:
   #
-  #   customer_with_no_projects.projects.to_xml(:root => "projects")
+  #   customer_with_no_projects.projects.to_xml(root: 'projects')
   #
   #   <?xml version="1.0" encoding="UTF-8"?>
   #   <projects type="array"/>
@@ -120,7 +178,7 @@ class Array
   #
   # The +options+ hash is passed downwards:
   #
-  #   Message.all.to_xml(:skip_types => true)
+  #   Message.all.to_xml(skip_types: true)
   #
   #   <?xml version="1.0" encoding="UTF-8"?>
   #   <messages>
@@ -138,27 +196,29 @@ class Array
 
     options = options.dup
     options[:indent]  ||= 2
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    options[:root]    ||= if first.class.to_s != "Hash" && all? { |e| e.is_a?(first.class) }
-      underscored = ActiveSupport::Inflector.underscore(first.class.name)
-      ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
-    else
-      "objects"
-    end
+    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
+    options[:root]    ||= \
+      if first.class != Hash && all? { |e| e.is_a?(first.class) }
+        underscored = ActiveSupport::Inflector.underscore(first.class.name)
+        ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
+      else
+        'objects'
+      end
 
     builder = options[:builder]
     builder.instruct! unless options.delete(:skip_instruct)
 
     root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
     children = options.delete(:children) || root.singularize
+    attributes = options[:skip_types] ? {} : { type: 'array' }
 
-    attributes = options[:skip_types] ? {} : {:type => "array"}
-    return builder.tag!(root, attributes) if empty?
-
-    builder.__send__(:method_missing, root, attributes) do
-      each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
-      yield builder if block_given?
+    if empty?
+      builder.tag!(root, attributes)
+    else
+      builder.tag!(root, attributes) do
+        each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
+        yield builder if block_given?
+      end
     end
   end
-
 end

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

@@ -17,8 +17,8 @@ class Array
   #     args.extract_options!
   #   end
   #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
   def extract_options!
     if last.is_a?(Hash) && last.extractable_options?
       pop

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

@@ -1,21 +1,22 @@
-require 'enumerator'
-
 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}
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
   #   ["1", "2", "3"]
   #   ["4", "5", "6"]
-  #   ["7", nil, nil]
+  #   ["7", "8", "9"]
+  #   ["10", nil, nil]
   #
-  #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
+  #   %w(1 2 3 4 5).in_groups_of(2, ' ') {|group| p group}
   #   ["1", "2"]
-  #   ["3", " "]
+  #   ["3", "4"]
+  #   ["5", " "]
   #
-  #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
+  #   %w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
   #   ["1", "2"]
-  #   ["3"]
+  #   ["3", "4"]
+  #   ["5"]
   def in_groups_of(number, fill_with = nil)
     if fill_with == false
       collection = self
@@ -44,10 +45,10 @@ class Array
   #   ["5", "6", "7", nil]
   #   ["8", "9", "10", nil]
   #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, ' ') {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", " "]
-  #   ["6", "7", " "]
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, ' ') {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", " "]
+  #   ["8", "9", "10", " "]
   #
   #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
   #   ["1", "2", "3"]
@@ -57,7 +58,7 @@ class Array
     # size / number gives minor group size;
     # size % number gives how many objects need extra accommodation;
     # each group hold either division or division + 1 items.
-    division = size / number
+    division = size.div number
     modulo = size % number
 
     # create a new array avoiding dup
@@ -66,9 +67,9 @@ class Array
 
     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)
+      groups << last_group = slice(start, length)
+      last_group << fill_with if fill_with != false &&
+        modulo > 0 && length == division
       start += length
     end
 
@@ -82,13 +83,11 @@ class Array
   # 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?
-
+  #   [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, &block)
     inject([[]]) do |results, element|
-      if (using_block && yield(element)) || (value == element)
+      if block && block.call(element) || value == element
         results << []
       else
         results.last << element