rubocop 0.59.2 → 0.60.0

data/lib/rubocop/cop/layout/space_after_method_name.rb

@@ -27,7 +27,7 @@ module RuboCop
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1,
                                                 expr.begin_pos)
-          return unless pos_before_left_paren.source =~ /\s/
+          return unless pos_before_left_paren.source.start_with?(' ')
 
           add_offense(pos_before_left_paren, location: pos_before_left_paren)
         end

data/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -222,7 +222,7 @@ module RuboCop
           node.each_ancestor do |ancestor|
             return true if ancestor.and_type? || ancestor.or_type?
             return false unless ancestor.send_type?
-            return true if operator?(ancestor.method_name)
+            return true if ancestor.operator_method?
           end
           false
         end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -23,6 +23,7 @@ module RuboCop
         include RangeHelp
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
+        EXCESSIVE_SPACE = '  '.freeze
 
         def self.autocorrect_incompatible_with
           [Style::SelfAssignment]
@@ -139,12 +140,12 @@ module RuboCop
         end
 
         def excess_leading_space?(operator, with_space)
-          with_space.source =~ /^  / &&
+          with_space.source.start_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_operator?(operator))
         end
 
         def excess_trailing_space?(right_operand, with_space)
-          with_space.source =~ /  $/ &&
+          with_space.source.end_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_something?(right_operand))
         end
 

data/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb

@@ -18,7 +18,7 @@ module RuboCop
 
         MSG = 'Use only a single space inside array percent literal.'.freeze
         MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
-          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/
+          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')

data/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb

@@ -21,8 +21,8 @@ module RuboCop
         include PercentLiteral
 
         MSG = 'Do not use spaces inside percent literal delimiters.'.freeze
-        BEGIN_REGEX = /\A( +)/
-        END_REGEX = /(?<!\\)( +)\z/
+        BEGIN_REGEX = /\A( +)/.freeze
+        END_REGEX = /(?<!\\)( +)\z/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')

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

@@ -24,11 +24,11 @@ module RuboCop
         include ParserDiagnostic
 
         AMBIGUITIES = {
-          '+'  => { actual: 'positive number', possible: 'addition' },
-          '-'  => { actual: 'negative number', possible: 'subtraction' },
-          '*'  => { actual: 'splat',           possible: 'multiplication' },
-          '&'  => { actual: 'block',           possible: 'binary AND' },
-          '**' => { actual: 'keyword splat',   possible: 'exponent' }
+          '+' => { actual: 'positive number', possible: 'addition' },
+          '-' => { actual: 'negative number', possible: 'subtraction' },
+          '*' => { actual: 'splat',           possible: 'multiplication' },
+          '&' => { actual: 'block',           possible: 'binary AND' },
+          '**' => { actual: 'keyword splat', possible: 'exponent' }
         }.each do |key, hash|
           hash[:operator] = key
         end

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

@@ -31,19 +31,20 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'.freeze
-        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
 
         def on_if(node)
-          check(node)
-        end
+          return if node.condition.block_type?
 
-        def on_while(node)
-          check(node)
-        end
+          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+            next :skip_children if skip_children?(asgn_node)
+            next if allowed_construct?(asgn_node)
 
-        def on_until(node)
-          check(node)
+            add_offense(asgn_node, location: :operator)
+          end
         end
+        alias on_while on_if
+        alias on_until on_if
 
         private
 
@@ -55,17 +56,6 @@ module RuboCop
           end
         end
 
-        def check(node)
-          return if node.condition.block_type?
-
-          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
-            next :skip_children if skip_children?(asgn_node)
-            next if allowed_construct?(asgn_node)
-
-            add_offense(asgn_node, location: :operator)
-          end
-        end
-
         def allowed_construct?(asgn_node)
           asgn_node.begin_type? || conditional_assignment?(asgn_node)
         end
@@ -75,7 +65,7 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && asgn_node.method_name !~ /=\z/) ||
+          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end

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

@@ -4,6 +4,9 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for *return* from an *ensure* block.
+      # Explicit return from an ensure block alters the control flow
+      # as the return will take precedence over any exception being raised,
+      # and the exception will be silently thrown away as if it were rescued.
       #
       # @example
       #

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

@@ -23,14 +23,14 @@ module RuboCop
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'.freeze
         FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/
-        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
+          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/.freeze
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/.freeze
         KERNEL = 'Kernel'.freeze
         SHOVEL = '<<'.freeze
         PERCENT = '%'.freeze
         PERCENT_PERCENT = '%%'.freeze
         STRING_TYPES = %i[str dstr].freeze
-        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
+        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/.freeze
 
         def on_send(node)
           return unless offending_node?(node)

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

@@ -101,7 +101,7 @@ module RuboCop
         def check_node(node)
           if node.send_type? && node.prefix_bang?
             handle_node(node.receiver)
-          elsif LOGICAL_OPERATOR_NODES.include?(node.type)
+          elsif node.operator_keyword?
             node.each_child_node { |op| handle_node(op) }
           elsif node.begin_type? && node.children.one?
             handle_node(node.children.first)

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

@@ -24,8 +24,8 @@ module RuboCop
         include PercentLiteral
 
         QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
-        LEADING_QUOTE = /^['"]/
-        TRAILING_QUOTE = /['"]?,?$/
+        LEADING_QUOTE = /^['"]/.freeze
+        TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
           'unwanted in the resulting strings.'.freeze

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

@@ -41,8 +41,9 @@ module RuboCop
             node.children.each do |child|
               range = child.loc.expression
 
-              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
-              corrector.remove_leading(range, 1) if /^:/ =~ range.source
+              corrector.remove_trailing(range, 1) if range.source.end_with?(',')
+              corrector.remove_leading(range, 1) if
+                range.source.start_with?(':')
             end
           end
         end
@@ -50,16 +51,18 @@ module RuboCop
         private
 
         def contains_colons_or_commas?(node)
-          patterns = [/^:/, /,$/]
           node.children.any? do |child|
-            literal = child.children.first
+            literal = child.children.first.to_s
 
-            # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.to_s.gsub(/[^[[:alnum:]]]/, '').empty?
+            next if non_alphanumeric_literal?(literal)
 
-            patterns.any? { |pat| literal =~ pat }
+            literal.start_with?(':') || literal.end_with?(',')
           end
         end
+
+        def non_alphanumeric_literal?(literal)
+          literal !~ /[[:alnum:]]/
+        end
       end
     end
   end

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

@@ -34,8 +34,7 @@ module RuboCop
           'inside of `&&` and `||`.'.freeze
 
         def on_csend(node)
-          return unless node.parent &&
-                        AST::Node::OPERATOR_KEYWORDS.include?(node.parent.type)
+          return unless node.parent && node.parent.operator_keyword?
 
           check(node)
         end
@@ -72,10 +71,10 @@ module RuboCop
         def top_conditional_ancestor(node)
           parent = node.parent
           unless parent &&
-                 (AST::Node::OPERATOR_KEYWORDS.include?(parent.type) ||
+                 (parent.operator_keyword? ||
                   (parent.begin_type? &&
                    parent.parent &&
-                   AST::Node::OPERATOR_KEYWORDS.include?(parent.parent.type)))
+                   parent.parent.operator_keyword?))
             return node
           end
 

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

@@ -154,8 +154,7 @@ module RuboCop
         def node_within_block_or_conditional?(node, stop_search_node)
           return false if node == stop_search_node
 
-          CONDITIONAL_NODES.include?(node.type) ||
-            node.block_type? ||
+          node.conditional? || node.block_type? ||
             node_within_block_or_conditional?(node.parent, stop_search_node)
         end
 

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # This is actually not a cop and inspects nothing. It just provides
-      # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
+      # This is not actually a cop. It does not inspect anything. It just
+      # provides methods to repack Parser's diagnostics/errors
+      # into RuboCop's offenses.
       class Syntax < Cop
         PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
                                        :end_pos)

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

@@ -4,11 +4,11 @@ module RuboCop
   module Cop
     module Lint
       # This cop identifies places where `URI.escape` can be replaced by
-      # `CGI.escape`, `URI.encode_www_form` or `URI.encode_www_form_component`
+      # `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component`
       # depending on your specific use case.
       # Also this cop identifies places where `URI.unescape` can be replaced by
-      # `CGI.unescape`, `URI.decode_www_form` or `URI.decode_www_form_component`
-      # depending on your specific use case.
+      # `CGI.unescape`, `URI.decode_www_form`,
+      # or `URI.decode_www_form_component` depending on your specific use case.
       #
       # @example
       #   # bad

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

@@ -49,19 +49,16 @@ module RuboCop
 
         private
 
+        def_node_matcher :setter_call_to_local_variable?, <<-PATTERN
+          [(send (lvar _) ...) setter_method?]
+        PATTERN
+
         def last_expression(body)
           expression = body.begin_type? ? body.children : body
 
           expression.is_a?(Array) ? expression.last : expression
         end
 
-        def setter_call_to_local_variable?(node)
-          return unless node && node.send_type?
-          return unless node.receiver && node.receiver.lvar_type?
-
-          node.method_name =~ /(?:\w|\[\])=$/
-        end
-
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.

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

@@ -11,27 +11,11 @@ module RuboCop
 
         MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
               '[%<complexity>.4g/%<max>.4g]'.freeze
-        BRANCH_NODES = %i[send csend].freeze
-        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
         private
 
         def complexity(node)
-          assignment = 0
-          branch = 0
-          condition = 0
-
-          node.each_node do |child|
-            if child.assignment?
-              assignment += 1
-            elsif BRANCH_NODES.include?(child.type)
-              branch += 1
-            elsif CONDITION_NODES.include?(child.type)
-              condition += 1
-            end
-          end
-
-          Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
+          Utils::AbcSizeCalculator.calculate(node)
         end
       end
     end

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

@@ -29,17 +29,18 @@ module RuboCop
           config.for_cop('Layout/Tab')['IndentationWidth']
         end
 
+        def indentation_difference(line)
+          return 0 unless tab_indentation_width
+
+          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+        end
+
         def line_length(line)
-          if tab_indentation_width
-            line = line.gsub("\t", ' ' * tab_indentation_width)
-          end
-          line.length
+          line.length + indentation_difference(line)
         end
 
         def highligh_start(line)
-          return max unless tab_indentation_width
-
-          max - (tab_indentation_width - 1) * line.count("\t")
+          max - indentation_difference(line)
         end
 
         def check_line(line, index, heredocs)
@@ -123,15 +124,18 @@ module RuboCop
 
         def allowed_uri_position?(line, uri_range)
           uri_range.begin < max &&
-            (uri_range.end == line.length ||
-             uri_range.end == line.length - 1)
+            (uri_range.end == line_length(line) ||
+             uri_range.end == line_length(line) - 1)
         end
 
         def find_excessive_uri_range(line)
           last_uri_match = match_uris(line).last
           return nil unless last_uri_match
 
-          begin_position, end_position = last_uri_match.offset(0)
+          begin_position, end_position =
+            last_uri_match.offset(0).map do |pos|
+              pos + indentation_difference(line)
+            end
           return nil if begin_position < max && end_position < max
 
           begin_position...end_position

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # > ABC is .. a software size metric .. computed by counting the number
+        # > of assignments, branches and conditions for a section of code.
+        # > http://c2.com/cgi/wiki?AbcMetric
+        #
+        # We separate the *calculator* from the *cop* so that the calculation,
+        # the formula itself, is easier to test.
+        module AbcSizeCalculator
+          # > Branch -- an explicit forward program branch out of scope -- a
+          # > function call, class method call ..
+          # > http://c2.com/cgi/wiki?AbcMetric
+          BRANCH_NODES = %i[send csend].freeze
+
+          # > Condition -- a logical/Boolean test, == != <= >= < > else case
+          # > default try catch ? and unary conditionals.
+          # > http://c2.com/cgi/wiki?AbcMetric
+          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+
+          def self.calculate(node)
+            assignment = 0
+            branch = 0
+            condition = 0
+
+            node.each_node do |child|
+              if child.assignment?
+                assignment += 1
+              elsif BRANCH_NODES.include?(child.type)
+                branch += 1
+              elsif CONDITION_NODES.include?(child.type)
+                condition += 1
+              end
+            end
+
+            Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,17 @@ module RuboCop
   module Cop
     # Common functionality for checking assignment nodes.
     module CheckAssignment
-      Util::ASGN_NODES.each do |type|
-        define_method("on_#{type}") do |node|
-          check_assignment(node, extract_rhs(node))
-        end
+      def on_lvasgn(node)
+        check_assignment(node, extract_rhs(node))
       end
+      alias on_ivasgn   on_lvasgn
+      alias on_cvasgn   on_lvasgn
+      alias on_gvasgn   on_lvasgn
+      alias on_casgn    on_lvasgn
+      alias on_masgn    on_lvasgn
+      alias on_op_asgn  on_lvasgn
+      alias on_or_asgn  on_lvasgn
+      alias on_and_asgn on_lvasgn
 
       def on_send(node)
         rhs = extract_rhs(node)
@@ -25,10 +31,10 @@ module RuboCop
           _scope, _lhs, rhs = *node
         elsif node.op_asgn_type?
           _lhs, _op, rhs = *node
-        elsif Util::ASGN_NODES.include?(node.type)
-          _lhs, rhs = *node
         elsif node.send_type?
           rhs = node.last_argument
+        elsif node.assignment?
+          _lhs, rhs = *node
         end
 
         rhs