Class: RuboCop::Cop::VariableForce

Inherits:
Force
  • Object
show all
Defined in:
lib/rubocop/cop/variable_force.rb,
lib/rubocop/cop/variable_force/scope.rb,
lib/rubocop/cop/variable_force/variable.rb,
lib/rubocop/cop/variable_force/locatable.rb,
lib/rubocop/cop/variable_force/reference.rb,
lib/rubocop/cop/variable_force/assignment.rb,
lib/rubocop/cop/variable_force/variable_table.rb

Overview

This force provides a way to track local variables and scopes of Ruby. Cops interact with this force need to override some of the hook methods.

def before_entering_scope(scope, variable_table)
end

def after_entering_scope(scope, variable_table)
end

def before_leaving_scope(scope, variable_table)
end

def after_leaving_scope(scope, variable_table)
end

def before_declaring_variable(variable, variable_table)
end

def after_declaring_variable(variable, variable_table)
end

Defined Under Namespace

Modules: Locatable Classes: Assignment, Reference, Scope, Variable, VariableTable

Constant Summary collapse

VARIABLE_ASSIGNMENT_TYPE =

rubocop:disable Metrics/ClassLength

:lvasgn
REGEXP_NAMED_CAPTURE_TYPE = 
:match_with_lvasgn
VARIABLE_ASSIGNMENT_TYPES = 
[VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
ARGUMENT_DECLARATION_TYPES = 
[
  :arg, :optarg, :restarg,
  :kwarg, :kwoptarg, :kwrestarg,
  :blockarg, # This doesn't mean block argument, it's block-pass (&block).
  :shadowarg # This means block local variable (obj.each { |arg; this| }).
].freeze
LOGICAL_OPERATOR_ASSIGNMENT_TYPES = 
[:or_asgn, :and_asgn].freeze
OPERATOR_ASSIGNMENT_TYPES = 
(LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
MULTIPLE_ASSIGNMENT_TYPE = 
:masgn
VARIABLE_REFERENCE_TYPE = 
:lvar
POST_CONDITION_LOOP_TYPES = 
[:while_post, :until_post].freeze
LOOP_TYPES = 
(POST_CONDITION_LOOP_TYPES + [:while, :until, :for]).freeze
RESCUE_TYPE = 
:rescue
ZERO_ARITY_SUPER_TYPE = 
:zsuper
TWISTED_SCOPE_TYPES = 
[:block, :class, :sclass, :defs].freeze
SCOPE_TYPES = 
(TWISTED_SCOPE_TYPES + [:module, :def]).freeze
SEND_TYPE = 
:send

Instance Attribute Summary

Attributes inherited from Force

#cops

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Force

all, force_name, inherited, #initialize, #name, #run_hook

Constructor Details

This class inherits a constructor from RuboCop::Cop::Force

Class Method Details

.wrap_with_top_level_scope_node(root_node) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/rubocop/cop/variable_force.rb', line 59

def self.wrap_with_top_level_scope_node(root_node)
  if root_node.begin_type?
    root_node
  else
    Node.new(:begin, [root_node])
  end
end

Instance Method Details

#dispatch_node(node) ⇒ Object

rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/rubocop/cop/variable_force.rb', line 108

def dispatch_node(node)
  case node.type
  when VARIABLE_ASSIGNMENT_TYPE
    process_variable_assignment(node)
  when REGEXP_NAMED_CAPTURE_TYPE
    process_regexp_named_captures(node)
  when MULTIPLE_ASSIGNMENT_TYPE
    process_variable_multiple_assignment(node)
  when VARIABLE_REFERENCE_TYPE
    process_variable_referencing(node)
  when RESCUE_TYPE
    process_rescue(node)
  when ZERO_ARITY_SUPER_TYPE
    process_zero_arity_super(node)
  when SEND_TYPE
    process_send(node)
  when *ARGUMENT_DECLARATION_TYPES
    process_variable_declaration(node)
  when *OPERATOR_ASSIGNMENT_TYPES
    process_variable_operator_assignment(node)
  when *LOOP_TYPES
    process_loop(node)
  when *SCOPE_TYPES
    process_scope(node)
  end
end

#find_variables_in_loop(loop_node) ⇒ Object 



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/rubocop/cop/variable_force.rb', line 320

def find_variables_in_loop(loop_node)
  referenced_variable_names_in_loop = []
  assignment_nodes_in_loop = []

  # #each_descendant does not consider scope,
  # but we don't need to care about it here.
  loop_node.each_descendant do |node|
    case node.type
    when :lvar
      referenced_variable_names_in_loop << node.children.first
    when :lvasgn
      assignment_nodes_in_loop << node
    when *OPERATOR_ASSIGNMENT_TYPES
      asgn_node = node.children.first
      if asgn_node.type == :lvasgn
        referenced_variable_names_in_loop << asgn_node.children.first
      end
    end
  end

  [referenced_variable_names_in_loop, assignment_nodes_in_loop]
end

#inspect_variables_in_scope(scope_node) ⇒ Object

This is called for each scope recursively.



83
84
85
86
87
 
# File 'lib/rubocop/cop/variable_force.rb', line 83

def inspect_variables_in_scope(scope_node)
  variable_table.push_scope(scope_node)
  process_children(scope_node)
  variable_table.pop_scope
end

#investigate(processed_source) ⇒ Object

Starting point.



72
73
74
75
76
77
78
79
80
 
# File 'lib/rubocop/cop/variable_force.rb', line 72

def investigate(processed_source)
  root_node = processed_source.ast
  return unless root_node

  # Wrap the root node with begin node if it's a standalone node.
  root_node = self.class.wrap_with_top_level_scope_node(root_node)

  inspect_variables_in_scope(root_node)
end

#mark_assignments_as_referenced_in_loop(node) ⇒ Object

Mark all assignments which are referenced in the same loop as referenced by ignoring AST order since they would be referenced in next iteration.



302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/rubocop/cop/variable_force.rb', line 302

def mark_assignments_as_referenced_in_loop(node)
  referenced_variable_names_in_loop, assignment_nodes_in_loop =
    find_variables_in_loop(node)

  referenced_variable_names_in_loop.each do |name|
    variable = variable_table.find_variable(name)
    # Non related references which are caught in the above scan
    # would be skipped here.
    next unless variable
    variable.assignments.each do |assignment|
      next if assignment_nodes_in_loop.none? do |assignment_node|
                assignment_node.equal?(assignment.node)
              end
      assignment.reference!
    end
  end
end

#process_children(origin_node) ⇒ Object 



89
90
91
92
93
94
 
# File 'lib/rubocop/cop/variable_force.rb', line 89

def process_children(origin_node)
  origin_node.each_child_node do |child_node|
    next if scanned_node?(child_node)
    process_node(child_node)
  end
end

#process_loop(node) ⇒ Object 



239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/rubocop/cop/variable_force.rb', line 239

def process_loop(node)
  if POST_CONDITION_LOOP_TYPES.include?(node.type)
    # See the comment at the end of file for this behavior.
    condition_node, body_node = *node
    process_node(body_node)
    process_node(condition_node)
  else
    process_children(node)
  end

  mark_assignments_as_referenced_in_loop(node)

  skip_children!
end

#process_node(node) ⇒ Object 



96
97
98
99
100
101
 
# File 'lib/rubocop/cop/variable_force.rb', line 96

def process_node(node)
  catch(:skip_children) do
    dispatch_node(node)
    process_children(node)
  end
end

#process_regexp_named_captures(node) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/rubocop/cop/variable_force.rb', line 168

def process_regexp_named_captures(node)
  regexp_node, rhs_node = *node

  regexp_string = regexp_node.children[0].children[0]
  regexp = Regexp.new(regexp_string)
  variable_names = regexp.named_captures.keys

  variable_names.each do |name|
    next if variable_table.variable_exist?(name)
    variable_table.declare_variable(name, node)
  end

  process_node(rhs_node)
  process_node(regexp_node)

  variable_names.each do |name|
    variable_table.assign_to_variable(name, node)
  end

  skip_children!
end

#process_rescue(node) ⇒ Object 



254
255
256
257
258
259
260
261
262
263
 
# File 'lib/rubocop/cop/variable_force.rb', line 254

def process_rescue(node)
  resbody_nodes = node.each_child_node(:resbody)

  contain_retry = resbody_nodes.any? do |resbody_node|
    resbody_node.each_descendant.any?(&:retry_type?)
  end

  # Treat begin..rescue..end with retry as a loop.
  process_loop(node) if contain_retry
end

#process_scope(node) ⇒ Object 



272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/rubocop/cop/variable_force.rb', line 272

def process_scope(node)
  if TWISTED_SCOPE_TYPES.include?(node.type)
    # See the comment at the end of file for this behavior.
    twisted_nodes = [node.children[0]]
    twisted_nodes << node.children[1] if node.type == :class
    twisted_nodes.compact!

    twisted_nodes.each do |twisted_node|
      process_node(twisted_node)
      scanned_nodes << twisted_node
    end
  end

  inspect_variables_in_scope(node)
  skip_children!
end

#process_send(node) ⇒ Object 



289
290
291
292
293
294
295
296
297
 
# File 'lib/rubocop/cop/variable_force.rb', line 289

def process_send(node)
  _receiver, method_name, args = *node
  return unless method_name == :binding
  return if args && !args.children.empty?

  variable_table.accessible_variables.each do |variable|
    variable.reference!(node)
  end
end

#process_variable_assignment(node) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/rubocop/cop/variable_force.rb', line 148

def process_variable_assignment(node)
  name = node.children.first

  unless variable_table.variable_exist?(name)
    variable_table.declare_variable(name, node)
  end

  # Need to scan rhs before assignment so that we can mark previous
  # assignments as referenced if rhs has referencing to the variable
  # itself like:
  #
  #   foo = 1
  #   foo = foo + 1
  process_children(node)

  variable_table.assign_to_variable(name, node)

  skip_children!
end

#process_variable_declaration(node) ⇒ Object

rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity



136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/rubocop/cop/variable_force.rb', line 136

def process_variable_declaration(node)
  variable_name = node.children.first

  # restarg and kwrestarg would have no name:
  #
  #   def initialize(*)
  #   end
  return unless variable_name

  variable_table.declare_variable(variable_name, node)
end

#process_variable_multiple_assignment(node) ⇒ Object 



227
228
229
230
231
232
 
# File 'lib/rubocop/cop/variable_force.rb', line 227

def process_variable_multiple_assignment(node)
  lhs_node, rhs_node = *node
  process_node(rhs_node)
  process_node(lhs_node)
  skip_children!
end

#process_variable_operator_assignment(node) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/rubocop/cop/variable_force.rb', line 190

def process_variable_operator_assignment(node)
  if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
    asgn_node, rhs_node = *node
  else
    asgn_node, _operator, rhs_node = *node
  end

  return unless asgn_node.type == :lvasgn

  name = asgn_node.children.first

  unless variable_table.variable_exist?(name)
    variable_table.declare_variable(name, asgn_node)
  end

  # The following statements:
  #
  #   foo = 1
  #   foo += foo = 2
  #   # => 3
  #
  # are equivalent to:
  #
  #   foo = 1
  #   foo = foo + (foo = 2)
  #   # => 3
  #
  # So, at operator assignment node, we need to reference the variable
  # before processing rhs nodes.

  variable_table.reference_variable(name, node)
  process_node(rhs_node)
  variable_table.assign_to_variable(name, asgn_node)

  skip_children!
end

#process_variable_referencing(node) ⇒ Object 



234
235
236
237
 
# File 'lib/rubocop/cop/variable_force.rb', line 234

def process_variable_referencing(node)
  name = node.children.first
  variable_table.reference_variable(name, node)
end

#process_zero_arity_super(node) ⇒ Object 



265
266
267
268
269
270
 
# File 'lib/rubocop/cop/variable_force.rb', line 265

def process_zero_arity_super(node)
  variable_table.accessible_variables.each do |variable|
    next unless variable.method_argument?
    variable.reference!(node)
  end
end

#scanned_node?(node) ⇒ Boolean

Use Node#equal? for accurate check.

Returns:

  • (Boolean) 


344
345
346
347
348
 
# File 'lib/rubocop/cop/variable_force.rb', line 344

def scanned_node?(node)
  scanned_nodes.any? do |scanned_node|
    scanned_node.equal?(node)
  end
end

#scanned_nodes ⇒ Object 



350
351
352
 
# File 'lib/rubocop/cop/variable_force.rb', line 350

def scanned_nodes
  @scanned_nodes ||= []
end

#skip_children! ⇒ Object 



103
104
105
 
# File 'lib/rubocop/cop/variable_force.rb', line 103

def skip_children!
  throw :skip_children
end

#variable_table ⇒ Object 



67
68
69
 
# File 'lib/rubocop/cop/variable_force.rb', line 67

def variable_table
  @variable_table ||= VariableTable.new(self)
end