rubocop 0.73.0 → 0.74.0

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

@@ -158,11 +158,7 @@ module RuboCop
           if indentation_consistency_style == 'indented_internal_methods'
             check_members_for_indented_internal_methods_style(members)
           else
-            members.first.children.each do |member|
-              next if member.send_type? && member.access_modifier?
-
-              check_indentation(base, member)
-            end
+            check_members_for_normal_style(base, members)
           end
         end
 
@@ -170,6 +166,8 @@ module RuboCop
           return unless member
 
           if access_modifier?(member.children.first)
+            return if access_modifier_indentation_style == 'outdent'
+
             member.children.first
           else
             member
@@ -183,6 +181,14 @@ module RuboCop
           end
         end
 
+        def check_members_for_normal_style(base, members)
+          members.first.children.each do |member|
+            next if member.send_type? && member.access_modifier?
+
+            check_indentation(base, member)
+          end
+        end
+
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
@@ -199,6 +205,14 @@ module RuboCop
           indentation_consistency_style == 'indented_internal_methods'
         end
 
+        def special_modifier?(node)
+          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def access_modifier_indentation_style
+          config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle']
+        end
+
         def indentation_consistency_style
           config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
         end

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

@@ -34,14 +34,14 @@ module RuboCop
 
           return if hash_table_style? && !node.parent.pairs_on_same_line?
 
-          check_operator(node.loc.operator, node.source_range)
+          check_operator(:pair, node.loc.operator, node.source_range)
         end
 
         def on_if(node)
           return unless node.ternary?
 
-          check_operator(node.loc.question, node.if_branch.source_range)
-          check_operator(node.loc.colon, node.else_branch.source_range)
+          check_operator(:if, node.loc.question, node.if_branch.source_range)
+          check_operator(:if, node.loc.colon, node.else_branch.source_range)
         end
 
         def on_resbody(node)
@@ -49,23 +49,33 @@ module RuboCop
 
           _, variable, = *node
 
-          check_operator(node.loc.assoc, variable.source_range)
+          check_operator(:resbody, node.loc.assoc, variable.source_range)
         end
 
         def on_send(node)
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(node.loc.selector, node.first_argument.source_range)
+            check_operator(:send,
+                           node.loc.selector,
+                           node.first_argument.source_range)
           end
         end
 
+        def on_assignment(node)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(:assignment, node.loc.operator, rhs.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
           return unless rhs
 
-          check_operator(node.loc.operator, rhs.source_range)
+          check_operator(:binary, node.loc.operator, rhs.source_range)
         end
 
         def on_special_asgn(node)
@@ -73,20 +83,20 @@ module RuboCop
 
           return unless right
 
-          check_operator(node.loc.operator, right.source_range)
+          check_operator(:special_asgn, node.loc.operator, right.source_range)
         end
 
         alias on_or       on_binary
         alias on_and      on_binary
-        alias on_lvasgn   on_binary
-        alias on_masgn    on_binary
+        alias on_lvasgn   on_assignment
+        alias on_masgn    on_assignment
         alias on_casgn    on_special_asgn
-        alias on_ivasgn   on_binary
-        alias on_cvasgn   on_binary
-        alias on_gvasgn   on_binary
+        alias on_ivasgn   on_assignment
+        alias on_cvasgn   on_assignment
+        alias on_gvasgn   on_assignment
         alias on_class    on_binary
-        alias on_or_asgn  on_binary
-        alias on_and_asgn on_binary
+        alias on_or_asgn  on_assignment
+        alias on_and_asgn on_assignment
         alias on_op_asgn  on_special_asgn
 
         def autocorrect(range)
@@ -113,35 +123,44 @@ module RuboCop
             !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
-        def check_operator(operator, right_operand)
+        def check_operator(type, operator, right_operand)
           with_space = range_with_surrounding_space(range: operator)
           return if with_space.source.start_with?("\n")
 
-          offense(operator, with_space, right_operand) do |msg|
+          offense(type, operator, with_space, right_operand) do |msg|
             add_offense(with_space, location: operator, message: msg)
           end
         end
 
-        def offense(operator, with_space, right_operand)
-          msg = offense_message(operator, with_space, right_operand)
+        def offense(type, operator, with_space, right_operand)
+          msg = offense_message(type, operator, with_space, right_operand)
           yield msg if msg
         end
 
-        def offense_message(operator, with_space, right_operand)
+        def offense_message(type, operator, with_space, right_operand)
           if operator.is?('**')
             'Space around operator `**` detected.' unless with_space.is?('**')
           elsif with_space.source !~ /^\s.*\s$/
             "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(operator, with_space) ||
+          elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
             "Operator `#{operator.source}` should be surrounded " \
             'by a single space.'
           end
         end
 
-        def excess_leading_space?(operator, with_space)
-          with_space.source.start_with?(EXCESSIVE_SPACE) &&
-            (!allow_for_alignment? || !aligned_with_operator?(operator))
+        def excess_leading_space?(type, operator, with_space)
+          return false unless allow_for_alignment?
+          return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
+
+          return !aligned_with_operator?(operator) unless type == :assignment
+
+          token            = Token.new(operator, nil, operator.source)
+          align_preceding  = aligned_with_preceding_assignment(token)
+
+          return align_preceding == :no unless align_preceding == :none
+
+          aligned_with_subsequent_assignment(token) != :yes
         end
 
         def excess_trailing_space?(right_operand, with_space)

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

@@ -19,61 +19,43 @@ module RuboCop
       #   # good
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
+        include Interpolation
+        include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space around string interpolation detected.'
+        SPACE_MSG = 'Missing space inside string interpolation detected.'
 
-        def on_dstr(node)
-          each_style_violation(node) do |final_node|
-            add_offense(final_node)
-          end
-        end
+        def on_interpolation(begin_node)
+          delims = delimiters(begin_node)
+          return if empty_brackets?(*delims)
 
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(
-              range_with_surrounding_space(range: node.source_range),
-              new_source
-            )
+          if style == :no_space
+            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+          else
+            space_offenses(begin_node, *delims, SPACE_MSG)
           end
         end
 
-        private
-
-        def each_style_violation(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
+        def autocorrect(begin_node)
+          lambda do |corrector|
+            delims = delimiters(begin_node)
 
-            if style == :no_space && space_on_any_side?(final_node)
-              yield final_node
-            elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node
+            if style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector, *delims)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, *delims)
             end
           end
         end
 
-        def message(_node)
-          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
-        end
-
-        def space_on_any_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
-
-          interp_with_surrounding_space != interp
-        end
-
-        def space_on_each_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
+        private
 
-          interp_with_surrounding_space.source == " #{interp.source} "
+        def delimiters(begin_node)
+          left = processed_source.tokens[index_of_first_token(begin_node)]
+          right = processed_source.tokens[index_of_last_token(begin_node)]
+          [left, right]
         end
       end
     end

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

@@ -56,8 +56,6 @@ module RuboCop
           (send (send {#kernel? nil?} :binding) :irb ...)
         PATTERN
 
-        def_node_matcher :pry_rescue?, '(send (const nil? :Pry) :rescue ...)'
-
         def on_send(node)
           return unless debugger_call?(node) || binding_irb?(node)
 

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

@@ -17,12 +17,12 @@ module RuboCop
       #
       #   "result is #{some_result}"
       class EmptyInterpolation < Cop
+        include Interpolation
+
         MSG = 'Empty interpolation detected.'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            add_offense(begin_node) if begin_node.children.empty?
-          end
+        def on_interpolation(begin_node)
+          add_offense(begin_node) if begin_node.children.empty?
         end
 
         def autocorrect(node)

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

@@ -61,6 +61,7 @@ module RuboCop
       #
       class ErbNewArguments < Cop
         extend TargetRubyVersion
+        include RangeHelp
 
         minimum_target_ruby_version 2.6
 
@@ -97,10 +98,65 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          str_arg = node.arguments[0].source
+
+          kwargs = build_kwargs(node)
+          overridden_kwargs = override_by_legacy_args(kwargs, node)
+
+          good_arguments = [
+            str_arg, overridden_kwargs
+          ].flatten.compact.join(', ')
+
+          lambda do |corrector|
+            corrector.replace(arguments_range(node), good_arguments)
+          end
+        end
+
+        private
+
         def correct_arguments?(arguments)
           arguments.size == 1 ||
             arguments.size == 2 && arguments[1].hash_type?
         end
+
+        def build_kwargs(node)
+          return [nil, nil] unless node.arguments.last.hash_type?
+
+          trim_mode_arg, eoutvar_arg = nil
+
+          node.arguments.last.pairs.each do |pair|
+            case pair.key.source
+            when 'trim_mode'
+              trim_mode_arg = "trim_mode: #{pair.value.source}"
+            when 'eoutvar'
+              eoutvar_arg = "eoutvar: #{pair.value.source}"
+            end
+          end
+
+          [trim_mode_arg, eoutvar_arg]
+        end
+
+        def override_by_legacy_args(kwargs, node)
+          overridden_kwargs = kwargs.dup
+
+          if node.arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{node.arguments[2].source}"
+          end
+
+          if node.arguments[3] && !node.arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{node.arguments[3].source}"
+          end
+
+          overridden_kwargs
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos,
+                        arguments.last.source_range.end_pos)
+        end
       end
     end
   end

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

@@ -17,21 +17,20 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
+        include Interpolation
         include RangeHelp
         include PercentLiteral
 
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
 
-            add_offense(final_node)
-          end
+          add_offense(final_node)
         end
 
         def autocorrect(node)

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

@@ -18,20 +18,20 @@ module RuboCop
       #
       #   "result is #{something}"
       class StringConversionInInterpolation < Cop
+        include Interpolation
+
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'
 
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
 
-            next unless to_s_without_args?(final_node)
+          return unless to_s_without_args?(final_node)
 
-            add_offense(final_node, location: :selector)
-          end
+          add_offense(final_node, location: :selector)
         end
 
         def autocorrect(node)

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

@@ -58,7 +58,12 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :array_new?, '$(send (const nil? :Array) :new ...)'
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const nil? :Array) :new ...)
+            $(block (send (const nil? :Array) :new ...) ...)
+          }
+        PATTERN
 
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)

data/lib/rubocop/cop/metrics/line_length.rb

@@ -10,6 +10,7 @@ module RuboCop
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
       # of the `Layout/Tab` cop.
+      # It also ignores a shebang line by default.
       #
       # This cop has some autocorrection capabilities.
       # It can programmatically shorten certain long lines by
@@ -138,9 +139,14 @@ module RuboCop
 
         def ignored_line?(line, line_index)
           matches_ignored_pattern?(line) ||
+            shebang?(line, line_index) ||
             heredocs && line_in_permitted_heredoc?(line_index.succ)
         end
 
+        def shebang?(line, line_index)
+          line_index.zero? && line.start_with?('#!')
+        end
+
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)