rubocop 0.46.0 → 0.47.0

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

@@ -30,7 +30,7 @@ module RuboCop
           end
           return check_uri_line(line, index) if allow_uri?
 
-          offense(
+          register_offense(
             source_range(processed_source.buffer, index + 1, 0...line.length),
             line
           )
@@ -41,7 +41,7 @@ module RuboCop
             heredocs && line_in_whitelisted_heredoc?(heredocs, index.succ)
         end
 
-        def offense(loc, line)
+        def register_offense(loc, line)
           message = format(MSG, line.length, max)
           add_offense(nil, loc, message) { self.max = line.length }
         end
@@ -137,7 +137,14 @@ module RuboCop
           return if line_length_without_directive(line) <= max
 
           range = max..(line_length_without_directive(line) - 1)
-          offense(source_range(processed_source.buffer, index + 1, range), line)
+          register_offense(
+            source_range(
+              processed_source.buffer,
+              index + 1,
+              range
+            ),
+            line
+          )
         end
 
         def directive_on_source_line?(index)
@@ -160,7 +167,7 @@ module RuboCop
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
 
-          offense(excess_range(uri_range, line, index), line)
+          register_offense(excess_range(uri_range, line, index), line)
         end
       end
     end

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

@@ -28,7 +28,6 @@ module RuboCop
       #   end                             # 7 complexity points
       class PerceivedComplexity < Cop
         include MethodComplexity
-        include IfNode
 
         MSG = 'Perceived complexity for %s is too high. [%d/%d]'.freeze
         COUNTED_NODES = [:if, :case, :while, :until,
@@ -51,7 +50,7 @@ module RuboCop
               (0.8 + 0.2 * whens.length).round
             end
           when :if
-            if_else?(node) && !elsif?(node) ? 2 : 1
+            node.else? && !node.elsif? ? 2 : 1
           else
             1
           end

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

@@ -6,18 +6,9 @@ module RuboCop
     # syntax.
     module ArraySyntax
       def bracketed_array_of?(element_type, node)
-        return false unless square_brackets?(node)
+        return false unless node.square_brackets? && node.values.size > 1
 
-        array_elems = node.children
-
-        # no need to check empty arrays
-        return false unless array_elems && array_elems.size > 1
-
-        array_elems.all? { |e| e.type == element_type }
-      end
-
-      def square_brackets?(node)
-        node.loc.begin && node.loc.begin.is?('[')
+        node.values.all? { |value| value.type == element_type }
       end
     end
   end

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

@@ -55,7 +55,7 @@ module RuboCop
         return no_acceptable_style! if style.nil?
         return no_acceptable_style! if style.empty?
 
-        config_to_allow_offenses[parameter_name] = style.first
+        config_to_allow_offenses[style_parameter_name] = style.first
       end
 
       alias conflicting_styles_detected no_acceptable_style!
@@ -63,7 +63,7 @@ module RuboCop
 
       def style
         @enforced_style ||= begin
-          s = cop_config[parameter_name].to_sym
+          s = cop_config[style_parameter_name].to_sym
           unless supported_styles.include?(s)
             raise "Unknown style #{s} selected!"
           end
@@ -76,14 +76,21 @@ module RuboCop
           raise 'alternative_style can only be used when there are exactly ' \
                '2 SupportedStyles'
         end
-        (supported_styles - [style]).first
+        alternative_styles.first
+      end
+
+      def alternative_styles
+        (supported_styles - [style])
       end
 
       def supported_styles
-        @supported_styles ||= cop_config['SupportedStyles'].map(&:to_sym)
+        @supported_styles ||= begin
+          supported_styles = Util.to_supported_styles(style_parameter_name)
+          cop_config[supported_styles].map(&:to_sym)
+        end
       end
 
-      def parameter_name
+      def style_parameter_name
         'EnforcedStyle'
       end
     end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Shared functionality between mixins that enforce naming conventions
+    module ConfigurableFormatting
+      include ConfigurableEnforcedStyle
+
+      def check_name(node, name, name_range)
+        return if operator?(name)
+
+        if valid_name?(node, name)
+          correct_style_detected
+        else
+          add_offense(node, name_range, message(style)) do
+            report_opposing_styles(node, name)
+          end
+        end
+      end
+
+      def report_opposing_styles(node, name)
+        alternative_styles.each do |alternative|
+          if valid_name?(node, name, alternative)
+            return unexpected_style_detected(alternative)
+          end
+        end
+      end
+
+      def valid_name?(node, name, given_style = style)
+        name.match(self.class::FORMATS.fetch(given_style)) ||
+          class_emitter_method?(node, name)
+      end
+
+      # A class emitter method is a singleton method in a class/module, where
+      # the method has the same name as a class defined in the class/module.
+      def class_emitter_method?(node, name)
+        return false unless node.parent && node.defs_type?
+        # a class emitter method may be defined inside `def self.included`,
+        # `def self.extended`, etc.
+        node = node.parent while node.parent.defs_type?
+
+        node.parent.each_child_node(:class).any? do |c|
+          c.loc.name.is?(name.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -7,11 +7,11 @@ module RuboCop
     module ConfigurableMax
       def max=(value)
         cfg = config_to_allow_offenses
-        value = [cfg[parameter_name], value].max if cfg[parameter_name]
-        cfg[parameter_name] = value
+        value = [cfg[max_parameter_name], value].max if cfg[max_parameter_name]
+        cfg[max_parameter_name] = value
       end
 
-      def parameter_name
+      def max_parameter_name
         'Max'
       end
     end

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

@@ -5,40 +5,12 @@ module RuboCop
     # This module provides functionality for checking if names match the
     # configured EnforcedStyle.
     module ConfigurableNaming
-      include ConfigurableEnforcedStyle
+      include ConfigurableFormatting
 
-      SNAKE_CASE = /^@{0,2}[\da-z_]+[!?=]?$/
-      CAMEL_CASE = /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
-
-      def check_name(node, name, name_range)
-        return if operator?(name)
-
-        if valid_name?(node, name)
-          correct_style_detected
-        else
-          add_offense(node, name_range, message(style)) do
-            opposite_style_detected
-          end
-        end
-      end
-
-      def valid_name?(node, name)
-        pattern = (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-        name.match(pattern) || class_emitter_method?(node, name)
-      end
-
-      # A class emitter method is a singleton method in a class/module, where
-      # the method has the same name as a class defined in the class/module.
-      def class_emitter_method?(node, name)
-        return false unless node.parent && node.defs_type?
-        # a class emitter method may be defined inside `def self.included`,
-        # `def self.extended`, etc.
-        node = node.parent while node.parent.defs_type?
-
-        node.parent.each_child_node(:class).any? do |c|
-          c.loc.name.is?(name.to_s)
-        end
-      end
+      FORMATS = {
+        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
+        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+      }.freeze
     end
   end
 end

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

@@ -5,54 +5,13 @@ module RuboCop
     # This module provides functionality for checking if numbering match the
     # configured EnforcedStyle.
     module ConfigurableNumbering
-      include ConfigurableEnforcedStyle
+      include ConfigurableFormatting
 
-      SNAKE_CASE = /(?:[a-z_]|_\d+)$/
-      NORMAL_CASE = /(?:_\D*|[A-Za-z]\d*)$/
-      NON_INTEGER = /[A-Za-z_]$/
-
-      def check_name(node, name, name_range)
-        return if operator?(name)
-
-        if valid_name?(node, name, style)
-          correct_style_detected
-        else
-          add_offense(node, name_range, message(style)) do
-            (supported_styles - [style]).each do |other_style|
-              if valid_name?(node, name, other_style)
-                unexpected_style_detected(other_style)
-                break
-              end
-            end
-          end
-        end
-      end
-
-      def valid_name?(node, name, given_style)
-        pattern =
-          case given_style
-          when :snake_case
-            SNAKE_CASE
-          when :normalcase
-            NORMAL_CASE
-          when :non_integer
-            NON_INTEGER
-          end
-        name.match(pattern) || class_emitter_method?(node, name)
-      end
-
-      # A class emitter method is a singleton method in a class/module, where
-      # the method has the same name as a class defined in the class/module.
-      def class_emitter_method?(node, name)
-        return false unless node.parent && node.defs_type?
-        # a class emitter method may be defined inside `def self.included`,
-        # `def self.extended`, etc.
-        node = node.parent while node.parent.defs_type?
-
-        node.parent.each_child_node(:class).any? do |c|
-          c.loc.name.is?(name.to_s)
-        end
-      end
+      FORMATS = {
+        snake_case:  /(?:[a-z_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
+        non_integer: /[A-Za-z_]$/
+      }.freeze
     end
   end
 end

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

@@ -17,7 +17,9 @@ module RuboCop
         return false unless preceding_comment?(node, preceding_lines.last)
 
         preceding_lines.any? do |comment|
-          !annotation?(comment) && !interpreter_directive_comment?(comment)
+          !annotation?(comment) &&
+            !interpreter_directive_comment?(comment) &&
+            !rubocop_directive_comment?(comment)
         end
       end
 
@@ -35,6 +37,10 @@ module RuboCop
       def interpreter_directive_comment?(comment)
         comment.text =~ /^#\s*(frozen_string_literal|encoding):/
       end
+
+      def rubocop_directive_comment?(comment)
+        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+      end
     end
   end
 end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with duplication.
+    module Duplication
+      private
+
+      # Whether the `collection` contains any duplicates.
+      #
+      # @param [Array] collection an array to check for duplicates
+      # @return [Boolean] whether the array contains any duplicates
+      def duplicates?(collection)
+        collection.size > 1 && collection.size > collection.uniq.size
+      end
+
+      # Returns all duplicates, including the first instance of the duplicated
+      # elements.
+      #
+      # @param [Array] collection an array to return duplicates for
+      # @return [Array] all the duplicates
+      def duplicates(collection)
+        grouped_duplicates(collection).flatten
+      end
+
+      # Returns the consecutive duplicates, leaving out the first instance of
+      # the duplicated elements.
+      #
+      # @param [Array] collection an array to return consecutive duplicates for
+      # @return [Array] the consecutive duplicates
+      def consecutive_duplicates(collection)
+        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+      end
+
+      # Returns a hash of grouped duplicates. The key will be the first
+      # instance of the element, and  the value an `array` of the initial
+      # element and all duplicate instances.
+      #
+      # @param [Array] collection an array to group duplicates for
+      # @return [Hash] the grouped duplicates
+      def grouped_duplicates(collection)
+        collection.group_by { |item| item }.values.reject(&:one?)
+      end
+    end
+  end
+end

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

@@ -44,8 +44,8 @@ module RuboCop
         add_offense(node, end_loc, msg)
       end
 
-      def parameter_name
-        'AlignWith'
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)

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

@@ -10,24 +10,27 @@ module RuboCop
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
       FROZEN_STRING_LITERAL_TYPES = [:str, :dstr].freeze
 
-      def frozen_string_literal_comment_exists?(processed_source,
-                                                comment = FROZEN_STRING_LITERAL)
-        first_three_lines =
-          [processed_source[0], processed_source[1], processed_source[2]]
-        first_three_lines.compact!
-        first_three_lines.any? do |line|
-          line.start_with?(comment)
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
         end
       end
 
-      def frozen_string_literals_enabled?(processed_source)
+      def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
         return true if ruby_version >= 3.0
         return false unless ruby_version >= 2.3
-        frozen_string_literal_comment_exists?(
-          processed_source, FROZEN_STRING_LITERAL_ENABLED
-        )
+
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal?
+        end
+      end
+
+      private
+
+      def leading_comment_lines
+        processed_source[0..2].compact
       end
     end
   end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common funcitonality for checking hash alignment.
+    module HashAlignment
+      # Handles calculation of deltas when the enforced style is 'key'.
+      class KeyAlignment
+        def checkable_layout?(_node)
+          true
+        end
+
+        def deltas_for_first_pair(*)
+          {}
+        end
+
+        def deltas(first_pair, current_pair)
+          if Util.begins_its_line?(current_pair.source_range)
+            { key: first_pair.key_delta(current_pair) }
+          else
+            {}
+          end
+        end
+      end
+
+      # Common functionality for checking alignment of hash values.
+      module ValueAlignment
+        def checkable_layout?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters?
+        end
+
+        def deltas(first_pair, current_pair)
+          key_delta = key_delta(first_pair, current_pair)
+          separator_delta = separator_delta(first_pair, current_pair,
+                                            key_delta)
+          value_delta = value_delta(first_pair, current_pair) -
+                        key_delta - separator_delta
+
+          { key: key_delta, separator: separator_delta, value: value_delta }
+        end
+
+        private
+
+        def separator_delta(first_pair, current_pair, key_delta)
+          if current_pair.colon?
+            0
+          else
+            hash_rocket_delta(first_pair, current_pair) - key_delta
+          end
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'table'.
+      class TableAlignment
+        include ValueAlignment
+
+        # The table style is the only one where the first key-value pair can
+        # be considered to have bad alignment.
+        def deltas_for_first_pair(first_pair, node)
+          self.max_key_width = node.keys.map { |key| key.source.length }.max
+
+          separator_delta = separator_delta(first_pair, first_pair, 0)
+          {
+            separator: separator_delta,
+            value: value_delta(first_pair, first_pair) - separator_delta
+          }
+        end
+
+        private
+
+        attr_accessor :max_key_width
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.loc.column + max_key_width + 1 -
+            current_pair.loc.operator.column
+        end
+
+        def value_delta(first_pair, current_pair)
+          correct_value_column = first_pair.key.loc.column +
+                                 current_pair.delimiter(true).length +
+                                 max_key_width
+          correct_value_column - current_pair.value.loc.column
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'separator'.
+      class SeparatorAlignment
+        include ValueAlignment
+
+        def deltas_for_first_pair(*)
+          {}
+        end
+
+        private
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair, :right)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.delimiter_delta(current_pair)
+        end
+
+        def value_delta(first_pair, current_pair)
+          first_pair.value_delta(current_pair)
+        end
+      end
+    end
+  end
+end