Methods
A
B
C
D
I
S
Attributes
[RW] abstract_class

Set this to true if this is an abstract class (see abstract_class?).
Instance Public methods
abstract_class?()

Returns whether this class is an abstract class or not.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 50
def abstract_class?
  defined?(@abstract_class) && @abstract_class == true
end
base_class()

Returns the base AR subclass that this class descends from. If A extends AR::Base, A.base_class will return A. If B descends from A through some arbitrarily deep hierarchy, B.base_class will return A.

If B < A and C < B and if A is an #abstract_class then both B.base_class and C.base_class would return B as the answer since A is an abstract_class.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 42
def base_class
  class_of_active_record_descendant(self)
end
descends_from_active_record?()

True if this isn’t a concrete subclass needing a STI type condition.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 15
def descends_from_active_record?
  if superclass.abstract_class?
    superclass.descends_from_active_record?
  else
    superclass == Base || !columns_hash.include?(inheritance_column)
  end
end
instantiate(record)

Finder methods must instantiate through this method to work with the single-table inheritance model that makes it possible to create objects of different types from the same table.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 61
def instantiate(record)
  sti_class = find_sti_class(record[inheritance_column])
  record_id = sti_class.primary_key && record[sti_class.primary_key]

  if ActiveRecord::IdentityMap.enabled? && record_id
    if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
      record_id = record_id.to_i
    end
    if instance = IdentityMap.get(sti_class, record_id)
      instance.reinit_with('attributes' => record)
    else
      instance = sti_class.allocate.init_with('attributes' => record)
      IdentityMap.add(instance)
    end
  else
    instance = sti_class.allocate.init_with('attributes' => record)
  end

  instance
end
sti_name()

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 54
def sti_name
  store_full_sti_class ? name : name.demodulize
end
symbolized_base_class()

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 28
def symbolized_base_class
  @symbolized_base_class ||= base_class.to_s.to_sym
end
symbolized_sti_name()

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 32
def symbolized_sti_name
  @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
end
Instance Protected methods
class_of_active_record_descendant(klass)

Returns the class descending directly from ActiveRecord::Base or an abstract class, if any, in the inheritance hierarchy.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 86
def class_of_active_record_descendant(klass)
  if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
    klass
  elsif klass.superclass.nil?
    raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
  else
    class_of_active_record_descendant(klass.superclass)
  end
end
compute_type(type_name)

Returns the class type of the record using the current module as a prefix. So descendants of MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.

Source: show | on GitHub 

# File activerecord/lib/active_record/inheritance.rb, line 98
def compute_type(type_name)
  if type_name.match(%r^::/)
    # If the type is prefixed with a scope operator then we assume that
    # the type_name is an absolute reference.
    ActiveSupport::Dependencies.constantize(type_name)
  else
    # Build a list of candidates to search for
    candidates = []
    name.scan(%r::|$/) { candidates.unshift "#{$`}::#{type_name}" }
    candidates << type_name

    candidates.each do |candidate|
      begin
        constant = ActiveSupport::Dependencies.constantize(candidate)
        return constant if candidate == constant.to_s
      rescue NameError => e
        # We don't want to swallow NoMethodError < NameError errors
        raise e unless e.instance_of?(NameError)
      end
    end

    raise NameError, "uninitialized constant #{candidates.first}"
  end
end