activesupport 1.4.4 → 2.0.0

data/lib/active_support/core_ext/integer.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/integer/even_odd'
-require File.dirname(__FILE__) + '/integer/inflections'
+require 'active_support/core_ext/integer/even_odd'
+require 'active_support/core_ext/integer/inflections'
 
 class Integer #:nodoc:
   include ActiveSupport::CoreExtensions::Integer::EvenOdd

data/lib/active_support/core_ext/kernel.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + '/kernel/daemonizing'
-require File.dirname(__FILE__) + '/kernel/reporting'
-require File.dirname(__FILE__) + '/kernel/agnostics'
-require File.dirname(__FILE__) + '/kernel/requires'
+require 'active_support/core_ext/kernel/daemonizing'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/kernel/agnostics'
+require 'active_support/core_ext/kernel/requires'
+require 'active_support/core_ext/kernel/debugger'

data/lib/active_support/core_ext/kernel/debugger.rb

@@ -0,0 +1,13 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call script/server --debugger to do load it).
+    def debugger
+      RAILS_DEFAULT_LOGGER.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+    end
+  end
+  
+  def breakpoint
+    RAILS_DEFAULT_LOGGER.info "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    debugger
+  end
+end

data/lib/active_support/core_ext/module.rb

@@ -1,7 +1,8 @@
-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'
+require 'active_support/core_ext/module/inclusion'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/attr_accessor_with_default'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/introspection'
+require 'active_support/core_ext/module/loading'
+require 'active_support/core_ext/module/aliasing'

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

@@ -25,8 +25,20 @@ class Module
     # 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}"
+    
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+    
+    alias_method without_method, target
+    alias_method target, with_method
+    
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
   end
 
   # Allows you to make aliases for attributes, which includes 
@@ -38,7 +50,7 @@ class Module
   #     # has a title attribute
   #   end
   #
-  #   class Email < ActiveRecord::Base
+  #   class Email < Content
   #     alias_attribute :subject, :title
   #   end
   #
@@ -50,8 +62,8 @@ class Module
   #   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}; self.#{old_name}; end
+      def #{new_name}?; self.#{old_name}?; end
       def #{new_name}=(v); self.#{old_name} = v; end
     STR
   end

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

@@ -0,0 +1,31 @@
+class Module
+  # Declare an attribute accessor with an initial default return value.
+  #
+  # To give attribute <tt>:age</tt> the initial value <tt>25</tt>:
+  #  
+  #   class Person
+  #     attr_accessor_with_default :age, 25
+  #   end
+  #
+  #   some_person.age
+  #   => 25
+  #   some_person.age = 26
+  #   some_person.age
+  #   => 26
+  #
+  # To give attribute <tt>:element_name</tt> a dynamic default value, evaluated
+  # in scope of self:
+  #
+  #   attr_accessor_with_default(:element_name) { name.underscore } 
+  #
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}=(value)
+        class << self; attr_reader :#{sym} end
+        @#{sym} = value
+      end
+    EVAL
+  end
+end

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

@@ -21,7 +21,7 @@ class Module # :nodoc:
   end
   
   def mattr_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__)
         unless defined? @@#{sym}

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

@@ -5,6 +5,7 @@ class Module
   # or string).  At least one method and the :to option are required.
   #
   # Delegation is particularly useful with Active Record associations:
+  #
   #   class Greeter < ActiveRecord::Base
   #     def hello()   "hello"   end
   #     def goodbye() "goodbye" end
@@ -20,10 +21,30 @@ class Module
   #
   # Multiple delegates to the same target are allowed:
   #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
   #     delegate :hello, :goodbye, :to => :greeter
   #   end
   #
   #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing the variable as a symbol:
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
   def delegate(*methods)
     options = methods.pop
     unless options.is_a?(Hash) && to = options[:to]

data/lib/active_support/core_ext/name_error.rb

@@ -1,5 +1,5 @@
 # Add a +missing_name+ method to NameError instances.
-class NameError < StandardError #:nodoc:  
+class NameError #:nodoc:  
   # Add a method to obtain the missing name from a NameError.
   def missing_name
     $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
@@ -14,4 +14,4 @@ class NameError < StandardError #:nodoc:
       missing_name == name.to_s
     end
   end
-end
+end

data/lib/active_support/core_ext/numeric.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/numeric/time'
-require File.dirname(__FILE__) + '/numeric/bytes'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/numeric/bytes'
 
 class Numeric #:nodoc:
   include ActiveSupport::CoreExtensions::Numeric::Time 

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

@@ -3,51 +3,70 @@ module ActiveSupport #:nodoc:
     module Numeric #:nodoc:
       # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
       #
-      # If you need precise date calculations that doesn't just treat months as 30 days, then have
-      # a look at Time#advance.
+      # 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
       # 
-      # Some of these methods are approximations, Ruby's core 
+      # 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
-          self
+          ActiveSupport::Duration.new(self, [[:seconds, self]])
         end
         alias :second :seconds
 
         def minutes
-          self * 60
+          ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
         end
         alias :minute :minutes  
         
         def hours
-          self * 60.minutes
+          ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
         end
         alias :hour :hours
         
         def days
-          self * 24.hours
+          ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
         end
         alias :day :days
 
         def weeks
-          self * 7.days
+          ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
         end
         alias :week :weeks
         
         def fortnights
-          self * 2.weeks
+          ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
         end
         alias :fortnight :fortnights
         
         def months
-          self * 30.days
+          ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
         end
         alias :month :months
 
         def years
-          (self * 365.25.days).to_i
+          ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
         end
         alias :year :years
 

data/lib/active_support/core_ext/object.rb

@@ -1,2 +1,3 @@
-require File.dirname(__FILE__) + '/object/extending'
-require File.dirname(__FILE__) + '/object/misc'
+require 'active_support/core_ext/object/extending'
+require 'active_support/core_ext/object/instance_variables'
+require 'active_support/core_ext/object/misc'

data/lib/active_support/core_ext/object/extending.rb

@@ -1,47 +1,58 @@
-class Object #:nodoc:
-  def remove_subclasses_of(*superclasses)
+class Object
+  def remove_subclasses_of(*superclasses) #:nodoc:
     Class.remove_class(*subclasses_of(*superclasses))
   end
 
-  def subclasses_of(*superclasses)
+  def subclasses_of(*superclasses) #:nodoc:
     subclasses = []
+
+    # Exclude this class unless it's a subclass of our supers and is defined.
+    # We check defined? in case we find a removed class that has yet to be
+    # garbage collected. This also fails for anonymous classes -- please
+    # submit a patch if you have a workaround.
     ObjectSpace.each_object(Class) do |k|
-      next if # Exclude this class if
-        (k.ancestors & superclasses).empty? || # It's not a subclass of our supers
-        superclasses.include?(k) || # It *is* one of the supers
-        eval("! defined?(::#{k})") || # It's not defined.
-        eval("::#{k}").object_id != k.object_id
-      subclasses << k
+      if superclasses.any? { |superclass| k < superclass } &&
+        (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+        subclasses << k
+      end
     end
+
     subclasses
   end
-  
-  def extended_by
+
+  def extended_by #:nodoc:
     ancestors = class << self; ancestors end
     ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
   end
-  
-  def copy_instance_variables_from(object, exclude = [])
-    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
-    
-    instance_variables = object.instance_variables - exclude.map { |name| name.to_s }
-    instance_variables.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-  end
-  
-  def extend_with_included_modules_from(object)
+
+  def extend_with_included_modules_from(object) #:nodoc:
     object.extended_by.each { |mod| extend mod }
   end
 
-  def instance_values
-    instance_variables.inject({}) do |values, name|
-      values[name[1..-1]] = instance_variable_get(name)
-      values
-    end
-  end
-  
   unless defined? instance_exec # 1.9
-    def instance_exec(*arguments, &block)
-      block.bind(self)[*arguments]
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
     end
   end
 end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -0,0 +1,22 @@
+class Object
+  # Available in 1.8.6 and later.
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+  def copy_instance_variables_from(object, exclude = []) #:nodoc:
+    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
+
+    vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
+    vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
+  end
+end

data/lib/active_support/core_ext/object/misc.rb

@@ -1,4 +1,9 @@
-class Object #:nodoc:
+class Object
+  unless respond_to?(:send!)
+    # Anticipating Ruby 1.9 neutering send
+    alias send! send
+  end
+
   # A Ruby-ized realization of the K combinator, courtesy of Mikael Brockman.
   #
   #   def foo
@@ -24,11 +29,31 @@ class Object #:nodoc:
     value
   end
 
+  # An elegant way to refactor out common options
+  # 
+  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
+  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
+  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
+  #     post.has_many :all_comments
+  #   end
+  #
+  # Can also be used with an explicit receiver:
+  #
+  #   map.with_options :controller => "people" do |people|
+  #     people.connect "/people",     :action => "index"
+  #     people.connect "/people/:id", :action => "show"
+  #   end
+  #
   def with_options(options)
     yield ActiveSupport::OptionMerger.new(self, options)
   end
   
-  def to_json
-    ActiveSupport::JSON.encode(self)
+  # A duck-type assistant method. For example, ActiveSupport extends Date
+  # to define an acts_like_date? method, and extends Time to define
+  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
+  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
+  # we want to act like Time simply need to define an acts_like_time? method.
+  def acts_like?(duck)
+    respond_to? "acts_like_#{duck}?"
   end
-end
+end

data/lib/active_support/core_ext/pathname.rb

@@ -1,5 +1,5 @@
 require 'pathname'
-require File.dirname(__FILE__) + '/pathname/clean_within'
+require 'active_support/core_ext/pathname/clean_within'
 
 class Pathname#:nodoc:
   extend ActiveSupport::CoreExtensions::Pathname::CleanWithin