rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,23 +7,24 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop
-        include OnMethodDef
-        include CodeLength
+        include TooManyLines
 
-        private
+        LABEL = 'Method'.freeze
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_def(node)
           check_code_length(node)
         end
+        alias on_defs on_def
 
-        def message(length, max_length)
-          format('Method has too many lines. [%d/%d]', length, max_length)
+        def on_block(node)
+          return unless node.send_node.method_name == :define_method
+          check_code_length(node)
         end
 
-        def code_length(node)
-          lines = node.source.lines.to_a[1..-2] || []
+        private
 
-          lines.count { |line| !irrelevant_line(line) }
+        def cop_label
+          LABEL
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,7 +16,9 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Module has too many lines. [%d/%d]', length, max_length)
+          format('Module has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,29 +5,39 @@ module RuboCop
     module Metrics
       # This cop checks for methods with too many parameters.
       # The maximum number of parameters is configurable.
-      # On Ruby 2.0+ keyword arguments can optionally
-      # be excluded from the total count.
+      # Keyword arguments can optionally be excluded from the total count.
       class ParameterLists < Cop
         include ConfigurableMax
 
-        MSG = 'Avoid parameter lists longer than %d parameters.'.freeze
+        MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
+              '[%<count>d/%<max>d]'.freeze
 
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
 
-          add_offense(node, :expression, format(MSG, max_params)) do
+          return if argument_to_lambda_or_proc?(node)
+
+          add_offense(node) do
             self.max = count
           end
         end
 
         private
 
+        def_node_matcher :argument_to_lambda_or_proc?, <<-PATTERN
+          ^lambda_or_proc?
+        PATTERN
+
+        def message(node)
+          format(MSG, max: max_params, count: args_count(node))
+        end
+
         def args_count(node)
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| ![:kwoptarg, :kwarg].include?(a.type) }
+            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
           end
         end
 

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -29,11 +28,11 @@ 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,
-                         :for, :rescue, :and, :or].freeze
+        MSG = 'Perceived complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'.freeze
+        COUNTED_NODES = %i[if case while until
+                           for rescue and or].freeze
 
         private
 
@@ -52,7 +51,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/alignment.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for nodes that should be aligned to the left or right.
+    # This amount is determined by the instance variable @column_delta.
+    module Alignment
+      private
+
+      SPACE = ' '.freeze
+
+      attr_reader :column_delta
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] ||
+          config.for_cop('IndentationWidth')['Width']
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def check_alignment(items, base_column = nil)
+        unless items.empty?
+          base_column ||= display_column(items.first.source_range)
+        end
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if offenses.any? { |o| within?(expr, o.location) }
+            # 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
+            # offense again and correct it.
+            add_offense(nil, location: expr)
+          else
+            add_offense(current)
+          end
+        end
+      end
+
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta.nonzero?
+          end
+          prev_line = current.loc.line
+        end
+      end
+
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.column])
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

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

@@ -1,16 +1,17 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common code for indenting literal arrays and hashes.
     module ArrayHashIndentation
+      private
+
       def each_argument_node(node, type)
-        _receiver, _method_name, *args = *node
         left_parenthesis = node.loc.begin
+
         return unless left_parenthesis
 
-        args.each do |arg|
+        node.arguments.each do |arg|
           on_node(type, arg, :send) do |type_node|
             left_brace = type_node.loc.begin
             if left_brace && left_brace.line == left_parenthesis.line
@@ -26,21 +27,21 @@ module RuboCop
         expected_column = base_column(left_brace, left_parenthesis) +
                           configured_indentation_width + offset
         @column_delta = expected_column - actual_column
+        styles =
+          detected_styles(actual_column, offset, left_parenthesis, left_brace)
 
         if @column_delta.zero?
-          # which column was actually used as 'base column' for indentation?
-          # (not the column which we think should be the 'base column',
-          # but the one which has actually been used for that purpose)
-          base_column = actual_column - configured_indentation_width - offset
-          styles = detected_styles(base_column, left_parenthesis, left_brace)
-          if styles.size > 1
-            ambiguous_style_detected(*styles)
-          else
-            correct_style_detected
-          end
+          check_expected_style(styles)
         else
-          incorrect_style_detected(actual_column, offset, first,
-                                   left_parenthesis, left_brace)
+          incorrect_style_detected(styles, first, left_parenthesis)
+        end
+      end
+
+      def check_expected_style(styles)
+        if styles.size > 1
+          ambiguous_style_detected(*styles)
+        else
+          correct_style_detected
         end
       end
 
@@ -54,7 +55,12 @@ module RuboCop
         end
       end
 
-      def detected_styles(column, left_parenthesis, left_brace)
+      def detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        base_column = actual_column - configured_indentation_width - offset
+        detected_styles_for_column(base_column, left_parenthesis, left_brace)
+      end
+
+      def detected_styles_for_column(column, left_parenthesis, left_brace)
         styles = []
         if column == (left_brace.source_line =~ /\S/)
           styles << :consistent
@@ -67,12 +73,10 @@ module RuboCop
         styles
       end
 
-      def incorrect_style_detected(column, offset, first, left_parenthesis,
-                                   left_brace)
-        add_offense(first, :expression,
-                    message(base_description(left_parenthesis))) do
-          base_column = column - configured_indentation_width - offset
-          styles = detected_styles(base_column, left_parenthesis, left_brace)
+      def incorrect_style_detected(styles, first, left_parenthesis)
+        msg = message(base_description(left_parenthesis))
+
+        add_offense(first, message: msg) do
           ambiguous_style_detected(*styles)
         end
       end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles the `MinSize` configuration option for array-based cops
+    # `Style/SymbolArray` and `Style/WordArray`, which check for use of the
+    # relevant percent literal syntax such as `%i[...]` and `%w[...]`
+    module ArrayMinSize
+      private
+
+      def below_array_length?(node)
+        node.values.length < min_size_config
+      end
+
+      def min_size_config
+        cop_config['MinSize']
+      end
+
+      def array_style_detected(style, ary_size)
+        cfg = config_to_allow_offenses
+        return if cfg['Enabled'] == false
+
+        largest_brackets = largest_brackets_size(style, ary_size)
+        smallest_percent = smallest_percent_size(style, ary_size)
+
+        if cfg['EnforcedStyle'] == style.to_s
+          # do nothing
+        elsif cfg['EnforcedStyle'].nil?
+          cfg['EnforcedStyle'] = style.to_s
+        elsif smallest_percent <= largest_brackets
+          self.config_to_allow_offenses = { 'Enabled' => false }
+        else
+          cfg['EnforcedStyle'] = 'percent'
+          cfg['MinSize'] = largest_brackets + 1
+        end
+      end
+
+      def largest_brackets_size(style, ary_size)
+        self.class.largest_brackets ||= -Float::INFINITY
+
+        if style == :brackets && ary_size > self.class.largest_brackets
+          self.class.largest_brackets = ary_size
+        end
+
+        self.class.largest_brackets
+      end
+
+      def smallest_percent_size(style, ary_size)
+        @smallest_percent ||= Float::INFINITY
+
+        if style == :percent && ary_size < @smallest_percent
+          @smallest_percent = ary_size
+        end
+
+        @smallest_percent
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,19 +5,12 @@ module RuboCop
     # Common code for ordinary arrays with [] that can be written with %
     # syntax.
     module ArraySyntax
-      def bracketed_array_of?(element_type, node)
-        return false unless square_brackets?(node)
-
-        array_elems = node.children
-
-        # no need to check empty arrays
-        return false unless array_elems && array_elems.size > 1
+      private
 
-        array_elems.all? { |e| e.type == element_type }
-      end
+      def bracketed_array_of?(element_type, node)
+        return false unless node.square_brackets? && node.values.size > 1
 
-      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/check_assignment.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -12,13 +11,13 @@ module RuboCop
       end
 
       def on_send(node)
-        # we only want to indent relative to the receiver
-        # when the method called looks like a setter
-        return unless node.asgn_method_call?
+        return unless node.setter_method?
 
-        # This will match if, case, begin, blocks, etc.
         rhs = extract_rhs(node)
-        check_assignment(node, rhs) if rhs.is_a?(AST::Node)
+
+        return unless rhs
+
+        check_assignment(node, rhs)
       end
 
       module_function
@@ -31,7 +30,7 @@ module RuboCop
         elsif Util::ASGN_NODES.include?(node.type)
           _lhs, rhs = *node
         elsif node.send_type?
-          rhs = node.children.last
+          rhs = node.last_argument
         end
 
         rhs

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,6 +6,8 @@ module RuboCop
     module CodeLength
       include ConfigurableMax
 
+      private
+
       def max_length
         cop_config['Max']
       end
@@ -15,11 +16,11 @@ module RuboCop
         cop_config['CountComments']
       end
 
-      def check_code_length(node, *_)
+      def check_code_length(node)
         length = code_length(node)
         return unless length > max_length
 
-        add_offense(node, :expression, message(length, max_length)) do
+        add_offense(node, message: message(length, max_length)) do
           self.max = length
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -28,12 +27,17 @@ module RuboCop
         # (if there is more than one which matches the observed code)
         detected_as_strings = Array(detected).map(&:to_s)
 
-        if !detected_style # we haven't observed any specific style yet
-          self.detected_style = detected_as_strings
-        elsif detected_style.is_a?(Array)
-          self.detected_style &= detected_as_strings
-        elsif !detected.include?(detected_style)
+        updated_list = if detected_style
+                         detected_style & detected_as_strings
+                       else
+                         # We haven't observed any specific style yet.
+                         detected_as_strings
+                       end
+        if updated_list.empty?
           no_acceptable_style!
+        else
+          self.detected_style = updated_list
+          config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
 
@@ -43,7 +47,6 @@ module RuboCop
 
       def no_acceptable_style!
         self.config_to_allow_offenses = { 'Enabled' => false }
-        Formatter::DisabledConfigFormatter.detected_styles[cop_name] = []
       end
 
       def detected_style
@@ -52,11 +55,6 @@ module RuboCop
 
       def detected_style=(style)
         Formatter::DisabledConfigFormatter.detected_styles[cop_name] = style
-
-        return no_acceptable_style! if style.nil?
-        return no_acceptable_style! if style.empty?
-
-        config_to_allow_offenses[parameter_name] = style.first
       end
 
       alias conflicting_styles_detected no_acceptable_style!
@@ -64,7 +62,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
@@ -77,14 +75,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, location: name_range, message: 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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,13 +5,15 @@ module RuboCop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
     module ConfigurableMax
+      private
+
       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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,41 +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.defs_type?
-        # a class emitter method may be defined inside `def self.included`,
-        # `def self.extended`, etc.
-        node = node.parent while node.parent && node.parent.defs_type?
-        return false unless node.parent
-
-        node.parent.children.compact.any? do |c|
-          c.class_type? && 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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides functionality for checking if numbering match the
+    # configured EnforcedStyle.
+    module ConfigurableNumbering
+      include ConfigurableFormatting
+
+      FORMATS = {
+        snake_case:  /(?:[a-z_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
+        non_integer: /[A-Za-z_]$/
+      }.freeze
+    end
+  end
+end