rubocop 0.76.0 → 0.79.0

data/lib/rubocop/cop/layout/{indent_heredoc.rb → heredoc_indentation.rb}

@@ -8,9 +8,9 @@ module RuboCop
       # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
       # use the older rubies, you should introduce some library to your project
       # (e.g. ActiveSupport, Powerpack or Unindent).
-      # Note: When `Metrics/LineLength`'s `AllowHeredoc` is false (not default),
+      # Note: When `Layout/LineLength`'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
-      #       avoid `Metrics/LineLength`'s offenses.
+      #       avoid `Layout/LineLength`'s offenses.
       #
       # @example EnforcedStyle: squiggly (default)
       #   # bad
@@ -49,7 +49,7 @@ module RuboCop
       #     something
       #   RUBY
       #
-      class IndentHeredoc < Cop
+      class HeredocIndentation < Cop
         include Heredoc
         include ConfigurableEnforcedStyle
 
@@ -159,11 +159,11 @@ module RuboCop
         end
 
         def unlimited_heredoc_length?
-          config.for_cop('Metrics/LineLength')['AllowHeredoc']
+          config.for_cop('Layout/LineLength')['AllowHeredoc']
         end
 
         def max_line_length
-          config.for_cop('Metrics/LineLength')['Max']
+          config.for_cop('Layout/LineLength')['Max']
         end
 
         def correct_by_squiggly(node)

data/lib/rubocop/cop/layout/{leading_blank_lines.rb → leading_empty_lines.rb}

@@ -27,7 +27,7 @@ module RuboCop
       #   # good
       #   # (start of file)
       #   # a comment
-      class LeadingBlankLines < Cop
+      class LeadingEmptyLines < Cop
         MSG = 'Unnecessary blank line at the beginning of the source.'
 
         def investigate(processed_source)

data/lib/rubocop/cop/{metrics → layout}/line_length.rb

@@ -2,10 +2,9 @@
 
 require 'uri'
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
-    module Metrics
+    module Layout
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
@@ -21,14 +20,14 @@ module RuboCop
       # If autocorrection is enabled, the following Layout cops
       # are recommended to further format the broken lines.
       #
-      #   - AlignArray
-      #   - AlignHash
-      #   - AlignParameters
+      #   - ParameterAlignment
+      #   - ArgumentAlignment
       #   - ClosingParenthesisIndentation
-      #   - IndentFirstArgument
-      #   - IndentFirstArrayElement
-      #   - IndentFirstHashElement
-      #   - IndentFirstParameter
+      #   - FirstArgumentIndentation
+      #   - FirstArrayElementIndentation
+      #   - FirstHashElementIndentation
+      #   - FirstParameterIndentation
+      #   - HashAlignment
       #   - MultilineArrayLineBreaks
       #   - MultilineHashBraceLayout
       #   - MultilineHashKeyLineBreaks
@@ -58,6 +57,7 @@ module RuboCop
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
+        include LineLengthHelp
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
@@ -68,6 +68,10 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
+        def investigate(processed_source)
+          check_for_breakable_semicolons(processed_source)
+        end
+
         def investigate_post_walk(processed_source)
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
@@ -89,29 +93,41 @@ module RuboCop
           return if breakable_node.nil?
 
           line_index = breakable_node.first_line - 1
-          breakable_nodes_by_line_index[line_index] = breakable_node
-        end
+          range = breakable_node.source_range
 
-        def breakable_nodes_by_line_index
-          @breakable_nodes_by_line_index ||= {}
-        end
+          existing = breakable_range_by_line_index[line_index]
+          return if existing
 
-        def heredocs
-          @heredocs ||= extract_heredocs(processed_source.ast)
+          breakable_range_by_line_index[line_index] = range
         end
 
-        def tab_indentation_width
-          config.for_cop('Layout/Tab')['IndentationWidth']
+        def check_for_breakable_semicolons(processed_source)
+          tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
+          tokens.reverse_each do |token|
+            range = breakable_range_after_semicolon(token)
+            breakable_range_by_line_index[range.line - 1] = range if range
+          end
         end
 
-        def indentation_difference(line)
-          return 0 unless tab_indentation_width
+        def breakable_range_after_semicolon(semicolon_token)
+          range = semicolon_token.pos
+          end_pos = range.end_pos
+          next_range = range_between(end_pos, end_pos + 1)
+          return nil unless next_range.line == range.line
+
+          next_char = next_range.source
+          return nil if /[\r\n]/ =~ next_char
+          return nil if next_char == ';'
 
-          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+          next_range
         end
 
-        def line_length(line)
-          line.length + indentation_difference(line)
+        def breakable_range_by_line_index
+          @breakable_range_by_line_index ||= {}
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
         end
 
         def highlight_start(line)
@@ -147,33 +163,12 @@ module RuboCop
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 
-          breakable_range = breakable_range(line, line_index)
+          breakable_range = breakable_range_by_line_index[line_index]
           add_offense(breakable_range, location: loc, message: message) do
             self.max = line_length(line)
           end
         end
 
-        def breakable_range(line, line_index)
-          return if line_in_heredoc?(line_index + 1)
-
-          semicolon_range = breakable_semicolon_range(line, line_index)
-          return semicolon_range if semicolon_range
-
-          breakable_node = breakable_nodes_by_line_index[line_index]
-          return breakable_node.source_range if breakable_node
-        end
-
-        def breakable_semicolon_range(line, line_index)
-          semicolon_separated_parts = line.split(';')
-          return if semicolon_separated_parts.length <= 1
-
-          column = semicolon_separated_parts.first.length + 1
-          range = source_range(processed_source.buffer, line_index, column, 1)
-          return if processed_source.commented?(range)
-
-          range
-        end
-
         def excess_range(uri_range, line, line_index)
           excessive_position = if uri_range && uri_range.begin < max
                                  uri_range.end
@@ -222,53 +217,6 @@ module RuboCop
           end
         end
 
-        def allow_uri?
-          cop_config['AllowURI']
-        end
-
-        def ignore_cop_directives?
-          cop_config['IgnoreCopDirectives']
-        end
-
-        def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max &&
-            (uri_range.end == line_length(line) ||
-             uri_range.end == line_length(line) - 1)
-        end
-
-        def find_excessive_uri_range(line)
-          last_uri_match = match_uris(line).last
-          return nil unless last_uri_match
-
-          begin_position, end_position =
-            last_uri_match.offset(0).map do |pos|
-              pos + indentation_difference(line)
-            end
-          return nil if begin_position < max && end_position < max
-
-          begin_position...end_position
-        end
-
-        def match_uris(string)
-          matches = []
-          string.scan(uri_regexp) do
-            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
-          end
-          matches
-        end
-
-        def valid_uri?(uri_ish_string)
-          URI.parse(uri_ish_string)
-          true
-        rescue URI::InvalidURIError, NoMethodError
-          false
-        end
-
-        def uri_regexp
-          @uri_regexp ||=
-            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
-        end
-
         def check_directive_line(line, line_index)
           return if line_length_without_directive(line) <= max
 
@@ -284,23 +232,6 @@ module RuboCop
           )
         end
 
-        def directive_on_source_line?(line_index)
-          source_line_number = line_index + processed_source.buffer.first_line
-          comment =
-            processed_source
-            .comments
-            .detect { |e| e.location.line == source_line_number }
-
-          return false unless comment
-
-          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        end
-
-        def line_length_without_directive(line)
-          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          before_comment.rstrip.length
-        end
-
         def check_uri_line(line, line_index)
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
@@ -315,4 +246,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

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

@@ -97,7 +97,8 @@ module RuboCop
         def line_break_necessary_in_args?(node)
           needed_length = node.source_range.column +
                           node.source.lines.first.length +
-                          block_arg_string(node.arguments).length + PIPE_SIZE
+                          block_arg_string(node, node.arguments).length +
+                          PIPE_SIZE
           needed_length > max_line_length
         end
 
@@ -115,7 +116,8 @@ module RuboCop
             newlines: false
           ).end_pos
           range = range_between(node.loc.begin.end.begin_pos, end_pos)
-          corrector.replace(range, " |#{block_arg_string(node.arguments)}|")
+          corrector.replace(range,
+                            " |#{block_arg_string(node, node.arguments)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
@@ -131,14 +133,21 @@ module RuboCop
                                   "\n  #{' ' * block_start_col}")
         end
 
-        def block_arg_string(args)
-          args.children.map do |arg|
+        def block_arg_string(node, args)
+          arg_string = args.children.map do |arg|
             if arg.mlhs_type?
-              "(#{block_arg_string(arg)})"
+              "(#{block_arg_string(node, arg)})"
             else
               arg.source
             end
           end.join(', ')
+          arg_string += ',' if include_trailing_comma?(node.arguments)
+          arg_string
+        end
+
+        def include_trailing_comma?(args)
+          arg_count = args.each_descendant(:arg).to_a.size
+          arg_count == 1 && args.source.include?(',')
         end
       end
     end

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

@@ -26,7 +26,7 @@ module RuboCop
           'on a separate line.'
 
         def on_send(node)
-          return if node.method_name == :[]=
+          return if node.method?(:[]=)
 
           args = node.arguments
 

data/lib/rubocop/cop/layout/{align_parameters.rb → parameter_alignment.rb}

@@ -68,7 +68,7 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class AlignParameters < Cop
+      class ParameterAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \

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

@@ -30,10 +30,12 @@ module RuboCop
 
         DO = 'do'
         SAFE_NAVIGATION = '&.'
+        NAMESPACE_OPERATOR = '::'
         ACCEPT_LEFT_PAREN =
           %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
           %w[super yield].freeze
+        ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -193,6 +195,8 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
+          return false if accept_namespace_operator?(range) &&
+                          namespace_operator?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
@@ -212,10 +216,18 @@ module RuboCop
           ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
         end
 
+        def accept_namespace_operator?(range)
+          ACCEPT_NAMESPACE_OPERATOR == range.source
+        end
+
         def safe_navigation_call?(range, pos)
           range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
         end
 
+        def namespace_operator?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(NAMESPACE_OPERATOR)
+        end
+
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them

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

@@ -3,24 +3,37 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
+      # Checks that operators have space around them, except for ** which
+      # should or shouldn't have surrounding space depending on configuration.
       #
       # @example
       #   # bad
       #   total = 3*4
       #   "apple"+"juice"
       #   my_number = 38/4
-      #   a ** b
       #
       #   # good
       #   total = 3 * 4
       #   "apple" + "juice"
       #   my_number = 38 / 4
+      #
+      # @example EnforcedStyleForExponentOperator: no_space (default)
+      #   # bad
+      #   a ** b
+      #
+      #   # good
+      #   a**b
+      #
+      # @example EnforcedStyleForExponentOperator: space
+      #   # bad
       #   a**b
+      #
+      #   # good
+      #   a ** b
       class SpaceAroundOperators < Cop
         include PrecedingFollowingAlignment
         include RangeHelp
+        include RationalLiteral
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
         EXCESSIVE_SPACE = '  '
@@ -53,6 +66,8 @@ module RuboCop
         end
 
         def on_send(node)
+          return if rational_literal?(node)
+
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
@@ -101,7 +116,7 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            if range.source =~ /\*\*/
+            if range.source =~ /\*\*/ && !space_around_exponent_operator?
               corrector.replace(range, '**')
             elsif range.source.end_with?("\n")
               corrector.replace(range, " #{range.source.strip}\n")
@@ -138,8 +153,10 @@ module RuboCop
         end
 
         def offense_message(type, operator, with_space, right_operand)
-          if operator.is?('**')
-            'Space around operator `**` detected.' unless with_space.is?('**')
+          if should_not_have_surrounding_space?(operator)
+            return if with_space.is?(operator.source)
+
+            "Space around operator `#{operator.source}` detected."
           elsif with_space.source !~ /^\s.*\s$/
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
@@ -169,13 +186,21 @@ module RuboCop
         end
 
         def align_hash_cop_config
-          config.for_cop('Layout/AlignHash')
+          config.for_cop('Layout/HashAlignment')
         end
 
         def hash_table_style?
           align_hash_cop_config &&
             align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
+
+        def space_around_exponent_operator?
+          cop_config['EnforcedStyleForExponentOperator'] == 'space'
+        end
+
+        def should_not_have_surrounding_space?(operator)
+          operator.is?('**') ? !space_around_exponent_operator? : false
+        end
       end
     end
   end

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

@@ -41,6 +41,14 @@ module RuboCop
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line braces when specifying
+          # `EnforcedStyle: no_space`. It will conflict with auto-correction
+          # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
+          # That means preventing auto-correction to incorrect auto-corrected
+          # code.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7534
+          return if conflict_with_block_delimiters?(node)
+
           left_brace = node.loc.begin
           space_plus_brace = range_with_surrounding_space(range: left_brace)
           used_style =
@@ -110,6 +118,15 @@ module RuboCop
           end
         end
 
+        def conflict_with_block_delimiters?(node)
+          block_delimiters_style == 'line_count_based' &&
+            style == :no_space && node.multiline?
+        end
+
+        def block_delimiters_style
+          config.for_cop('Style/BlockDelimiters')['EnforcedStyle']
+        end
+
         def empty_braces?(loc)
           loc.begin.end_pos == loc.end.begin_pos
         end

data/lib/rubocop/cop/layout/{trailing_blank_lines.rb → trailing_empty_lines.rb}

@@ -37,7 +37,7 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingBlankLines < Cop
+      class TrailingEmptyLines < Cop
         include ConfigurableEnforcedStyle
         include RangeHelp
 

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

@@ -43,9 +43,9 @@ module RuboCop
         PATTERN
 
         def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug :console} ...)
            (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote} ...)
+             {:pry :remote_pry :pry_remote :console} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
            (send nil? {:save_and_open_page
                       :save_and_open_screenshot

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

@@ -33,7 +33,7 @@ module RuboCop
 
         # @param [DefNode] node a constructor definition
         def check(node)
-          return unless node.method_name == :initialize
+          return unless node.method?(:initialize)
 
           check_body(node.body)
         end

data/lib/rubocop/cop/lint/{duplicated_key.rb → duplicate_hash_key.rb}

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicatedKey < Cop
+      class DuplicateHashKey < Cop
         include Duplication
 
         MSG = 'Duplicated key in hash literal.'

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

@@ -22,7 +22,7 @@ module RuboCop
       #   num = 0
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Cop
-        MSG = 'The argument to each_with_object can not be immutable.'
+        MSG = 'The argument to each_with_object cannot be immutable.'
 
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def correct_visibility?(node, modifier, ignored_methods)
-          return true if modifier.nil? || modifier.method_name == :public
+          return true if modifier.nil? || modifier.method?(:public)
 
           ignored_methods.include?(node.method_name)
         end

data/lib/rubocop/cop/lint/{multiple_compare.rb → multiple_comparison.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
+      class MultipleComparison < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      class NonDeterministicRequireOrder < Cop
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node)
+          end
+        end
+
+        def autocorrect(node)
+          if unsorted_dir_block?(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node.loc.expression, "#{source}.sort.each")
+            end
+          end
+        end
+
+        private
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const nil? :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? :require (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end