rbhint 0.85.1.rc2 → 0.87.1.rc1

data/lib/rubocop/cop/lint/duplicate_elsif_condition.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      #
+      # @example
+      #   # bad
+      #   if x == 1
+      #     do_something
+      #   elsif x == 1
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x == 1
+      #     do_something
+      #   elsif x == 2
+      #     do_something_else
+      #   end
+      #
+      class DuplicateElsifCondition < Base
+        MSG = 'Duplicate `elsif` condition detected.'
+
+        def on_if(node)
+          previous = []
+          while node.if? || node.elsif?
+            condition = node.condition
+            add_offense(condition) if previous.include?(condition)
+            previous << condition
+            node = node.else_branch
+            break unless node&.if_type?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -126,7 +126,7 @@ module RuboCop
         end
 
         def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: @definitions[method_name],
+          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
                       current: source_location(node))
         end
 
@@ -152,7 +152,7 @@ module RuboCop
 
             add_offense(node, location: loc, message: message)
           else
-            @definitions[method_name] = source_location(node)
+            @definitions[method_name] = node
           end
         end
 

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -64,9 +64,10 @@ module RuboCop
 
         def ending_delimiter(str)
           # implicit string concatenation does not work with %{}, etc.
-          if str.source[0] == "'"
+          case str.source[0]
+          when "'"
             "'"
-          elsif str.source[0] == '"'
+          when '"'
             '"'
           end
         end

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -30,6 +30,19 @@ module RuboCop
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            starting_token, ending_token = if node.source.include?('"')
+                                             ['%{', '}']
+                                           else
+                                             ['"', '"']
+                                           end
+
+            corrector.replace(node.loc.begin, starting_token)
+            corrector.replace(node.loc.end, ending_token)
+          end
+        end
+
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) ||
             (node.parent && heredoc?(node.parent))

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -30,6 +30,8 @@ module RuboCop
       #     break if condition
       #   end
       class LiteralAsCondition < Cop
+        include RangeHelp
+
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
         def on_if(node)
@@ -57,7 +59,8 @@ module RuboCop
             case_node.each_when do |when_node|
               next unless when_node.conditions.all?(&:literal?)
 
-              add_offense(when_node)
+              range = when_conditions_range(when_node)
+              add_offense(when_node, location: range, message: message(range))
             end
           end
         end
@@ -129,6 +132,13 @@ module RuboCop
             node.condition
           end
         end
+
+        def when_conditions_range(when_node)
+          range_between(
+            when_node.conditions.first.source_range.begin_pos,
+            when_node.conditions.last.source_range.end_pos
+          )
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -59,31 +59,25 @@ module RuboCop
               'Use `lambda` instead.'
 
         def on_def(node)
-          find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node)
-          end
-        end
-        alias on_defs on_def
-
-        private
+          subject, = *node
+          return if node.defs_type? && subject.lvar_type?
 
-        def find_nested_defs(node, &block)
-          node.each_child_node do |child|
-            if child.def_type?
-              yield child
-            elsif child.defs_type?
-              subject, = *child
-              next if subject.lvar_type?
+          def_ancestor = node.each_ancestor(:def, :defs).first
+          return unless def_ancestor
 
-              yield child
-            elsif !scoping_method_call?(child)
-              find_nested_defs(child, &block)
+          within_scoping_def =
+            node.each_ancestor(:block, :sclass).any? do |ancestor|
+              scoping_method_call?(ancestor)
             end
-          end
+
+          add_offense(node) if def_ancestor && !within_scoping_def
         end
+        alias on_defs on_def
+
+        private
 
         def scoping_method_call?(child)
-          eval_call?(child) || exec_call?(child) || child.sclass_type? ||
+          child.sclass_type? || eval_call?(child) || exec_call?(child) ||
             class_or_module_or_struct_new_call?(child)
         end
 
@@ -96,7 +90,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -69,11 +69,11 @@ module RuboCop
         end
 
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
-          (send (const nil? :Dir) :glob ...)
+          (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
-          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
         def_node_matcher :loop_variable, <<~PATTERN

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -48,17 +48,22 @@ module RuboCop
             return true
           end
 
-          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+          node.operator_method? || node.setter_method? || chained_calls?(node) ||
+            operator_keyword?(node)
         end
 
         def first_argument_starts_with_left_parenthesis?(node)
           node.first_argument.source.start_with?('(')
         end
 
-        def grouped_parentheses?(node)
+        def chained_calls?(node)
           first_argument = node.first_argument
+          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+        end
 
-          first_argument.send_type? && first_argument.receiver&.begin_type?
+        def operator_keyword?(node)
+          first_argument = node.first_argument
+          first_argument.operator_keyword?
         end
 
         def spaces_before_left_parenthesis(node)

data/lib/rubocop/cop/lint/raise_exception.rb

@@ -44,6 +44,14 @@ module RuboCop
             exception_new_with_message?(node, &check(node))
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            exception_class = node.children.first&.cbase_type? ? '::StandardError' : 'StandardError'
+
+            corrector.replace(node, exception_class)
+          end
+        end
+
         private
 
         def check(node)

data/lib/rubocop/cop/lint/rand_one.rb

@@ -25,7 +25,7 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'
 
         def_node_matcher :rand_one?, <<~PATTERN
-          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
+          (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -25,34 +25,34 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class RedundantCopDisableDirective < Cop
+      class RedundantCopDisableDirective < Base
         include RangeHelp
+        extend AutoCorrector
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
 
-        def check(offenses, cop_disabled_line_ranges, comments)
+        attr_accessor :offenses_to_check
+
+        def initialize(config = nil, options = nil, offenses = nil)
+          @offenses_to_check = offenses
+          super(config, options)
+        end
+
+        def on_new_investigation
+          return unless offenses_to_check
+
+          comments = processed_source.comments
+          cop_disabled_line_ranges = processed_source.disabled_line_ranges
+
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
           each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses, comments) do |comment, redundant_cop|
+                                 offenses_to_check, comments) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
           add_offenses(redundant_cops)
-        end
-
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
-
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
-
-            corrector.remove(range)
-          end
+          super
         end
 
         private
@@ -187,10 +187,12 @@ module RuboCop
           cop_list = cops.sort.map { |c| describe(c) }
 
           add_offense(
-            [[location], location],
-            location: location,
+            location,
             message: "Unnecessary disabling of #{cop_list.join(', ')}."
-          )
+          ) do |corrector|
+            range = comment_range_with_surrounding_space(location)
+            corrector.remove(range)
+          end
         end
 
         def add_offense_for_some_cops(comment, cops)
@@ -200,10 +202,12 @@ module RuboCop
 
           cop_ranges.each do |cop, range|
             add_offense(
-              [ranges, range],
-              location: range,
+              range,
               message: "Unnecessary disabling of #{describe(cop)}."
-            )
+            ) do |corrector|
+              range = directive_range_in_list(range, ranges)
+              corrector.remove(range)
+            end
           end
         end
 

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -60,8 +60,8 @@ module RuboCop
 
         def_node_matcher :array_new?, <<~PATTERN
           {
-            $(send (const nil? :Array) :new ...)
-            $(block (send (const nil? :Array) :new ...) ...)
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
           }
         PATTERN
 

data/lib/rubocop/cop/lint/regexp_as_condition.rb

@@ -23,6 +23,12 @@ module RuboCop
         def on_match_current_line(node)
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, "#{node.source} =~ $_")
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -32,6 +32,14 @@ module RuboCop
 
           add_offense(node.condition)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            receiver = node.receiver.source
+
+            corrector.replace(node, "#{receiver} && #{receiver}.#{node.method_name}")
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/syntax.rb

@@ -3,49 +3,34 @@
 module RuboCop
   module Cop
     module Lint
-      # This is not actually a cop. It does not inspect anything. It just
-      # provides methods to repack Parser's diagnostics/errors
+      # This cop repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
-      class Syntax < Cop
-        PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                       :end_pos)
-
-        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
-
-        def self.offenses_from_processed_source(processed_source,
-                                                config, options)
-          cop = new(config, options)
-
-          cop.add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-
+      class Syntax < Base
+        def on_other_file
+          add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
           processed_source.diagnostics.each do |diagnostic|
-            cop.add_offense_from_diagnostic(diagnostic,
-                                            processed_source.ruby_version)
+            add_offense_from_diagnostic(diagnostic,
+                                        processed_source.ruby_version)
           end
-
-          cop.offenses
+          super
         end
 
+        private
+
         def add_offense_from_diagnostic(diagnostic, ruby_version)
           message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
             'configure using `TargetRubyVersion` parameter, under `AllCops`)'
-          add_offense(nil,
-                      location: diagnostic.location,
+          add_offense(diagnostic.location,
                       message: message,
                       severity: diagnostic.level)
         end
 
         def add_offense_from_error(error)
           message = beautify_message(error.message)
-          add_offense(nil,
-                      location: ERROR_SOURCE_RANGE,
-                      message: message,
-                      severity: :fatal)
+          add_global_offense(message, severity: :fatal)
         end
 
-        private
-
         def beautify_message(message)
           message = message.capitalize
           message << '.' unless message.end_with?('.')

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -62,7 +62,7 @@ module RuboCop
         include UnusedArgument
 
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const nil? :NotImplementedError))
+          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
            (send nil? :fail ...)}
         PATTERN
 

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -172,7 +172,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)