rubocop 0.82.0 → 1.18.4

data/lib/rubocop/cop/util.rb

@@ -8,13 +8,18 @@ module RuboCop
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX =
-        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
+      LITERAL_REGEX = %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
 
       module_function
 
+      # This is a bad API
       def comment_line?(line_source)
-        line_source =~ /^\s*#/
+        /^\s*#/.match?(line_source)
+      end
+
+      # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
       def line_range(node)
@@ -22,12 +27,36 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end &&
-          node.loc.end.is?(')')
+        node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
+      end
+
+      def add_parentheses(node, corrector)
+        if !node.respond_to?(:arguments)
+          corrector.wrap(node, '(', ')')
+        elsif node.arguments.empty?
+          corrector.insert_after(node, '()')
+        else
+          args_begin = args_begin(node)
+
+          corrector.remove(args_begin)
+          corrector.insert_before(args_begin, '(')
+          corrector.insert_after(args_end(node), ')')
+        end
+      end
+
+      def args_begin(node)
+        loc = node.loc
+        selector =
+          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector.end.resize(1)
+      end
+
+      def args_end(node)
+        node.loc.expression.end
       end
 
       def on_node(syms, sexp, excludes = [], &block)
-        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
+        return to_enum(:on_node, syms, sexp, excludes) unless block
 
         yield sexp if Array(syms).include?(sexp.type)
         return if Array(excludes).include?(sexp.type)
@@ -36,7 +65,7 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
+        range.source_line.index(/\S/) == range.column
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -64,7 +93,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)
@@ -84,7 +113,7 @@ module RuboCop
       end
 
       def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
       def interpret_string_escapes(string)
@@ -92,28 +121,15 @@ module RuboCop
       end
 
       def same_line?(node1, node2)
-        node1.respond_to?(:loc) &&
-          node2.respond_to?(:loc) &&
-          node1.loc.line == node2.loc.line
+        node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
       end
 
-      def to_supported_styles(enforced_style)
-        enforced_style
-          .sub(/^Enforced/, 'Supported')
-          .sub('Style', 'Styles')
+      def indent(node)
+        ' ' * node.loc.column
       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
-
-        @tokens[node.object_id] = processed_source.tokens.select do |token|
-          token.end_pos <= end_pos && token.begin_pos >= begin_pos
-        end
+      def to_supported_styles(enforced_style)
+        enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
       private

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

@@ -41,8 +41,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos
-          attr_reader :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
 
           def initialize(match)
             @source = match[0]
@@ -73,9 +72,7 @@ module RuboCop
           end
 
           def max_digit_dollar_num
-            @source.scan(DIGIT_DOLLAR).map do |(digit_dollar_num)|
-              digit_dollar_num.to_i
-            end.max
+            @source.scan(DIGIT_DOLLAR).map { |(digit_dollar_num)| digit_dollar_num.to_i }.max
           end
 
           def style
@@ -97,6 +94,10 @@ module RuboCop
           @format_sequences ||= parse
         end
 
+        def valid?
+          !mixed_formats?
+        end
+
         def named_interpolation?
           format_sequences.any?(&:name)
         end
@@ -108,11 +109,23 @@ module RuboCop
         private
 
         def parse
-          @source.to_enum(:scan, SEQUENCE).map do
-            FormatSequence.new(
-              Regexp.last_match
-            )
+          matches = []
+          @source.scan(SEQUENCE) { matches << FormatSequence.new(Regexp.last_match) }
+          matches
+        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

data/lib/rubocop/cop/variable_force.rb

@@ -22,11 +22,12 @@ module RuboCop
     #
     #     def after_declaring_variable(variable, variable_table)
     #     end
+    #
+    # @api private
     class VariableForce < Force # rubocop:disable Metrics/ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
-      VARIABLE_ASSIGNMENT_TYPES =
-        [VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
+      VARIABLE_ASSIGNMENT_TYPES = [VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
 
       ARGUMENT_DECLARATION_TYPES = [
         :arg, :optarg, :restarg,
@@ -36,8 +37,7 @@ module RuboCop
       ].freeze
 
       LOGICAL_OPERATOR_ASSIGNMENT_TYPES = %i[or_asgn and_asgn].freeze
-      OPERATOR_ASSIGNMENT_TYPES =
-        (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
+      OPERATOR_ASSIGNMENT_TYPES = (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
 
       MULTIPLE_ASSIGNMENT_TYPE = :masgn
 
@@ -152,9 +152,7 @@ module RuboCop
       def process_variable_assignment(node)
         name = node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, node)
-        end
+        variable_table.declare_variable(name, node) unless variable_table.variable_exist?(name)
 
         # Need to scan rhs before assignment so that we can mark previous
         # assignments as referenced if rhs has referencing to the variable
@@ -182,9 +180,7 @@ module RuboCop
         process_node(rhs_node)
         process_node(regexp_node)
 
-        variable_names.each do |name|
-          variable_table.assign_to_variable(name, node)
-        end
+        variable_names.each { |name| variable_table.assign_to_variable(name, node) }
 
         skip_children!
       end
@@ -199,7 +195,6 @@ module RuboCop
         regexp.named_captures.keys
       end
 
-      # rubocop:disable Metrics/AbcSize
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -211,9 +206,7 @@ module RuboCop
 
         name = asgn_node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, asgn_node)
-        end
+        variable_table.declare_variable(name, asgn_node) unless variable_table.variable_exist?(name)
 
         # The following statements:
         #
@@ -236,7 +229,6 @@ module RuboCop
 
         skip_children!
       end
-      # rubocop:enable Metrics/AbcSize
 
       def process_variable_multiple_assignment(node)
         lhs_node, rhs_node = *node
@@ -308,17 +300,14 @@ module RuboCop
         return unless method_name == :binding
         return if args && !args.children.empty?
 
-        variable_table.accessible_variables.each do |variable|
-          variable.reference!(node)
-        end
+        variable_table.accessible_variables.each { |variable| variable.reference!(node) }
       end
 
       # Mark all assignments which are referenced in the same loop
       # as referenced by ignoring AST order since they would be referenced
       # in next iteration.
       def mark_assignments_as_referenced_in_loop(node)
-        referenced_variable_names_in_loop, assignment_nodes_in_loop =
-          find_variables_in_loop(node)
+        referenced_variable_names_in_loop, assignment_nodes_in_loop = find_variables_in_loop(node)
 
         referenced_variable_names_in_loop.each do |name|
           variable = variable_table.find_variable(name)
@@ -369,17 +358,13 @@ module RuboCop
           AssignmentReference.new(node)
         when *OPERATOR_ASSIGNMENT_TYPES
           asgn_node = node.children.first
-          if asgn_node.lvasgn_type?
-            VariableReference.new(asgn_node.children.first)
-          end
+          VariableReference.new(asgn_node.children.first) if asgn_node.lvasgn_type?
         end
       end
 
       # Use Node#equal? for accurate check.
       def scanned_node?(node)
-        scanned_nodes.any? do |scanned_node|
-          scanned_node.equal?(node)
-        end
+        scanned_nodes.any? { |scanned_node| scanned_node.equal?(node) }
       end
 
       def scanned_nodes

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

@@ -10,6 +10,7 @@ module RuboCop
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
         attr_reader :node, :variable, :referenced, :references
+
         alias referenced? referenced
 
         def initialize(node, variable)
@@ -65,8 +66,7 @@ module RuboCop
 
         def meta_assignment_node
           unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node =
-              operator_assignment_node || multiple_assignment_node
+            @meta_assignment_node = operator_assignment_node || multiple_assignment_node
           end
 
           @meta_assignment_node

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

@@ -20,8 +20,6 @@ module RuboCop
           nil
         end
 
-        # rubocop:disable Metrics/BlockLength
-
         # Abstract base class for branch classes.
         # A branch represents a conditional branch in a scope.
         #
@@ -42,13 +40,12 @@ module RuboCop
         #     do_something     # no branch
         #   end
         Base = Struct.new(:child_node, :scope) do
-          # rubocop:enable Metrics/BlockLength
-
           def self.classes
             @classes ||= []
           end
 
           def self.inherited(subclass)
+            super
             classes << subclass
           end
 
@@ -81,9 +78,7 @@ module RuboCop
           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
 
             yield self if include_self
             scan_ancestors(&block)
@@ -126,8 +121,7 @@ module RuboCop
           def ==(other)
             return false unless other
 
-            control_node.equal?(other.control_node) &&
-              child_node.equal?(other.child_node)
+            control_node.equal?(other.control_node) && child_node.equal?(other.child_node)
           end
 
           alias_method :eql?, :==
@@ -232,6 +226,21 @@ module RuboCop
           end
         end
 
+        # case target
+        # in pattern # in_pattern
+        # else
+        #   else_body
+        # end
+        class CaseMatch < Base
+          define_predicate :target?,     child_index: 0
+          define_predicate :in_pattern?, child_index: 1..-2
+          define_predicate :else_body?,  child_index: -1
+
+          def always_run?
+            target?
+          end
+        end
+
         # for element in collection
         #   loop_body
         # end

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

@@ -8,9 +8,7 @@ module RuboCop
         include Branchable
 
         VARIABLE_REFERENCE_TYPES = (
-          [VARIABLE_REFERENCE_TYPE] +
-          OPERATOR_ASSIGNMENT_TYPES +
-          [ZERO_ARITY_SUPER_TYPE, SEND_TYPE]
+          [VARIABLE_REFERENCE_TYPE] + OPERATOR_ASSIGNMENT_TYPES + [ZERO_ARITY_SUPER_TYPE, SEND_TYPE]
         ).freeze
 
         attr_reader :node, :scope

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

@@ -16,16 +16,16 @@ module RuboCop
         }.freeze
 
         attr_reader :node, :variables, :naked_top_level
+
         alias naked_top_level? naked_top_level
 
         def initialize(node)
           unless SCOPE_TYPES.include?(node.type)
             # Accept any node type for top level scope
             if node.parent
-              raise ArgumentError,
-                    "Node type must be any of #{SCOPE_TYPES}, " \
-                    "passed #{node.type}"
+              raise ArgumentError, "Node type must be any of #{SCOPE_TYPES}, passed #{node.type}"
             end
+
             @naked_top_level = true
           end
           @node = node
@@ -55,12 +55,11 @@ module RuboCop
         end
 
         def include?(target_node)
-          !belong_to_outer_scope?(target_node) &&
-            !belong_to_inner_scope?(target_node)
+          !belong_to_outer_scope?(target_node) && !belong_to_inner_scope?(target_node)
         end
 
         def each_node(&block)
-          return to_enum(__method__) unless block_given?
+          return to_enum(__method__) unless block
 
           yield node if naked_top_level?
           scan_node(node, &block)
@@ -99,9 +98,7 @@ module RuboCop
         end
 
         def ancestor_node?(target_node)
-          node.each_ancestor.any? do |ancestor_node|
-            ancestor_node.equal?(target_node)
-          end
+          node.each_ancestor.any? { |ancestor_node| ancestor_node.equal?(target_node) }
         end
       end
     end

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

@@ -6,11 +6,10 @@ module RuboCop
       # A Variable represents existence of a local variable.
       # This holds a variable declaration node and some states of the variable.
       class Variable
-        VARIABLE_DECLARATION_TYPES =
-          (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
+        VARIABLE_DECLARATION_TYPES = (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
+
+        attr_reader :name, :declaration_node, :scope, :assignments, :references, :captured_by_block
 
-        attr_reader :name, :declaration_node, :scope,
-                    :assignments, :references, :captured_by_block
         alias captured_by_block? captured_by_block
 
         def initialize(name, declaration_node, scope)
@@ -37,18 +36,16 @@ module RuboCop
           !@references.empty?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branches = Set.new
+          consumed_branches = nil
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branches.include?(assignment.branch)
+            next if consumed_branches&.include?(assignment.branch)
 
-            unless assignment.run_exclusively_with?(reference)
-              assignment.reference!(node)
-            end
+            assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
 
             # Modifier if/unless conditions are special. Assignments made in
             # them do not put the assigned variable in scope to the left of the
@@ -60,11 +57,11 @@ module RuboCop
             break if !assignment.branch || assignment.branch == reference.branch
 
             unless assignment.branch.may_run_incompletely?
-              consumed_branches << assignment.branch
+              (consumed_branches ||= Set.new) << assignment.branch
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def in_modifier_if?(assignment)
           parent = assignment.node.parent