rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This mixin detects collections that are safe to "break"
+    # by inserting new lines. This is useful for breaking
+    # up long lines.
+    #
+    # Let's look at hashes as an example:
+    #
+    # We know hash keys are safe to break across lines. We can add
+    # linebreaks into hashes on lines longer than the specified maximum.
+    # Then in further passes cops can clean up the multi-line hash.
+    # For example, say the maximum line length is as indicated below:
+    #
+    #                                         |
+    #                                         v
+    # {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+    #
+    # In a LineLength autocorrection pass, a line is added before
+    # the first key that exceeds the column limit:
+    #
+    # {foo: "0000000000", bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # In a MultilineHashKeyLineBreaks pass, lines are inserted
+    # before all keys:
+    #
+    # {foo: "0000000000",
+    # bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # Then in future passes FirstHashElementLineBreak,
+    # MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
+    # manipulate as well until we get:
+    #
+    # {
+    #   foo: "0000000000",
+    #   bar: "0000000000",
+    #   baz: "0000000000",
+    # }
+    #
+    # (Note: Passes may not happen exactly in this sequence.)
+    module CheckLineBreakable
+      def extract_breakable_node(node, max)
+        if node.send_type?
+          args = process_args(node.arguments)
+          return extract_breakable_node_from_elements(node, args, max)
+        elsif node.array_type? || node.hash_type?
+          return extract_breakable_node_from_elements(node, node.children, max)
+        end
+        nil
+      end
+
+      private
+
+      def extract_breakable_node_from_elements(node, elements, max)
+        return unless breakable_collection?(node, elements)
+        return if safe_to_ignore?(node)
+
+        line = processed_source.lines[node.first_line - 1]
+        return if processed_source.commented?(node.loc.begin)
+        return if line.length <= max
+
+        extract_first_element_over_column_limit(node, elements, max)
+      end
+
+      def extract_first_element_over_column_limit(node, elements, max)
+        line = node.first_line
+        i = 0
+        i += 1 while within_column_limit?(elements[i], max, line)
+        return elements.first if i.zero?
+
+        elements[i - 1]
+      end
+
+      def within_column_limit?(element, max, line)
+        element && element.loc.column < max && element.loc.line == line
+      end
+
+      def safe_to_ignore?(node)
+        return true unless max
+        return true if already_on_multiple_lines?(node)
+
+        # If there's a containing breakable collection on the same
+        # line, we let that one get broken first. In a separate pass,
+        # this one might get broken as well, but to avoid conflicting
+        # or redundant edits, we only mark one offense at a time.
+        return true if contained_by_breakable_collection_on_same_line?(node)
+
+        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
+
+        false
+      end
+
+      def breakable_collection?(node, elements)
+        # For simplicity we only want to insert breaks in normal
+        # hashes wrapped in a set of curly braces like {foo: 1}.
+        # That is, not a kwargs hash. For method calls, this ensures
+        # the method call is made with parens.
+        starts_with_bracket = node.loc.begin
+
+        # If the call has a second argument, we can insert a line
+        # break before the second argument and the rest of the
+        # argument will get auto-formatted onto separate lines
+        # by other cops.
+        has_second_element = elements.length >= 2
+
+        starts_with_bracket && has_second_element
+      end
+
+      def contained_by_breakable_collection_on_same_line?(node)
+        node.each_ancestor.find do |ancestor|
+          # Ignore ancestors on different lines.
+          break if ancestor.first_line != node.first_line
+
+          if ancestor.hash_type? || ancestor.array_type?
+            elements = ancestor.children
+          elsif ancestor.send_type?
+            elements = process_args(ancestor.arguments)
+          else
+            next
+          end
+
+          return true if breakable_collection?(ancestor, elements)
+        end
+
+        false
+      end
+
+      def contained_by_multiline_collection_that_could_be_broken_up?(node)
+        node.each_ancestor.find do |ancestor|
+          if ancestor.hash_type? || ancestor.array_type?
+            if breakable_collection?(ancestor, ancestor.children)
+              return children_could_be_broken_up?(ancestor.children)
+            end
+          end
+
+          next unless ancestor.send_type?
+
+          args = process_args(ancestor.arguments)
+          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+        end
+
+        false
+      end
+
+      def children_could_be_broken_up?(children)
+        return false if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          return true if last_seen_line >= child.first_line
+
+          last_seen_line = child.last_line
+        end
+        false
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+
+      def process_args(args)
+        # If there is a trailing hash arg without explicit braces, like this:
+        #
+        #    method(1, 'key1' => value1, 'key2' => value2)
+        #
+        # ...then each key/value pair is treated as a method 'argument'
+        # when determining where line breaks should appear.
+        if (last_arg = args.last)
+          args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+        end
+        args
+      end
+
+      def already_on_multiple_lines?(node)
+        node.first_line != node.last_line
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module RuboCop
     module CodeLength
       include ConfigurableMax
 
+      private
+
       def max_length
         cop_config['Max']
       end
@@ -14,11 +16,19 @@ module RuboCop
         cop_config['CountComments']
       end
 
+      def count_as_one
+        Array(cop_config['CountAsOne']).map(&:to_sym)
+      end
+
       def check_code_length(node)
         length = code_length(node)
+
         return unless length > max_length
 
-        add_offense(node, message: message(length, max_length)) do
+        location = node.casgn_type? ? :name : :expression
+
+        add_offense(node, location: location,
+                          message: message(length, max_length)) do
           self.max = length
         end
       end

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

@@ -23,7 +23,7 @@ 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)
 
@@ -60,12 +60,15 @@ 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
-        @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

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

@@ -7,12 +7,10 @@ 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, location: name_range, message: message(style)) do
+          add_offense(name_range, message: message(style)) do
             report_opposing_styles(node, name)
           end
         end
@@ -20,14 +18,12 @@ module RuboCop
 
       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)) ||
+        name.match?(self.class::FORMATS.fetch(given_style)) ||
           class_emitter_method?(node, name)
       end
 
@@ -35,6 +31,7 @@ module RuboCop
       # 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?

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

@@ -5,10 +5,14 @@ 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[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

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

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

@@ -8,18 +8,24 @@ module RuboCop
 
       NON_PUBLIC_MODIFIERS = %w[private protected].freeze
 
+      private
+
       def non_public?(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|
+        stripped_source_upto(node.first_line).any? do |line|
           NON_PUBLIC_MODIFIERS.include?(line)
         end
       end
 
-      def_node_matcher :non_public_modifier?, <<-PATTERN
+      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} ...))
       PATTERN
     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,9 +21,17 @@ 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)
@@ -35,11 +41,11 @@ module RuboCop
       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
+        CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
       end
     end
   end

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

@@ -8,36 +8,24 @@ module RuboCop
       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
 
         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
-
-        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 +48,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 +63,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)
@@ -109,7 +107,7 @@ module RuboCop
           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)
@@ -124,6 +122,7 @@ module RuboCop
         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)
@@ -154,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,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      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)
+        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,37 @@ 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)
+        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(node, location: end_loc, message: msg)
       end
 
+      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 style_parameter_name
         'EnforcedStyleAlignWith'
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        end_alignment_style == :variable &&
-          !line_break_before_keyword?(whole_expression, rhs)
-      end
-
-      def line_break_before_keyword?(whole_expression, rhs)
-        rhs.loc.line > whole_expression.line
-      end
-
-      def align(node, align_to)
-        whitespace = whitespace_range(node)
-        return false unless whitespace.source.strip.empty?
+        return if end_alignment_style == :keyword
 
-        column = alignment_column(align_to)
-        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+        !line_break_before_keyword?(whole_expression, rhs)
       end
 
-      def whitespace_range(node)
-        begin_pos = node.loc.end.begin_pos
-
-        range_between(begin_pos - node.loc.end.column, begin_pos)
-      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

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

@@ -5,12 +5,14 @@ module RuboCop
     # Common functionality for enforcing a specific superclass
     module EnforceSuperclass
       def self.included(base)
-        base.def_node_matcher :class_definition, <<-PATTERN
-        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN
 
-        base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 
@@ -25,12 +27,6 @@ module RuboCop
           add_offense(node.children.last)
         end
       end
-
-      def autocorrect(node)
-        lambda do |corrector|
-          corrector.replace(node.source_range, self.class::SUPERCLASS)
-        end
-      end
     end
   end
 end

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

@@ -5,10 +5,6 @@ module RuboCop
     # Common functionality for checking for a line break before the first
     # element in a multi-line collection.
     module FirstElementLineBreak
-      def autocorrect(node)
-        ->(corrector) { corrector.insert_before(node.source_range, "\n") }
-      end
-
       private
 
       def check_method_line_break(node, children)
@@ -21,29 +17,29 @@ module RuboCop
 
       def method_uses_parens?(node, limit)
         source = node.source_range.source_line[0...limit.loc.column]
-        source =~ /\s*\(\s*$/
+        /\s*\(\s*$/.match?(source)
       end
 
       def check_children_line_break(node, children, start = node)
         return if children.size < 2
 
-        line = start.loc.line
+        line = start.first_line
 
         min = first_by_line(children)
-        return if line != min.loc.first_line
+        return if line != min.first_line
 
         max = last_by_line(children)
-        return if line == max.loc.last_line
+        return if line == max.last_line
 
         add_offense(min)
       end
 
       def first_by_line(nodes)
-        nodes.min_by { |n| n.loc.first_line }
+        nodes.min_by(&:first_line)
       end
 
       def last_by_line(nodes)
-        nodes.max_by { |n| n.loc.last_line }
+        nodes.max_by(&:last_line)
       end
     end
   end