activerecord 1.0.0 → 4.0.0

data/lib/active_record/associations/association_collection.rb

@@ -1,70 +0,0 @@
-module ActiveRecord
-  module Associations
-    class AssociationCollection #:nodoc:
-      alias_method :proxy_respond_to?, :respond_to?
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?|^proxy_respond_to\?)/ }
-      
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        @owner = owner
-        @options = options
-        @association_name = association_name
-        @association_class = eval(association_class_name)
-        @association_class_primary_key_name = association_class_primary_key_name
-      end
-      
-      def method_missing(symbol, *args, &block)
-        load_collection_to_array
-        @collection_array.send(symbol, *args, &block)
-      end
-  
-      def to_ary
-        load_collection_to_array
-        @collection_array.to_ary
-      end
-      
-      def respond_to?(symbol)
-        proxy_respond_to?(symbol) || [].respond_to?(symbol)
-      end
-      
-      def reload
-        @collection_array = nil
-      end
-      
-      def concat(*records)
-        records.flatten!
-        records.each {|record| self << record; }
-      end
-      
-      def destroy_all
-        load_collection_to_array
-        @collection_array.each { |object| object.destroy  }
-        @collection_array = []
-      end
-      
-      def size
-        (@collection_array.nil?) ? count_records : @collection_array.size
-      end
-      
-      def empty?
-        size == 0
-      end
-      
-      alias_method :length, :size
-      
-      private
-        def load_collection_to_array
-          return unless @collection_array.nil? 
-          begin
-            @collection_array = find_all_records
-          rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordNotFound
-            @collection_array = []
-          end       
-        end
-        
-        def duplicated_records_array(records)
-          records = [records] unless records.is_a?(Array) || records.is_a?(ActiveRecord::Associations::AssociationCollection)
-          records.dup
-        end
-    end
-  end
-end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,107 +0,0 @@
-# sqlite_adapter.rb
-# author:   Luke Holden <lholden@cablelan.net>
-
-require 'active_record/connection_adapters/abstract_adapter'
-
-begin
-  require 'sqlite' unless self.class.const_defined?(:SQLite)
-
-  module ActiveRecord
-    class Base
-      # Establishes a connection to the database that's used by all Active Record objects
-      def self.sqlite_connection(config) # :nodoc:
-        symbolize_strings_in_hash(config)
-        unless config.has_key?(:dbfile)
-          raise ArgumentError, "No database file specified. Missing argument: dbfile"
-        end
-
-        db = SQLite::Database.new(config[:dbfile], 0)
-
-        db.show_datatypes   = "ON" if !defined? SQLite::Version
-        db.results_as_hash  = true if defined? SQLite::Version
-        db.type_translation = false
-
-        ConnectionAdapters::SQLiteAdapter.new(db, logger)
-      end
-    end
-
-    module ConnectionAdapters
-      class SQLiteAdapter < AbstractAdapter # :nodoc:
-        def select_all(sql, name = nil)
-          select(sql, name)
-        end
-
-        def select_one(sql, name = nil)
-          result = select(sql, name)
-          result.nil? ? nil : result.first
-        end
-
-        def columns(table_name, name = nil)
-          table_structure(table_name).inject([]) do |columns, field| 
-            columns << Column.new(field['name'], field['dflt_value'], field['type'])
-            columns
-          end
-        end
-
-        def insert(sql, name = nil, pk = nil, id_value = nil)
-          execute(sql, name = nil)
-          id_value || @connection.send( defined?( SQLite::Version ) ? :last_insert_row_id : :last_insert_rowid )
-        end
-
-        def execute(sql, name = nil)
-          log(sql, name, @connection) do |connection|
-            if defined?( SQLite::Version )
-              case sql
-                when "BEGIN" then connection.transaction
-                when "COMMIT" then connection.commit
-                when "ROLLBACK" then connection.rollback
-                else connection.execute(sql)
-              end
-            else
-              connection.execute( sql )
-            end
-          end
-        end
-
-        alias_method :update, :execute
-        alias_method :delete, :execute
-
-        def begin_db_transaction()    execute "BEGIN" end
-        def commit_db_transaction()   execute "COMMIT" end
-        def rollback_db_transaction() execute "ROLLBACK" end
-
-        def quote_column_name(name)
-          return "'#{name}'"
-        end
-
-        private
-          def select(sql, name = nil)
-            results = nil
-            log(sql, name, @connection) { |connection| results = connection.execute(sql) }
-
-            rows = []
-
-            results.each do |row|
-              hash_only_row = {}
-              row.each_key do |key|
-                hash_only_row[key.gsub(/\w\./, "")] = row[key] unless key.class == Fixnum
-              end
-              rows << hash_only_row
-            end
-
-            return rows
-          end
-
-          def table_structure(table_name)
-            sql = "PRAGMA table_info(#{table_name});"
-            results = nil
-            log(sql, nil, @connection) { |connection| results = connection.execute(sql) }
-            return results
-          end
-      end
-    end
-  end
-rescue LoadError
-  retry if require('rubygems') rescue LoadError
-  # SQLite driver is not availible
-end

data/lib/active_record/deprecated_associations.rb

@@ -1,70 +0,0 @@
-module ActiveRecord
-  module Associations # :nodoc:
-    module ClassMethods
-      def deprecated_collection_count_method(collection_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def #{collection_name}_count(force_reload = false)
-            #{collection_name}.reload if force_reload
-            #{collection_name}.size
-          end
-        end_eval
-      end
-      
-      def deprecated_add_association_relation(association_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def add_#{association_name}(*items)
-            #{association_name}.concat(items)
-          end
-        end_eval
-      end
-    
-       def deprecated_remove_association_relation(association_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def remove_#{association_name}(items)
-            #{association_name}.delete(items)
-          end
-        end_eval
-      end
-    
-      def deprecated_has_collection_method(collection_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def has_#{collection_name}?(force_reload = false)
-            !#{collection_name}(force_reload).empty?
-          end
-        end_eval
-      end
-      
-      def deprecated_find_in_collection_method(collection_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def find_in_#{collection_name}(association_id)
-            #{collection_name}.find(association_id)
-          end
-        end_eval
-      end
-      
-      def deprecated_find_all_in_collection_method(collection_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def find_all_in_#{collection_name}(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
-            #{collection_name}.find_all(runtime_conditions, orderings, limit, joins)
-          end
-        end_eval
-      end
-    
-      def deprecated_create_method(collection_name)# :nodoc:
-        module_eval <<-"end_eval", __FILE__, __LINE__
-          def create_in_#{collection_name}(attributes = {})
-            #{collection_name}.create(attributes)
-          end
-        end_eval
-      end
-    
-      def deprecated_build_method(collection_name)# :nodoc:
-          module_eval <<-"end_eval", __FILE__, __LINE__
-            def build_to_#{collection_name}(attributes = {})
-              #{collection_name}.build(attributes)
-            end
-          end_eval
-        end
-    end
-  end
-end

data/lib/active_record/observer.rb

@@ -1,71 +0,0 @@
-require 'singleton'
-
-module ActiveRecord
-  # Observers can be programmed to react to lifecycle callbacks in another class to implement
-  # trigger-like behavior outside the original class. This is a great way to reduce the clutter that
-  # normally comes when the model class is burdened with excess responsibility that doesn't pertain to
-  # the core and nature of the class. Example:
-  #
-  #   class CommentObserver < ActiveRecord::Observer
-  #     def after_save(comment)
-  #       NotificationServer.send_email("admin@do.com", "New comment was posted", comment)
-  #     end
-  #   end
-  #
-  # This Observer is triggered when a Comment#save is finished and sends a notification about it to the administrator.
-  #
-  # == Observing a class that can't be infered
-  #
-  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
-  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
-  # something else than the class you're interested in observing, you can implement the observed_class class method. Like this:
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     def self.observed_class() Account end
-  #     def after_update(account)
-  #       AuditTrail.new(account, "UPDATED")
-  #     end
-  #   end
-  #
-  # == Observing multiple classes at once
-  #
-  # If the audit observer needs to watch more than one kind of object, this can be specified in an array, like this:
-  #
-  #   class AuditObserver < ActiveRecord::Observer
-  #     def self.observed_class() [ Account, Balance ] end
-  #     def after_update(record)
-  #       AuditTrail.new(record, "UPDATED")
-  #     end
-  #   end
-  #
-  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
-  #
-  # The observer can implement callback methods for each of the methods described in the Callbacks module.
-  class Observer
-    include Singleton
-  
-    def initialize
-      [ observed_class ].flatten.each do |klass| 
-        klass.add_observer(self)
-        klass.send(:define_method, :after_find) unless klass.respond_to?(:after_find)
-      end
-    end
-  
-    def update(callback_method, object)
-      send(callback_method, object) if respond_to?(callback_method)
-    end
-    
-    private
-      def observed_class
-        if self.class.respond_to? "observed_class"
-          self.class.observed_class
-        else
-          Object.const_get(infer_observed_class_name)
-        end
-      end
-      
-      def infer_observed_class_name
-        self.class.name.scan(/(.*)Observer/)[0][0]
-      end
-  end
-end

data/lib/active_record/support/class_attribute_accessors.rb

@@ -1,43 +0,0 @@
-# attr_* style accessors for class-variables that can accessed both on an instance and class level.
-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}
-          self.class.#{sym.id2name}
-        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 #{sym.id2name}=(obj)
-          self.class.#{sym.id2name}=(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,37 +0,0 @@
-# Allows attributes to be shared within an inheritance hierarchy, but where each descentent 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
-    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 read_inheritable_attribute(key)
-      inheritable_attributes[key]
-    end
-    
-    private 
-      def inherited(child)
-        @@classes[child] = inheritable_attributes.dup
-      end
-      
-  end
-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/inflector.rb

@@ -1,70 +0,0 @@
-# The Inflector transforms words from singular to plural, class names to table names, modulized class names to ones without,
-# and class names to foreign keys.
-module Inflector 
-  extend self
-
-  def pluralize(word)
-    result = word.dup
-    plural_rules.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
-    end
-    return result
-  end
-
-  def singularize(word)
-    result = word.dup
-    singular_rules.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
-    end
-    return result
-  end
-
-  def camelize(lower_case_and_underscored_word)
-    lower_case_and_underscored_word.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
-  end
-
-  def demodulize(class_name_in_module)
-    class_name_in_module.gsub(/^.*::/, '')
-  end
-
-  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-    Inflector.underscore(Inflector.demodulize(class_name)) + 
-      (separate_class_name_and_id_with_underscore ? "_id" : "id")
-  end
-  
-  private
-    def plural_rules #:doc:
-      [
-        [/(x|ch|ss)$/, '\1es'],               # search, switch, fix, box, process, address
-        [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
-        [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
-        [/sis$/, 'ses'],                      # basis, diagnosis
-        [/([ti])um$/, '\1a'],                 # datum, medium
-        [/person$/, 'people'],                # person, salesperson
-        [/man$/, 'men'],                      # man, woman, spokesman
-        [/child$/, 'children'],               # child
-        [/s$/, 's'],                          # no change (compatibility)
-        [/$/, 's']
-      ]
-    end
-
-    def singular_rules #:doc:
-      [
-          [/(x|ch|ss)es$/, '\1'],
-          [/([^aeiouy]|qu)ies$/, '\1y'],
-          [/([lr])ves$/, '\1f'],
-          [/([^f])ves$/, '\1fe'],
-          [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'],
-          [/([ti])a$/, '\1um'],
-          [/people$/, 'person'],
-          [/men$/, 'man'],
-          [/status$/, 'status'],
-          [/children$/, 'child'],
-          [/s$/, '']
-        ]
-    end
-end