rubocop 0.90.0 → 0.91.0

data/lib/rubocop/cop/style/alias.rb

@@ -32,6 +32,8 @@ module RuboCop
         MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
                            '`alias %<current>s`.'
 
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)

data/lib/rubocop/cop/style/array_join.rb

@@ -21,6 +21,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Favor `Array#join` over `Array#*`.'
+        RESTRICT_ON_SEND = %i[*].freeze
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 

data/lib/rubocop/cop/style/attr.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[attr].freeze
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?

data/lib/rubocop/cop/style/auto_resource_cleanup.rb

@@ -23,6 +23,8 @@ module RuboCop
           File: :open
         }.freeze
 
+        RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
+
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
             next if node.method_name != target_method

data/lib/rubocop/cop/style/case_equality.rb

@@ -33,11 +33,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid the use of the case equality operator `===`.'
+        RESTRICT_ON_SEND = %i[===].freeze
 
         def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
+            return if lhs.const_type? && !lhs.module_name?
+
             add_offense(node.loc.selector) do |corrector|
               replacement = replacement(lhs, rhs)
               corrector.replace(node, replacement) if replacement

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -112,6 +112,8 @@ module RuboCop
         end
 
         def check_style(node, body)
+          return if node.identifier.children[0]&.cbase_type?
+
           if style == :nested
             check_nested_style(node)
           else

data/lib/rubocop/cop/style/class_check.rb

@@ -28,19 +28,16 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
-
-        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+        RESTRICT_ON_SEND = %i[is_a? kind_of?].freeze
 
         def on_send(node)
-          class_check?(node) do |method_name|
-            return if style == method_name
+          return if style == node.method_name
 
-            message = message(node)
-            add_offense(node.loc.selector, message: message) do |corrector|
-              replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
-              corrector.replace(node.loc.selector, replacement)
-            end
+            corrector.replace(node.loc.selector, replacement)
           end
         end
 

data/lib/rubocop/cop/style/class_methods_definitions.rb

@@ -62,22 +62,19 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include CommentsHelp
         include VisibilityHelp
+        include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<preferred>s` to define class method.'
+        MSG = 'Use `%<preferred>s` to define a class method.'
+        MSG_SCLASS = 'Do not define public methods within class << self.'
 
         def on_sclass(node)
           return unless def_self_style?
           return unless node.identifier.source == 'self'
-          return if contains_non_public_methods?(node)
+          return unless all_methods_public?(node)
 
-          def_nodes(node).each do |def_node|
-            next unless node_visibility(def_node) == :public
-
-            message = format(MSG, preferred: "def self.#{def_node.method_name}")
-            add_offense(def_node, message: message) do |corrector|
-              extract_def_from_sclass(def_node, node, corrector)
-            end
+          add_offense(node, message: MSG_SCLASS) do |corrector|
+            autocorrect_sclass(node, corrector)
           end
         end
 
@@ -94,8 +91,11 @@ module RuboCop
           style == :def_self
         end
 
-        def contains_non_public_methods?(sclass_node)
-          def_nodes(sclass_node).any? { |def_node| node_visibility(def_node) != :public }
+        def all_methods_public?(sclass_node)
+          def_nodes = def_nodes(sclass_node)
+          return false if def_nodes.empty?
+
+          def_nodes.all? { |def_node| node_visibility(def_node) == :public }
         end
 
         def def_nodes(sclass_node)
@@ -111,19 +111,45 @@ module RuboCop
           end
         end
 
-        def extract_def_from_sclass(def_node, sclass_node, corrector)
+        def autocorrect_sclass(node, corrector)
+          rewritten_defs = []
+
+          def_nodes(node).each do |def_node|
+            next unless node_visibility(def_node) == :public
+
+            range, source = extract_def_from_sclass(def_node, node)
+
+            corrector.remove(range)
+            rewritten_defs << source
+          end
+
+          if sclass_only_has_methods?(node)
+            corrector.remove(node)
+            rewritten_defs.first&.strip!
+          else
+            corrector.insert_after(node, "\n")
+          end
+
+          corrector.insert_after(node, rewritten_defs.join("\n"))
+        end
+
+        def sclass_only_has_methods?(node)
+          node.body.def_type? || node.body.each_child_node.all?(&:def_type?)
+        end
+
+        def extract_def_from_sclass(def_node, sclass_node)
           range = source_range_with_comment(def_node)
           source = range.source.sub!(
             "def #{def_node.method_name}",
             "def self.#{def_node.method_name}"
           )
 
-          corrector.insert_before(sclass_node, "#{source}\n#{indent(sclass_node)}")
-          corrector.remove(range)
+          source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
+          [range, source.chomp]
         end
 
-        def indent(node)
-          ' ' * node.loc.column
+        def indentation_diff(node1, node2)
+          node1.loc.column - node2.loc.column
         end
       end
     end

data/lib/rubocop/cop/style/class_vars.rb

@@ -47,14 +47,13 @@ module RuboCop
       #
       class ClassVars < Base
         MSG = 'Replace class var %<class_var>s with a class instance var.'
+        RESTRICT_ON_SEND = %i[class_variable_set].freeze
 
         def on_cvasgn(node)
           add_offense(node.loc.name, message: format(MSG, class_var: node.children.first))
         end
 
         def on_send(node)
-          return unless node.method?(:class_variable_set)
-
           add_offense(
             node.first_argument, message: format(MSG, class_var: node.first_argument.source)
           )

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -208,10 +208,11 @@ module RuboCop
       #     some_other_method
       #     bar = 2
       #   end
-      class ConditionalAssignment < Cop
+      class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
         include IgnoredNode
+        extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment ' \
               'and comparison.'
@@ -275,14 +276,6 @@ module RuboCop
           check_node(node, branches)
         end
 
-        def autocorrect(node)
-          if assignment_type?(node)
-            move_assignment_inside_condition(node)
-          else
-            move_assignment_outside_condition(node)
-          end
-        end
-
         private
 
         def check_assignment_to_condition(node)
@@ -298,7 +291,9 @@ module RuboCop
           return unless else_branch
           return if allowed_single_line?([*branches, else_branch])
 
-          add_offense(node, message: ASSIGN_TO_CONDITION_MSG)
+          add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def candidate_node?(node)
@@ -326,25 +321,25 @@ module RuboCop
           assignment
         end
 
-        def move_assignment_outside_condition(node)
+        def move_assignment_outside_condition(corrector, node)
           if node.case_type?
-            CaseCorrector.correct(self, node)
+            CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
-            TernaryCorrector.correct(node)
+            TernaryCorrector.correct(corrector, node)
           elsif node.if? || node.unless?
-            IfCorrector.correct(self, node)
+            IfCorrector.correct(corrector, self, node)
           end
         end
 
-        def move_assignment_inside_condition(node)
+        def move_assignment_inside_condition(corrector, node)
           *_assignment, condition = *node
 
           if ternary_condition?(condition)
-            TernaryCorrector.move_assignment_inside_condition(node)
+            TernaryCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.case_type?
-            CaseCorrector.move_assignment_inside_condition(node)
+            CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
-            IfCorrector.move_assignment_inside_condition(node)
+            IfCorrector.move_assignment_inside_condition(corrector, node)
           end
         end
 
@@ -371,7 +366,17 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(corrector, node)
+          else
+            move_assignment_outside_condition(corrector, node)
+          end
         end
 
         def allowed_statements?(branches)
@@ -499,24 +504,20 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(node)
-            lambda do |corrector|
-              corrector.replace(node, correction(node))
-            end
+          def correct(corrector, node)
+            corrector.replace(node, correction(node))
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             *_var, rhs = *node
             if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
 
-            lambda do |corrector|
-              remove_parentheses(corrector, rhs) if Util.parentheses?(rhs)
-              corrector.remove(assignment)
+            remove_parentheses(corrector, rhs) if Util.parentheses?(rhs)
+            corrector.remove(assignment)
 
-              move_branch_inside_condition(corrector, if_branch, assignment)
-              move_branch_inside_condition(corrector, else_branch, assignment)
-            end
+            move_branch_inside_condition(corrector, if_branch, assignment)
+            move_branch_inside_condition(corrector, else_branch, assignment)
           end
 
           private
@@ -565,22 +566,19 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(cop, node)
-            ->(corrector) { correct_if_branches(corrector, cop, node) }
+          def correct(corrector, cop, node)
+            correct_if_branches(corrector, cop, node)
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             column = node.loc.expression.column
             *_var, condition = *node
             assignment = assignment(node)
 
-            lambda do |corrector|
-              corrector.remove(assignment)
+            corrector.remove(assignment)
 
-              condition.branches.flatten.each do |branch|
-                move_branch_inside_condition(corrector, branch, condition,
-                                             assignment, column)
-              end
+            condition.branches.flatten.each do |branch|
+              move_branch_inside_condition(corrector, branch, condition, assignment, column)
             end
           end
 
@@ -614,31 +612,25 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(cop, node)
+          def correct(corrector, cop, node)
             when_branches, else_branch = extract_tail_branches(node)
 
-            lambda do |corrector|
-              corrector.insert_before(node, lhs(else_branch))
-              correct_branches(corrector, when_branches)
-              replace_branch_assignment(corrector, else_branch)
+            corrector.insert_before(node, lhs(else_branch))
+            correct_branches(corrector, when_branches)
+            replace_branch_assignment(corrector, else_branch)
 
-              corrector.insert_before(node.loc.end,
-                                      indent(cop, lhs(else_branch)))
-            end
+            corrector.insert_before(node.loc.end, indent(cop, lhs(else_branch)))
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             column = node.loc.expression.column
             *_var, condition = *node
             assignment = assignment(node)
 
-            lambda do |corrector|
-              corrector.remove(assignment)
+            corrector.remove(assignment)
 
-              extract_branches(condition).flatten.each do |branch|
-                move_branch_inside_condition(corrector, branch, condition,
-                                             assignment, column)
-              end
+            extract_branches(condition).flatten.each do |branch|
+              move_branch_inside_condition(corrector, branch, condition, assignment, column)
             end
           end
 
@@ -656,17 +648,14 @@ module RuboCop
             [when_branches, case_node.else_branch]
           end
 
-          def move_branch_inside_condition(corrector, branch, condition,
-                                           assignment, column)
+          def move_branch_inside_condition(corrector, branch, condition, assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment,
-                                    assignment.source)
+            corrector.insert_before(branch_assignment, assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
-            corrector.remove_preceding(parent_keyword,
-                                       parent_keyword.column - column)
+            corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end
       end

data/lib/rubocop/cop/style/dir.rb

@@ -20,6 +20,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = "Use `__dir__` to get an absolute path to the current file's directory."
+        RESTRICT_ON_SEND = %i[expand_path dirname].freeze
 
         def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))

data/lib/rubocop/cop/style/double_negation.rb

@@ -36,6 +36,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = 'Avoid the use of double negation (`!!`).'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 

data/lib/rubocop/cop/style/empty_literal.rb

@@ -25,6 +25,8 @@ module RuboCop
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
         STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
@@ -69,7 +71,7 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.object_id == parent.arguments.first.object_id &&
+          node.equal?(parent.arguments.first) &&
             !parentheses?(node.parent)
         end
 

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -37,7 +37,7 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
-        EVAL_METHODS = %i[eval class_eval module_eval instance_eval].to_set.freeze
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
         def_node_matcher :eval_without_location?, <<~PATTERN
           {
@@ -63,8 +63,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless EVAL_METHODS.include?(node.method_name)
-
           eval_without_location?(node) do |code|
             if with_lineno?(node)
               on_with_lineno(node, code)