activerecord 1.6.0 → 1.7.0

data/lib/active_record/support/class_attribute_accessors.rb

@@ -1,57 +0,0 @@
-# Extends the class object with class and instance accessors for class attributes, 
-# just like the native attr* accessors for instance attributes.
-class Class # :nodoc:
-  def cattr_reader(*syms)
-    syms.each do |sym|
-      class_eval <<-EOS
-        if ! defined? @@#{sym.id2name}
-          @@#{sym.id2name} = nil
-        end
-        
-        def self.#{sym.id2name}
-          @@#{sym}
-        end
-
-        def #{sym.id2name}
-          @@#{sym}
-        end
-
-        def call_#{sym.id2name}
-          case @@#{sym.id2name}
-            when Symbol then send(@@#{sym})
-            when Proc   then @@#{sym}.call(self)
-            when String then @@#{sym}
-            else nil
-          end
-        end
-      EOS
-    end
-  end
-  
-  def cattr_writer(*syms)
-    syms.each do |sym|
-      class_eval <<-EOS
-        if ! defined? @@#{sym.id2name}
-          @@#{sym.id2name} = nil
-        end
-        
-        def self.#{sym.id2name}=(obj)
-          @@#{sym.id2name} = obj
-        end
-
-        def self.set_#{sym.id2name}(obj)
-          @@#{sym.id2name} = obj
-        end
-
-        def #{sym.id2name}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-    end
-  end
-  
-  def cattr_accessor(*syms)
-    cattr_reader(*syms)
-    cattr_writer(*syms)
-  end
-end

data/lib/active_record/support/class_inheritable_attributes.rb

@@ -1,117 +0,0 @@
-# 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.
-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
-  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 #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-      EOS
-    end
-  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
-
-  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/clean_logger.rb

@@ -1,10 +0,0 @@
-require 'logger'
-
-class Logger #:nodoc:
-  private
-    remove_const "Format"
-    Format = "%s\n"
-    def format_message(severity, timestamp, msg, progname)
-      Format % [msg]
-    end
-end

data/lib/active_record/support/core_ext.rb

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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/object_and_class.rb

@@ -1,24 +0,0 @@
-class Object #:nodoc:
-  def remove_subclasses_of(superclass)
-    subclasses_of(superclass).each { |subclass| Object.send(:remove_const, subclass) rescue nil }
-  end
-
-  def subclasses_of(superclass)
-    subclasses = []
-    ObjectSpace.each_object(Class) do |k|
-      next if !k.ancestors.include?(superclass) || superclass == k || k.to_s.include?("::") || subclasses.include?(k.to_s)
-      subclasses << k.to_s
-    end
-    subclasses
-  end
-end
-
-class Class #:nodoc:
-  def remove_subclasses
-    Object.remove_subclasses_of(self)
-  end
-
-  def subclasses
-    Object.subclasses_of(self)
-  end
-end

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

@@ -1,5 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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 humanize
-          Inflector.humanize(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

@@ -1,63 +0,0 @@
-require File.dirname(__FILE__) + '/module_attribute_accessors'
-
-module Dependencies
-  extend self
-  
-  @@loaded = [ ]
-  mattr_accessor :loaded
-
-  @@mechanism = :load
-  mattr_accessor :mechanism
-  
-  def load?
-    mechanism == :load
-  end
-  
-  def depend_on(file_name, swallow_load_errors = false)
-    if !loaded.include?(file_name)
-      loaded << file_name
-      begin
-        require_or_load(file_name)
-      rescue LoadError
-        raise unless swallow_load_errors
-      rescue Object => e
-        raise ScriptError, "#{e.message}"
-      end
-    end
-  end
-
-  def associate_with(file_name)
-    depend_on(file_name, true)
-  end
-  
-  def clear
-    self.loaded = [ ]
-  end
-  
-  def require_or_load(file_name)
-    load? ? load("#{file_name}.rb") : require(file_name)
-  end
-  
-  def remove_subclasses_for(*classes)
-    classes.each { |klass| klass.remove_subclasses }
-  end
-end
-
-Object.send(:define_method, :require_or_load)     { |file_name| Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
-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 #:nodoc:
-  class << self
-    # Use const_missing to autoload associations so we don't have to
-    # require_association when using single-table inheritance.
-    def const_missing(class_id)
-      begin
-        require_or_load(class_id.to_s.demodulize.underscore)
-        if Object.const_defined?(class_id) then return Object.const_get(class_id) else raise LoadError end
-      rescue LoadError
-        raise NameError, "uninitialized constant #{class_id}"
-      end
-    end
-  end
-end