activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/schema_dumper.rb

@@ -24,6 +24,7 @@ module ActiveRecord
 
     def dump(stream)
       header(stream)
+      extensions(stream)
       tables(stream)
       trailer(stream)
       stream
@@ -38,7 +39,7 @@ module ActiveRecord
       end
 
       def header(stream)
-        define_params = @version ? ":version => #{@version}" : ""
+        define_params = @version ? "version: #{@version}" : ""
 
         if stream.respond_to?(:external_encoding) && stream.external_encoding
           stream.puts "# encoding: #{stream.external_encoding.name}"
@@ -55,7 +56,7 @@ module ActiveRecord
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
 # you'll amass, the slower it'll run and the greater likelihood for issues).
 #
-# It's strongly recommended to check this file into your version control system.
+# It's strongly recommended that you check this file into your version control system.
 
 ActiveRecord::Schema.define(#{define_params}) do
 
@@ -66,6 +67,18 @@ HEADER
         stream.puts "end"
       end
 
+      def extensions(stream)
+        return unless @connection.supports_extensions?
+        extensions = @connection.extensions
+        if extensions.any?
+          stream.puts "  # These are extensions that must be enabled in order to support this database"
+          extensions.each do |extension|
+            stream.puts "  enable_extension #{extension.inspect}"
+          end
+          stream.puts
+        end
+      end
+
       def tables(stream)
         @connection.tables.sort.each do |tbl|
           next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
@@ -95,42 +108,30 @@ HEADER
           tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
           if columns.detect { |c| c.name == pk }
             if pk != 'id'
-              tbl.print %Q(, :primary_key => "#{pk}")
+              tbl.print %Q(, primary_key: "#{pk}")
             end
           else
-            tbl.print ", :id => false"
+            tbl.print ", id: false"
           end
-          tbl.print ", :force => true"
+          tbl.print ", force: true"
           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}'" if @types[column.type].nil?
             next if column.name == pk
-            spec = {}
-            spec[:name]      = column.name.inspect
-
-            # AR has an optimization which handles zero-scale decimals as integers. This
-            # code ensures that the dumper still dumps the column as a decimal.
-            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
-                                 'decimal'
-                               else
-                                 column.type.to_s
-                               end
-            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-            spec[:precision] = column.precision.inspect if column.precision
-            spec[:scale]     = column.scale.inspect if column.scale
-            spec[:null]      = 'false' unless column.null
-            spec[:default]   = default_string(column.default) if column.has_default?
-            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
-            spec
+            @connection.column_spec(column, @types)
           end.compact
 
           # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
+          keys = @connection.migration_keys
 
           # figure out the lengths for each column based on above keys
-          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+          lengths = keys.map { |key|
+            column_specs.map { |spec|
+              spec[key] ? spec[key].length + 2 : 0
+            }.max
+          }
 
           # the string we're going to sprintf our values against, with standardized column widths
           format_string = lengths.map{ |len| "%-#{len}s" }
@@ -166,32 +167,23 @@ HEADER
         stream
       end
 
-      def default_string(value)
-        case value
-        when BigDecimal
-          value.to_s
-        when Date, DateTime, Time
-          "'" + value.to_s(:db) + "'"
-        else
-          value.inspect
-        end
-      end
-
       def indexes(table, stream)
         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,
-              (':name => ' + index.name.inspect),
+              ('name: ' + index.name.inspect),
             ]
-            statement_parts << ':unique => true' if index.unique
+            statement_parts << 'unique: true' if index.unique
 
             index_lengths = (index.lengths || []).compact
-            statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+            statement_parts << ('length: ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
 
             index_orders = (index.orders || {})
-            statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
+            statement_parts << ('order: ' + index.orders.inspect) unless index_orders.empty?
+
+            statement_parts << ('where: ' + index.where.inspect) if index.where
 
             '  ' + statement_parts.join(', ')
           end

data/lib/active_record/schema_migration.rb

@@ -0,0 +1,36 @@
+require 'active_record/scoping/default'
+require 'active_record/scoping/named'
+require 'active_record/base'
+
+module ActiveRecord
+  class SchemaMigration < ActiveRecord::Base
+
+    def self.table_name
+      "#{Base.table_name_prefix}schema_migrations#{Base.table_name_suffix}"
+    end
+
+    def self.index_name
+      "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
+    end
+
+    def self.create_table
+      unless connection.table_exists?(table_name)
+        connection.create_table(table_name, :id => false) do |t|
+          t.column :version, :string, :null => false
+        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)
+      end
+    end
+
+    def version
+      super.to_i
+    end
+  end
+end

data/lib/active_record/scoping.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 module ActiveRecord
   module Scoping
     extend ActiveSupport::Concern
@@ -10,118 +8,6 @@ module ActiveRecord
     end
 
     module ClassMethods
-      # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
-      # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
-      # <tt>:create</tt> parameters are an attributes hash.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.create_with_scope
-      #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
-      #         find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
-      #         a = create(1)
-      #         a.blog_id # => 1
-      #       end
-      #     end
-      #   end
-      #
-      # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
-      # <tt>where</tt>, <tt>includes</tt>, and <tt>joins</tt> operations in <tt>Relation</tt>, which are merged.
-      #
-      # <tt>joins</tt> operations are uniqued so multiple scopes can join in the same table without table aliasing
-      # problems. If you need to join multiple tables, but still want one of the tables to be uniqued, use the
-      # array of strings format for your joins.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.find_with_scope
-      #       with_scope(:find => where(:blog_id => 1).limit(1), :create => { :blog_id => 1 }) do
-      #         with_scope(:find => limit(10)) do
-      #           all # => SELECT * from articles WHERE blog_id = 1 LIMIT 10
-      #         end
-      #         with_scope(:find => where(:author_id => 3)) do
-      #           all # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.find_with_exclusive_scope
-      #       with_scope(:find => where(:blog_id => 1).limit(1)) do
-      #         with_exclusive_scope(:find => limit(10)) do
-      #           all # => SELECT * from articles LIMIT 10
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
-      def with_scope(scope = {}, action = :merge, &block)
-        # If another Active Record class has been passed in, get its current scope
-        scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
-
-        previous_scope = self.current_scope
-
-        if scope.is_a?(Hash)
-          # Dup first and second level of hash (method and params).
-          scope = scope.dup
-          scope.each do |method, params|
-            scope[method] = params.dup unless params == true
-          end
-
-          scope.assert_valid_keys([ :find, :create ])
-          relation = construct_finder_arel(scope[:find] || {})
-          relation.default_scoped = true unless action == :overwrite
-
-          if previous_scope && previous_scope.create_with_value && scope[:create]
-            scope_for_create = if action == :merge
-              previous_scope.create_with_value.merge(scope[:create])
-            else
-              scope[:create]
-            end
-
-            relation = relation.create_with(scope_for_create)
-          else
-            scope_for_create = scope[:create]
-            scope_for_create ||= previous_scope.create_with_value if previous_scope
-            relation = relation.create_with(scope_for_create) if scope_for_create
-          end
-
-          scope = relation
-        end
-
-        scope = previous_scope.merge(scope) if previous_scope && action == :merge
-
-        self.current_scope = scope
-        begin
-          yield
-        ensure
-          self.current_scope = previous_scope
-        end
-      end
-
-      protected
-
-      # Works like with_scope, but discards any nested properties.
-      def with_exclusive_scope(method_scoping = {}, &block)
-        if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
-          raise ArgumentError, <<-MSG
-  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
-
-  User.unscoped.where(:active => true)
-
-  Or call unscoped with a block:
-
-  User.unscoped do
-  User.where(:active => true).all
-  end
-
-  MSG
-        end
-        with_scope(method_scoping, :overwrite, &block)
-      end
-
       def current_scope #:nodoc:
         Thread.current["#{self}_current_scope"]
       end
@@ -129,15 +15,6 @@ module ActiveRecord
       def current_scope=(scope) #:nodoc:
         Thread.current["#{self}_current_scope"] = scope
       end
-
-      private
-
-      def construct_finder_arel(options = {}, scope = nil)
-        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
-        relation = scope.merge(relation) if scope
-        relation
-      end
-
     end
 
     def populate_with_current_scope_attributes
@@ -147,6 +24,5 @@ module ActiveRecord
         send("#{att}=", value) if respond_to?("#{att}=")
       end
     end
-
   end
 end

data/lib/active_record/scoping/default.rb

@@ -1,22 +1,20 @@
-require 'active_support/concern'
-
 module ActiveRecord
   module Scoping
     module Default
       extend ActiveSupport::Concern
 
       included do
-        # Stores the default scope for the class
-        class_attribute :default_scopes, :instance_writer => false
+        # Stores the default scope for the class.
+        class_attribute :default_scopes, instance_writer: false
         self.default_scopes = []
       end
 
       module ClassMethods
-        # Returns a scope for the model without the default_scope.
+        # Returns a scope for the model without the +default_scope+.
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
-        #       where :published => true
+        #       where published: true
         #     end
         #   end
         #
@@ -24,20 +22,20 @@ module ActiveRecord
         #   Post.unscoped.all # Fires "SELECT * FROM posts"
         #
         # This method also accepts a block. All queries inside the block will
-        # not use the default_scope:
+        # not use the +default_scope+:
         #
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
         #
-        # It is recommended to use the block form of unscoped because chaining
-        # unscoped with <tt>scope</tt> does not work.  Assuming that
-        # <tt>published</tt> is a <tt>scope</tt>, the following two statements
-        # are equal: the default_scope is applied on both.
+        # It is recommended that you use the block form of unscoped because
+        # chaining unscoped with +scope+ does not work. Assuming that
+        # +published+ is a +scope+, the following two statements
+        # are equal: the +default_scope+ is applied on both.
         #
         #   Post.unscoped.published
         #   Post.published
-        def unscoped #:nodoc:
+        def unscoped
           block_given? ? relation.scoping { yield } : relation
         end
 
@@ -51,62 +49,67 @@ module ActiveRecord
         # the model.
         #
         #   class Article < ActiveRecord::Base
-        #     default_scope where(:published => true)
+        #     default_scope { where(published: true) }
         #   end
         #
         #   Article.all # => SELECT * FROM articles WHERE published = true
         #
-        # The <tt>default_scope</tt> is also applied while creating/building a record. It is not
-        # applied while updating 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
         #   Article.create.published # => true
         #
-        # You can also use <tt>default_scope</tt> with a block, in order to have it lazily evaluated:
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(:published_at => Time.now - 1.week) }
-        #   end
-        #
-        # (You can also pass any object which responds to <tt>call</tt> to the <tt>default_scope</tt>
-        # macro, and it will be called when building the default scope.)
+        # (You can also pass any object which responds to +call+ to the
+        # +default_scope+ macro, and it will be called when building the
+        # default scope.)
         #
-        # If you use multiple <tt>default_scope</tt> declarations in your model then they will
-        # be merged together:
+        # If you use multiple +default_scope+ declarations in your model then
+        # they will be merged together:
         #
         #   class Article < ActiveRecord::Base
-        #     default_scope where(:published => true)
-        #     default_scope where(:rating => 'G')
+        #     default_scope { where(published: true) }
+        #     default_scope { where(rating: 'G') }
         #   end
         #
         #   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 <tt>default_scope</tt> and the child or including class defines a second one.
+        # This is also the case with inheritance and module includes where the
+        # 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 alternatively
-        # define it as a class method:
+        # If you need to do more complex things with a default scope, you can
+        # alternatively define it as a class method:
         #
         #   class Article < ActiveRecord::Base
         #     def self.default_scope
         #       # Should return a scope, you can call 'super' here etc.
         #     end
         #   end
-        def default_scope(scope = {})
+        def default_scope(scope = nil)
           scope = Proc.new if block_given?
-          self.default_scopes = default_scopes + [scope]
+
+          if scope.is_a?(Relation) || !scope.respond_to?(:call)
+            ActiveSupport::Deprecation.warn(
+              "Calling #default_scope without a block is deprecated. 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 #:nodoc:
-          if method(:default_scope).owner != ActiveRecord::Scoping::Default::ClassMethods
+        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(relation) do |default_scope, scope|
-                if scope.is_a?(Hash)
-                  default_scope.apply_finder_options(scope)
-                elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
-                  default_scope.merge(scope.call)
+                if !scope.is_a?(Relation) && scope.respond_to?(:call)
+                  default_scope.merge(unscoped { scope.call })
                 else
                   default_scope.merge(scope)
                 end
@@ -115,17 +118,18 @@ module ActiveRecord
           end
         end
 
-        def ignore_default_scope? #:nodoc:
+        def ignore_default_scope? # :nodoc:
           Thread.current["#{self}_ignore_default_scope"]
         end
 
-        def ignore_default_scope=(ignore) #:nodoc:
+        def ignore_default_scope=(ignore) # :nodoc:
           Thread.current["#{self}_ignore_default_scope"] = ignore
         end
 
-        # The ignore_default_scope flag is used to prevent an infinite recursion situation where
-        # a default scope references a scope which has a default scope which references a scope...
-        def evaluate_default_scope
+        # The ignore_default_scope flag is used to prevent an infinite recursion
+        # situation where a default scope references a scope which has a default
+        # scope which references a scope...
+        def evaluate_default_scope # :nodoc:
           return if ignore_default_scope?
 
           begin
@@ -135,7 +139,6 @@ module ActiveRecord
             self.ignore_default_scope = false
           end
         end
-
       end
     end
   end