rubocop 0.89.1 → 0.90.0

data/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb

@@ -64,25 +64,15 @@ module RuboCop
 
         private
 
-        def check_regexp(regexp)
-          return if contain_non_literal?(regexp)
-
-          tree = Regexp::Parser.parse(regexp.content)
-          @valid_ref = regexp_captures(tree)
-        end
-
-        def contain_non_literal?(node)
-          node.children.size != 2 || !node.children.first.str_type?
-        end
-
-        def regexp_captures(tree)
-          named_capture = numbered_capture = 0
-          tree.each_expression do |e|
-            if e.type?(:group)
-              e.respond_to?(:name) ? named_capture += 1 : numbered_capture += 1
-            end
-          end
-          named_capture.positive? ? named_capture : numbered_capture
+        def check_regexp(node)
+          return if node.interpolation?
+
+          named_capture = node.each_capture(named: true).count
+          @valid_ref = if named_capture.positive?
+                         named_capture
+                       else
+                         node.each_capture(named: false).count
+                       end
         end
       end
     end

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -39,23 +39,19 @@ module RuboCop
           return unless contains_quotes_or_commas?(node)
 
           add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
+            node.each_value do |value|
+              range = value.loc.expression
 
-        def autocorrect(corrector, node)
-          node.each_value do |value|
-            range = value.loc.expression
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
 
-            match = range.source.match(TRAILING_QUOTE)
-            corrector.remove_trailing(range, match[0].length) if match
-
-            corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+            end
           end
         end
 
+        private
+
         def contains_quotes_or_commas?(node)
           node.values.any? do |value|
             literal = value.children.first.to_s.scrub

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for use of the same name as outer local variables
-      # for block arguments or block local variables.
-      # This is a mimic of the warning
-      # "shadowing outer local variable - foo" from `ruby -cw`.
+      # This cop checks for the use of local variable names from an outer scope
+      # in block arguments or block-local variables. This mirrors the warning
+      # given by `ruby -cw` prior to Ruby 2.6:
+      # "shadowing outer local variable - foo".
       #
       # @example
       #

data/lib/rubocop/cop/lint/top_level_return_with_argument.rb

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   # Detected since Ruby 2.7
       #   return 1 # 1 is always ignored.
-      class TopLevelReturnWithArgument < Cop
+      class TopLevelReturnWithArgument < Base
         # This cop works by validating the ancestors of the return node. A
         # top-level return node's ancestors should not be of block, def, or
         # defs type.

data/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for trailing commas in attribute declarations, such as
+      # `#attr_reader`. Leaving a trailing comma will nullify the next method
+      # definition by overriding it with a getter method.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     attr_reader :foo,
+      #
+      #     def bar
+      #       puts "Unreachable."
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :foo
+      #
+      #     def bar
+      #       puts "No problem!"
+      #     end
+      #   end
+      #
+      class TrailingCommaInAttributeDeclaration < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+
+        def on_send(node)
+          return unless node.attribute_accessor? && node.arguments.last.def_type?
+
+          trailing_comma = trailing_comma_range(node)
+
+          add_offense(trailing_comma) do |corrector|
+            corrector.remove(trailing_comma)
+          end
+        end
+
+        private
+
+        def trailing_comma_range(node)
+          range_with_surrounding_space(
+            range: node.arguments[-2].source_range,
+            side: :right
+          ).end.resize(1)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_method_definition.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless method definitions, specifically: empty constructors
+      # and methods just delegating to `super`.
+      #
+      # This cop is marked as unsafe as it can trigger false positives for cases when
+      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #   end
+      #
+      #   def method
+      #     super
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     initialize_internals
+      #   end
+      #
+      #   def method
+      #     super
+      #     do_something_else
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   def initialize
+      #     # Comment.
+      #   end
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   def initialize
+      #     # Comment.
+      #   end
+      #
+      class UselessMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Useless method definition detected.'
+
+        def on_def(node)
+          return unless (constructor?(node) && empty_constructor?(node)) ||
+                        delegating?(node.body, node)
+
+          add_offense(node) { |corrector| corrector.remove(node) }
+        end
+        alias on_defs on_def
+
+        private
+
+        def empty_constructor?(node)
+          return false if node.body
+          return false if cop_config['AllowComments'] && comment_lines?(node)
+
+          true
+        end
+
+        def constructor?(node)
+          node.def_type? && node.method?(:initialize)
+        end
+
+        def delegating?(node, def_node)
+          return false unless node&.super_type? || node&.zsuper_type?
+
+          !node.arguments? || node.arguments.map(&:source) == def_node.arguments.map(&:source)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -31,6 +31,8 @@ module RuboCop
           # TODO: move to rubocop-ast
           ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
 
+          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
+
           def initialize(node)
             @assignment = 0
             @branch = 0

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -11,6 +11,7 @@ module RuboCop
 
           FOLDABLE_TYPES = %i[array hash heredoc].freeze
           CLASSLIKE_TYPES = %i[class module].freeze
+          private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
             @node = node

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

@@ -42,6 +42,7 @@ module RuboCop
         end
       end
 
+      # @api private
       def each_bad_alignment(items, base_column)
         prev_line = -1
         items.each do |current|
@@ -55,11 +56,13 @@ module RuboCop
         end
       end
 
+      # @api public
       def display_column(range)
         line = processed_source.lines[range.line - 1]
         Unicode::DisplayWidth.of(line[0, range.column])
       end
 
+      # @api public
       def within?(inner, outer)
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end

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

@@ -7,10 +7,12 @@ module RuboCop
     module AllowedMethods
       private
 
+      # @api public
       def allowed_method?(name)
         allowed_methods.include?(name.to_s)
       end
 
+      # @api public
       def allowed_methods
         cop_config.fetch('AllowedMethods', [])
       end

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

@@ -7,12 +7,14 @@ module RuboCop
       module AnnotationComment
         private
 
+        # @api public
         def annotation?(comment)
           _margin, first_word, colon, space, note = split_comment(comment)
           keyword_appearance?(first_word, colon, space) &&
             !just_first_word_of_sentence?(first_word, colon, space, note)
         end
 
+        # @api public
         def split_comment(comment)
           match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
           return false unless match
@@ -20,14 +22,17 @@ module RuboCop
           match.captures
         end
 
+        # @api public
         def keyword_appearance?(first_word, colon, space)
           first_word && keyword?(first_word.upcase) && (colon || space)
         end
 
+        # @api private
         def just_first_word_of_sentence?(first_word, colon, space, note)
           first_word == first_word.capitalize && !colon && space && note
         end
 
+        # @api public
         def keyword?(word)
           config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
         end

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

@@ -54,6 +54,7 @@ module RuboCop
 
       private
 
+      # @api private
       def extract_breakable_node_from_elements(node, elements, max)
         return unless breakable_collection?(node, elements)
         return if safe_to_ignore?(node)
@@ -65,6 +66,7 @@ module RuboCop
         extract_first_element_over_column_limit(node, elements, max)
       end
 
+      # @api private
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
         i = 0
@@ -74,10 +76,12 @@ module RuboCop
         elements[i - 1]
       end
 
+      # @api private
       def within_column_limit?(element, max, line)
         element && element.loc.column < max && element.loc.line == line
       end
 
+      # @api private
       def safe_to_ignore?(node)
         return true unless max
         return true if already_on_multiple_lines?(node)
@@ -93,6 +97,7 @@ module RuboCop
         false
       end
 
+      # @api private
       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}.
@@ -109,6 +114,7 @@ module RuboCop
         starts_with_bracket && has_second_element
       end
 
+      # @api private
       def contained_by_breakable_collection_on_same_line?(node)
         node.each_ancestor.find do |ancestor|
           # Ignore ancestors on different lines.
@@ -128,12 +134,12 @@ module RuboCop
         false
       end
 
+      # @api private
       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
+          if (ancestor.hash_type? || ancestor.array_type?) &&
+             breakable_collection?(ancestor, ancestor.children)
+            return children_could_be_broken_up?(ancestor.children)
           end
 
           next unless ancestor.send_type?
@@ -145,6 +151,7 @@ module RuboCop
         false
       end
 
+      # @api private
       def children_could_be_broken_up?(children)
         return false if all_on_same_line?(children)
 
@@ -157,12 +164,14 @@ module RuboCop
         false
       end
 
+      # @api private
       def all_on_same_line?(nodes)
         return true if nodes.empty?
 
         nodes.first.first_line == nodes.last.last_line
       end
 
+      # @api private
       def process_args(args)
         # If there is a trailing hash arg without explicit braces, like this:
         #
@@ -170,12 +179,12 @@ module RuboCop
         #
         # ...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[0...-1] + last_arg.children if last_arg.hash_type? && !last_arg.braces?
-        end
+        last_arg = args.last
+        args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
         args
       end
 
+      # @api private
       def already_on_multiple_lines?(node)
         node.first_line != node.last_line
       end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for working with nodes containing comments.
+    module CommentsHelp
+      include VisibilityHelp
+
+      def source_range_with_comment(node)
+        begin_pos, end_pos =
+          if node.def_type?
+            start_node = find_visibility_start(node) || node
+            end_node = find_visibility_end(node) || node
+            [begin_pos_with_comment(start_node),
+             end_position_for(end_node) + 1]
+          else
+            [begin_pos_with_comment(node), end_position_for(node)]
+          end
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      private
+
+      def end_position_for(node)
+        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        buffer.line_range(end_line).end_pos
+      end
+
+      def begin_pos_with_comment(node)
+        annotation_line = node.first_line - 1
+        first_comment = nil
+
+        processed_source.comments_before_line(annotation_line)
+                        .reverse_each do |comment|
+          if comment.location.line == annotation_line
+            first_comment = comment
+            annotation_line -= 1
+          end
+        end
+
+        start_line_position(first_comment || node)
+      end
+
+      def start_line_position(node)
+        buffer.line_range(node.loc.line).begin_pos - 1
+      end
+
+      def buffer
+        processed_source.buffer
+      end
+    end
+  end
+end