class RuboCop::Cop::Lint::Void
Checks for operators, variables, literals, lambda, proc and nonmutating methods used in void context.
‘each` blocks are allowed to prevent false positives. For example, the expression inside the `each` block below. It’s not void, especially when the receiver is an ‘Enumerator`:
- source,ruby
enumerator = [1, 2, 3].filter enumerator.each { |item| item >= 2 } #=> [2, 3]
@example CheckForMethodsWithNoSideEffects: false (default)
# bad def some_method some_num * 10 do_something end def some_method(some_var) some_var do_something end
@example CheckForMethodsWithNoSideEffects: true
# bad def some_method(some_array) some_array.sort do_something(some_array) end # good def some_method do_something some_num * 10 end def some_method(some_var) do_something some_var end def some_method(some_array) some_array.sort! do_something(some_array) end
Constants
- BINARY_OPERATORS
- CONST_MSG
- EXPRESSION_MSG
- LIT_MSG
- METHODS_REPLACEABLE_BY_EACH
- NONMUTATING_METHODS
- NONMUTATING_METHODS_WITH_BANG_VERSION
- NONMUTATING_MSG
- OPERATORS
- OP_MSG
- SELF_MSG
- UNARY_OPERATORS
- VAR_MSG
Public Instance Methods
on_begin(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 90 def on_begin(node) check_begin(node) end
Also aliased as: on_kwbegin
on_block(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 81 def on_block(node) return unless node.body && !node.body.begin_type? return unless in_void_context?(node.body) check_void_op(node.body) { node.method?(:each) } check_expression(node.body) end
Also aliased as: on_numblock
on_ensure(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 95 def on_ensure(node) check_ensure(node) end
Private Instance Methods
all_keys_entirely_literal?(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 258 def all_keys_entirely_literal?(node) node.each_key.all? { |key| entirely_literal?(key) } end
all_values_entirely_literal?(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 262 def all_values_entirely_literal?(node) node.each_value.all? { |value| entirely_literal?(value) } end
autocorrect_nonmutating_send(corrector, node, suggestion)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 236 def autocorrect_nonmutating_send(corrector, node, suggestion) send_node = if node.send_type? node else node.send_node end corrector.replace(send_node.loc.selector, suggestion) end
autocorrect_void_expression(corrector, node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 230 def autocorrect_void_expression(corrector, node) return if node.parent.if_type? && node.parent.modifier_form? corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left)) end
autocorrect_void_op(corrector, node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 218 def autocorrect_void_op(corrector, node) if node.arguments.empty? corrector.replace(node, node.receiver.source) else corrector.replace( range_with_surrounding_space(range: node.loc.selector, side: :both, newlines: false), "\n" ) end end
check_begin(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 101 def check_begin(node) expressions = *node expressions.pop unless in_void_context?(node) expressions.each do |expr| check_void_op(expr) do block_node = node.each_ancestor(:block).first block_node&.method?(:each) end check_expression(expr) end end
check_ensure(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 198 def check_ensure(node) return unless (body = node.body) # NOTE: the `begin` node case is already handled via `on_begin` return if body.begin_type? check_void_op(body) do block_node = node.each_ancestor(:block).first block_node&.method?(:each) end check_expression(body) end
check_expression(expr)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 115 def check_expression(expr) expr = expr.body if expr.if_type? && expr.modifier_form? check_literal(expr) check_var(expr) check_self(expr) check_void_expression(expr) return unless cop_config['CheckForMethodsWithNoSideEffects'] check_nonmutating(expr) end
check_literal(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 156 def check_literal(node) return if !entirely_literal?(node) || node.xstr_type? || node.range_type? add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector| autocorrect_void_expression(corrector, node) end end
check_nonmutating(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 180 def check_nonmutating(node) return if !node.send_type? && !node.block_type? && !node.numblock_type? method_name = node.method_name return unless NONMUTATING_METHODS.include?(method_name) suggestion = if METHODS_REPLACEABLE_BY_EACH.include?(method_name) 'each' else "#{method_name}!" end add_offense(node, message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion)) do |corrector| autocorrect_nonmutating_send(corrector, node, suggestion) end end
check_self(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 164 def check_self(node) return unless node.self_type? add_offense(node, message: SELF_MSG) do |corrector| autocorrect_void_expression(corrector, node) end end
check_var(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 138 def check_var(node) return unless node.variable? || node.const_type? if node.const_type? template = node.special_keyword? ? VAR_MSG : CONST_MSG offense_range = node message = format(template, var: node.source) else offense_range = node.loc.name message = format(VAR_MSG, var: node.loc.name.source) end add_offense(offense_range, message: message) do |corrector| autocorrect_void_expression(corrector, node) end end
check_void_expression(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 172 def check_void_expression(node) return unless node.defined_type? || node.lambda_or_proc? add_offense(node, message: format(EXPRESSION_MSG, expression: node.source)) do |corrector| autocorrect_void_expression(corrector, node) end end
check_void_op(node) { |node| ... }
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 127 def check_void_op(node, &block) node = node.children.first while node.begin_type? return unless node.send_type? && OPERATORS.include?(node.method_name) return if block && yield(node) add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name)) do |corrector| autocorrect_void_op(corrector, node) end end
entirely_literal?(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 245 def entirely_literal?(node) case node.type when :array all_values_entirely_literal?(node) when :hash all_keys_entirely_literal?(node) && all_values_entirely_literal?(node) when :send, :csend node.method?(:freeze) && node.receiver && entirely_literal?(node.receiver) else node.literal? end end
in_void_context?(node)
click to toggle source
# File lib/rubocop/cop/lint/void.rb, line 211 def in_void_context?(node) parent = node.parent return false unless parent && parent.children.last == node parent.respond_to?(:void_context?) && parent.void_context? end