rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/util.rb

@@ -1,81 +1,53 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
     module Util
       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
-      ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
-
-      MODIFIER_NODES = %i[if while until].freeze
-      CONDITIONAL_NODES = (MODIFIER_NODES + [:case]).freeze
-      LOGICAL_OPERATOR_NODES = %i[and or].freeze
-
-      # http://phrogz.net/programmingruby/language.html#table_18.4
-      # Backtick is added last just to help editors parse this code.
-      OPERATOR_METHODS = %w(
-        | ^ & <=> == === =~ > >= < <= << >>
-        + - * / % ** ~ +@ -@ [] []= ! != !~
-      ).map(&:to_sym).push(:'`').freeze
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/
+      LITERAL_REGEX =
+        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
 
       module_function
 
-      def operator?(symbol)
-        OPERATOR_METHODS.include?(symbol)
+      def comment_line?(line_source)
+        /^\s*#/.match?(line_source)
       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
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
-      def block_length(block_node)
-        block_node.loc.end.line - block_node.loc.begin.line
+      def line_range(node)
+        node.first_line..node.last_line
       end
 
-      def comment_line?(line_source)
-        line_source =~ /^\s*#/
+      def parentheses?(node)
+        node.loc.respond_to?(:end) && node.loc.end &&
+          node.loc.end.is?(')')
       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 add_parentheses(node, corrector)
+        if node.arguments.empty?
+          corrector.insert_after(node, '()')
+        else
+          corrector.replace(args_begin(node), '(')
+          corrector.insert_after(args_end(node), ')')
+        end
       end
 
-      def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end &&
-          node.loc.end.is?(')'.freeze)
+      def args_begin(node)
+        loc = node.loc
+        selector =
+          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector.end.resize(1)
       end
 
-      def parenthesized_call?(send)
-        send.loc.begin && send.loc.begin.is?('(')
+      def args_end(node)
+        node.loc.expression.end
       end
 
       def on_node(syms, sexp, excludes = [], &block)
@@ -87,127 +59,19 @@ 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, with_newline = true)
-        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, /[ \t]/)
-        begin_pos = move_pos(src, begin_pos, -1, go_left && with_newline, /\n/)
-        end_pos = move_pos(src, end_pos, 1, go_right, /[ \t]/)
-        end_pos = move_pos(src, end_pos, 1, go_right && with_newline, /\n/)
-        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 move_pos(src, pos, step, condition, regexp)
-        offset = step == -1 ? -1 : 0
-        pos += step while condition && src[pos + offset] =~ regexp
-        pos < 0 ? 0 : pos
-      end
-
-      def directions(side)
-        if side == :both
-          [true, true]
-        else
-          [side == :left, side == :right]
-        end
-      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)
         while node
           case node.type
           when :send
-            receiver, _method_name, _args = *node
-            node = receiver
+            node = node.receiver
           when :block
-            method, _args, _body = *node
-            node = method
+            node = node.send_node
           else
             break
           end
@@ -224,7 +88,7 @@ module RuboCop
 
         # Regex matches IF there is a ' or there is a \\ in the string that is
         # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+        /'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
       end
 
       def needs_escaping?(string)
@@ -243,67 +107,45 @@ 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)
+      def trim_string_interporation_escape_character(str)
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       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
+      def same_line?(node1, node2)
+        node1.respond_to?(:loc) &&
+          node2.respond_to?(:loc) &&
+          node1.loc.line == node2.loc.line
       end
 
-      def line_distance(n1, n2)
-        n2.loc.line - n1.loc.line
+      def to_supported_styles(enforced_style)
+        enforced_style
+          .sub(/^Enforced/, 'Supported')
+          .sub('Style', 'Styles')
       end
 
-      def preceed?(n1, n2)
-        line_distance(n1, n2) == 1
-      end
+      def tokens(node)
+        @tokens ||= {}
+        return @tokens[node.object_id] if @tokens[node.object_id]
+
+        source_range = node.source_range
+        begin_pos = source_range.begin_pos
+        end_pos = source_range.end_pos
 
-      def stripped_source_upto(line)
-        processed_source[0..line].map(&:strip)
+        @tokens[node.object_id] = processed_source.tokens.select do |token|
+          token.end_pos <= end_pos && token.begin_pos >= begin_pos
+        end
       end
 
+      private
+
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
+        src = src.dup if RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
-
-      def to_supported_styles(enforced_style)
-        enforced_style
-          .sub(/^Enforced/, 'Supported')
-          .sub('Style', 'Styles')
-      end
     end
   end
 end

data/lib/rubocop/cop/utils/format_string.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Utils
+      # Parses {Kernel#sprintf} format strings.
+      class FormatString
+        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
+        NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        WIDTH         = /(?<width>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
+        NAME          = /<(?<name>\w+)>/.freeze
+        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+
+        SEQUENCE = /
+            % (?<type>%)
+          | % (?<flags>#{FLAG}*)
+            (?:
+              (?: #{WIDTH}? #{PRECISION}? #{NAME}?
+                | #{WIDTH}? #{NAME} #{PRECISION}?
+                | #{NAME} (?<more_flags>#{FLAG}*) #{WIDTH}? #{PRECISION}?
+              ) #{TYPE}
+              | #{WIDTH}? #{PRECISION}? #{TEMPLATE_NAME}
+            )
+        /x.freeze
+
+        # The syntax of a format sequence is as follows.
+        #
+        # ```
+        # %[flags][width][.precision]type
+        # ```
+        #
+        # A format sequence consists of a percent sign, followed by optional
+        # flags, width, and precision indicators, then terminated with a field
+        # type character.
+        #
+        # For more complex formatting, Ruby supports a reference by name.
+        #
+        # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
+        class FormatSequence
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
+
+          def initialize(match)
+            @source = match[0]
+            @begin_pos = match.begin(0)
+            @end_pos = match.end(0)
+            @flags = match[:flags].to_s + match[:more_flags].to_s
+            @width = match[:width]
+            @precision = match[:precision]
+            @name = match[:name]
+            @type = match[:type]
+          end
+
+          def percent?
+            type == '%'
+          end
+
+          def annotated?
+            name && @source.include?('<')
+          end
+
+          def template?
+            name && @source.include?('{')
+          end
+
+          # Number of arguments required for the format sequence
+          def arity
+            @source.scan('*').count + 1
+          end
+
+          def max_digit_dollar_num
+            @source.scan(DIGIT_DOLLAR).map do |(digit_dollar_num)|
+              digit_dollar_num.to_i
+            end.max
+          end
+
+          def style
+            if annotated?
+              :annotated
+            elsif template?
+              :template
+            else
+              :unannotated
+            end
+          end
+        end
+
+        def initialize(string)
+          @source = string
+        end
+
+        def format_sequences
+          @format_sequences ||= parse
+        end
+
+        def valid?
+          !mixed_formats?
+        end
+
+        def named_interpolation?
+          format_sequences.any?(&:name)
+        end
+
+        def max_digit_dollar_num
+          format_sequences.map(&:max_digit_dollar_num).max
+        end
+
+        private
+
+        def parse
+          @source.to_enum(:scan, SEQUENCE).map do
+            FormatSequence.new(
+              Regexp.last_match
+            )
+          end
+        end
+
+        def mixed_formats?
+          formats = format_sequences.reject(&:percent?).map do |seq|
+            if seq.name
+              :named
+            elsif seq.max_digit_dollar_num
+              :numbered
+            else
+              :unnumbered
+            end
+          end
+
+          formats.uniq.size > 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -9,7 +9,8 @@ module RuboCop
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
-        attr_reader :node, :variable, :referenced
+        attr_reader :node, :variable, :referenced, :references
+
         alias referenced? referenced
 
         def initialize(node, variable)
@@ -22,6 +23,7 @@ module RuboCop
           @node = node
           @variable = variable
           @referenced = false
+          @references = []
         end
 
         def name
@@ -32,7 +34,8 @@ module RuboCop
           @variable.scope
         end
 
-        def reference!
+        def reference!(node)
+          @references << node
           @referenced = true
         end
 
@@ -46,11 +49,13 @@ module RuboCop
 
         def operator_assignment?
           return false unless meta_assignment_node
+
           OPERATOR_ASSIGNMENT_TYPES.include?(meta_assignment_node.type)
         end
 
         def multiple_assignment?
           return false unless meta_assignment_node
+
           meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
         end
 
@@ -74,6 +79,7 @@ module RuboCop
           return nil unless node.parent
           return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
           return nil unless node.sibling_index.zero?
+
           node.parent
         end
 
@@ -82,6 +88,7 @@ module RuboCop
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+
           grandparent_node
         end
       end

data/lib/rubocop/cop/variable_force/branch.rb

@@ -9,8 +9,10 @@ module RuboCop
           ([target_node] + target_node.ancestors).each do |node|
             return nil unless node.parent
             return nil unless scope.include?(node)
+
             klass = CLASSES_BY_TYPE[node.parent.type]
             next unless klass
+
             branch = klass.new(node, scope)
             return branch if branch.branched?
           end
@@ -74,13 +76,12 @@ module RuboCop
 
           def parent
             return @parent if instance_variable_defined?(:@parent)
+
             @branch = Branch.of(control_node, scope: scope)
           end
 
           def each_ancestor(include_self: false, &block)
-            unless block_given?
-              return to_enum(__method__, include_self: include_self)
-            end
+            return to_enum(__method__, include_self: include_self) unless block_given?
 
             yield self if include_self
             scan_ancestors(&block)
@@ -122,6 +123,7 @@ module RuboCop
 
           def ==(other)
             return false unless other
+
             control_node.equal?(other.control_node) &&
               child_node.equal?(other.child_node)
           end

data/lib/rubocop/cop/variable_force/branchable.rb

@@ -8,11 +8,13 @@ module RuboCop
       module Branchable
         def branch
           return @branch if instance_variable_defined?(:@branch)
+
           @branch = Branch.of(node, scope: scope)
         end
 
         def run_exclusively_with?(other)
           return false if !branch || !other.branch
+
           branch.exclusive_with?(other.branch)
         end
       end

data/lib/rubocop/cop/variable_force/scope.rb

@@ -16,6 +16,7 @@ module RuboCop
         }.freeze
 
         attr_reader :node, :variables, :naked_top_level
+
         alias naked_top_level? naked_top_level
 
         def initialize(node)
@@ -37,11 +38,7 @@ module RuboCop
         end
 
         def name
-          # TODO: Add an else clause
-          case @node.type
-          when :def  then @node.children[0]
-          when :defs then @node.children[1]
-          end
+          @node.method_name
         end
 
         def body_node
@@ -65,6 +62,7 @@ module RuboCop
 
         def each_node(&block)
           return to_enum(__method__) unless block_given?
+
           yield node if naked_top_level?
           scan_node(node, &block)
         end
@@ -74,6 +72,7 @@ module RuboCop
         def scan_node(node, &block)
           node.each_child_node do |child_node|
             next unless include?(child_node)
+
             yield child_node
             scan_node(child_node, &block)
           end
@@ -83,16 +82,20 @@ module RuboCop
           return true if !naked_top_level? && target_node.equal?(node)
           return true if ancestor_node?(target_node)
           return false unless target_node.parent.equal?(node)
+
           indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
           return false unless indices
+
           indices.include?(target_node.sibling_index)
         end
 
         def belong_to_inner_scope?(target_node)
           return false if !target_node.parent || target_node.parent.equal?(node)
           return false unless SCOPE_TYPES.include?(target_node.parent.type)
+
           indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
           return true unless indices
+
           !indices.include?(target_node.sibling_index)
         end