Class: RuboCop::Cop::Style::InverseMethods

Inherits:
Cop
  • Object
show all
Includes:
IgnoredNode, RangeHelp
Defined in:
lib/rubocop/cop/style/inverse_methods.rb

Overview

This cop check for usages of not (not or !) called on a method when an inverse of that method can be used instead. Methods that can be inverted by a not (not or !) should be defined in InverseMethods Methods that are inverted by inverting the return of the block that is passed to the method should be defined in InverseBlocks

Examples:

# bad
!foo.none?
!foo.any? { |f| f.even? }
!foo.blank?
!(foo == bar)
foo.select { |f| !f.even? }
foo.reject { |f| f != 7 }

# good
foo.none?
foo.blank?
foo.any? { |f| f.even? }
foo != bar
foo == bar
!!('foo' =~ /^\w+$/)
!(foo.class < Numeric) # Checking class hierarchy is allowed
# Blocks with guard clauses are ignored:
foo.select do |f|
  next if f.zero?
  f != 1
end

Constant Summary collapse

MSG = 
'Use `%<inverse>s` instead of inverting `%<method>s`.'
CLASS_COMPARISON_METHODS = 
%i[<= >= < >].freeze
EQUALITY_METHODS = 
%i[== != =~ !~ <= >= < >].freeze
NEGATED_EQUALITY_METHODS = 
%i[!= !~].freeze
CAMEL_CASE = 
/[A-Z]+[a-z]+/.freeze

Constants included from Util

Util::LITERAL_REGEX

Instance Attribute Summary

Attributes inherited from Cop

#config, #corrections, #offenses, #processed_source

Class Method Summary collapse

Instance Method Summary collapse

Methods included from IgnoredNode

#ignore_node, #ignored_node?, #part_of_ignored_node?

Methods inherited from Cop

#add_offense, all, badge, #config_to_allow_offenses, #config_to_allow_offenses=, #cop_config, cop_name, #cop_name, #correct, department, #disable_uncorrectable, #duplicate_location?, #excluded_file?, #external_dependency_checksum, #find_location, #highlights, inherited, #initialize, #join_force?, lint?, match?, #message, #messages, #parse, qualified_cop_name, #reason_to_not_correct, #relevant_file?, #target_rails_version, #target_ruby_version

Methods included from AST::Sexp

#s

Methods included from NodePattern::Macros

#def_node_matcher, #def_node_search, #node_search, #node_search_all, #node_search_body, #node_search_first

Methods included from AutocorrectLogic

#autocorrect?, #autocorrect_enabled?, #autocorrect_requested?, #correctable?, #disable_offense, #disable_uncorrectable?, #safe_autocorrect?, #support_autocorrect?

Methods included from Util

begins_its_line?, comment_line?, double_quotes_required?, escape_string, first_part_of_call_chain, interpret_string_escapes, line_range, needs_escaping?, on_node, parentheses?, same_line?, to_string_literal, to_supported_styles, tokens, trim_string_interporation_escape_character

Methods included from PathUtil

absolute?, chdir, hidden_dir?, hidden_file_in_not_hidden_dir?, match_path?, pwd, relative_path, reset_pwd, smart_path

Constructor Details

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

Class Method Details

.autocorrect_incompatible_with ⇒ Object 



46
47
48
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 46

def self.autocorrect_incompatible_with
  [Style::Not, Style::SymbolProc]
end

Instance Method Details

#autocorrect(node) ⇒ Object 



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

def autocorrect(node)
  if node.block_type?
    correct_inverse_block(node)
  elsif node.send_type?
    correct_inverse_method(node)
  end
end

#correct_inverse_block(node) ⇒ Object 



116
117
118
119
120
121
122
123
124
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 116

def correct_inverse_block(node)
  method_call, method, block = inverse_block?(node)

  lambda do |corrector|
    corrector.replace(method_call.loc.selector,
                      inverse_blocks[method].to_s)
    correct_inverse_selector(block, corrector)
  end
end

#correct_inverse_method(node) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 104

def correct_inverse_method(node)
  method_call, _lhs, method, _rhs = inverse_candidate?(node)
  return unless method_call && method

  lambda do |corrector|
    corrector.remove(not_to_receiver(node, method_call))
    corrector.replace(method_call.loc.selector,
                      inverse_methods[method].to_s)
    remove_end_parenthesis(corrector, node, method, method_call)
  end
end

#correct_inverse_selector(block, corrector) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 126

def correct_inverse_selector(block, corrector)
  selector_loc = block.loc.selector
  selector = selector_loc.source

  if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
    selector[0] = '='
    corrector.replace(selector_loc, selector)
  else
    if block.loc.dot
      range = dot_range(block.loc)
      corrector.remove(range)
    end

    corrector.remove(selector_loc)
  end
end

#on_block(node) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 80

def on_block(node)
  inverse_block?(node) do |_method_call, method, block|
    return unless inverse_blocks.key?(method)
    return if negated?(node) && negated?(node.parent)
    return if node.each_node(:next).any?

    # Inverse method offenses inside of the block of an inverse method
    # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
    # can cause auto-correction to apply improper corrections.
    ignore_node(block)
    add_offense(node,
                message: format(MSG, method: method,
                                     inverse: inverse_blocks[method]))
  end
end

#on_send(node) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/rubocop/cop/style/inverse_methods.rb', line 66

def on_send(node)
  return if part_of_ignored_node?(node)

  inverse_candidate?(node) do |_method_call, lhs, method, rhs|
    return unless inverse_methods.key?(method)
    return if possible_class_hierarchy_check?(lhs, rhs, method)
    return if negated?(node)

    add_offense(node,
                message: format(MSG, method: method,
                                     inverse: inverse_methods[method]))
  end
end