rubocop 0.77.0 → 0.78.0

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) ||
@@ -176,6 +193,14 @@ module RuboCop
           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?
+
           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?
+          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/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/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

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

@@ -19,9 +19,9 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   x += 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   x += 1

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

@@ -15,20 +15,20 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
       #   # rubocop:enable all
       #   baz

data/lib/rubocop/cop/mixin/alignment.rb

@@ -35,7 +35,7 @@ module RuboCop
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same
-            # cop can not be handled. The next iteration will find the
+            # cop cannot be handled. The next iteration will find the
             # offense again and correct it.
             add_offense(nil, location: expr)
           else

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      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 allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      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_line_length &&
+                      end_position < max_line_length
+
+        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 indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/Tab')['IndentationWidth']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/rational_literal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -52,9 +52,9 @@ module RuboCop
       end
 
       def max_line_length
-        return unless config.for_cop('Metrics/LineLength')['Enabled']
+        return unless config.for_cop('Layout/LineLength')['Enabled']
 
-        config.for_cop('Metrics/LineLength')['Max']
+        config.for_cop('Layout/LineLength')['Max']
       end
 
       def indentation_multiplier

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -93,9 +93,12 @@ module RuboCop
       end
 
       def method_name_and_arguments_on_same_line?(node)
-        %i[send csend].include?(node.type) &&
-          node.loc.selector.line == node.arguments.last.last_line &&
-          node.last_line == node.arguments.last.last_line
+        return false unless node.call_type?
+
+        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+
+        line == node.last_argument.last_line &&
+          node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end

data/lib/rubocop/cop/offense.rb

@@ -65,6 +65,17 @@ module RuboCop
         freeze
       end
 
+      # @api public
+      #
+      # @!attribute [r] correctable?
+      #
+      # @return [Boolean]
+      #   whether this offense can be automatically corrected via
+      #   autocorrect or a todo.
+      def correctable?
+        @status != :unsupported
+      end
+
       # @api public
       #
       # @!attribute [r] corrected?

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

@@ -21,6 +21,10 @@ module RuboCop
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
+          # check only for method definitions in class/module body
+          return if node.parent &&
+                    !node.parent.class_type? &&
+                    !class_eval?(node.parent)
 
           add_offense(node, location: :selector)
         end
@@ -56,6 +60,10 @@ module RuboCop
             'attr_reader'
           end
         end
+
+        def_node_matcher :class_eval?, <<~PATTERN
+          (block (send _ {:class_eval :module_eval}) ...)
+        PATTERN
       end
     end
   end

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

@@ -212,7 +212,7 @@ module RuboCop
           %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
                            %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Metrics/LineLength'
+        LINE_LENGTH = 'Layout/LineLength'
         INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
@@ -376,7 +376,7 @@ module RuboCop
             assignment_types_match?(*statements)
         end
 
-        # If `Metrics/LineLength` is enabled, we do not want to introduce an
+        # If `Layout/LineLength` is enabled, we do not want to introduce an
         # offense by auto-correcting this cop. Find the max configured line
         # length. Find the longest line of condition. Remove the assignment
         # from lines that contain the offending assignment because after