rubocop 0.51.0 → 0.87.0

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

@@ -7,6 +7,10 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
+      # In addition it checks whether different formats are used in the same
+      # format string. Do not mix numbered, unnumbered, and named formats in
+      # the same format string.
+      #
       # @example
       #
       #   # bad
@@ -18,21 +22,37 @@ module RuboCop
       #   # good
       #
       #   format('A value: %s and another: %i', a_value, another)
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
-        MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
-              'fields (%i).'.freeze
-        FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/
-        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
-        KERNEL = 'Kernel'.freeze
-        SHOVEL = '<<'.freeze
-        PERCENT = '%'.freeze
-        PERCENT_PERCENT = '%%'.freeze
+        MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
+              'match the number of fields (%<field_num>i).'
+        MSG_INVALID = 'Format string is invalid because formatting sequence types ' \
+                      '(numbered, named or unnumbered) are mixed.'
+
+        KERNEL = 'Kernel'
+        SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
-        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
 
         def on_send(node)
+          return unless format_string?(node)
+
+          if invalid_format_string?(node)
+            add_offense(node, location: :selector, message: MSG_INVALID)
+            return
+          end
+
           return unless offending_node?(node)
 
           add_offense(node, location: :selector)
@@ -40,52 +60,50 @@ module RuboCop
 
         private
 
+        def format_string?(node)
+          called_on_string?(node) && method_with_format_args?(node)
+        end
+
+        def invalid_format_string?(node)
+          string = if sprintf?(node) || format?(node)
+                     node.first_argument.source
+                   else
+                     node.receiver.source
+                   end
+          !RuboCop::Cop::Utils::FormatString.new(string).valid?
+        end
+
         def offending_node?(node)
-          return false unless called_on_string?(node)
-          return false unless method_with_format_args?(node)
-          return false if named_mode?(node) || splat_args?(node)
+          return false if splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
           return false if num_of_format_args == :unknown
+
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
 
         def matched_arguments_count?(expected, passed)
-          if passed < 0
+          if passed.negative?
             expected < passed.abs
           else
             expected != passed
           end
         end
 
-        def called_on_string?(node)
-          receiver_node, _method, format_string, = *node
-          if receiver_node.nil? || receiver_node.const_type?
-            format_string && format_string.str_type?
-          else
-            receiver_node.str_type?
-          end
-        end
+        def_node_matcher :called_on_string?, <<~PATTERN
+          {(send {nil? const_type?} _ (str _) ...)
+           (send (str ...) ...)}
+        PATTERN
 
         def method_with_format_args?(node)
           sprintf?(node) || format?(node) || percent?(node)
         end
 
-        def named_mode?(node)
-          relevant_node = if sprintf?(node) || format?(node)
-                            node.first_argument
-                          elsif percent?(node)
-                            node.receiver
-                          end
-
-          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
-        end
-
         def splat_args?(node)
           return false if percent?(node)
 
-          node.arguments.butfirst.any?(&:splat_type?)
+          node.arguments.drop(1).any?(&:splat_type?)
         end
 
         def heredoc?(node)
@@ -129,18 +147,17 @@ module RuboCop
 
         def expected_fields_count(node)
           return :unknown unless node.str_type?
-          return 1 if node.source =~ NAMED_INTERPOLATION
 
-          node
-            .source
-            .scan(FIELD_REGEX)
-            .reject { |x| x.first == PERCENT_PERCENT }
-            .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
-        end
+          format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
+          return 1 if format_string.named_interpolation?
+
+          max_digit_dollar_num = format_string.max_digit_dollar_num
+          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
 
-        # number of arguments required for the format sequence
-        def arguments_count(format)
-          format.scan('*').count + 1
+          format_string
+            .format_sequences
+            .reject(&:percent?)
+            .reduce(0) { |acc, seq| acc + seq.arity }
         end
 
         def format?(node)
@@ -169,7 +186,8 @@ module RuboCop
 
           method_name = node.method?(:%) ? 'String#%' : node.method_name
 
-          format(MSG, num_args_for_format, method_name, num_expected_fields)
+          format(MSG, arg_num: num_args_for_format, method: method_name,
+                      field_num: num_expected_fields)
         end
       end
     end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the ordering of a method call where
+      # the receiver of the call is a HEREDOC.
+      #
+      # @example
+      #   # bad
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #      .trim
+      #
+      #   # good
+      #
+      #      <<~SQL
+      #        bar
+      #      SQL
+      #
+      #      <<~SQL.trim
+      #        bar
+      #      SQL
+      #
+      class HeredocMethodCallPosition < Cop
+        include RangeHelp
+
+        MSG = 'Put a method call with a HEREDOC receiver on the ' \
+        'same line as the HEREDOC opening.'
+
+        def on_send(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+          return unless heredoc
+          return if correctly_positioned?(node, heredoc)
+
+          add_offense(node, location: call_after_heredoc_range(heredoc))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+
+          lambda do |corrector|
+            call_range = call_range_to_safely_reposition(node, heredoc)
+            return if call_range.nil?
+
+            call_source = call_range.source.strip
+            corrector.remove(call_range)
+            corrector.insert_after(heredoc_begin_line_range(node), call_source)
+          end
+        end
+
+        private
+
+        def heredoc_node_descendent_receiver(node)
+          while send_node?(node)
+            return node.receiver if heredoc_node?(node.receiver)
+
+            node = node.receiver
+          end
+        end
+
+        def send_node?(node)
+          return nil unless node
+
+          node.call_type?
+        end
+
+        def heredoc_node?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def call_after_heredoc_range(heredoc)
+          pos = heredoc_end_pos(heredoc)
+          range_between(pos + 1, pos + 2)
+        end
+
+        def correctly_positioned?(node, heredoc)
+          heredoc_end_pos(heredoc) > call_end_pos(node)
+        end
+
+        def calls_on_multiple_lines?(node, _heredoc)
+          last_line = node.last_line
+          while send_node?(node)
+            return true unless last_line == node.last_line
+            return true unless all_on_same_line?(node.arguments)
+
+            node = node.receiver
+          end
+          false
+        end
+
+        def all_on_same_line?(nodes)
+          return true if nodes.empty?
+
+          nodes.first.first_line == nodes.last.last_line
+        end
+
+        def heredoc_end_pos(heredoc)
+          heredoc.location.heredoc_end.end_pos
+        end
+
+        def call_end_pos(node)
+          node.source_range.end_pos
+        end
+
+        def heredoc_begin_line_range(heredoc)
+          pos = heredoc.source_range.begin_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        def call_line_range(node)
+          pos = node.source_range.end_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        # Returns nil if no range can be safely repositioned.
+        def call_range_to_safely_reposition(node, heredoc)
+          return nil if calls_on_multiple_lines?(node, heredoc)
+
+          heredoc_end_pos = heredoc_end_pos(heredoc)
+          call_end_pos = call_end_pos(node)
+
+          call_range = range_between(heredoc_end_pos, call_end_pos)
+          call_line_range = call_line_range(node)
+
+          call_source = call_range.source.strip
+          call_line_source = call_line_range.source.strip
+
+          return call_range if call_source == call_line_source
+
+          if trailing_comma?(call_source, call_line_source)
+            # If there's some on the last line other than the call, e.g.
+            # a trailing comma, then we leave the "\n" following the
+            # heredoc_end in place.
+            return range_between(heredoc_end_pos, call_end_pos + 1)
+          end
+
+          nil
+        end
+
+        def trailing_comma?(call_source, call_line_source)
+          call_source + ',' == call_line_source
+        end
+      end
+    end
+  end
+end

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

@@ -23,20 +23,22 @@ module RuboCop
       #     'Item 2'
       #   ]
       class ImplicitStringConcatenation < Cop
-        MSG = 'Combine %s and %s into a single string literal, rather than ' \
-              'using implicit string concatenation.'.freeze
+        MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
+              'literal, rather than using implicit string concatenation.'
         FOR_ARRAY = ' Or, if they were intended to be separate array ' \
-                    'elements, separate them with a comma.'.freeze
+                    'elements, separate them with a comma.'
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
-                     'arguments, separate them with a comma.'.freeze
+                     'arguments, separate them with a comma.'
 
         def on_dstr(node)
-          each_bad_cons(node) do |child1, child2|
-            range   = child1.source_range.join(child2.source_range)
-            message = format(MSG, display_str(child1), display_str(child2))
-            if node.parent && node.parent.array_type?
+          each_bad_cons(node) do |child_node1, child_node2|
+            range   = child_node1.source_range.join(child_node2.source_range)
+            message = format(MSG,
+                             string1: display_str(child_node1),
+                             string2: display_str(child_node2))
+            if node.parent&.array_type?
               message << FOR_ARRAY
-            elsif node.parent && node.parent.send_type?
+            elsif node.parent&.send_type?
               message << FOR_METHOD
             end
             add_offense(node, location: range, message: message)
@@ -46,17 +48,17 @@ module RuboCop
         private
 
         def each_bad_cons(node)
-          node.children.each_cons(2) do |child1, child2|
+          node.children.each_cons(2) do |child_node1, child_node2|
             # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
-            next unless string_literal?(child1) && string_literal?(child2)
-            next unless child1.loc.last_line == child2.loc.line
+            next unless string_literals?(child_node1, child_node2)
+            next unless child_node1.last_line == child_node2.first_line
 
             # Make sure we don't flag a string literal which simply has
             # embedded newlines
             # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
-            next unless child1.source[-1] == ending_delimiter(child1)
+            next unless child_node1.source[-1] == ending_delimiter(child_node1)
 
-            yield child1, child2
+            yield child_node1, child_node2
           end
         end
 
@@ -74,8 +76,12 @@ module RuboCop
             (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
         end
 
+        def string_literals?(node1, node2)
+          string_literal?(node1) && string_literal?(node2)
+        end
+
         def display_str(node)
-          if node.source =~ /\n/
+          if /\n/.match?(node.source)
             str_content(node).inspect
           else
             node.source

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

@@ -46,14 +46,14 @@ module RuboCop
       #     end
       #   end
       class IneffectiveAccessModifier < Cop
-        MSG = '`%s` (on line %d) does not make singleton methods %s. ' \
-              'Use %s instead.'.freeze
+        MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
+              'methods %<modifier>s. Use %<alternative>s instead.'
         ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
-                              '`class << self` block'.freeze
+                              '`class << self` block'
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
-                                'block'.freeze
+                                'block'
 
-        def_node_matcher :private_class_method, <<-PATTERN
+        def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN
 
@@ -67,81 +67,59 @@ module RuboCop
 
         private
 
-        def clear
-          @useless = {}
-          @last_access_modifier = nil
-        end
-
         def check_node(node)
-          return unless node && node.begin_type?
+          return unless node&.begin_type?
 
-          clear
-          check_scope(node)
+          ignored_methods = private_class_method_names(node)
 
-          @useless.each do |_name, (defs_node, visibility, modifier)|
+          ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
             add_offense(defs_node,
                         location: :keyword,
-                        message: format_message(visibility, modifier))
+                        message: format_message(modifier))
           end
         end
 
-        def format_message(visibility, modifier)
+        def private_class_method_names(node)
+          private_class_methods(node).to_a.flatten
+                                     .select(&:basic_literal?)
+                                     .map(&:value)
+        end
+
+        def format_message(modifier)
+          visibility = modifier.method_name
           alternative = if visibility == :private
                           ALTERNATIVE_PRIVATE
                         else
                           ALTERNATIVE_PROTECTED
                         end
-          format(MSG, visibility, modifier.location.expression.line, visibility,
-                 alternative)
-        end
-
-        def check_scope(node, cur_vis = :public)
-          node.children.reduce(cur_vis) do |visibility, child|
-            check_child_scope(child, visibility)
-          end
+          format(MSG, modifier: visibility,
+                      line: modifier.location.expression.line,
+                      alternative: alternative)
         end
 
-        def check_child_scope(node, cur_vis)
-          case node.type
-          when :send
-            cur_vis = check_send(node, cur_vis)
-          when :defs
-            check_defs(node, cur_vis)
-          when :kwbegin
-            check_scope(node, cur_vis)
+        def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
+          node.each_child_node do |child|
+            case child.type
+            when :send
+              modifier = child if access_modifier?(child)
+            when :defs
+              next if correct_visibility?(child, modifier, ignored_methods)
+
+              yield child, modifier
+            when :kwbegin
+              ineffective_modifier(child, ignored_methods, modifier, &block)
+            end
           end
-
-          cur_vis
         end
 
-        def check_send(node, cur_vis)
-          if node.access_modifier? && !node.method?(:module_function)
-            @last_access_modifier = node
-            return node.method_name
-          elsif (methods = private_class_method(node))
-            # don't warn about defs nodes which are followed by a call to
-            # `private_class_method :name`
-            # obviously the programmer knows what they are doing
-            revert_method_uselessness(methods)
-          end
-
-          cur_vis
+        def access_modifier?(node)
+          node.bare_access_modifier? && !node.method?(:module_function)
         end
 
-        def check_defs(node, cur_vis)
-          mark_method_as_useless(node, cur_vis) if cur_vis != :public
-        end
+        def correct_visibility?(node, modifier, ignored_methods)
+          return true if modifier.nil? || modifier.method?(:public)
 
-        def mark_method_as_useless(node, cur_vis)
-          _, method_name, = *node
-          @useless[method_name] = [node, cur_vis, @last_access_modifier]
-        end
-
-        def revert_method_uselessness(methods)
-          methods.each do |sym|
-            next unless sym.sym_type?
-            @useless.delete(sym.children[0])
-          end
+          ignored_methods.include?(node.method_name)
         end
       end
     end

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

@@ -8,31 +8,35 @@ module RuboCop
       # `StandardError`. It is configurable to suggest using either
       # `RuntimeError` (default) or `StandardError` instead.
       #
-      # @example
-      #
+      # @example EnforcedStyle: runtime_error (default)
       #   # bad
       #
       #   class C < Exception; end
       #
-      # @example
-      #
-      #   # EnforcedStyle: runtime_error (default)
+      #   C = Class.new(Exception)
       #
       #   # good
       #
       #   class C < RuntimeError; end
       #
-      # @example
+      #   C = Class.new(RuntimeError)
+      #
+      # @example EnforcedStyle: standard_error
+      #   # bad
+      #
+      #   class C < Exception; end
       #
-      #   # EnforcedStyle: standard_error
+      #   C = Class.new(Exception)
       #
       #   # good
       #
       #   class C < StandardError; end
+      #
+      #   C = Class.new(StandardError)
       class InheritException < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Inherit from `%s` instead of `%s`.'.freeze
+        MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
@@ -51,26 +55,38 @@ module RuboCop
           SystemExit
         ].freeze
 
-        def on_class(node)
-          _class, base_class, _body = *node
+        def_node_matcher :class_new_call?, <<~PATTERN
+          (send
+            (const {cbase nil?} :Class) :new
+            $(const {cbase nil?} _))
+        PATTERN
 
-          return unless base_class && illegal_class_name?(base_class)
+        def on_class(node)
+          return unless node.parent_class &&
+                        illegal_class_name?(node.parent_class)
 
-          add_offense(base_class)
+          add_offense(node.parent_class)
         end
 
-        private
+        def on_send(node)
+          constant = class_new_call?(node)
+          return unless constant && illegal_class_name?(constant)
 
-        def message(node)
-          format(MSG, preferred_base_class, node.const_name)
+          add_offense(constant)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, preferred_base_class)
+            corrector.replace(node, preferred_base_class)
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, prefer: preferred_base_class, current: node.const_name)
+        end
+
         def illegal_class_name?(class_node)
           ILLEGAL_CLASSES.include?(class_node.const_name)
         end

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

@@ -18,15 +18,31 @@ module RuboCop
       #   foo = "something with #{interpolation} inside"
       class InterpolationCheck < Cop
         MSG = 'Interpolation in single quoted string detected. '\
-	      'Use double quoted strings if you need interpolation.'.freeze
+              'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
           return if heredoc?(node)
-          return if node.parent && node.parent.dstr_type?
-          return unless node.str_content.scrub =~ /#\{.*\}/
+
+          parent = node.parent
+          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless /(?<!\\)#\{.*\}/.match?(node.source.scrub)
+
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            starting_token, ending_token = if node.source.include?('"')
+                                             ['%{', '}']
+                                           else
+                                             ['"', '"']
+                                           end
+
+            corrector.replace(node.loc.begin, starting_token)
+            corrector.replace(node.loc.end, ending_token)
+          end
+        end
+
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) ||
             (node.parent && heredoc?(node.parent))