rubocop 0.87.1 → 0.88.0

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -150,9 +150,10 @@ module RuboCop
         end
 
         def alignment_node(node)
-          if style == :keyword
+          case style
+          when :keyword
             node
-          elsif style == :variable
+          when :variable
             alignment_node_for_variable_style(node)
           else
             start_line_range(node)

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -95,11 +95,22 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
-          needed_length = node.source_range.column +
-                          node.source.lines.first.length +
-                          block_arg_string(node, node.arguments).length +
-                          PIPE_SIZE
-          needed_length > max_line_length
+          needed_length_for_args(node) > max_line_length
+        end
+
+        def needed_length_for_args(node)
+          node.source_range.column +
+            characters_needed_for_space_and_pipes(node) +
+            node.source.lines.first.chomp.length +
+            block_arg_string(node, node.arguments).length
+        end
+
+        def characters_needed_for_space_and_pipes(node)
+          if node.source.lines.first.end_with?("|\n")
+            PIPE_SIZE
+          else
+            1 + PIPE_SIZE * 2
+          end
         end
 
         def add_offense_for_expression(node, expr, msg)

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -56,11 +56,12 @@ module RuboCop
         def check_inside_pipes(arguments)
           opening_pipe, closing_pipe = pipes(arguments)
 
-          if style == :no_space
+          case style
+          when :no_space
             check_no_space_style_inside_pipes(arguments.children,
                                               opening_pipe,
                                               closing_pipe)
-          elsif style == :space
+          when :space
             check_space_style_inside_pipes(arguments.children,
                                            opening_pipe,
                                            closing_pipe)

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -34,96 +34,55 @@ module RuboCop
       #   RuboCop::Cop::Cop
       #   ::RuboCop::Cop
       #
-      class SpaceAroundMethodCallOperator < Cop
-        include SurroundingSpace
+      class SpaceAroundMethodCallOperator < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        SPACES_REGEXP = /\A[ \t]+\z/.freeze
 
         MSG = 'Avoid using spaces around a method call operator.'
 
         def on_send(node)
-          return unless dot_or_safe_navigation_operator?(node)
+          return unless node.dot? || node.safe_navigation?
 
-          check_and_add_offense(node)
+          check_space_before_dot(node)
+          check_space_after_dot(node)
         end
+        alias on_csend on_send
 
         def on_const(node)
           return unless node.loc.double_colon
 
-          check_and_add_offense(node, false)
-        end
-
-        def autocorrect(node)
-          operator = operator_token(node)
-          left = left_token_for_auto_correction(node, operator)
-          right = right_token_for_auto_correction(operator)
-
-          lambda do |corrector|
-            SpaceCorrector.remove_space(
-              processed_source, corrector, left, right
-            )
-          end
+          check_space_after_double_colon(node)
         end
 
-        alias on_csend on_send
-
         private
 
-        def check_and_add_offense(node, add_left_offense = true)
-          operator = operator_token(node)
-          left = previous_token(operator)
-          right = next_token(operator)
-
-          if !right.comment? && valid_right_token?(right, operator)
-            no_space_offenses(node, operator, right, MSG)
-          end
-          return unless valid_left_token?(left, operator)
-
-          no_space_offenses(node, left, operator, MSG) if add_left_offense
-        end
-
-        def operator_token(node)
-          operator_location =
-            node.const_type? ? node.loc.double_colon : node.loc.dot
-
-          processed_source.find_token do |token|
-            token.pos == operator_location
-          end
-        end
-
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
-        def next_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          processed_source.tokens[index + 1]
-        end
-
-        def dot_or_safe_navigation_operator?(node)
-          node.dot? || node.safe_navigation?
+        def check_space_before_dot(node)
+          receiver_pos = node.receiver.source_range.end_pos
+          dot_pos = node.loc.dot.begin_pos
+          check_space(receiver_pos, dot_pos)
         end
 
-        def valid_left_token?(left, operator)
-          left && left.line == operator.line
+        def check_space_after_dot(node)
+          dot_pos = node.loc.dot.end_pos
+          selector_pos = node.loc.selector.begin_pos
+          check_space(dot_pos, selector_pos)
         end
 
-        def valid_right_token?(right, operator)
-          right && right.line == operator.line
+        def check_space_after_double_colon(node)
+          double_colon_pos = node.loc.double_colon.end_pos
+          name_pos = node.loc.name.begin_pos
+          check_space(double_colon_pos, name_pos)
         end
 
-        def left_token_for_auto_correction(node, operator)
-          left_token = previous_token(operator)
-          return operator if node.const_type?
-          return left_token if valid_left_token?(left_token, operator)
-
-          operator
-        end
+        def check_space(begin_pos, end_pos)
+          return if end_pos <= begin_pos
 
-        def right_token_for_auto_correction(operator)
-          right_token = next_token(operator)
-          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
+          range = range_between(begin_pos, end_pos)
+          return unless range.source.match?(SPACES_REGEXP)
 
-          operator
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
       end
     end

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -142,11 +142,12 @@ module RuboCop
         end
 
         def issue_offenses(node, left, right, start_ok, end_ok)
-          if style == :no_space
+          case style
+          when :no_space
             start_ok = next_to_comment?(node, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                       end_ok: end_ok)
-          elsif style == :space
+          when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                    end_ok: end_ok)
           else

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

@@ -22,7 +22,9 @@ module RuboCop
       #   def initialize
       #     @x = 1
       #   end
-      class DisjunctiveAssignmentInConstructor < Cop
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
 
         def on_def(node)
@@ -73,7 +75,11 @@ module RuboCop
         # @param [Node] node a disjunctive assignment
         def check_disjunctive_assignment(node)
           lhs = node.child_nodes.first
-          add_offense(node, location: :operator) if lhs.ivasgn_type?
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
         end
       end
     end

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/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
 

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

@@ -35,6 +35,22 @@ module RuboCop
       #     require file
       #   end
       #
+      # @example
+      #
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
       class NonDeterministicRequireOrder < Cop
         MSG = 'Sort files before requiring them.'
 
@@ -49,7 +65,16 @@ module RuboCop
           end
         end
 
+        def on_block_pass(node)
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          add_offense(node.parent)
+        end
+
         def autocorrect(node)
+          return correct_block_pass(node) if node.arguments.last&.block_pass_type?
+
           if unsorted_dir_block?(node)
             lambda do |corrector|
               corrector.replace(node, "#{node.source}.sort.each")
@@ -64,10 +89,38 @@ module RuboCop
 
         private
 
+        def correct_block_pass(node)
+          if unsorted_dir_glob_pass?(node)
+            lambda do |corrector|
+              block_arg = node.arguments.last
+              corrector.remove(last_arg_range(node))
+              corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+            end
+          else
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, 'sort.each')
+            end
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.arguments.last.source_range.with(
+            begin_pos: node.arguments[-2].source_range.end_pos
+          )
+        end
+
         def unsorted_dir_loop?(node)
           unsorted_dir_block?(node) || unsorted_dir_each?(node)
         end
 
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
@@ -76,6 +129,20 @@ module RuboCop
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym :require)))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN