Module: RuboCop::Cop::ActiveRecordHelper

Extended by:
NodePattern::Macros
Included in:
Rails::DuplicateAssociation, Rails::DynamicFindBy, Rails::FindEach, Rails::PluckId, Rails::PluckInWhere, Rails::RedundantActiveRecordAllMethod, Rails::TableNameAssignment, Rails::UniqueValidationWithoutIndex, Rails::UnusedIgnoredColumns
Defined in:
lib/rubocop/cop/mixin/active_record_helper.rb

Overview

A mixin to extend cops for Active Record features

Constant Summary collapse

WHERE_METHODS = 
i[where rewhere].freeze

Instance Method Summary collapse

Instance Method Details

#external_dependency_checksum ⇒ Object 



30
31
32
33
34
35
36
37
38
39
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 30

def external_dependency_checksum
  return @external_dependency_checksum if defined?(@external_dependency_checksum)

  schema_path = RuboCop::Rails::SchemaLoader.db_schema_path
  return nil if schema_path.nil?

  schema_code = File.read(schema_path)

  @external_dependency_checksum ||= Digest::SHA1.hexdigest(schema_code)
end

#foreign_key_of(belongs_to) ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 84

def foreign_key_of(belongs_to)
  options = belongs_to.last_argument
  return unless options.hash_type?

  options.each_pair.find do |pair|
    next unless pair.key.sym_type? && pair.key.value == :foreign_key
    next unless pair.value.type?(:sym, :str)

    break pair.value.value.to_s
  end
end

#in_where?(node) ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 105

def in_where?(node)
  send_node = node.each_ancestor(:call).first
  return false unless send_node

  return true if WHERE_METHODS.include?(send_node.method_name) && send_node.receiver != node

  receiver = send_node.receiver
  return false unless receiver&.send_type?

  send_node.method?(:not) && WHERE_METHODS.include?(receiver.method_name)
end

#inherit_active_record_base?(node) ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 26

def inherit_active_record_base?(node)
  node.each_ancestor(:class).any? { |class_node| active_record?(class_node.parent_class) }
end

#polymorphic?(belongs_to) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
99
100
101
102
103
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 96

def polymorphic?(belongs_to)
  options = belongs_to.last_argument
  return false unless options.hash_type?

  options.each_pair.any? do |pair|
    pair.key.sym_type? && pair.key.value == :polymorphic && pair.value.true_type?
  end
end

#resolve_relation_into_column(name:, class_node:, table:) ⇒ Array, ...

Resolve relation into column name. It just returns column_name if the column exists. Or it tries to resolve column_name as a relation. Returns an array of column names if the relation is polymorphic. It returns nil if it can’t resolve.

Parameters:

Returns:

  • (Array, String, nil) 


69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 69

def resolve_relation_into_column(name:, class_node:, table:)
  return unless table
  return name if table.with_column?(name: name)

  find_belongs_to(class_node) do |belongs_to|
    next unless belongs_to.first_argument.value.to_s == name

    fk = foreign_key_of(belongs_to) || "#{name}_id"
    next unless table.with_column?(name: fk)

    return polymorphic?(belongs_to) ? [fk, "#{name}_type"] : fk
  end
  nil
end

#schema ⇒ Object 



41
42
43
44
45
46
47
48
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 41

def schema
  # For compatibility with RuboCop 1.61.0 or lower.
  if respond_to?(:parser_engine)
    RuboCop::Rails::SchemaLoader.load(target_ruby_version, parser_engine)
  else
    RuboCop::Rails::SchemaLoader.load(target_ruby_version, :parser_whitequark)
  end
end

#table_name(class_node) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/rubocop/cop/mixin/active_record_helper.rb', line 50

def table_name(class_node)
  table_name = find_set_table_name(class_node).to_a.last&.first_argument
  return table_name.value.to_s if table_name

  class_nodes = class_node.defined_module.each_node
  namespaces = class_node.each_ancestor(:class, :module).map(&:identifier)
  [*class_nodes, *namespaces].reverse.map { |node| node.children[1] }.join('_').tableize
end