activerecord 4.0.4 → 4.1.16

data/lib/active_record/store.rb

@@ -15,6 +15,11 @@ module ActiveRecord
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
+  # NOTE - If you are using PostgreSQL specific columns like +hstore+ or +json+ there is no need for
+  # the serialization provided by +store+. Simply use +store_accessor+ instead to generate
+  # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
+  # using a symbol.
+  #
   # Examples:
   #
   #   class User < ActiveRecord::Base
@@ -61,8 +66,9 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :stored_attributes, instance_accessor: false
-      self.stored_attributes = {}
+      class << self
+        attr_accessor :local_stored_attributes
+      end
     end
 
     module ClassMethods
@@ -86,8 +92,11 @@ module ActiveRecord
           end
         end
 
-        self.stored_attributes[store_attribute] ||= []
-        self.stored_attributes[store_attribute] |= keys
+        # assign new store attribute and create new hash to ensure that each class in the hierarchy
+        # has its own hash of stored attributes.
+        self.local_stored_attributes ||= {}
+        self.local_stored_attributes[store_attribute] ||= []
+        self.local_stored_attributes[store_attribute] |= keys
       end
 
       def _store_accessors_module
@@ -97,30 +106,70 @@ module ActiveRecord
           mod
         end
       end
+
+      def stored_attributes
+        parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
+        if self.local_stored_attributes
+          parent.merge!(self.local_stored_attributes) { |k, a, b| a | b }
+        end
+        parent
+      end
     end
 
     protected
       def read_store_attribute(store_attribute, key)
-        attribute = initialize_store_attribute(store_attribute)
-        attribute[key]
+        accessor = store_accessor_for(store_attribute)
+        accessor.read(self, store_attribute, key)
       end
 
       def write_store_attribute(store_attribute, key, value)
-        attribute = initialize_store_attribute(store_attribute)
-        if value != attribute[key]
-          send :"#{store_attribute}_will_change!"
-          attribute[key] = value
-        end
+        accessor = store_accessor_for(store_attribute)
+        accessor.write(self, store_attribute, key, value)
       end
 
     private
-      def initialize_store_attribute(store_attribute)
-        attribute = send(store_attribute)
-        unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
-          attribute = IndifferentCoder.as_indifferent_hash(attribute)
-          send :"#{store_attribute}=", attribute
+      def store_accessor_for(store_attribute)
+        @column_types[store_attribute.to_s].accessor
+      end
+
+      class HashAccessor
+        def self.read(object, attribute, key)
+          prepare(object, attribute)
+          object.public_send(attribute)[key]
+        end
+
+        def self.write(object, attribute, key, value)
+          prepare(object, attribute)
+          if value != read(object, attribute, key)
+            object.public_send :"#{attribute}_will_change!"
+            object.public_send(attribute)[key] = value
+          end
+        end
+
+        def self.prepare(object, attribute)
+          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+        end
+      end
+
+      class StringKeyedHashAccessor < HashAccessor
+        def self.read(object, attribute, key)
+          super object, attribute, key.to_s
+        end
+
+        def self.write(object, attribute, key, value)
+          super object, attribute, key.to_s, value
+        end
+      end
+
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
+        def self.prepare(object, store_attribute)
+          attribute = object.send(store_attribute)
+          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            attribute = IndifferentCoder.as_indifferent_hash(attribute)
+            object.send :"#{store_attribute}=", attribute
+          end
+          attribute
         end
-        attribute
       end
 
     class IndifferentCoder # :nodoc:
@@ -138,7 +187,7 @@ module ActiveRecord
       end
 
       def load(yaml)
-        self.class.as_indifferent_hash @coder.load(yaml || '')
+        self.class.as_indifferent_hash(@coder.load(yaml || ''))
       end
 
       def self.as_indifferent_hash(obj)

data/lib/active_record/tasks/database_tasks.rb

@@ -36,9 +36,8 @@ module ActiveRecord
     module DatabaseTasks
       extend self
 
-      attr_writer :current_config
-      attr_accessor :database_configuration, :migrations_paths, :seed_loader, :db_dir,
-                    :fixtures_path, :env, :root
+      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      attr_accessor :database_configuration
 
       LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
 
@@ -51,20 +50,36 @@ module ActiveRecord
       register_task(/postgresql/,   ActiveRecord::Tasks::PostgreSQLDatabaseTasks)
       register_task(/sqlite/,       ActiveRecord::Tasks::SQLiteDatabaseTasks)
 
-      register_task(/firebird/,     ActiveRecord::Tasks::FirebirdDatabaseTasks)
-      register_task(/sqlserver/,    ActiveRecord::Tasks::SqlserverDatabaseTasks)
-      register_task(/(oci|oracle)/, ActiveRecord::Tasks::OracleDatabaseTasks)
+      def db_dir
+        @db_dir ||= Rails.application.config.paths["db"].first
+      end
+
+      def migrations_paths
+        @migrations_paths ||= Rails.application.paths['db/migrate'].to_a
+      end
+
+      def fixtures_path
+        @fixtures_path ||= File.join(root, 'test', 'fixtures')
+      end
+
+      def root
+        @root ||= Rails.root
+      end
+
+      def env
+        @env ||= Rails.env
+      end
+
+      def seed_loader
+        @seed_loader ||= Rails.application
+      end
 
       def current_config(options = {})
         options.reverse_merge! :env => env
         if options.has_key?(:config)
           @current_config = options[:config]
         else
-          @current_config ||= if ENV['DATABASE_URL']
-                                database_url_config
-                              else
-                                ActiveRecord::Base.configurations[options[:env]]
-                              end
+          @current_config ||= ActiveRecord::Base.configurations[options[:env]]
         end
       end
 
@@ -86,11 +101,7 @@ module ActiveRecord
         each_current_configuration(environment) { |configuration|
           create configuration
         }
-        ActiveRecord::Base.establish_connection environment
-      end
-
-      def create_database_url
-        create database_url_config
+        ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def drop(*arguments)
@@ -111,10 +122,6 @@ module ActiveRecord
         }
       end
 
-      def drop_database_url
-        drop database_url_config
-      end
-
       def charset_current(environment = env)
         charset ActiveRecord::Base.configurations[environment]
       end
@@ -149,6 +156,43 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
       end
 
+      def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
+        load_schema_current(format, file)
+      end
+
+      # This method is the successor of +load_schema+. We should rename it
+      # after +load_schema+ went through a deprecation cycle. (Rails > 4.2)
+      def load_schema_for(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        case format
+        when :ruby
+          file ||= File.join(db_dir, "schema.rb")
+          check_schema_file(file)
+          ActiveRecord::Base.establish_connection(configuration)
+          load(file)
+        when :sql
+          file ||= File.join(db_dir, "structure.sql")
+          check_schema_file(file)
+          structure_load(configuration, file)
+        else
+          raise ArgumentError, "unknown format #{format.inspect}"
+        end
+      end
+
+      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        each_current_configuration(environment) { |configuration|
+          load_schema_for configuration, format, file
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def check_schema_file(filename)
+        unless File.exist?(filename)
+          message = %{#{filename} doesn't exist yet. Run `rake db:migrate` to create it, then try again.}
+          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
+          Kernel.abort message
+        end
+      end
+
       def load_seed
         if seed_loader
           seed_loader.load_seed
@@ -161,11 +205,6 @@ module ActiveRecord
 
       private
 
-      def database_url_config
-        @database_url_config ||=
-               ConnectionAdapters::ConnectionSpecification::Resolver.new(ENV["DATABASE_URL"], {}).spec.config.stringify_keys
-      end
-
       def class_for_adapter(adapter)
         key = @tasks.keys.detect { |pattern| adapter[pattern] }
         unless key
@@ -176,7 +215,8 @@ module ActiveRecord
 
       def each_current_configuration(environment)
         environments = [environment]
-        environments << 'test' if environment == 'development'
+        # add test environment only if no RAILS_ENV was specified.
+        environments << 'test' if environment == 'development' && ENV['RAILS_ENV'].nil?
 
         configurations = ActiveRecord::Base.configurations.values_at(*environments)
         configurations.compact.each do |configuration|

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -42,7 +42,7 @@ module ActiveRecord
       end
 
       def purge
-        establish_connection :test
+        establish_connection configuration
         connection.recreate_database configuration['database'], creation_options
       end
 
@@ -129,15 +129,21 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
       end
 
       def prepare_command_options(command)
-        args = [command]
-        args.concat(['--user', configuration['username']]) if configuration['username']
-        args << "--password=#{configuration['password']}"  if configuration['password']
-        args.concat(['--default-character-set', configuration['encoding']]) if configuration['encoding']
-        configuration.slice('host', 'port', 'socket').each do |k, v|
-          args.concat([ "--#{k}", v.to_s ]) if v
-        end
-
-        args
+        args = {
+          'host'      => '--host',
+          'port'      => '--port',
+          'socket'    => '--socket',
+          'username'  => '--user',
+          'password'  => '--password',
+          'encoding'  => '--default-character-set',
+          'sslca'     => '--ssl-ca',
+          'sslcert'   => '--ssl-cert',
+          'sslcapath' => '--ssl-capath',
+          'sslcipher' => '--ssl-cipher',
+          'sslkey'    => '--ssl-key'
+        }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+
+        [command, *args]
       end
     end
   end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -51,7 +51,7 @@ module ActiveRecord
           search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
         end
 
-        command = "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
+        command = "pg_dump -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
         raise 'Error dumping database' unless Kernel.system(command)
 
         File.open(filename, "a") { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -21,7 +21,11 @@ module ActiveRecord
 
         FileUtils.rm(file) if File.exist?(file)
       end
-      alias :purge :drop
+
+      def purge
+        drop
+        create
+      end
 
       def charset
         connection.encoding

data/lib/active_record/timestamp.rb

@@ -37,13 +37,13 @@ module ActiveRecord
     end
 
     def initialize_dup(other) # :nodoc:
-      clear_timestamp_attributes
       super
+      clear_timestamp_attributes
     end
 
   private
 
-    def create_record
+    def _create_record
       if self.record_timestamps
         current_time = current_time_from_proper_timezone
 
@@ -57,7 +57,7 @@ module ActiveRecord
       super
     end
 
-    def update_record(*args)
+    def _update_record(*args)
       if should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
@@ -71,7 +71,7 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      self.record_timestamps && (!partial_writes? || changed? || (attributes.keys & self.class.serialized_attributes.keys).present?)
+      self.record_timestamps && (!partial_writes? || changed?)
     end
 
     def timestamp_attributes_for_create_in_model
@@ -98,8 +98,8 @@ module ActiveRecord
       timestamp_attributes_for_create + timestamp_attributes_for_update
     end
 
-    def max_updated_column_timestamp
-      if (timestamps = timestamp_attributes_for_update.map { |attr| self[attr] }.compact).present?
+    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
+      if (timestamps = timestamp_names.map { |attr| self[attr] }.compact).present?
         timestamps.map { |ts| ts.to_time }.max
       end
     end

data/lib/active_record/transactions.rb

@@ -6,11 +6,10 @@ module ActiveRecord
     extend ActiveSupport::Concern
     ACTIONS = [:create, :destroy, :update]
 
-    class TransactionError < ActiveRecordError # :nodoc:
-    end
-
     included do
-      define_callbacks :commit, :rollback, :terminator => "result == false", :scope => [:kind, :name]
+      define_callbacks :commit, :rollback,
+                       terminator: ->(_, result) { result == false },
+                       scope: [:kind, :name]
     end
 
     # = Active Record Transactions
@@ -241,17 +240,16 @@ module ActiveRecord
       def set_options_for_callbacks!(args)
         options = args.last
         if options.is_a?(Hash) && options[:on]
-          assert_valid_transaction_action(options[:on])
-          options[:if] = Array(options[:if])
           fire_on = Array(options[:on])
+          assert_valid_transaction_action(fire_on)
+          options[:if] = Array(options[:if])
           options[:if] << "transaction_include_any_action?(#{fire_on})"
         end
       end
 
       def assert_valid_transaction_action(actions)
-        actions = Array(actions)
         if (actions - ACTIONS).any?
-          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS.join(",")}"
+          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS}"
         end
       end
     end
@@ -306,6 +304,7 @@ module ActiveRecord
       run_callbacks :rollback
     ensure
       restore_transaction_record_state(force_restore_state)
+      clear_transaction_record_state
     end
 
     # Add the record to the current transaction so that the +after_rollback+ and +after_commit+ callbacks
@@ -362,21 +361,20 @@ module ActiveRecord
     # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
     def restore_transaction_record_state(force = false) #:nodoc:
       unless @_start_transaction_state.empty?
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-        if @_start_transaction_state[:level] < 1 || force
+        transaction_level = (@_start_transaction_state[:level] || 0) - 1
+        if transaction_level < 1 || force
           restore_state = @_start_transaction_state
           was_frozen = restore_state[:frozen?]
           @attributes = @attributes.dup if @attributes.frozen?
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
           if restore_state.has_key?(:id)
-            self.id = restore_state[:id]
+            write_attribute(self.class.primary_key, restore_state[:id])
           else
             @attributes.delete(self.class.primary_key)
             @attributes_cache.delete(self.class.primary_key)
           end
           @attributes.freeze if was_frozen
-          @_start_transaction_state.clear
         end
       end
     end

data/lib/active_record/validations/presence.rb

@@ -4,7 +4,7 @@ module ActiveRecord
       def validate(record)
         super
         attributes.each do |attribute|
-          next unless record.class.reflect_on_association(attribute)
+          next unless record.class._reflect_on_association(attribute)
           associated_records = Array.wrap(record.send(attribute))
 
           # Superclass validates presence. Ensure present records aren't about to be destroyed.

data/lib/active_record/validations/uniqueness.rb

@@ -7,16 +7,13 @@ module ActiveRecord
                                "Pass a callable instead: `conditions: -> { where(approved: true) }`"
         end
         super({ case_sensitive: true }.merge!(options))
-      end
-
-      # Unfortunately, we have to tie Uniqueness validators to a class.
-      def setup(klass)
-        @klass = klass
+        @klass = options[:class]
       end
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
         table = finder_class.arel_table
+        value = map_enum_attribute(finder_class,attribute,value)
         value = deserialize_attribute(record, attribute, value)
 
         relation = build_relation(finder_class, table, attribute, value)
@@ -34,7 +31,6 @@ module ActiveRecord
       end
 
     protected
-
       # The check for an existing value should be run from a class that
       # isn't abstract. This means working down from the current class
       # (self), to the first non-abstract class. Since classes don't know
@@ -51,7 +47,7 @@ module ActiveRecord
       end
 
       def build_relation(klass, table, attribute, value) #:nodoc:
-        if reflection = klass.reflect_on_association(attribute)
+        if reflection = klass._reflect_on_association(attribute)
           attribute = reflection.foreign_key
           value = value.attributes[reflection.primary_key_column.name] unless value.nil?
         end
@@ -79,13 +75,21 @@ module ActiveRecord
 
       def scope_relation(record, table, relation)
         Array(options[:scope]).each do |scope_item|
-          if reflection = record.class.reflect_on_association(scope_item)
+          if reflection = record.class._reflect_on_association(scope_item)
             scope_value = record.send(reflection.foreign_key)
             scope_item  = reflection.foreign_key
           else
             scope_value = record.read_attribute(scope_item)
           end
-          relation = relation.and(table[scope_item].eq(scope_value))
+
+          # This is basically emulating an Arel::Nodes::Casted
+          column = record.class.columns_hash[scope_item.to_s]
+          quoted_value = record.class.connection.quote(scope_value, column)
+          unless scope_value.nil?
+            node = Arel::Nodes::SqlLiteral.new(quoted_value)
+          end
+
+          relation = relation.and(table[scope_item].eq(node))
         end
 
         relation
@@ -96,6 +100,12 @@ module ActiveRecord
         value = coder.dump value if value && coder
         value
       end
+
+      def map_enum_attribute(klass, attribute, value)
+        mapping = klass.defined_enums[attribute.to_s]
+        value = mapping[value] if value && mapping
+        value
+      end
     end
 
     module ClassMethods

data/lib/active_record/version.rb

@@ -1,11 +1,8 @@
+require_relative 'gem_version'
+
 module ActiveRecord
-  # Returns the version of the currently loaded ActiveRecord as a Gem::Version
+  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
   def self.version
-    Gem::Version.new "4.0.4"
-  end
-
-  module VERSION #:nodoc:
-    MAJOR, MINOR, TINY, PRE = ActiveRecord.version.segments
-    STRING = ActiveRecord.version.to_s
+    gem_version
   end
 end

data/lib/active_record.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2013 David Heinemeier Hansson
+# Copyright (c) 2004-2014 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -25,7 +25,6 @@ require 'active_support'
 require 'active_support/rails'
 require 'active_model'
 require 'arel'
-require 'active_record/deprecated_finders'
 
 require 'active_record/version'
 
@@ -38,6 +37,7 @@ module ActiveRecord
   autoload :ConnectionHandling
   autoload :CounterCache
   autoload :DynamicMatchers
+  autoload :Enum
   autoload :Explain
   autoload :Inheritance
   autoload :Integration
@@ -45,10 +45,12 @@ module ActiveRecord
   autoload :Migrator, 'active_record/migration'
   autoload :ModelSchema
   autoload :NestedAttributes
+  autoload :NoTouching
   autoload :Persistence
   autoload :QueryCache
   autoload :Querying
   autoload :ReadonlyAttributes
+  autoload :RecordInvalid, 'active_record/validations'
   autoload :Reflection
   autoload :RuntimeRegistry
   autoload :Sanitization
@@ -94,6 +96,7 @@ module ActiveRecord
 
   module Coders
     autoload :YAMLColumn, 'active_record/coders/yaml_column'
+    autoload :JSON, 'active_record/coders/json'
   end
 
   module AttributeMethods
@@ -146,13 +149,8 @@ module ActiveRecord
     autoload :MySQLDatabaseTasks,  'active_record/tasks/mysql_database_tasks'
     autoload :PostgreSQLDatabaseTasks,
       'active_record/tasks/postgresql_database_tasks'
-
-    autoload :FirebirdDatabaseTasks, 'active_record/tasks/firebird_database_tasks'
-    autoload :SqlserverDatabaseTasks, 'active_record/tasks/sqlserver_database_tasks'
-    autoload :OracleDatabaseTasks, 'active_record/tasks/oracle_database_tasks'
   end
 
-  autoload :TestCase
   autoload :TestFixtures, 'active_record/fixtures'
 
   def self.eager_load!

data/lib/rails/generators/active_record/migration/migration_generator.rb

@@ -14,6 +14,10 @@ module ActiveRecord
       protected
       attr_reader :migration_action, :join_tables
 
+      # sets the default migration template that is being used for the generation of the migration
+      # depending on the arguments which would be sent out in the command line, the migration template 
+      # and the table name instance variables are setup.
+
       def set_local_assigns!
         @migration_template = "migration.rb"
         case file_name

data/lib/rails/generators/active_record/migration.rb

@@ -0,0 +1,18 @@
+require 'rails/generators/migration'
+
+module ActiveRecord
+  module Generators # :nodoc:
+    module Migration
+      extend ActiveSupport::Concern
+      include Rails::Generators::Migration
+
+      module ClassMethods
+        # Implement the required interface for Rails::Generators::Migration.
+        def next_migration_number(dirname)
+          next_migration_number = current_migration_number(dirname) + 1
+          ActiveRecord::Migration.next_migration_number(next_migration_number)
+        end
+      end
+    end
+  end
+end

data/lib/rails/generators/active_record/model/model_generator.rb

@@ -12,6 +12,9 @@ module ActiveRecord
       class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
       class_option :indexes,    :type => :boolean, :default => true, :desc => "Add indexes for references and belongs_to columns"
 
+      
+      # creates the migration file for the model.
+
       def create_migration_file
         return unless options[:migration] && options[:parent].nil?
         attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
@@ -39,6 +42,7 @@ module ActiveRecord
 
       protected
 
+        # Used by the migration template to determine the parent name of the model
         def parent_class_name
           options[:parent] || "ActiveRecord::Base"
         end