module ActiveRecord::Scoping::Default::ClassMethods

def build_default_scope(relation = relation(), all_queries: nil) 

def build_default_scope(relation = relation(), all_queries: nil)
  return if abstract_class?
  if default_scope_override.nil?
    self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
  end
  if default_scope_override
    # The user has defined their own default scope method, so call that
    evaluate_default_scope do
      relation.scoping { default_scope }
    end
  elsif default_scopes.any?
    evaluate_default_scope do
      default_scopes.inject(relation) do |combined_scope, scope_obj|
        if execute_scope?(all_queries, scope_obj)
          scope = scope_obj.scope.respond_to?(:to_proc) ? scope_obj.scope : scope_obj.scope.method(:call)
          combined_scope.instance_exec(&scope) || combined_scope
        else
          combined_scope
        end
      end
    end
  end
end

def default_scope(scope = nil, all_queries: nil, &block) # :doc:

:doc:
end
end
# Should return a scope, you can call 'super' here etc.
def self.default_scope
class Article < ActiveRecord::Base

alternatively define it as a class method:
If you need to do more complex things with a default scope, you can

class defines a second one.
parent or module defines a #default_scope and the child or including
This is also the case with inheritance and module includes where the

Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'

end
default_scope { where(rating: 'G') }
default_scope { where(published: true) }
class Article < ActiveRecord::Base

they will be merged together:
If you use multiple #default_scope declarations in your model then

default scope.)
+default_scope+ macro, and it will be called when building the
(You can also pass any object which responds to +call+ to the

=> DELETE ... FROM `articles` where ID = 1 AND blog_id = 1;
Article.find(1).destroy

queries that return a single object by primary key.
where clauses apply, as it does not make sense to add order to
are always queried by the additional conditions. Note that only
Applying a default scope to all queries will ensure that records

end
default_scope -> { where(blog_id: 1) }, all_queries: true
class Article < ActiveRecord::Base

all_queries: true:
To apply a #default_scope when updating or deleting a record, add

Article.create.published # => true
Article.new.published # => true

It is not applied while updating or deleting a record.
The #default_scope is also applied while creating/building a record.

Article.all # => SELECT * FROM articles WHERE published = true

end
default_scope { where(published: true) }
class Article < ActiveRecord::Base

the model.
Use this macro in your model to set a default scope for all operations on 
def default_scope(scope = nil, all_queries: nil, &block) # :doc:
  scope = block if block_given?
  if scope.is_a?(Relation) || !scope.respond_to?(:call)
    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
  default_scope = DefaultScope.new(scope, all_queries)
  self.default_scopes += [default_scope]
end

def default_scopes?(all_queries: false)

default_scopes for the model where +all_queries+ is true.
is set to true, the method will check if there are any
Checks if the model has any default scopes. If all_queries 
def default_scopes?(all_queries: false)
  if all_queries
    self.default_scopes.any?(&:all_queries)
  else
    self.default_scopes.any?
  end
end

def evaluate_default_scope

scope which references a scope...
situation where a default scope references a scope which has a default
The ignore_default_scope flag is used to prevent an infinite recursion 
def evaluate_default_scope
  return if ignore_default_scope?
  begin
    self.ignore_default_scope = true
    yield
  ensure
    self.ignore_default_scope = false
  end
end

def execute_scope?(all_queries, default_scope_obj)

and delete.
all_queries set, then execute on all queries; select, insert, update
If all_queries is true, check if the default_scope object has

If all_queries is nil, only execute on select and insert queries. 
def execute_scope?(all_queries, default_scope_obj)
  all_queries.nil? || all_queries && default_scope_obj.all_queries
end

def ignore_default_scope=(ignore) 

def ignore_default_scope=(ignore)
  ScopeRegistry.set_ignore_default_scope(base_class, ignore)
end

def ignore_default_scope? 

def ignore_default_scope?
  ScopeRegistry.ignore_default_scope(base_class)
end

def scope_attributes? # :nodoc:

:nodoc:
Are there attributes associated with this scope? 
def scope_attributes? # :nodoc:
  super || default_scopes.any? || respond_to?(:default_scope)
end

def unscoped(&block)

}
Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
Post.unscoped {

not use the previously set scopes.
This method also accepts a block. All queries inside the block will

Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
Post.unscoped.all # Fires "SELECT * FROM posts"
Post.all # Fires "SELECT * FROM posts WHERE published = true"

end
end
where(published: true)
def self.default_scope
class Post < ActiveRecord::Base

Returns a scope for the model without the previously set scopes. 
def unscoped(&block)
  block_given? ? relation.scoping(&block) : relation
end