activesupport 2.3.18 → 3.0.0.beta

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

@@ -116,7 +116,7 @@ class Module
         if options[:allow_nil]
           'return'
         else
-          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+          %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
         end
 
       module_eval(<<-EOS, file, line)

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

@@ -0,0 +1,9 @@
+class Module
+  # Declare that a method has been deprecated.
+  #   deprecate :foo
+  #   deprecate :bar => 'message'
+  #   deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
+  def deprecate(*method_names)
+    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
+  end
+end

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

@@ -1,90 +1,88 @@
-module ActiveSupport
-  module CoreExtensions
-    module Module
-      # Returns the name of the module containing this one.
-      #
-      #   p M::N.parent_name # => "M"
-      def parent_name
-        unless defined? @parent_name
-          @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
-        end
-        @parent_name
-      end
+require 'active_support/inflector'
 
-      # Returns the module which contains this one according to its name.
-      #
-      #   module M
-      #     module N
-      #     end
-      #   end
-      #   X = M::N
-      #
-      #   p M::N.parent # => M
-      #   p X.parent    # => M
-      #
-      # The parent of top-level and anonymous modules is Object.
-      #
-      #   p M.parent          # => Object
-      #   p Module.new.parent # => Object
-      #
-      def parent
-        parent_name ? parent_name.constantize : Object
-      end
+class Module
+  # Returns the name of the module containing this one.
+  #
+  #   p M::N.parent_name # => "M"
+  def parent_name
+    unless defined? @parent_name
+      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+    end
+    @parent_name
+  end
 
-      # Returns all the parents of this module according to its name, ordered from
-      # nested outwards. The receiver is not contained within the result.
-      #
-      #   module M
-      #     module N
-      #     end
-      #   end
-      #   X = M::N
-      #
-      #   p M.parents    # => [Object]
-      #   p M::N.parents # => [M, Object]
-      #   p X.parents    # => [M, Object]
-      #
-      def parents
-        parents = []
-        if parent_name
-          parts = parent_name.split('::')
-          until parts.empty?
-            parents << (parts * '::').constantize
-            parts.pop
-          end
-        end
-        parents << Object unless parents.include? Object
-        parents
-      end
+  # Returns the module which contains this one according to its name.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   p M::N.parent # => M
+  #   p X.parent    # => M
+  #
+  # The parent of top-level and anonymous modules is Object.
+  #
+  #   p M.parent          # => Object
+  #   p Module.new.parent # => Object
+  #
+  def parent
+    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
+  end
 
-      if RUBY_VERSION < '1.9'
-        # Returns the constants that have been defined locally by this object and
-        # not in an ancestor. This method is exact if running under Ruby 1.9. In
-        # previous versions it may miss some constants if their definition in some
-        # ancestor is identical to their definition in the receiver.
-        def local_constants
-          inherited = {}
+  # Returns all the parents of this module according to its name, ordered from
+  # nested outwards. The receiver is not contained within the result.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   p M.parents    # => [Object]
+  #   p M::N.parents # => [M, Object]
+  #   p X.parents    # => [M, Object]
+  #
+  def parents
+    parents = []
+    if parent_name
+      parts = parent_name.split('::')
+      until parts.empty?
+        parents << ActiveSupport::Inflector.constantize(parts * '::')
+        parts.pop
+      end
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
 
-          ancestors.each do |anc|
-            next if anc == self
-            anc.constants.each { |const| inherited[const] = anc.const_get(const) }
-          end
+  if RUBY_VERSION < '1.9'
+    # Returns the constants that have been defined locally by this object and
+    # not in an ancestor. This method is exact if running under Ruby 1.9. In
+    # previous versions it may miss some constants if their definition in some
+    # ancestor is identical to their definition in the receiver.
+    def local_constants
+      inherited = {}
 
-          constants.select do |const|
-            !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
-          end
-        end
-      else
-        def local_constants #:nodoc:
-          constants(false)
-        end
+      ancestors.each do |anc|
+        next if anc == self
+        anc.constants.each { |const| inherited[const] = anc.const_get(const) }
       end
 
-      # Returns the names of the constants defined locally rather than the
-      # constants themselves. See <tt>local_constants</tt>.
-      def local_constant_names
-        local_constants.map { |c| c.to_s }
+      constants.select do |const|
+        !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
       end
     end
+  else
+    def local_constants #:nodoc:
+      constants(false)
+    end
+  end
+
+  # Returns the names of the constants defined locally rather than the
+  # constants themselves. See <tt>local_constants</tt>.
+  def local_constant_names
+    local_constants.map { |c| c.to_s }
   end
 end

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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/inflections'
+
 class Module
   # Returns String#underscore applied to the module name minus trailing classes.
   #

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

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/array/extract_options'
+
 class Module
   # Synchronize access around a method, delegating synchronization to a
   # particular mutex. A mutex (either a Mutex, or any object that responds to 
@@ -25,7 +28,7 @@ class Module
         raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
       end
 
-      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      module_eval(<<-EOS, __FILE__, __LINE__)
         def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
           #{with}.synchronize do                                                    #   @@lock.synchronize do
             #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)

data/lib/active_support/core_ext/name_error.rb

@@ -1,12 +1,11 @@
-# Add a +missing_name+ method to NameError instances.
-class NameError #:nodoc:  
-  # Add a method to obtain the missing name from a NameError.
+class NameError
+  # Extract the name of the missing constant from the exception message.
   def missing_name
     if /undefined local variable or method/ !~ message
       $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
     end
   end
-  
+
   # Was this exception raised because the given name was missing?
   def missing_name?(name)
     if name.is_a? Symbol

data/lib/active_support/core_ext/numeric.rb

@@ -1,9 +1,2 @@
-require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/numeric/bytes'
-require 'active_support/core_ext/numeric/conversions'
-
-class Numeric #:nodoc:
-  include ActiveSupport::CoreExtensions::Numeric::Time 
-  include ActiveSupport::CoreExtensions::Numeric::Bytes
-  include ActiveSupport::CoreExtensions::Numeric::Conversions 
-end
+require 'active_support/core_ext/numeric/time'

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -1,50 +1,44 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Numeric #:nodoc:
-      # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-      module Bytes
-        KILOBYTE = 1024
-        MEGABYTE = KILOBYTE * 1024
-        GIGABYTE = MEGABYTE * 1024
-        TERABYTE = GIGABYTE * 1024
-        PETABYTE = TERABYTE * 1024
-        EXABYTE  = PETABYTE * 1024
+class Numeric
+  KILOBYTE = 1024
+  MEGABYTE = KILOBYTE * 1024
+  GIGABYTE = MEGABYTE * 1024
+  TERABYTE = GIGABYTE * 1024
+  PETABYTE = TERABYTE * 1024
+  EXABYTE  = PETABYTE * 1024
 
-        def bytes
-          self
-        end
-        alias :byte :bytes
+  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  def bytes
+    self
+  end
+  alias :byte :bytes
 
-        def kilobytes
-          self * KILOBYTE
-        end
-        alias :kilobyte :kilobytes
+  def kilobytes
+    self * KILOBYTE
+  end
+  alias :kilobyte :kilobytes
 
-        def megabytes
-          self * MEGABYTE
-        end
-        alias :megabyte :megabytes
+  def megabytes
+    self * MEGABYTE
+  end
+  alias :megabyte :megabytes
 
-        def gigabytes
-          self * GIGABYTE
-        end
-        alias :gigabyte :gigabytes
+  def gigabytes
+    self * GIGABYTE
+  end
+  alias :gigabyte :gigabytes
 
-        def terabytes
-          self * TERABYTE
-        end
-        alias :terabyte :terabytes
+  def terabytes
+    self * TERABYTE
+  end
+  alias :terabyte :terabytes
 
-        def petabytes
-          self * PETABYTE
-        end
-        alias :petabyte :petabytes
+  def petabytes
+    self * PETABYTE
+  end
+  alias :petabyte :petabytes
 
-        def exabytes
-          self * EXABYTE
-        end
-        alias :exabyte :exabytes
-      end
-    end
+  def exabytes
+    self * EXABYTE
   end
+  alias :exabyte :exabytes
 end

data/lib/active_support/core_ext/numeric/time.rb

@@ -1,81 +1,77 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Numeric #:nodoc:
-      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-      #
-      # These methods use Time#advance for precise date calculations when using from_now, ago, etc. 
-      # as well as adding or subtracting their results from a Time object. For example:
-      #
-      #   # equivalent to Time.now.advance(:months => 1)
-      #   1.month.from_now
-      #
-      #   # equivalent to Time.now.advance(:years => 2)
-      #   2.years.from_now
-      #
-      #   # equivalent to Time.now.advance(:months => 4, :years => 5)
-      #   (4.months + 5.years).from_now
-      # 
-      # While these methods provide precise calculation when used as in the examples above, care
-      # should be taken to note that this is not true if the result of `months', `years', etc is
-      # converted before use:
-      #
-      #   # equivalent to 30.days.to_i.from_now
-      #   1.month.to_i.from_now
-      #
-      #   # equivalent to 365.25.days.to_f.from_now
-      #   1.year.to_f.from_now
-      #
-      # In such cases, Ruby's core 
-      # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
-      # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-      # date and time arithmetic
-      module Time
-        def seconds
-          ActiveSupport::Duration.new(self, [[:seconds, self]])
-        end
-        alias :second :seconds
+require 'active_support/duration'
 
-        def minutes
-          ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
-        end
-        alias :minute :minutes  
-        
-        def hours
-          ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
-        end
-        alias :hour :hours
-        
-        def days
-          ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
-        end
-        alias :day :days
+class Numeric
+  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+  #
+  # These methods use Time#advance for precise date calculations when using from_now, ago, etc. 
+  # as well as adding or subtracting their results from a Time object. For example:
+  #
+  #   # equivalent to Time.now.advance(:months => 1)
+  #   1.month.from_now
+  #
+  #   # equivalent to Time.now.advance(:years => 2)
+  #   2.years.from_now
+  #
+  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   (4.months + 5.years).from_now
+  # 
+  # While these methods provide precise calculation when used as in the examples above, care
+  # should be taken to note that this is not true if the result of `months', `years', etc is
+  # converted before use:
+  #
+  #   # equivalent to 30.days.to_i.from_now
+  #   1.month.to_i.from_now
+  #
+  #   # equivalent to 365.25.days.to_f.from_now
+  #   1.year.to_f.from_now
+  #
+  # In such cases, Ruby's core 
+  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
+  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+  # date and time arithmetic
+  def seconds
+    ActiveSupport::Duration.new(self, [[:seconds, self]])
+  end
+  alias :second :seconds
 
-        def weeks
-          ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
-        end
-        alias :week :weeks
-        
-        def fortnights
-          ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
-        end
-        alias :fortnight :fortnights
-        
-        # Reads best without arguments:  10.minutes.ago
-        def ago(time = ::Time.now)
-          time - self
-        end
+  def minutes
+    ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+  end
+  alias :minute :minutes  
+  
+  def hours
+    ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+  end
+  alias :hour :hours
+  
+  def days
+    ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+  end
+  alias :day :days
 
-        # Reads best with argument:  10.minutes.until(time)
-        alias :until :ago
+  def weeks
+    ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+  end
+  alias :week :weeks
+  
+  def fortnights
+    ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+  end
+  alias :fortnight :fortnights
+  
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
 
-        # Reads best with argument:  10.minutes.since(time)
-        def since(time = ::Time.now)
-          time + self
-        end
+  # Reads best with argument:  10.minutes.until(time)
+  alias :until :ago
 
-        # Reads best without arguments:  10.minutes.from_now
-        alias :from_now :since
-      end
-    end
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
   end
+
+  # Reads best without arguments:  10.minutes.from_now
+  alias :from_now :since
 end