activerecord 1.4.0 → 1.5.0

data/lib/active_record/support/class_inheritable_attributes.rb

@@ -1,41 +1,117 @@
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
+
 # Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
 # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
 # to, for example, an array without those additions being shared with either their parent, siblings, or
 # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
-module ClassInheritableAttributes # :nodoc:
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-  end
-  
-  module ClassMethods # :nodoc:
-    @@classes ||= {}
-    
-    def inheritable_attributes
-      @@classes[self] ||= {}
-    end
-    
-    def write_inheritable_attribute(key, value)
-      inheritable_attributes[key] = value
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
     end
-    
-    def write_inheritable_array(key, elements)
-      write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-      write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
     end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
 
-    def read_inheritable_attribute(key)
-      inheritable_attributes[key]
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
     end
-    
-    def reset_inheritable_attributes
-      inheritable_attributes.clear
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
     end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
 
-    private 
-      def inherited(child)
-        @@classes[child] = inheritable_attributes.dup
-      end
-   
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
   end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= {}
+  end
+  
+  def write_inheritable_attribute(key, value)
+    inheritable_attributes[key] = value
+  end
+  
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+  
+  def reset_inheritable_attributes
+    inheritable_attributes.clear
+  end
+
+  private 
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
+    end
+
+    if respond_to?(:inherited)
+      alias_method :inherited_without_inheritable_attributes, :inherited
+    end
+    alias_method :inherited, :inherited_with_inheritable_attributes
 end

data/lib/active_record/support/core_ext.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }

data/lib/active_record/support/core_ext/hash.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/hash/keys'
+
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::Keys
+end

data/lib/active_record/support/core_ext/hash/keys.rb

@@ -0,0 +1,35 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Keys
+
+        # Return a new hash with all keys converted to symbols.
+        def symbolize_keys
+          inject({}) do |options, (key, value)|
+            options[key.to_sym] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to symbols.
+        def symbolize_keys!
+          keys.each do |key|
+            unless key.is_a?(Symbol)
+              self[key.to_sym] = self[key]
+              delete(key)
+            end
+          end
+          self
+        end
+
+        alias_method :to_options,  :symbolize_keys
+        alias_method :to_options!, :symbolize_keys!
+
+        def assert_valid_keys(valid_keys)
+          unknown_keys = keys - valid_keys
+          raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+        end
+      end
+    end
+  end
+end

data/lib/active_record/support/core_ext/numeric.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/numeric/time'
+require File.dirname(__FILE__) + '/numeric/bytes'
+
+class Numeric #:nodoc:
+  include ActiveSupport::CoreExtensions::Numeric::Time 
+  include ActiveSupport::CoreExtensions::Numeric::Bytes 
+end

data/lib/active_record/support/core_ext/numeric/bytes.rb

@@ -0,0 +1,33 @@
+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
+        def bytes
+          self
+        end
+        alias :byte :bytes
+
+        def kilobytes
+          self * 1024
+        end
+        alias :kilobyte :kilobytes
+
+        def megabytes
+          self * 1024.kilobytes
+        end
+        alias :megabyte :megabytes
+
+        def gigabytes
+          self * 1024.megabytes 
+        end
+        alias :gigabyte :gigabytes
+
+        def terabytes
+          self * 1024.gigabytes
+        end
+        alias :terabyte :terabytes
+      end
+    end
+  end
+end

data/lib/active_record/support/core_ext/numeric/time.rb

@@ -0,0 +1,59 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years
+      module Time
+        def minutes
+          self * 60
+        end
+        alias :minute :minutes  
+        
+        def hours
+          self * 60.minutes
+        end
+        alias :hour :hours
+        
+        def days
+          self * 24.hours
+        end
+        alias :day :days
+
+        def weeks
+          self * 7.days
+        end
+        alias :week :weeks
+        
+        def fortnights
+          self * 2.weeks
+        end
+        alias :fortnight :fortnights
+        
+        def months
+          self * 30.days
+        end
+        alias :month :months
+        
+        def years
+          self * 365.days
+        end
+        alias :year :years
+
+        # Reads best without arguments:  10.minutes.ago
+        def ago(time = ::Time.now)
+          time - self
+        end
+
+        # Reads best with argument:  10.minutes.until(time)
+        alias :until :ago
+
+        # 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
+    end
+  end
+end

data/lib/active_record/support/core_ext/string.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/string/inflections'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Inflections
+end

data/lib/active_record/support/core_ext/string/inflections.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../inflector'
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Makes it possible to do "posts".singularize that returns "post" and "MegaCoolClass".underscore that returns "mega_cool_class".
+      module Inflections
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        def camelize
+          Inflector.camelize(self)
+        end
+
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        def classify
+          Inflector.classify(self)
+        end
+
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/support/dependencies.rb

@@ -24,19 +24,6 @@ module Dependencies
   def associate_with(file_name)
     depend_on(file_name, true)
   end
-
-  def reload
-    old_loaded = loaded
-    clear
-    
-    old_loaded.each do |file_name| 
-      begin
-        silence_warnings { load("#{file_name}.rb") }
-      rescue LoadError
-        # The association didn't reside in its own file, so we assume it was required by other means
-      end
-    end
-  end
   
   def clear
     self.loaded = [ ]
@@ -51,7 +38,7 @@ end
 Object.send(:define_method, :require_dependency)  { |file_name| Dependencies.depend_on(file_name) } unless Object.respond_to?(:require_dependency)
 Object.send(:define_method, :require_association) { |file_name| Dependencies.associate_with(file_name) } unless Object.respond_to?(:require_association)
 
-class Object
+class Object #:nodoc:
   class << self
     # Use const_missing to autoload associations so we don't have to
     # require_association when using single-table inheritance.

data/lib/active_record/support/inflector.rb

@@ -4,7 +4,7 @@ module Inflector
   extend self
 
   def pluralize(word)
-    result = word.dup
+    result = word.to_s.dup
     plural_rules.each do |(rule, replacement)|
       break if result.gsub!(rule, replacement)
     end
@@ -12,7 +12,7 @@ module Inflector
   end
 
   def singularize(word)
-    result = word.dup
+    result = word.to_s.dup
     singular_rules.each do |(rule, replacement)|
       break if result.gsub!(rule, replacement)
     end
@@ -20,15 +20,15 @@ module Inflector
   end
 
   def camelize(lower_case_and_underscored_word)
-    lower_case_and_underscored_word.gsub(/(^|_)(.)/){$2.upcase}
+    lower_case_and_underscored_word.to_s.gsub(/(^|_)(.)/){$2.upcase}
   end
   
   def underscore(camel_cased_word)
-    camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+    camel_cased_word.to_s.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
   end
 
   def demodulize(class_name_in_module)
-    class_name_in_module.gsub(/^.*::/, '')
+    class_name_in_module.to_s.gsub(/^.*::/, '')
   end
 
   def tableize(class_name)
@@ -47,7 +47,7 @@ module Inflector
   private
     def plural_rules #:doc:
       [
-        [/(x|ch|ss)$/, '\1es'],               # search, switch, fix, box, process, address
+        [/(x|ch|ss|sh)$/, '\1es'],               # search, switch, fix, box, process, address
         [/([^aeiouy]|qu)ies$/, '\1y'],
         [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
         [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife

data/lib/active_record/support/misc.rb

@@ -6,27 +6,3 @@ def silence_warnings
     $VERBOSE = old_verbose
   end
 end
-
-class Hash
-  # Return a new hash with all keys converted to symbols.
-  def symbolize_keys
-    inject({}) do |options, (key, value)|
-      options[key.to_sym] = value
-      options
-    end
-  end
-
-  # Destructively convert all keys to symbols.
-  def symbolize_keys!
-    keys.each do |key|
-      unless key.is_a?(Symbol)
-        self[key.to_sym] = self[key]
-        delete(key)
-      end
-    end
-    self
-  end
-
-  alias_method :to_options,  :symbolize_keys
-  alias_method :to_options!, :symbolize_keys!
-end