activerecord 4.0.13 → 4.1.0.beta1

data/lib/active_record/relation/spawn_methods.rb

@@ -64,8 +64,7 @@ module ActiveRecord
     private
 
       def relation_with(values) # :nodoc:
-        result = Relation.new(klass, table, values)
-        result.default_scoped = default_scoped
+        result = Relation.create(klass, table, values)
         result.extend(*extending_values) if extending_values.any?
         result
       end

data/lib/active_record/result.rb

@@ -3,11 +3,36 @@ module ActiveRecord
   # This class encapsulates a Result returned from calling +exec_query+ on any
   # database connection adapter. For example:
   #
-  #   x = ActiveRecord::Base.connection.exec_query('SELECT * FROM foo')
-  #   x # => #<ActiveRecord::Result:0xdeadbeef>
+  #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
+  #   result # => #<ActiveRecord::Result:0xdeadbeef>
+  #
+  #   # Get the column names of the result:
+  #   result.columns
+  #   # => ["id", "title", "body"]
+  #
+  #   # Get the record values of the result:
+  #   result.rows
+  #   # => [[1, "title_1", "body_1"],
+  #         [2, "title_2", "body_2"],
+  #         ...
+  #        ]
+  #
+  #   # Get an array of hashes representing the result (column => value):
+  #   result.to_hash
+  #   # => [{"id" => 1, "title" => "title_1", "body" => "body_1"},
+  #         {"id" => 2, "title" => "title_2", "body" => "body_2"},
+  #         ...
+  #        ]
+  #
+  #   # ActiveRecord::Result also includes Enumerable.
+  #   result.each do |row|
+  #     puts row['title'] + " " + row['body']
+  #   end
   class Result
     include Enumerable
 
+    IDENTITY_TYPE = Class.new { def type_cast(v); v; end }.new # :nodoc:
+
     attr_reader :columns, :rows, :column_types
 
     def initialize(columns, rows, column_types = {})
@@ -17,8 +42,20 @@ module ActiveRecord
       @column_types = column_types
     end
 
+    def identity_type # :nodoc:
+      IDENTITY_TYPE
+    end
+
+    def column_type(name)
+      @column_types[name] || identity_type
+    end
+
     def each
-      hash_rows.each { |row| yield row }
+      if block_given?
+        hash_rows.each { |row| yield row }
+      else
+        hash_rows.to_enum
+      end
     end
 
     def to_hash
@@ -46,12 +83,14 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      @columns   = columns.dup
-      @rows      = rows.dup
-      @hash_rows = nil
+      @columns      = columns.dup
+      @rows         = rows.dup
+      @column_types = column_types.dup
+      @hash_rows    = nil
     end
 
     private
+
     def hash_rows
       @hash_rows ||=
         begin

data/lib/active_record/runtime_registry.rb

@@ -13,5 +13,10 @@ module ActiveRecord
     extend ActiveSupport::PerThreadRegistry
 
     attr_accessor :connection_handler, :sql_runtime, :connection_id
+
+    [:connection_handler, :sql_runtime, :connection_id].each do |val|
+      class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
+      class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
+    end
   end
 end

data/lib/active_record/sanitization.rb

@@ -3,8 +3,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def quote_value(value, column = nil) #:nodoc:
-        connection.quote(value,column)
+      def quote_value(value, column) #:nodoc:
+        connection.quote(value, column)
       end
 
       # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
@@ -86,6 +86,7 @@ module ActiveRecord
       #   { address: Address.new("123 abc st.", "chicago") }
       #     # => "address_street='123 abc st.' and address_city='chicago'"
       def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
+        attrs = PredicateBuilder.resolve_column_aliases self, attrs
         attrs = expand_hash_conditions_for_aggregates(attrs)
 
         table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
@@ -99,9 +100,8 @@ module ActiveRecord
       #   { status: nil, group_id: 1 }
       #     # => "status = NULL , group_id = 1"
       def sanitize_sql_hash_for_assignment(attrs, table)
-        c = connection
         attrs.map do |attr, value|
-          "#{c.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value, c, columns_hash[attr.to_s])}"
+          "#{connection.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value)}"
         end.join(', ')
       end
 
@@ -152,10 +152,8 @@ module ActiveRecord
         end
       end
 
-      def quote_bound_value(value, c = connection, column = nil) #:nodoc:
-        if column
-          c.quote(value, column)
-        elsif value.respond_to?(:map) && !value.acts_like?(:string)
+      def quote_bound_value(value, c = connection) #:nodoc:
+        if value.respond_to?(:map) && !value.acts_like?(:string)
           if value.respond_to?(:empty?) && value.empty?
             c.quote(nil)
           else

data/lib/active_record/schema_dumper.rb

@@ -17,9 +17,19 @@ module ActiveRecord
     cattr_accessor :ignore_tables
     @@ignore_tables = []
 
-    def self.dump(connection=ActiveRecord::Base.connection, stream=STDOUT)
-      new(connection).dump(stream)
-      stream
+    class << self
+      def dump(connection=ActiveRecord::Base.connection, stream=STDOUT, config = ActiveRecord::Base)
+        new(connection, generate_options(config)).dump(stream)
+        stream
+      end
+
+      private
+        def generate_options(config)
+          {
+            table_name_prefix: config.table_name_prefix,
+            table_name_suffix: config.table_name_suffix
+          }
+        end
     end
 
     def dump(stream)
@@ -32,10 +42,11 @@ module ActiveRecord
 
     private
 
-      def initialize(connection)
+      def initialize(connection, options = {})
         @connection = connection
         @types = @connection.native_database_types
         @version = Migrator::current_version rescue nil
+        @options = options
       end
 
       def header(stream)
@@ -202,7 +213,7 @@ HEADER
       end
 
       def remove_prefix_and_suffix(table)
-        table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+        table.gsub(/^(#{@options[:table_name_prefix]})(.+)(#{@options[:table_name_suffix]})$/,  "\\2")
       end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -4,41 +4,40 @@ require 'active_record/base'
 
 module ActiveRecord
   class SchemaMigration < ActiveRecord::Base
-    def self.primary_key
-      nil
-    end
+    class << self
 
-    def self.table_name
-      "#{Base.table_name_prefix}schema_migrations#{Base.table_name_suffix}"
-    end
+      def table_name
+        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      end
 
-    def self.index_name
-      "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
-    end
+      def index_name
+        "#{table_name_prefix}unique_#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      end
 
-    def self.create_table(limit=nil)
-      unless connection.table_exists?(table_name)
-        version_options = {null: false}
-        version_options[:limit] = limit if limit
+      def table_exists?
+        connection.table_exists?(table_name)
+      end
 
-        connection.create_table(table_name, id: false) do |t|
-          t.column :version, :string, version_options
+      def create_table(limit=nil)
+        unless table_exists?
+          version_options = {null: false}
+          version_options[:limit] = limit if limit
+
+          connection.create_table(table_name, id: false) do |t|
+            t.column :version, :string, version_options
+          end
+          connection.add_index table_name, :version, unique: true, name: index_name
         end
-        connection.add_index table_name, :version, unique: true, name: index_name
       end
-    end
 
-    def self.drop_table
-      if connection.table_exists?(table_name)
-        connection.remove_index table_name, name: index_name
-        connection.drop_table(table_name)
+      def drop_table
+        if table_exists?
+          connection.remove_index table_name, name: index_name
+          connection.drop_table(table_name)
+        end
       end
     end
 
-    def self.normalize_migration_number(number)
-      "%.3d" % number.to_i
-    end
-
     def version
       super.to_i
     end

data/lib/active_record/scoping/default.rb

@@ -8,14 +8,6 @@ module ActiveRecord
         class_attribute :default_scopes, instance_writer: false, instance_predicate: false
 
         self.default_scopes = []
-
-        def self.default_scopes?
-          ActiveSupport::Deprecation.warn(
-            "#default_scopes? is deprecated. Do something like #default_scopes.empty? instead."
-          )
-
-          !!self.default_scopes
-        end
       end
 
       module ClassMethods
@@ -91,29 +83,24 @@ module ActiveRecord
           scope = Proc.new if block_given?
 
           if scope.is_a?(Relation) || !scope.respond_to?(:call)
-            ActiveSupport::Deprecation.warn(
-              "Calling #default_scope without a block is deprecated. For example instead " \
+            raise ArgumentError,
+              "Support for calling #default_scope without a block is removed. For example instead " \
               "of `default_scope where(color: 'red')`, please use " \
               "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
               "self.default_scope.)"
-            )
           end
 
           self.default_scopes += [scope]
         end
 
-        def build_default_scope(base_rel = relation) # :nodoc:
+        def build_default_scope # :nodoc:
           if !Base.is_a?(method(:default_scope).owner)
             # The user has defined their own default scope method, so call that
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
             evaluate_default_scope do
-              default_scopes.inject(base_rel) do |default_scope, scope|
-                if !scope.is_a?(Relation) && scope.respond_to?(:call)
-                  default_scope.merge(base_rel.scoping { scope.call })
-                else
-                  default_scope.merge(scope)
-                end
+              default_scopes.inject(relation) do |default_scope, scope|
+                default_scope.merge(unscoped { scope.call })
               end
             end
           end

data/lib/active_record/scoping/named.rb

@@ -25,22 +25,18 @@ module ActiveRecord
           if current_scope
             current_scope.clone
           else
-            scope = relation
-            scope.default_scoped = true
-            scope
+            default_scoped
           end
         end
 
+        def default_scoped # :nodoc:
+          relation.merge(build_default_scope)
+        end
+
         # Collects attributes from scopes that should be applied when creating
         # an AR instance for the particular class this is called on.
         def scope_attributes # :nodoc:
-          if current_scope
-            current_scope.scope_for_create
-          else
-            scope = relation
-            scope.default_scoped = true
-            scope.scope_for_create
-          end
+          all.scope_for_create
         end
 
         # Are there default attributes associated with this scope?
@@ -145,26 +141,9 @@ module ActiveRecord
         def scope(name, body, &block)
           extension = Module.new(&block) if block
 
-          # Check body.is_a?(Relation) to prevent the relation actually being
-          # loaded by respond_to?
-          if body.is_a?(Relation) || !body.respond_to?(:call)
-            ActiveSupport::Deprecation.warn(
-              "Using #scope without passing a callable object is deprecated. For " \
-              "example `scope :red, where(color: 'red')` should be changed to " \
-              "`scope :red, -> { where(color: 'red') }`. There are numerous gotchas " \
-              "in the former usage and it makes the implementation more complicated " \
-              "and buggy. (If you prefer, you can just define a class method named " \
-              "`self.red`.)"
-            )
-          end
-
           singleton_class.send(:define_method, name) do |*args|
-            if body.respond_to?(:call)
-              scope = all.scoping { body.call(*args) }
-              scope = scope.extending(extension) if extension
-            else
-              scope = body
-            end
+            scope = all.scoping { body.call(*args) }
+            scope = scope.extending(extension) if extension
 
             scope || all
           end

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,9 +66,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class << self
-        attr_accessor :local_stored_attributes
-      end
+      class_attribute :stored_attributes, instance_accessor: false
+      self.stored_attributes = {}
     end
 
     module ClassMethods
@@ -89,9 +93,9 @@ module ActiveRecord
 
         # 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
+        self.stored_attributes = {} if self.stored_attributes.blank?
+        self.stored_attributes[store_attribute] ||= []
+        self.stored_attributes[store_attribute] |= keys
       end
 
       def _store_accessors_module
@@ -101,38 +105,62 @@ 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:
@@ -150,7 +178,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)