rubocop 0.75.1 → 0.93.1

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

@@ -26,7 +26,7 @@ module RuboCop
       #     public_constant :BAZ
       #   end
       #
-      class ConstantVisibility < Cop
+      class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
@@ -34,7 +34,8 @@ module RuboCop
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
 
-          add_offense(node)
+          message = message(node)
+          add_offense(node, message: message)
         end
 
         private

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

@@ -8,41 +8,31 @@ module RuboCop
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
       #
-      #     Style/Copyright:
-      #       Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      #  Style/Copyright:
+      #    Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
       #
       # This regex string is treated as an unanchored regex. For each file
       # that RuboCop scans, a comment that matches this regex must be found or
       # an offense is reported.
       #
-      class Copyright < Cop
+      class Copyright < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
                                     'your RuboCop config'
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
+        def on_new_investigation
+          return if notice.empty? || notice_found?(processed_source)
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source),
-                      location: range, message: format(MSG, notice: notice))
-        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
+          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
+            verify_autocorrect_notice!
 
-          lambda do |corrector|
+            token = insert_notice_before(processed_source)
             range = token.nil? ? range_between(0, 0) : token.pos
+
             corrector.insert_before(range, "#{autocorrect_notice}\n")
           end
         end
@@ -57,6 +47,20 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def offense_range
+          source_range(processed_source.buffer, 1, 0)
+        end
+
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice&.match?(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)
@@ -68,14 +72,14 @@ module RuboCop
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && token.text =~ /^#!.*$/
+          token.comment? && /^#!.*$/.match?(token.text)
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
         end
 
         def notice_found?(processed_source)
@@ -84,7 +88,7 @@ module RuboCop
           processed_source.each_token do |token|
             break unless token.comment?
 
-            notice_found = !(token.text =~ notice_regexp).nil?
+            notice_found = notice_regexp.match?(token.text)
             break if notice_found
           end
           notice_found

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

@@ -41,7 +41,9 @@ module RuboCop
       #
       #   # good
       #   something.to_time
-      class DateTime < Cop
+      class DateTime < Base
+        extend AutoCorrector
+
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
@@ -50,7 +52,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const nil? :Date) _))
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         def_node_matcher :to_datetime?, <<~PATTERN
@@ -63,7 +65,10 @@ module RuboCop
           return if historic_date?(node)
 
           message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
-          add_offense(node, message: message)
+
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         private
@@ -71,6 +76,12 @@ module RuboCop
         def disallow_coercion?
           !cop_config['AllowCoercion']
         end
+
+        def autocorrect(corrector, node)
+          return if to_datetime?(node)
+
+          corrector.replace(node.receiver.loc.name, 'Time')
+        end
       end
     end
   end

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

@@ -33,24 +33,22 @@ module RuboCop
       #   def Baz.foo
       #     # does a thing
       #   end
-      class DefWithParentheses < Cop
+      class DefWithParentheses < Base
+        extend AutoCorrector
+
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'
 
         def on_def(node)
           return if node.single_line?
-          return unless !node.arguments? && node.arguments.loc.begin
+          return unless !node.arguments? && (node_arguments_loc_begin = node.arguments.loc.begin)
 
-          add_offense(node.arguments, location: :begin)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+          add_offense(node_arguments_loc_begin) do |corrector|
+            corrector.remove(node_arguments_loc_begin)
+            corrector.remove(node.arguments.loc.end)
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -16,24 +16,22 @@ module RuboCop
       #
       #   # good
       #   path = __dir__
-      class Dir < Cop
-        MSG = 'Use `__dir__` to get an absolute path to the current ' \
-              "file's directory."
+      class Dir < Base
+        extend AutoCorrector
+
+        MSG = "Use `__dir__` to get an absolute path to the current file's directory."
+        RESTRICT_ON_SEND = %i[expand_path dirname].freeze
 
         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?))}
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
         PATTERN
 
         def on_send(node)
           dir_replacement?(node) do
-            add_offense(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, '__dir__')
+            add_offense(node) do |corrector|
+              corrector.replace(node, '__dir__')
+            end
           end
         end
 

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects comments to enable/disable RuboCop.
+      # This is useful if want to make sure that every RuboCop error gets fixed
+      # and not quickly disabled with a comment.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # good
+      #   def fixed_method_name_and_no_rubocop_comments
+      #   end
+      #
+      class DisableCopsWithinSourceCodeDirective < Base
+        extend AutoCorrector
+
+        # rubocop:enable Lint/RedundantCopDisableDirective
+        MSG = 'Comment to disable/enable RuboCop.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless rubocop_directive_comment?(comment)
+
+            add_offense(comment) do |corrector|
+              corrector.replace(comment, '')
+            end
+          end
+        end
+
+        private
+
+        def rubocop_directive_comment?(comment)
+          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for missing top-level documentation of
-      # classes and modules. Classes with no body are exempt from the
-      # check and so are namespace modules - modules that have nothing in
-      # their bodies except classes, other modules, or constant definitions.
+      # This cop checks for missing top-level documentation of classes and
+      # modules. Classes with no body are exempt from the check and so are
+      # namespace modules - modules that have nothing in their bodies except
+      # classes, other modules, constant definitions or constant visibility
+      # declarations.
       #
       # The documentation requirement is annulled if the class or module has
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
@@ -18,19 +19,52 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   module Math
+      #   end
+      #
       #   # good
       #   # Description/Explanation of Person class
       #   class Person
       #     # ...
       #   end
       #
-      class Documentation < Cop
+      #   # allowed
+      #     # Class without body
+      #     class Person
+      #     end
+      #
+      #     # Namespace - A namespace can be a class or a module
+      #     # Containing a class
+      #     module Namespace
+      #       # Description/Explanation of Person class
+      #       class Person
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # Containing constant visibility declaration
+      #     module Namespace
+      #       class Private
+      #       end
+      #
+      #       private_constant :Private
+      #     end
+      #
+      #     # Containing constant definition
+      #     module Namespace
+      #       Public = Class.new
+      #     end
+      #
+      class Documentation < Base
         include DocumentationComment
 
         MSG = 'Missing top-level %<type>s documentation comment.'
 
         def_node_matcher :constant_definition?, '{class module casgn}'
         def_node_search :outer_module, '(const (const nil? _) _)'
+        def_node_matcher :constant_visibility_declaration?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} _))
+        PATTERN
 
         def on_class(node)
           return unless node.body
@@ -50,23 +84,25 @@ module RuboCop
           return if compact_namespace?(node) &&
                     nodoc_comment?(outer_module(node).first)
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, type: type))
+          add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
         def namespace?(node)
           return false unless node
 
           if node.begin_type?
-            node.children.all? { |child| constant_definition?(child) }
+            node.children.all?(&method(:constant_declaration?))
           else
             constant_definition?(node)
           end
         end
 
+        def constant_declaration?(node)
+          constant_definition?(node) || constant_visibility_declaration?(node)
+        end
+
         def compact_namespace?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.loc.name.source)
         end
 
         # First checks if the :nodoc: comment is associated with the
@@ -74,18 +110,18 @@ module RuboCop
         # proceeds to check its ancestors for :nodoc: all.
         # Note: How end-of-line comments are associated with code changed in
         # parser-2.2.0.4.
-        def nodoc_comment?(node, require_all = false)
+        def nodoc_comment?(node, require_all: false)
           return false unless node&.children&.first
 
           nodoc = nodoc(node)
 
-          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all)
+          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all: require_all)
 
-          nodoc_comment?(node.parent, true)
+          nodoc_comment?(node.parent, require_all: true)
         end
 
-        def nodoc?(comment, require_all = false)
-          comment.text =~ /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
+        def nodoc?(comment, require_all: false)
+          /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/.match?(comment.text)
         end
 
         def nodoc(node)

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

@@ -91,7 +91,7 @@ module RuboCop
       #     end
       #   end
       #
-      class DocumentationMethod < Cop
+      class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 # rubocop:disable Style/DoubleCopDisableDirective
 
 module RuboCop
@@ -24,29 +24,26 @@ module RuboCop
       #   def f # rubocop:disable Style/For, Metrics/AbcSize
       #   end
       #
-      class DoubleCopDisableDirective < Cop
+      class DoubleCopDisableDirective < Base
+        extend AutoCorrector
+
         # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
         MSG = 'More than one disable comment on one line.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           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
+            add_offense(comment) do |corrector|
+              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+/])
+              corrector.replace(comment, comment.text[/#{prefix} \S+/])
+            end
           end
         end
       end