rubocop 0.89.1 → 0.93.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of `Integer#times` that will never yield
+      # (when the integer <= 0) or that will only ever yield once
+      # (`1.times`).
+      #
+      # This cop is marked as unsafe as `times` returns its receiver, which
+      # is *usually* OK, but might change behavior.
+      #
+      # @example
+      #   # bad
+      #   -5.times { do_something }
+      #   0.times { do_something }
+      #   1.times { do_something  }
+      #   1.times { |i| do_something(i) }
+      #
+      #   # good
+      #   do_something
+      #   do_something(1)
+      class UselessTimes < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless call to `%<count>i.times` detected.'
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        def_node_matcher :times_call?, <<~PATTERN
+          (send (int $_) :times (block-pass (sym $_))?)
+        PATTERN
+
+        def_node_matcher :block_arg, <<~PATTERN
+          (block _ (args (arg $_)) ...)
+        PATTERN
+
+        def_node_search :block_reassigns_arg?, <<~PATTERN
+          (lvasgn %)
+        PATTERN
+
+        def on_send(node)
+          return unless (count, proc_name = times_call?(node))
+          return if count > 1
+
+          # Get the block node if applicable
+          node = node.block_node if node.block_literal?
+
+          add_offense(node, message: format(MSG, count: count)) do |corrector|
+            next unless own_line?(node)
+
+            if never_process?(count, node)
+              remove_node(corrector, node)
+            elsif !proc_name.empty?
+              autocorrect_block_pass(corrector, node, proc_name)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def never_process?(count, node)
+          count < 1 || node.block_type? && node.body.nil?
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+        end
+
+        def autocorrect_block_pass(corrector, node, proc_name)
+          corrector.replace(node, proc_name)
+        end
+
+        def autocorrect_block(corrector, node)
+          block_arg = block_arg(node)
+          return if block_reassigns_arg?(node, block_arg)
+
+          source = node.body.source
+          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+
+          corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
+        end
+
+        def fix_indentation(source, range)
+          # Cleanup indentation in a multiline block
+          source_lines = source.split("\n")
+
+          source_lines[1..-1].each do |line|
+            next if line.empty?
+
+            line[range] = ''
+          end
+          source_lines.join("\n")
+        end
+
+        def own_line?(node)
+          # If there is anything else on the line other than whitespace,
+          # don't try to autocorrect
+          processed_source.buffer.source_line(node.loc.line)[0...node.loc.column] !~ /\S/
+        end
+      end
+    end
+  end
+end

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

@@ -29,6 +29,8 @@ module RuboCop
       #       content.
       #     HEREDOC
       #   end                 # 5 points
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
 
@@ -36,7 +38,7 @@ module RuboCop
 
         def on_block(node)
           return if excluded_method?(node)
-          return if node.class_constructor?
+          return if node.class_constructor? || node.struct_constructor?
 
           check_code_length(node)
         end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end                 # 5 points
       #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
@@ -37,17 +39,17 @@ module RuboCop
         end
 
         def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
+          if node.parent&.assignment?
+            block_node = node.parent.children[1]
+          else
+            _scope, _name, block_node = *node
           end
+
+          check_code_length(block_node) if block_node.class_definition?
         end
 
         private
 
-        def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
-        PATTERN
-
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]',
                  length: length,

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
@@ -79,40 +81,49 @@ module RuboCop
           private
 
           def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
             node.for_type? ||
-              node.op_asgn_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
-              (simple_assignment?(node) && capturing_variable?(node.children.first))
+              simple_assignment?(node) ||
+              argument?(node)
           end
 
-          def simple_assignment?(node)
-            return false if node.masgn_type?
+          def compound_assignment(node)
+            # Methods setter can not be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
 
-            if node.equals_asgn?
-              reset_on_lvasgn(node) if node.lvasgn_type?
-              return true
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) &&
+                !child.setter_method?
             end
+            @assignment += will_be_miscounted
 
-            argument?(node)
+            false
           end
 
-          def capturing_variable?(name)
-            name && !/^_/.match?(name)
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
           end
 
-          # Returns true for nodes which otherwise would be counted
-          # as one too many assignment
-          def assignment_doubled_in_ast?(node)
-            node.masgn_type? || node.or_asgn_type? || node.and_asgn_type?
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
           end
 
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
-          # TODO: move to rubocop-ast
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

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,48 @@
+# 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 = begin_pos_with_comment(node)
+        end_pos = end_position_for(node)
+        end_pos += 1 if node.def_type?
+
+        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