rubocop 0.52.1 → 0.53.0

data/lib/rubocop/cop/style/trailing_body_on_module.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the module definition.
+      #
+      # @example
+      #   # bad
+      #   module Foo extend self
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     extend self
+      #   end
+      #
+      class TrailingBodyOnModule < Cop
+        include Alignment
+        include TrailingBody
+
+        MSG = 'Place the first line of module body on its own line.'.freeze
+
+        def on_module(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.to_a.last))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{trailing_comma_in_literal.rb → trailing_comma_in_array_literal.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing comma in array and hash literals.
+      # This cop checks for trailing comma in array literals.
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -40,8 +40,7 @@ module RuboCop
       #     1,
       #     2
       #   ]
-      class TrailingCommaInLiteral < Cop
-        include ArraySyntax
+      class TrailingCommaInArrayLiteral < Cop
         include TrailingComma
 
         def on_array(node)
@@ -49,26 +48,9 @@ module RuboCop
           check_literal(node, 'item of %<article>s array')
         end
 
-        def on_hash(node)
-          check_literal(node, 'item of %<article>s hash')
-        end
-
         def autocorrect(range)
           PunctuationCorrector.swap_comma(range)
         end
-
-        private
-
-        def check_literal(node, kind)
-          return if node.children.empty?
-          # A braceless hash is the last parameter of a method call and will be
-          # checked as such.
-          return unless brackets?(node)
-
-          check(node, node.children, kind,
-                node.children.last.source_range.end_pos,
-                node.loc.end.begin_pos)
-        end
       end
     end
   end

data/lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in hash literals.
+      #
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2
+      #   }
+      class TrailingCommaInHashLiteral < Cop
+        include TrailingComma
+
+        def on_hash(node)
+          check_literal(node, 'item of %<article>s hash')
+        end
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_method_end_statement.rb

@@ -42,13 +42,13 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node.to_a.last, location: end_token.pos)
+          add_offense(node.to_a.last, location: end_token(node).pos)
         end
 
-        def autocorrect(_node)
+        def autocorrect(node)
           lambda do |corrector|
-            break_line_before_end(corrector)
-            remove_semicolon(corrector)
+            break_line_before_end(node, corrector)
+            remove_semicolon(node, corrector)
           end
         end
 
@@ -57,37 +57,34 @@ module RuboCop
         def trailing_end?(node)
           node.body &&
             node.multiline? &&
-            end_token &&
-            body_and_end_on_same_line?
+            body_and_end_on_same_line?(node)
         end
 
-        def end_token
-          @end_token ||= processed_source.tokens.reverse.find do |token|
-            token.type == :kEND
-          end
+        def end_token(node)
+          @end_token ||= tokens(node).reverse.find(&:end?)
         end
 
-        def body_and_end_on_same_line?
-          end_token.line == token_before_end.line
+        def body_and_end_on_same_line?(node)
+          end_token(node).line == token_before_end(node).line
         end
 
-        def token_before_end
+        def token_before_end(node)
           @token_before_end ||= begin
-            i = processed_source.tokens.index(end_token)
-            processed_source.tokens[i - 1]
+            i = tokens(node).index(end_token(node))
+            tokens(node)[i - 1]
           end
         end
 
-        def break_line_before_end(corrector)
+        def break_line_before_end(node, corrector)
           corrector.insert_before(
-            end_token.pos,
+            end_token(node).pos,
             "\n" + ' ' * configured_indentation_width
           )
         end
 
-        def remove_semicolon(corrector)
-          return unless token_before_end.semicolon?
-          corrector.remove(token_before_end.pos)
+        def remove_semicolon(node, corrector)
+          return unless token_before_end(node).semicolon?
+          corrector.remove(token_before_end(node).pos)
         end
       end
     end

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -24,6 +24,7 @@ module RuboCop
       #   a, b, _something = foo()
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
+        include RangeHelp
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'.freeze

data/lib/rubocop/cop/style/unless_else.rb

@@ -20,6 +20,8 @@ module RuboCop
       #     # do a different thing...
       #   end
       class UnlessElse < Cop
+        include RangeHelp
+
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'.freeze
 

data/lib/rubocop/cop/style/word_array.rb

@@ -36,7 +36,6 @@ module RuboCop
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
-        QUESTION_MARK_SIZE = '?'.size
 
         class << self
           attr_accessor :largest_brackets

data/lib/rubocop/cop/style/yoda_condition.rb

@@ -30,6 +30,7 @@ module RuboCop
       #   3 < a && a < 5
       class YodaCondition < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG = 'Reverse the order of the operands `%<source>s`.'.freeze
 

data/lib/rubocop/cop/team.rb

@@ -164,21 +164,21 @@ module RuboCop
         end
       end
 
-      def handle_warning(e, location)
-        message = Rainbow("#{e.message} (from file: #{location})").yellow
+      def handle_warning(error, location)
+        message = Rainbow("#{error.message} (from file: #{location})").yellow
 
         @warnings << message
         warn message
-        puts e.backtrace if debug?
+        puts error.backtrace if debug?
       end
 
-      def handle_error(e, location, cop)
+      def handle_error(error, location, cop)
         message = Rainbow("An error occurred while #{cop.name}" \
                            " cop was inspecting #{location}.").red
         @errors << message
         warn message
         if debug?
-          puts e.message, e.backtrace
+          puts error.message, error.backtrace
         else
           warn 'To see the complete backtrace run rubocop -d.'
         end

data/lib/rubocop/cop/util.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
@@ -8,8 +7,6 @@ module RuboCop
       include PathUtil
       extend RuboCop::AST::Sexp
 
-      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
-
       EQUALS_ASGN_NODES = %i[lvasgn ivasgn cvasgn gvasgn
                              casgn masgn].freeze
       SHORTHAND_ASGN_NODES = %i[op_asgn or_asgn and_asgn].freeze
@@ -36,33 +33,12 @@ module RuboCop
         OPERATOR_METHODS.include?(symbol)
       end
 
-      def strip_quotes(str)
-        if str[0] == '"' || str[0] == "'"
-          str[0] = ''
-        else
-          # we're dealing with %q or %Q
-          str[0, 3] = ''
-        end
-        str[-1] = ''
-
-        str
-      end
-
       def comment_line?(line_source)
         line_source =~ /^\s*#/
       end
 
-      def line_range(arg)
-        source_range = case arg
-                       when Parser::Source::Range
-                         arg
-                       when Parser::AST::Node
-                         arg.source_range
-                       else
-                         raise ArgumentError, "Invalid argument #{arg}"
-                       end
-
-        source_range.begin.line..source_range.end.line
+      def line_range(node)
+        node.first_line..node.last_line
       end
 
       def parentheses?(node)
@@ -70,10 +46,6 @@ module RuboCop
           node.loc.end.is?(')'.freeze)
       end
 
-      def parenthesized_call?(send)
-        send.loc.begin && send.loc.begin.is?('(')
-      end
-
       def on_node(syms, sexp, excludes = [], &block)
         return to_enum(:on_node, syms, sexp, excludes) unless block_given?
 
@@ -83,106 +55,10 @@ module RuboCop
         sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
       end
 
-      def source_range(source_buffer, line_number, column, length = 1)
-        if column.is_a?(Range)
-          column_index = column.begin
-          length = column.size
-        else
-          column_index = column
-        end
-
-        line_begin_pos = if line_number.zero?
-                           0
-                         else
-                           source_buffer.line_range(line_number).begin_pos
-                         end
-        begin_pos = line_begin_pos + column_index
-        end_pos = begin_pos + length
-
-        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
-      end
-
-      # Returns the column attribute of the range, except if the range is on
-      # the first line and there's a byte order mark at the beginning of that
-      # line, in which case 1 is subtracted from the column value. This gives
-      # the column as it appears when viewing the file in an editor.
-      def effective_column(range)
-        if range.line == 1 &&
-           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
-          range.column - 1
-        else
-          range.column
-        end
-      end
-
-      def range_between(start_pos, end_pos)
-        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
-      end
-
-      def range_with_surrounding_comma(range, side = :both)
-        buffer = @processed_source.buffer
-        src = buffer.source
-
-        go_left, go_right = directions(side)
-
-        begin_pos = range.begin_pos
-        end_pos = range.end_pos
-        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
-        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
-
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
-
-      def range_with_surrounding_space(range:,
-                                       side: :both,
-                                       newlines: true,
-                                       whitespace: false)
-        buffer = @processed_source.buffer
-        src = buffer.source
-
-        go_left, go_right = directions(side)
-
-        begin_pos = range.begin_pos
-        if go_left
-          begin_pos =
-            final_pos(src, begin_pos, -1, newlines, whitespace)
-        end
-        end_pos = range.end_pos
-        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
-
-      def range_by_whole_lines(range, include_final_newline: false)
-        buffer = @processed_source.buffer
-
-        begin_pos = range.begin_pos
-        begin_offset = range.column
-        begin_of_first_line = begin_pos - begin_offset
-
-        last_line = buffer.source_line(range.last_line)
-        end_pos = range.end_pos
-        end_offset = last_line.length - range.last_column
-        end_offset += 1 if include_final_newline
-        end_of_last_line = end_pos + end_offset
-
-        Parser::Source::Range.new(buffer, begin_of_first_line, end_of_last_line)
-      end
-
       def begins_its_line?(range)
         (range.source_line =~ /\S/) == range.column
       end
 
-      def ends_its_line?(range)
-        line = range.source_buffer.source_line(range.last_line)
-        (line =~ /\s*\z/) == range.last_column
-      end
-
-      def within_node?(inner, outer)
-        o = outer.is_a?(AST::Node) ? outer.source_range : outer
-        i = inner.is_a?(AST::Node) ? inner.source_range : inner
-        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
-      end
-
       # Returns, for example, a bare `if` node if the given node is an `if`
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)
@@ -229,51 +105,14 @@ module RuboCop
         end
       end
 
-      def to_symbol_literal(string)
-        if symbol_without_quote?(string)
-          ":#{string}"
-        else
-          ":#{to_string_literal(string)}"
-        end
-      end
-
-      def symbol_without_quote?(string)
-        special_gvars = %w[
-          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
-          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
-        ]
-        redefinable_operators = %w(
-          | ^ & <=> == === =~ > >= < <= << >>
-          + - * / % ** ~ +@ -@ [] []= ` ! != !~
-        )
-
-        # method name
-        string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
-          # instance / class variable
-          string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
-          # global variable
-          string =~ /\A\$[1-9]\d*\z/ ||
-          string =~ /\A\$[a-zA-Z_]\w*\z/ ||
-          special_gvars.include?(string) ||
-          redefinable_operators.include?(string)
-      end
-
       def interpret_string_escapes(string)
         StringInterpreter.interpret(string)
       end
 
-      def same_line?(n1, n2)
-        n1.respond_to?(:loc) &&
-          n2.respond_to?(:loc) &&
-          n1.loc.line == n2.loc.line
-      end
-
-      def precede?(n1, n2)
-        line_distance(n1, n2) == 1
-      end
-
-      def stripped_source_upto(line)
-        processed_source[0..line].map(&:strip)
+      def same_line?(node1, node2)
+        node1.respond_to?(:loc) &&
+          node2.respond_to?(:loc) &&
+          node1.loc.line == node2.loc.line
       end
 
       def to_supported_styles(enforced_style)
@@ -282,37 +121,33 @@ module RuboCop
           .sub('Style', 'Styles')
       end
 
-      private
+      def tokens(node) # rubocop:disable Metrics/AbcSize
+        @tokens ||= {}
+        return @tokens[node.object_id] if @tokens[node.object_id]
 
-      def directions(side)
-        if side == :both
-          [true, true]
-        else
-          [side == :left, side == :right]
+        source_range = node.source_range
+        begin_pos = source_range.begin_pos
+        end_pos = source_range.end_pos
+
+        tokens_to_node_end = processed_source.tokens.take_while do |token|
+          token.end_pos <= end_pos
         end
-      end
 
-      def final_pos(src, pos, increment, newlines, whitespace)
-        pos = move_pos(src, pos, increment, true, /[ \t]/)
-        pos = move_pos(src, pos, increment, newlines, /\n/)
-        move_pos(src, pos, increment, whitespace, /\s/)
-      end
+        node_tokens = []
+        tokens_to_node_end.reverse_each do |token|
+          break unless token.begin_pos >= begin_pos
+          node_tokens.unshift(token)
+        end
 
-      def move_pos(src, pos, step, condition, regexp)
-        offset = step == -1 ? -1 : 0
-        pos += step while condition && src[pos + offset] =~ regexp
-        pos < 0 ? 0 : pos
+        @tokens[node.object_id] = node_tokens
       end
 
+      private
+
       def compatible_external_encoding_for?(src)
         src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
-
-      def line_distance(n1, n2)
-        n2.loc.line - n1.loc.line
-      end
     end
   end
 end
-# rubocop:enable Metrics/ModuleLength