activerecord 3.2.22.4 → 4.0.13

data/lib/active_record/scoping/default.rb

@@ -1,22 +1,29 @@
-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, 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
-        # 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 +31,12 @@ 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.
-        #
-        #   Post.unscoped.published
-        #   Post.published
-        def unscoped #:nodoc:
+        def unscoped
           block_given? ? relation.scoping { yield } : relation
         end
 
@@ -51,62 +50,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:
+        # (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.)
         #
-        #   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.)
-        #
-        # 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(base_rel = relation) # :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)
+              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
@@ -115,17 +119,18 @@ module ActiveRecord
           end
         end
 
-        def ignore_default_scope? #:nodoc:
-          Thread.current["#{self}_ignore_default_scope"]
+        def ignore_default_scope? # :nodoc:
+          ScopeRegistry.value_for(:ignore_default_scope, self)
         end
 
-        def ignore_default_scope=(ignore) #:nodoc:
-          Thread.current["#{self}_ignore_default_scope"] = ignore
+        def ignore_default_scope=(ignore) # :nodoc:
+          ScopeRegistry.set_value_for(:ignore_default_scope, self, 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 +140,6 @@ module ActiveRecord
             self.ignore_default_scope = false
           end
         end
-
       end
     end
   end

data/lib/active_record/scoping/named.rb

@@ -1,47 +1,36 @@
 require 'active_support/core_ext/array'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
-  # = Active Record Named \Scopes
+  # = Active Record \Named \Scopes
   module Scoping
     module Named
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Returns an anonymous \scope.
+        # Returns an <tt>ActiveRecord::Relation</tt> scope object.
         #
-        #   posts = Post.scoped
+        #   posts = Post.all
         #   posts.size # Fires "select count(*) from  posts" and returns the count
         #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
         #
-        #   fruits = Fruit.scoped
-        #   fruits = fruits.where(:color => 'red') if options[:red_only]
+        #   fruits = Fruit.all
+        #   fruits = fruits.where(color: 'red') if options[:red_only]
         #   fruits = fruits.limit(10) if limited?
         #
-        # Anonymous \scopes tend to be useful when procedurally generating complex
-        # queries, where passing intermediate values (\scopes) around as first-class
-        # objects is convenient.
-        #
-        # You can define a \scope that applies to all finders using
-        # ActiveRecord::Base.default_scope.
-        def scoped(options = nil)
-          if options
-            scoped.apply_finder_options(options)
+        # You can define a scope that applies to all finders using
+        # <tt>ActiveRecord::Base.default_scope</tt>.
+        def all
+          if current_scope
+            current_scope.clone
           else
-            if current_scope
-              current_scope.clone
-            else
-              scope = relation
-              scope.default_scoped = true
-              scope
-            end
+            scope = relation
+            scope.default_scoped = true
+            scope
           end
         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:
@@ -54,86 +43,70 @@ module ActiveRecord
           end
         end
 
-        ##
         # Are there default attributes associated with this scope?
         def scope_attributes? # :nodoc:
           current_scope || default_scopes.any?
         end
 
-        # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
-        # such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
+        # Adds a class method for retrieving and querying objects. 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
-        #     scope :red, where(:color => 'red')
-        #     scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true)
+        #     scope :red, -> { where(color: 'red') }
+        #     scope :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
         #   end
         #
-        # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
-        # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
+        # 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
+        # time it is called.
         #
-        # Note that this is simply 'syntactic sugar' for defining an actual class method:
+        # Note that this is simply 'syntactic sugar' for defining an actual
+        # class method:
         #
         #   class Shirt < ActiveRecord::Base
         #     def self.red
-        #       where(:color => 'red')
+        #       where(color: 'red')
         #     end
         #   end
         #
-        # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
-        # resembles the association object constructed by a <tt>has_many</tt> 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 Shirt.red really was an Array.
-        #
-        # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
-        # all shirts that are both red and dry clean only.
-        # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
-        # returns the number of garments for which these criteria obtain. Similarly with
-        # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-        #
-        # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which
-        # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
+        # 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.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.
+        #
+        # These named \scopes are composable. For instance,
+        # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
+        # both red and dry clean only. Nested finds and calculations also work
+        # with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+        # returns the number of garments for which these criteria obtain.
+        # Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+        #
+        # 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,
         #
         #   class Person < ActiveRecord::Base
         #     has_many :shirts
         #   end
         #
-        # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
-        # only shirts.
-        #
-        # Named \scopes can also be procedural:
-        #
-        #   class Shirt < ActiveRecord::Base
-        #     scope :colored, lambda { |color| where(:color => color) }
-        #   end
-        #
-        # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+        # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
+        # Elton's red, dry clean only shirts.
         #
-        # On Ruby 1.9 you can use the 'stabby lambda' syntax:
-        #
-        #   scope :colored, ->(color) { where(:color => color) }
-        #
-        # Note that scopes defined with \scope will be evaluated when they are defined, rather than
-        # when they are used. For example, the following would be incorrect:
-        #
-        #   class Post < ActiveRecord::Base
-        #     scope :recent, where('published_at >= ?', Time.current - 1.week)
-        #   end
-        #
-        # The example above would be 'frozen' to the <tt>Time.current</tt> value when the <tt>Post</tt>
-        # class was defined, and so the resultant SQL query would always be the same. The correct
-        # way to do this would be via a lambda, which will re-evaluate the scope each time
-        # it is called:
-        #
-        #   class Post < ActiveRecord::Base
-        #     scope :recent, lambda { where('published_at >= ?', Time.current - 1.week) }
-        #   end
-        #
-        # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+        # \Named scopes can also have extensions, just as with +has_many+
+        # declarations:
         #
         #   class Shirt < ActiveRecord::Base
-        #     scope :red, where(:color => 'red') do
+        #     scope :red, -> { where(color: 'red') } do
         #       def dom_id
         #         'red_shirts'
         #       end
@@ -143,18 +116,18 @@ module ActiveRecord
         # Scopes can also be used while creating/building a record.
         #
         #   class Article < ActiveRecord::Base
-        #     scope :published, where(:published => true)
+        #     scope :published, -> { where(published: true) }
         #   end
         #
         #   Article.published.new.published    # => true
         #   Article.published.create.published # => true
         #
-        # Class methods on your model are automatically available
+        # \Class methods on your model are automatically available
         # on scopes. Assuming the following setup:
         #
         #   class Article < ActiveRecord::Base
-        #     scope :published, where(:published => true)
-        #     scope :featured, where(:featured => true)
+        #     scope :published, -> { where(published: true) }
+        #     scope :featured, -> { where(featured: true) }
         #
         #     def self.latest_article
         #       order('published_at desc').first
@@ -169,29 +142,31 @@ module ActiveRecord
         #
         #   Article.published.featured.latest_article
         #   Article.featured.titles
-        def scope(name, scope_options = {})
-          name = name.to_sym
-          valid_scope_name?(name)
-          extension = Module.new(&Proc.new) if block_given?
-
-          scope_proc = lambda do |*args|
-            options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
-            options = scoped.apply_finder_options(options) if options.is_a?(Hash)
+        def scope(name, body, &block)
+          extension = Module.new(&block) if block
 
-            relation = scoped.merge(options)
-
-            extension ? relation.extending(extension) : relation
+          # 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(:redefine_method, name, &scope_proc)
-        end
-
-      protected
+          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
 
-        def valid_scope_name?(name)
-          if logger && respond_to?(name, true)
-            logger.warn "Creating scope :#{name}. " \
-                        "Overwriting existing method #{self.name}.#{name}."
+            scope || all
           end
         end
       end

data/lib/active_record/scoping.rb

@@ -1,4 +1,4 @@
-require 'active_support/concern'
+require 'active_support/per_thread_registry'
 
 module ActiveRecord
   module Scoping
@@ -10,134 +10,13 @@ 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"]
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
       end
 
       def current_scope=(scope) #:nodoc:
-        Thread.current["#{self}_current_scope"] = scope
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, 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
@@ -148,5 +27,56 @@ module ActiveRecord
       end
     end
 
+    # This class stores the +:current_scope+ and +:ignore_default_scope+ values
+    # for different classes. The registry is stored as a thread local, which is
+    # accessed through +ScopeRegistry.current+.
+    #
+    # This class allows you to store and get the scope values on different
+    # classes and different types of scopes. For example, if you are attempting
+    # to get the current_scope for the +Board+ model, then you would use the
+    # following code:
+    #
+    #   registry = ActiveRecord::Scoping::ScopeRegistry
+    #   registry.set_value_for(:current_scope, "Board", some_new_scope)
+    #
+    # Now when you run:
+    #
+    #   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+
+    # object, so the above example code can also be called as:
+    #
+    #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
+    #       "Board", some_new_scope)
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        if !VALID_SCOPE_TYPES.include?(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        end
+      end
+    end
   end
 end

data/lib/active_record/serialization.rb

@@ -4,11 +4,15 @@ module ActiveRecord #:nodoc:
     extend ActiveSupport::Concern
     include ActiveModel::Serializers::JSON
 
+    included do
+      self.include_root_in_json = false
+    end
+
     def serializable_hash(options = nil)
       options = options.try(:clone) || {}
 
-      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
-      options[:except] |= Array.wrap(self.class.inheritance_column)
+      options[:except] = Array(options[:except]).map { |n| n.to_s }
+      options[:except] |= Array(self.class.inheritance_column)
 
       super(options)
     end