rubocop 0.72.0 → 0.76.0

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

@@ -46,7 +46,14 @@ module RuboCop
         end
 
         def class_or_module_scope?(node)
-          node.parent && %i[class module].include?(node.parent.type)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
         end
 
         def visibility_declaration?(node)
@@ -57,9 +64,13 @@ module RuboCop
           end
         end
 
-        def_node_matcher :visibility_declaration_for?, <<-PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} %1))
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
         PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
       end
     end
   end

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

@@ -33,13 +33,7 @@ module RuboCop
         end
 
         def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
+          verify_autocorrect_notice!
 
           lambda do |corrector|
             range = token.nil? ? range_between(0, 0) : token.pos
@@ -57,6 +51,16 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice =~ regex
+
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                         "match Notice /#{notice}/"
+        end
+
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)

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

@@ -45,15 +45,15 @@ module RuboCop
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
-        def_node_matcher :date_time?, <<-PATTERN
+        def_node_matcher :date_time?, <<~PATTERN
           (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
-        def_node_matcher :historic_date?, <<-PATTERN
+        def_node_matcher :historic_date?, <<~PATTERN
           (send _ _ _ (const (const nil? :Date) _))
         PATTERN
 
-        def_node_matcher :to_datetime?, <<-PATTERN
+        def_node_matcher :to_datetime?, <<~PATTERN
           (send _ :to_datetime)
         PATTERN
 

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

@@ -20,7 +20,7 @@ module RuboCop
         MSG = 'Use `__dir__` to get an absolute path to the current ' \
               "file's directory."
 
-        def_node_matcher :dir_replacement?, <<-PATTERN
+        def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
            (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
         PATTERN

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

@@ -47,13 +47,57 @@ module RuboCop
       #   def foo.bar
       #     puts baz
       #   end
+      #
+      # @example RequireForNonPublicMethods: false (default)
+      #   # good
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      # @example RequireForNonPublicMethods: true
+      #   # bad
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
       class DocumentationMethod < Cop
         include DocumentationComment
         include DefNode
 
         MSG = 'Missing method documentation comment.'
 
-        def_node_matcher :module_function_node?, <<-PATTERN
+        def_node_matcher :module_function_node?, <<~PATTERN
           (send nil? :module_function ...)
         PATTERN
 

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects double disable comments on one line. This is mostly to catch
+      # automatically generated comments that need to be regenerated.
+      #
+      # @example
+      #   # bad
+      #   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
+      #   end
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f # rubocop:disable Style/For
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # if both fit on one line
+      #   def f # rubocop:disable Style/For, Metrics/AbcSize
+      #   end
+      #
+      class DoubleCopDisableDirective < Cop
+        # rubocop:enable Style/For, Style/DoubleCopDisableDirective
+        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
+        MSG = 'More than one disable comment on one line.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          prefix = if comment.text.start_with?('# rubocop:disable')
+                     '# rubocop:disable'
+                   else
+                     '# rubocop:todo'
+                   end
+
+          lambda do |corrector|
+            corrector.replace(comment.loc.expression,
+                              comment.text[/#{prefix} \S+/])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :offending_each_range, <<-PATTERN
+        def_node_matcher :offending_each_range, <<~PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN
       end

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+        def_node_matcher :each_with_object_candidate?, <<~PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)
         PATTERN
 

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

@@ -84,8 +84,8 @@ module RuboCop
 
             next unless conditions.size > 1
 
-            range = range_between(conditions.first.loc.expression.begin_pos,
-                                  conditions.last.loc.expression.end_pos)
+            range = range_between(conditions.first.source_range.begin_pos,
+                                  conditions.last.source_range.end_pos)
 
             corrector.replace(range, conditions.map(&:source).join(' || '))
           end

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

@@ -84,8 +84,8 @@ module RuboCop
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].loc.expression.begin_pos - 1,
-                          args[-1].loc.expression.end_pos)
+            range_between(args[0].source_range.begin_pos - 1,
+                          args[-1].source_range.end_pos)
           else
             node.source_range
           end

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

@@ -73,11 +73,11 @@ module RuboCop
         end
 
         def corrected(node)
-          has_parentheses = parentheses?(node.arguments)
-
-          arguments   = node.arguments? ? node.arguments.source : ''
-          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
-          scope       = node.receiver ? "#{node.receiver.source}." : ''
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
 
           signature = [scope, node.method_name, extra_space, arguments].join
 

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

@@ -37,7 +37,7 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
-        def_node_matcher :eval_without_location?, <<-PATTERN
+        def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
             (send nil? :eval ${str dstr} _)
@@ -53,7 +53,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :line_with_offset?, <<-PATTERN
+        def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
             (send (int %2) %1 #special_line_keyword?)

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

@@ -18,7 +18,7 @@ module RuboCop
       class EvenOdd < Cop
         MSG = 'Replace with `Integer#%<method>s?`.'
 
-        def_node_matcher :even_odd_candidate?, <<-PATTERN
+        def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}

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

@@ -51,21 +51,21 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
-        def_node_matcher :file_expand_path, <<-PATTERN
+        def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const nil? :File) :expand_path
             $_
             $_)
         PATTERN
 
-        def_node_matcher :pathname_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
               (send nil? :Pathname
                 $_) :parent) :expand_path)
         PATTERN
 
-        def_node_matcher :pathname_new_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send
               (send
@@ -160,7 +160,7 @@ module RuboCop
         def depth(current_path)
           paths = current_path.split(File::SEPARATOR)
 
-          paths.reject { |path| path == '.' }.count
+          paths.count { |path| path != '.' }
         end
 
         def parent_path(current_path)

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

@@ -42,16 +42,16 @@ module RuboCop
       class FloatDivision < Cop
         include ConfigurableEnforcedStyle
 
-        def_node_matcher :right_coerce?, <<-PATTERN
+        def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN
-        def_node_matcher :left_coerce?, <<-PATTERN
+        def_node_matcher :left_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ _)
         PATTERN
-        def_node_matcher :both_coerce?, <<-PATTERN
+        def_node_matcher :both_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ (send _ :to_f))
         PATTERN
-        def_node_matcher :any_coerce?, <<-PATTERN
+        def_node_matcher :any_coerce?, <<~PATTERN
           {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
         PATTERN
 

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

@@ -40,15 +40,15 @@ module RuboCop
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
 
-        def_node_matcher :formatter, <<-PATTERN
-        {
-          (send nil? ${:sprintf :format} _ _ ...)
-          (send {str dstr} $:% ... )
-          (send !nil? $:% {array hash})
-        }
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
         PATTERN
 
-        def_node_matcher :variable_argument?, <<-PATTERN
+        def_node_matcher :variable_argument?, <<~PATTERN
           (send {str dstr} :% {send_type? lvar_type?})
         PATTERN
 
@@ -94,10 +94,12 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          args = if %i[array hash].include?(node.first_argument.type)
-                   node.first_argument.children.map(&:source).join(', ')
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
                  else
-                   node.first_argument.source
+                   percent_rhs.source
                  end
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
@@ -106,14 +108,15 @@ module RuboCop
         end
 
         def autocorrect_to_percent(corrector, node)
-          format = node.first_argument.source
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
 
-          args = if node.arguments.size == 2
-                   arg = node.arguments.last
+          args = if param_args.one?
+                   arg = param_args.last
 
                    arg.hash_type? ? "{ #{arg.source} }" : arg.source
                  else
-                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                   "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node.loc.expression, "#{format} % #{args}")

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

@@ -8,7 +8,7 @@ module RuboCop
       # **Note:**
       # `unannotated` style cop only works for strings
       # which are passed as arguments to those methods:
-      # `sprintf`, `format`, `%`.
+      # `printf`, `sprintf`, `format`, `%`.
       # The reason is that *unannotated* format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
@@ -41,17 +41,7 @@ module RuboCop
       class FormatStringToken < Cop
         include ConfigurableEnforcedStyle
 
-        FIELD_CHARACTERS = Regexp.union(%w[A B E G X a b c d e f g i o p s u x])
-        FORMAT_STRING_METHODS = %i[sprintf format %].freeze
-
-        STYLE_PATTERNS = {
-          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
-          template: /(?<token>%\{[^\}]+\})/,
-          unannotated: /(?<token>%#{FIELD_CHARACTERS})/
-        }.freeze
-
         def on_str(node)
-          return if placeholder_argument?(node)
           return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
@@ -68,14 +58,16 @@ module RuboCop
 
         private
 
-        def includes_format_methods?(node)
-          node.each_ancestor(:send).any? do |ancestor|
-            FORMAT_STRING_METHODS.include?(ancestor.method_name)
-          end
-        end
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
 
         def unannotated_format?(node, detected_style)
-          detected_style == :unannotated && !includes_format_methods?(node)
+          detected_style == :unannotated &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -102,67 +94,26 @@ module RuboCop
           if source_map.is_a?(Parser::Source::Map::Heredoc)
             source_map.heredoc_body
           elsif source_map.begin
-            slice_source(
-              source_map.expression,
-              source_map.expression.begin_pos + 1,
-              source_map.expression.end_pos - 1
-            )
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
           else
             source_map.expression
           end
         end
 
         def token_ranges(contents)
-          while (offending_match = match_token(contents))
-            detected_style, *range = *offending_match
-            token, contents = split_token(contents, *range)
-            yield(detected_style, token)
-          end
-        end
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-        def match_token(source_range)
-          supported_styles.each do |style_name|
-            pattern = STYLE_PATTERNS.fetch(style_name)
-            match = source_range.source.match(pattern)
-            next unless match
+          format_string.format_sequences.each do |seq|
+            next if seq.percent?
 
-            return [style_name, match.begin(:token), match.end(:token)]
-          end
-
-          nil
-        end
-
-        def split_token(source_range, match_begin, match_end)
-          token =
-            slice_source(
-              source_range,
-              source_range.begin_pos + match_begin,
-              source_range.begin_pos + match_end
-            )
-
-          remainder =
-            slice_source(
-              source_range,
-              source_range.begin_pos + match_end,
-              source_range.end_pos
+            detected_style = seq.style
+            token = contents.begin.adjust(
+              begin_pos: seq.begin_pos,
+              end_pos:   seq.end_pos
             )
 
-          [token, remainder]
-        end
-
-        def slice_source(source_range, new_begin, new_end)
-          Parser::Source::Range.new(
-            source_range.source_buffer,
-            new_begin,
-            new_end
-          )
-        end
-
-        def placeholder_argument?(node)
-          return false unless node.parent
-          return true if node.parent.pair_type?
-
-          placeholder_argument?(node.parent)
+            yield(detected_style, token)
+          end
         end
       end
     end