activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/schema.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Schema
+  # = Active Record \Schema
   #
   # Allows programmers to programmatically define a schema in a portable
   # DSL. This means you can define tables, indexes, etc. without using SQL
@@ -27,29 +27,12 @@ module ActiveRecord
   #
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
-  class Schema < Migration
-
-    # Returns the migrations paths.
-    #
-    #   ActiveRecord::Schema.new.migrations_paths
-    #   # => ["db/migrate"] # Rails migration path by default.
-    def migrations_paths
-      ActiveRecord::Migrator.migrations_paths
-    end
-
-    def define(info, &block) # :nodoc:
-      instance_eval(&block)
-
-      unless info[:version].blank?
-        initialize_schema_migrations_table
-        connection.assume_migrated_upto_version(info[:version], migrations_paths)
-      end
-    end
-
+  class Schema < Migration::Current
     # Eval the given block. All methods available to the current connection
     # adapter are available within the block, so you can easily use the
-    # database definition DSL to build up your schema (+create_table+,
-    # +add_index+, etc.).
+    # database definition DSL to build up your schema (
+    # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
+    # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
     #
     # The +info+ hash is optional, and if given is used to define metadata
     # about the current schema (currently, only the schema's version):
@@ -60,5 +43,23 @@ module ActiveRecord
     def self.define(info={}, &block)
       new.define(info, &block)
     end
+
+    def define(info, &block) # :nodoc:
+      instance_eval(&block)
+
+      if info[:version].present?
+        initialize_schema_migrations_table
+        connection.assume_migrated_upto_version(info[:version], migrations_paths)
+      end
+    end
+
+    private
+      # Returns the migrations paths.
+      #
+      #   ActiveRecord::Schema.new.migrations_paths
+      #   # => ["db/migrate"] # Rails migration path by default.
+      def migrations_paths # :nodoc:
+        ActiveRecord::Migrator.migrations_paths
+      end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -1,5 +1,4 @@
 require 'stringio'
-require 'active_support/core_ext/big_decimal'
 
 module ActiveRecord
   # = Active Record Schema Dumper
@@ -44,7 +43,6 @@ module ActiveRecord
 
       def initialize(connection, options = {})
         @connection = connection
-        @types = @connection.native_database_types
         @version = Migrator::current_version rescue nil
         @options = options
       end
@@ -91,7 +89,7 @@ HEADER
       end
 
       def tables(stream)
-        sorted_tables = @connection.tables.sort
+        sorted_tables = @connection.data_sources.sort - @connection.views
 
         sorted_tables.each do |table_name|
           table(table_name, stream) unless ignored?(table_name)
@@ -106,35 +104,50 @@ HEADER
       end
 
       def table(table, stream)
-        columns = @connection.columns(table)
+        columns = @connection.columns(table).map do |column|
+          column.instance_variable_set(:@table_name, table)
+          column
+        end
         begin
           tbl = StringIO.new
 
           # first dump primary key column
-          pk = @connection.primary_key(table)
+          if @connection.respond_to?(:primary_keys)
+            pk = @connection.primary_keys(table)
+            pk = pk.first unless pk.size > 1
+          else
+            pk = @connection.primary_key(table)
+          end
 
           tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
-          pkcol = columns.detect { |c| c.name == pk }
-          if pkcol
-            if pk != 'id'
-              tbl.print %Q(, primary_key: "#{pk}")
-            elsif pkcol.sql_type == 'bigint'
-              tbl.print ", id: :bigserial"
-            elsif pkcol.sql_type == 'uuid'
-              tbl.print ", id: :uuid"
-              tbl.print %Q(, default: #{pkcol.default_function.inspect})
+
+          case pk
+          when String
+            tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
+            pkcol = columns.detect { |c| c.name == pk }
+            pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+            if pkcolspec
+              pkcolspec.each do |key, value|
+                tbl.print ", #{key}: #{value}"
+              end
             end
+          when Array
+            tbl.print ", primary_key: #{pk.inspect}"
           else
             tbl.print ", id: false"
           end
           tbl.print ", force: :cascade"
+
+          table_options = @connection.table_options(table)
+          tbl.print ", options: #{table_options.inspect}" unless table_options.blank?
+
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
           column_specs = columns.map do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            @connection.column_spec(column, @types)
+            @connection.column_spec(column)
           end.compact
 
           # find all migration keys used in this table
@@ -165,11 +178,11 @@ HEADER
             tbl.puts
           end
 
+          indexes(table, tbl)
+
           tbl.puts "  end"
           tbl.puts
 
-          indexes(table, tbl)
-
           tbl.rewind
           stream.print tbl.read
         rescue => e
@@ -185,8 +198,7 @@ HEADER
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
             statement_parts = [
-              "add_index #{remove_prefix_and_suffix(index.table).inspect}",
-              index.columns.inspect,
+              "t.index #{index.columns.inspect}",
               "name: #{index.name.inspect}",
             ]
             statement_parts << 'unique: true' if index.unique
@@ -200,11 +212,10 @@ HEADER
             statement_parts << "using: #{index.using.inspect}" if index.using
             statement_parts << "type: #{index.type.inspect}" if index.type
 
-            "  #{statement_parts.join(', ')}"
+            "    #{statement_parts.join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
-          stream.puts
         end
       end
 
@@ -243,7 +254,7 @@ HEADER
       end
 
       def ignored?(table_name)
-        ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+        [ActiveRecord::Base.schema_migrations_table_name, ignore_tables].flatten.any? do |ignored|
           ignored === remove_prefix_and_suffix(table_name)
         end
       end

data/lib/active_record/schema_migration.rb

@@ -1,9 +1,12 @@
 require 'active_record/scoping/default'
 require 'active_record/scoping/named'
-require 'active_record/base'
 
 module ActiveRecord
-  class SchemaMigration < ActiveRecord::Base
+  # This class is used to create a table that keeps track of which migrations
+  # have been applied to a given database. When a migration is run, its schema
+  # number is inserted in to the `SchemaMigration.table_name` so it doesn't need
+  # to be executed the next time.
+  class SchemaMigration < ActiveRecord::Base # :nodoc:
     class << self
       def primary_key
         nil
@@ -18,7 +21,7 @@ module ActiveRecord
       end
 
       def table_exists?
-        connection.table_exists?(table_name)
+        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
       end
 
       def create_table(limit=nil)
@@ -34,7 +37,10 @@ module ActiveRecord
       end
 
       def drop_table
-        connection.drop_table table_name if table_exists?
+        if table_exists?
+          connection.remove_index table_name, name: index_name
+          connection.drop_table(table_name)
+        end
       end
 
       def normalize_migration_number(number)

data/lib/active_record/scoping.rb

@@ -11,15 +11,26 @@ module ActiveRecord
 
     module ClassMethods
       def current_scope #:nodoc:
-        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+        ScopeRegistry.value_for(:current_scope, self.to_s)
       end
 
       def current_scope=(scope) #:nodoc:
-        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+        ScopeRegistry.set_value_for(:current_scope, self.to_s, 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:
+        all.scope_for_create
+      end
+
+      # Are there attributes associated with this scope?
+      def scope_attributes? # :nodoc:
+        current_scope
       end
     end
 
-    def populate_with_current_scope_attributes
+    def populate_with_current_scope_attributes # :nodoc:
       return unless self.class.scope_attributes?
 
       self.class.scope_attributes.each do |att,value|
@@ -27,7 +38,7 @@ module ActiveRecord
       end
     end
 
-    def initialize_internals_callback
+    def initialize_internals_callback # :nodoc:
       super
       populate_with_current_scope_attributes
     end
@@ -48,8 +59,8 @@ module ActiveRecord
     #
     #   registry.value_for(:current_scope, "Board")
     #
-    # You will obtain whatever was defined in +some_new_scope+. The +value_for+
-    # and +set_value_for+ methods are delegated to the current +ScopeRegistry+
+    # You will obtain whatever was defined in +some_new_scope+. The #value_for
+    # and #set_value_for methods are delegated to the current ScopeRegistry
     # object, so the above example code can also be called as:
     #
     #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,

data/lib/active_record/scoping/default.rb

@@ -6,8 +6,10 @@ module ActiveRecord
       included do
         # Stores the default scope for the class.
         class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+        class_attribute :default_scope_override, instance_predicate: false
 
         self.default_scopes = []
+        self.default_scope_override = nil
       end
 
       module ClassMethods
@@ -15,7 +17,7 @@ module ActiveRecord
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
-        #       where published: true
+        #       where(published: true)
         #     end
         #   end
         #
@@ -33,6 +35,11 @@ module ActiveRecord
           block_given? ? relation.scoping { yield } : relation
         end
 
+        # Are there attributes associated with this scope?
+        def scope_attributes? # :nodoc:
+          super || default_scopes.any? || respond_to?(:default_scope)
+        end
+
         def before_remove_const #:nodoc:
           self.current_scope = nil
         end
@@ -48,7 +55,7 @@ module ActiveRecord
         #
         #   Article.all # => SELECT * FROM articles WHERE published = true
         #
-        # The +default_scope+ is also applied while creating/building a record.
+        # The #default_scope is also applied while creating/building a record.
         # It is not applied while updating a record.
         #
         #   Article.new.published    # => true
@@ -58,7 +65,7 @@ module ActiveRecord
         # +default_scope+ macro, and it will be called when building the
         # default scope.)
         #
-        # If you use multiple +default_scope+ declarations in your model then
+        # If you use multiple #default_scope declarations in your model then
         # they will be merged together:
         #
         #   class Article < ActiveRecord::Base
@@ -69,7 +76,7 @@ module ActiveRecord
         #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
         #
         # This is also the case with inheritance and module includes where the
-        # parent or module defines a +default_scope+ and the child or including
+        # parent or module defines a #default_scope and the child or including
         # class defines a second one.
         #
         # If you need to do more complex things with a default scope, you can
@@ -94,12 +101,18 @@ module ActiveRecord
           self.default_scopes += [scope]
         end
 
-        def build_default_scope(base_rel = relation) # :nodoc:
+        def build_default_scope(base_rel = nil) # :nodoc:
           return if abstract_class?
-          if !Base.is_a?(method(:default_scope).owner)
+
+          if self.default_scope_override.nil?
+            self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
+          end
+
+          if self.default_scope_override
             # The user has defined their own default scope method, so call that
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
+            base_rel ||= relation
             evaluate_default_scope do
               default_scopes.inject(base_rel) do |default_scope, scope|
                 default_scope.merge(base_rel.scoping { scope.call })

data/lib/active_record/scoping/named.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Returns an <tt>ActiveRecord::Relation</tt> scope object.
+        # Returns an ActiveRecord::Relation scope object.
         #
         #   posts = Post.all
         #   posts.size # Fires "select count(*) from  posts" and returns the count
@@ -20,7 +20,7 @@ module ActiveRecord
         #   fruits = fruits.limit(10) if limited?
         #
         # You can define a scope that applies to all finders using
-        # <tt>ActiveRecord::Base.default_scope</tt>.
+        # {default_scope}[rdoc-ref:Scoping::Default::ClassMethods#default_scope].
         def all
           if current_scope
             current_scope.clone
@@ -30,22 +30,22 @@ module ActiveRecord
         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:
-          all.scope_for_create
-        end
+          scope = build_default_scope
 
-        # Are there default attributes associated with this scope?
-        def scope_attributes? # :nodoc:
-          current_scope || default_scopes.any?
+          if scope
+            relation.spawn.merge!(scope)
+          else
+            relation
+          end
         end
 
-        # Adds a class method for retrieving and querying objects. A \scope
-        # represents a narrowing of a database query, such as
+        # Adds a class method for retrieving and querying objects.
+        # The method is intended to return an ActiveRecord::Relation
+        # object, which is composable with other scopes.
+        # If it returns nil or false, an
+        # {all}[rdoc-ref:Scoping::Named::ClassMethods#all] scope is returned instead.
+        #
+        # A \scope represents a narrowing of a database query, such as
         # <tt>where(color: :red).select('shirts.*').includes(:washing_instructions)</tt>.
         #
         #   class Shirt < ActiveRecord::Base
@@ -53,12 +53,12 @@ module ActiveRecord
         #     scope :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
         #   end
         #
-        # The above calls to +scope+ define class methods <tt>Shirt.red</tt> and
+        # The above calls to #scope define class methods <tt>Shirt.red</tt> and
         # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
         # represents the query <tt>Shirt.where(color: 'red')</tt>.
         #
         # You should always pass a callable object to the scopes defined
-        # with +scope+. This ensures that the scope is re-evaluated each
+        # with #scope. This ensures that the scope is re-evaluated each
         # time it is called.
         #
         # Note that this is simply 'syntactic sugar' for defining an actual
@@ -71,14 +71,15 @@ module ActiveRecord
         #   end
         #
         # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by
-        # <tt>Shirt.red</tt> is not an Array; it resembles the association object
-        # constructed by a +has_many+ declaration. For instance, you can invoke
-        # <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
+        # <tt>Shirt.red</tt> is not an Array but an ActiveRecord::Relation,
+        # which is composable with other scopes; it resembles the association object
+        # constructed by a {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
         # <tt>Shirt.red.where(size: 'small')</tt>. Also, just as with the
         # association objects, named \scopes act like an Array, implementing
         # Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>,
         # and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if
-        # <tt>Shirt.red</tt> really was an Array.
+        # <tt>Shirt.red</tt> really was an array.
         #
         # These named \scopes are composable. For instance,
         # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
@@ -89,7 +90,8 @@ module ActiveRecord
         #
         # All scopes are available as class methods on the ActiveRecord::Base
         # descendant upon which the \scopes were defined. But they are also
-        # available to +has_many+ associations. If,
+        # available to {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # associations. If,
         #
         #   class Person < ActiveRecord::Base
         #     has_many :shirts
@@ -98,8 +100,8 @@ module ActiveRecord
         # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
         # Elton's red, dry clean only shirts.
         #
-        # \Named scopes can also have extensions, just as with +has_many+
-        # declarations:
+        # \Named scopes can also have extensions, just as with
+        # {has_many}[rdoc-ref:Associations::ClassMethods#has_many] declarations:
         #
         #   class Shirt < ActiveRecord::Base
         #     scope :red, -> { where(color: 'red') } do
@@ -151,11 +153,20 @@ module ActiveRecord
 
           extension = Module.new(&block) if block
 
-          singleton_class.send(:define_method, name) do |*args|
-            scope = all.scoping { body.call(*args) }
-            scope = scope.extending(extension) if extension
+          if body.respond_to?(:to_proc)
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { instance_exec(*args, &body) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          else
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { body.call(*args) }
+              scope = scope.extending(extension) if extension
 
-            scope || all
+              scope || all
+            end
           end
         end
       end