rubocop 0.78.0 → 0.82.0

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

@@ -60,6 +60,10 @@ module RuboCop
       alias conflicting_styles_detected no_acceptable_style!
       alias unrecognized_style_detected no_acceptable_style!
 
+      def style_configured?
+        cop_config.key?(style_parameter_name)
+      end
+
       def style
         @style ||= begin
           s = cop_config[style_parameter_name].to_sym

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

@@ -20,7 +20,7 @@ module RuboCop
         return if ignored_node?(node)
 
         end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
+        return if accept_end_kw_alignment?(end_loc)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -49,6 +49,11 @@ module RuboCop
         add_offense(node, location: end_loc, message: msg)
       end
 
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+      end
+
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -39,15 +39,15 @@ module RuboCop
         end
       end
 
-      def leading_comment_lines
-        comments = processed_source.comments
-
-        comments.each_with_object([]) do |comment, leading_comments|
-          next if comment.loc.line > 3
-
-          leading_comments << comment.text
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
         end
       end
+
+      def leading_comment_lines
+        processed_source.comments.first(3).map(&:text)
+      end
     end
   end
 end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = node.parent&.block_type? ? 0 : '.to_h'.length
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -63,7 +63,7 @@ module RuboCop
       end
 
       def tab_indentation_width
-        config.for_cop('Layout/Tab')['IndentationWidth']
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth']
       end
 
       def uri_regexp

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

@@ -5,15 +5,20 @@ module RuboCop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      include IgnoredMethods
       extend NodePattern::Macros
 
       def on_def(node)
+        return if ignored_method?(node.method_name)
+
         check_complexity(node, node.method_name)
       end
       alias on_defs on_def
 
       def on_block(node)
         define_method?(node) do |name|
+          return if ignored_method?(name)
+
           check_complexity(node, name)
         end
       end

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

@@ -58,12 +58,13 @@ module RuboCop
       end
 
       def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
+        return 1 if config.for_cop('Layout/IndentationStyle')['Enabled']
 
         default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
           config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
+          default_configuration
+            .for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
           default_configuration.for_cop('Layout/IndentationWidth')['Width']
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind)
+          put_comma(items, kind)
         end
       end
 
@@ -135,7 +135,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = kind =~ /array/ ? 'an' : 'a'
+        article = /array/.match?(kind) ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
@@ -145,9 +145,7 @@ module RuboCop
         add_offense(range, location: range, message: msg)
       end
 
-      def put_comma(node, items, kind)
-        return if avoid_autocorrect?(elements(node))
-
+      def put_comma(items, kind)
         last_item = items.last
         return if last_item.block_pass_type?
 
@@ -169,11 +167,6 @@ module RuboCop
         range_between(expr.begin_pos + ix, expr.end_pos)
       end
 
-      # By default, there's no reason to avoid auto-correct.
-      def avoid_autocorrect?(_nodes)
-        false
-      end
-
       def any_heredoc?(items)
         items.any? { |item| heredoc?(item) }
       end

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
-          return unless node.loc.name.source =~ /_/
+          return unless /_/.match?(node.loc.name.source)
 
           add_offense(node, location: :name)
         end

data/lib/rubocop/cop/naming/constant_name.rb

@@ -45,8 +45,9 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+          add_offense(node, location: :name)
         end
 
         private

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -39,7 +39,7 @@ module RuboCop
         def meaningful_delimiters?(node)
           delimiters = delimiter_string(node)
 
-          return false unless delimiters =~ /\w/
+          return false unless /\w/.match?(delimiters)
 
           forbidden_delimiters.none? do |forbidden_delimiter|
             delimiters =~ Regexp.new(forbidden_delimiter)

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -10,7 +10,7 @@ module RuboCop
       # directive. It can be configured to allow for memoized instance variables
       # prefixed with an underscore. Prefixing ivars with an underscore is a
       # convention that is used to implicitly indicate that an ivar should not
-      # be set or referencd outside of the memoization method.
+      # be set or referenced outside of the memoization method.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad

data/lib/rubocop/cop/naming/method_name.rb

@@ -31,9 +31,28 @@ module RuboCop
       class MethodName < Cop
         include ConfigurableNaming
         include IgnoredPattern
+        include RangeHelp
 
         MSG = 'Use %<style>s for method names.'
 
+        def_node_matcher :attr?, <<~PATTERN
+          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+        PATTERN
+
+        def_node_matcher :sym_name, '(sym $_name)'
+        def_node_matcher :str_name, '(str $_name)'
+
+        def on_send(node)
+          return unless (attrs = attr?(node))
+
+          attrs.last.each do |name_item|
+            name = attr_name(name_item)
+            next if !name || matches_ignored_pattern?(name)
+
+            check_name(node, name, range_position(node))
+          end
+        end
+
         def on_def(node)
           return if node.operator_method? ||
                     matches_ignored_pattern?(node.method_name)
@@ -44,6 +63,17 @@ module RuboCop
 
         private
 
+        def attr_name(name_item)
+          sym_name(name_item) || str_name(name_item)
+        end
+
+        def range_position(node)
+          selector_end_pos = node.loc.selector.end_pos + 1
+          expr_end_pos = node.loc.expression.end_pos
+
+          range_between(selector_end_pos, expr_end_pos)
+        end
+
         def message(style)
           format(MSG, style: style)
         end

data/lib/rubocop/cop/naming/method_parameter_name.rb

@@ -49,7 +49,7 @@ module RuboCop
         def on_def(node)
           return unless node.arguments?
 
-          check(node, node.arguments)
+          check(node, node.arguments.reject(&:forward_args_type?))
         end
         alias on_defs on_def
       end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -73,7 +73,7 @@ module RuboCop
             node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
-              corrector.replace(var.loc.expression, preferred_name)
+              corrector.replace(var, preferred_name)
             end
           end
         end

data/lib/rubocop/cop/registry.rb

@@ -22,12 +22,13 @@ module RuboCop
 
     # Registry that tracks all cops by their badge and department.
     class Registry
-      def initialize(cops = [])
+      def initialize(cops = [], options = {})
         @registry = {}
         @departments = {}
         @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
 
         cops.each { |cop| enlist(cop) }
+        @options = options
       end
 
       def enlist(cop)
@@ -146,13 +147,24 @@ module RuboCop
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
+
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config)
+
         if only_safe
-          cfg.fetch('Enabled') && cfg.fetch('Safe', true)
+          cop_enabled && cfg.fetch('Safe', true)
         else
-          cfg.fetch('Enabled')
+          cop_enabled
         end
       end
 
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
       def names
         cops.map(&:cop_name)
       end