rubocop 0.48.1 → 1.16.0

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

@@ -23,16 +23,21 @@ module RuboCop
       def style_detected(detected)
         return if no_acceptable_style?
 
-        # `detected` can be a single style, or an Array of possible styles
+        # `detected` can be a single style or an Array of possible styles
         # (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
 
@@ -42,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
@@ -51,31 +55,29 @@ 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[style_parameter_name] = style.first
       end
 
       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
-        @enforced_style ||= begin
+        @style ||= begin
           s = cop_config[style_parameter_name].to_sym
-          unless supported_styles.include?(s)
-            raise "Unknown style #{s} selected!"
-          end
+          raise "Unknown style #{s} selected!" unless supported_styles.include?(s)
+
           s
         end
       end
 
       def alternative_style
         if supported_styles.size != 2
-          raise 'alternative_style can only be used when there are exactly ' \
-               '2 SupportedStyles'
+          raise 'alternative_style can only be used when there are exactly 2 SupportedStyles'
         end
+
         alternative_styles.first
       end
 

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

@@ -7,41 +7,33 @@ module RuboCop
       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
+          add_offense(name_range, message: message(style)) { report_opposing_styles(node, name) }
         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
+          return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
       end
 
       def valid_name?(node, name, given_style = style)
-        name.match(self.class::FORMATS.fetch(given_style)) ||
-          class_emitter_method?(node, name)
+        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
+        node.parent.each_child_node(:class).any? { |c| c.loc.name.is?(name.to_s) }
       end
     end
   end

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

@@ -4,11 +4,16 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
+    # @deprecated Use `exclude_limit ParameterName` instead.
     module ConfigurableMax
+      private
+
       def max=(value)
         cfg = config_to_allow_offenses
-        value = [cfg[max_parameter_name], value].max if cfg[max_parameter_name]
-        cfg[max_parameter_name] = value
+        cfg[:exclude_limit] ||= {}
+        current_max = cfg[:exclude_limit][max_parameter_name]
+        value = [current_max, value].max if current_max
+        cfg[:exclude_limit][max_parameter_name] = value
       end
 
       def max_parameter_name

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

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+        snake_case: /^@{0,2}[\d[[:lower:]]_]+[!?=]?$/,
+        camelCase:  /^@{0,2}(?:_|_?[[[:lower:]]][\d[[:lower:]][[:upper:]]]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -7,10 +7,11 @@ module RuboCop
     module ConfigurableNumbering
       include ConfigurableFormatting
 
+      implicit_param = /\A_\d+\z/
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:\D|_\d+|\A\d+)\z/,
+        normalcase:  /(?:\D|[^_\d]\d+|\A\d+)\z|#{implicit_param}/,
+        non_integer: /(\D|\A\d+)\z|#{implicit_param}/
       }.freeze
     end
   end

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

@@ -2,25 +2,29 @@
 
 module RuboCop
   module Cop
-    # Common functionality for checking if nodes.
+    # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
 
       NON_PUBLIC_MODIFIERS = %w[private protected].freeze
 
+      private
+
       def non_public?(node)
-        non_public_modifier?(node.parent) ||
-          preceding_non_public_modifier?(node)
+        non_public_modifier?(node.parent) || preceding_non_public_modifier?(node)
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.loc.line).any? do |line|
-          NON_PUBLIC_MODIFIERS.include?(line)
-        end
+        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
+      end
+
+      def stripped_source_upto(index)
+        processed_source[0..index].map(&:strip)
       end
 
-      def_node_matcher :non_public_modifier?, <<-PATTERN
-        (send nil {:private :protected} ({def defs} ...))
+      # @!method non_public_modifier?(node)
+      def_node_matcher :non_public_modifier?, <<~PATTERN
+        (send nil? {:private :protected} ({def defs} ...))
       PATTERN
     end
   end

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

@@ -7,8 +7,6 @@ module RuboCop
       extend NodePattern::Macros
       include Style::AnnotationComment
 
-      def_node_matcher :constant_definition?, '{class module casgn}'
-
       private
 
       def documentation_comment?(node)
@@ -23,23 +21,28 @@ module RuboCop
         end
       end
 
-      def preceding_comment?(n1, n2)
-        n1 && n2 && preceed?(n2, n1) &&
-          comment_line?(n2.loc.expression.source)
+      # The args node1 & node2 may represent a RuboCop::AST::Node
+      # or a Parser::Source::Comment. Both respond to #loc.
+      def preceding_comment?(node1, node2)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+      end
+
+      # The args node1 & node2 may represent a RuboCop::AST::Node
+      # or a Parser::Source::Comment. Both respond to #loc.
+      def precede?(node1, node2)
+        node2.loc.line - node1.loc.line == 1
       end
 
       def preceding_lines(node)
-        processed_source.ast_with_comments[node].select do |line|
-          line.loc.line < node.loc.line
-        end
+        processed_source.ast_with_comments[node].select { |line| line.loc.line < node.loc.line }
       end
 
       def interpreter_directive_comment?(comment)
-        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        /^#\s*(frozen_string_literal|encoding):/.match?(comment.text)
       end
 
       def rubocop_directive_comment?(comment)
-        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+        !!DirectiveComment.new(comment).match_captures
       end
     end
   end

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

@@ -2,42 +2,32 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
       module EmptyLinesAroundBody
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
-        MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
-        MSG_DEFERRED = 'Empty line missing before first %s definition'.freeze
+        MSG_EXTRA = 'Extra empty line detected at %<kind>s body %<location>s.'
+        MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
+        MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
 
+        private
+
+        # @!method constant_definition?(node)
         def_node_matcher :constant_definition?, '{class module}'
-        def_node_matcher :empty_line_required?, '{def defs class module}'
-
-        def autocorrect(args)
-          offense_style, range = args
-          lambda do |corrector|
-            case offense_style
-            when :no_empty_lines then
-              corrector.remove(range)
-            when :empty_lines then
-              corrector.insert_before(range, "\n")
-            end
-          end
-        end
 
-        private
+        # @!method empty_line_required?(node)
+        def_node_matcher :empty_line_required?,
+                         '{def defs class module (send nil? {:private :protected :public})}'
 
-        def check(node, body)
-          # When style is `empty_lines`, if the body is empty, we don't enforce
-          # the presence OR absence of an empty line
-          # But if style is `no_empty_lines`, there must not be an empty line
-          return unless body || style == :no_empty_lines
+        def check(node, body, adjusted_first_line: nil)
+          return if valid_body_style?(body)
           return if node.single_line?
 
-          first_line = node.source_range.first_line
+          first_line = adjusted_first_line || node.source_range.first_line
           last_line = node.source_range.last_line
 
           case style
@@ -60,6 +50,7 @@ module RuboCop
 
         def check_empty_lines_special(body, first_line, last_line)
           return unless body
+
           if namespace?(body, with_one_child: true)
             check_both(:no_empty_lines, first_line, last_line)
           else
@@ -74,8 +65,17 @@ module RuboCop
         end
 
         def check_both(style, first_line, last_line)
-          check_beginning(style, first_line)
-          check_ending(style, last_line)
+          case style
+          when :beginning_only
+            check_beginning(:empty_lines, first_line)
+            check_ending(:no_empty_lines, last_line)
+          when :ending_only
+            check_beginning(:no_empty_lines, first_line)
+            check_ending(:empty_lines, last_line)
+          else
+            check_beginning(style, first_line)
+            check_ending(style, last_line)
+          end
         end
 
         def check_beginning(style, first_line)
@@ -91,9 +91,7 @@ module RuboCop
           when :no_empty_lines
             check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
           when :empty_lines
-            check_line(style, line_no, message(MSG_MISSING, desc)) do |line|
-              !line.empty?
-            end
+            check_line(style, line_no, message(MSG_MISSING, desc)) { |line| !line.empty? }
           end
         end
 
@@ -102,23 +100,29 @@ module RuboCop
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense([style, range], range, msg)
+          add_offense(range, message: msg) do |corrector|
+            EmptyLineCorrector.correct(corrector, [style, range])
+          end
         end
 
         def check_deferred_empty_line(body)
           node = first_empty_line_required_child(body)
           return unless node
 
-          line = previous_line_ignoring_comments(node.loc.first_line)
+          line = previous_line_ignoring_comments(node.first_line)
           return if processed_source[line].empty?
 
           range = source_range(processed_source.buffer, line + 2, 0)
-          add_offense([:empty_lines, range], range, deferred_message(node))
+
+          add_offense(range, message: deferred_message(node)) do |corrector|
+            EmptyLineCorrector.correct(corrector, [:empty_lines, range])
+          end
         end
 
         def namespace?(body, with_one_child: false)
           if body.begin_type?
             return false if with_one_child
+
             body.children.all? { |child| constant_definition?(child) }
           else
             constant_definition?(body)
@@ -149,11 +153,18 @@ module RuboCop
         end
 
         def message(type, desc)
-          format(type, self.class::KIND, desc)
+          format(type, kind: self.class::KIND, location: desc)
         end
 
         def deferred_message(node)
-          format(MSG_DEFERRED, node.type)
+          format(MSG_DEFERRED, type: node.type)
+        end
+
+        def valid_body_style?(body)
+          # When style is `empty_lines`, if the body is empty, we don't enforce
+          # the presence OR absence of an empty line
+          # But if style is `no_empty_lines`, there must not be an empty line
+          body.nil? && style != :no_empty_lines
         end
       end
     end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      # @!method empty_arguments?(node)
+      def_node_matcher :empty_arguments?, <<~PATTERN
+        (block _ $(args) _)
+      PATTERN
+
+      def check(node)
+        empty_arguments?(node) do |args|
+          return if args.empty_and_without_delimiters?
+
+          add_offense(args) { |corrector| autocorrect(corrector, args) }
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,10 @@ module RuboCop
     # Functions for checking the alignment of the `end` keyword.
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
+      include RangeHelp
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+      MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
+            '`%<source>s` at %<align_line>d, %<align_col>d.'
 
       private
 
@@ -18,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)
 
@@ -33,52 +35,46 @@ module RuboCop
       def matching_ranges(end_loc, align_ranges)
         align_ranges.select do |_, range|
           range.line == end_loc.line ||
-            effective_column(range) == end_loc.column
+            column_offset_between(range, end_loc).zero?
         end
       end
 
-      def add_offense_for_misalignment(node, align_with)
-        end_loc = node.loc.end
-        msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
-                     align_with.line, align_with.column)
-        add_offense(node, end_loc, msg)
-      end
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
 
-      def style_parameter_name
-        'EnforcedStyleAlignWith'
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
       end
 
-      def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        end_alignment_style == :variable &&
-          !line_break_before_keyword?(whole_expression, rhs)
+      def add_offense_for_misalignment(node, align_with)
+        end_loc = node.loc.end
+        msg = format(MSG, end_line: end_loc.line,
+                          end_col: end_loc.column,
+                          source: align_with.source,
+                          align_line: align_with.line,
+                          align_col: align_with.column)
+        add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
-      def line_break_before_keyword?(whole_expression, rhs)
-        rhs.loc.line > whole_expression.line
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
       end
 
-      def align(node, align_to)
-        whitespace = whitespace_range(node)
-        return false unless whitespace.source.strip.empty?
-
-        column = alignment_column(align_to)
-        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
       end
 
-      def whitespace_range(node)
-        begin_pos = node.loc.end.begin_pos
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        return if end_alignment_style == :keyword
 
-        range_between(begin_pos - node.loc.end.column, begin_pos)
+        !line_break_before_keyword?(whole_expression, rhs)
       end
 
-      def alignment_column(align_to)
-        if !align_to
-          0
-        elsif align_to.respond_to?(:loc)
-          align_to.source_range.column
-        else
-          align_to.column
-        end
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.first_line > whole_expression.line
       end
     end
   end