rubocop 0.51.0 → 0.87.0

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

@@ -6,27 +6,39 @@ module RuboCop
       # Check that a copyright notice was given in each source file.
       #
       # The default regexp for an acceptable copyright notice can be found in
-      # config/default.yml.  The default can be changed as follows:
+      # 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
+      # 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
-        MSG = 'Include a copyright notice matching /%s/ before ' \
-              'any code.'.freeze
-        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
-                                    'your RuboCop config'.freeze
+        include RangeHelp
+
+        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)
+
           range = source_range(processed_source.buffer, 1, 0)
           add_offense(insert_notice_before(processed_source),
-                      location: range, message: MSG % notice)
+                      location: range, message: format(MSG, notice: notice))
+        end
+
+        def autocorrect(token)
+          verify_autocorrect_notice!
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
         end
 
         private
@@ -39,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&.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)
@@ -48,41 +70,29 @@ module RuboCop
 
         def shebang_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
+
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT && 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.type == :tCOMMENT &&
-            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)
           notice_found = false
           notice_regexp = Regexp.new(notice)
-          processed_source.tokens.each do |token|
-            break unless token.type == :tCOMMENT
-            notice_found = !(token.text =~ notice_regexp).nil?
+          processed_source.each_token do |token|
+            break unless token.comment?
+
+            notice_found = notice_regexp.match?(token.text)
             break if notice_found
           end
           notice_found
         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
-
-          lambda do |corrector|
-            range = token.nil? ? range_between(0, 0) : token.pos
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
-          end
-        end
       end
     end
   end

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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `DateTime` that should be replaced by
-      # `Date` or `Time`.
+      # This cop checks for consistent usage of the `DateTime` class over the
+      # `Time` class. This cop is disabled by default since these classes,
+      # although highly overlapping, have particularities that make them not
+      # replaceable in certain situations when dealing with multiple timezones
+      # and/or DST.
       #
       # @example
       #
@@ -17,26 +20,56 @@ module RuboCop
       #   # bad - uses `DateTime` for modern date
       #   DateTime.iso8601('2016-06-29')
       #
-      #   # good - uses `Date` for modern date
-      #   Date.iso8601('2016-06-29')
+      #   # good - uses `Time` for modern date
+      #   Time.iso8601('2016-06-29')
       #
       #   # good - uses `DateTime` with start argument for historical date
       #   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+      #
+      # @example AllowCoercion: false (default)
+      #
+      #   # bad - coerces to `DateTime`
+      #   something.to_datetime
+      #
+      #   # good - coerces to `Time`
+      #   something.to_time
+      #
+      # @example AllowCoercion: true
+      #
+      #   # good
+      #   something.to_datetime
+      #
+      #   # good
+      #   something.to_time
       class DateTime < Cop
-        MSG = 'Prefer Date or Time over DateTime.'.freeze
+        CLASS_MSG = 'Prefer Time over DateTime.'
+        COERCION_MSG = 'Do not use #to_datetime.'
 
-        def_node_matcher :date_time?, <<-PATTERN
-          (send (const _ :DateTime) ...)
+        def_node_matcher :date_time?, <<~PATTERN
+          (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
-        def_node_matcher :historic_date?, <<-PATTERN
-          (send _ _ _ (const (const _ :Date) _))
+        def_node_matcher :historic_date?, <<~PATTERN
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+        PATTERN
+
+        def_node_matcher :to_datetime?, <<~PATTERN
+          (send _ :to_datetime)
         PATTERN
 
         def on_send(node)
-          return unless date_time?(node)
+          return unless date_time?(node) ||
+                        (to_datetime?(node) && disallow_coercion?)
           return if historic_date?(node)
-          add_offense(node)
+
+          message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def disallow_coercion?
+          !cop_config['AllowCoercion']
         end
       end
     end

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

@@ -6,9 +6,36 @@ module RuboCop
       # This cop checks for parentheses in the definition of a method,
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     # does a thing
+      #   end
+      #
+      #   # also good
+      #   def foo() does_a_thing end
+      #
+      # @example
+      #
+      #   # bad
+      #   def Baz.foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def Baz.foo
+      #     # does a thing
+      #   end
       class DefWithParentheses < Cop
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
-              'any arguments.'.freeze
+              'any arguments.'
 
         def on_def(node)
           return if node.single_line?
@@ -18,8 +45,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.loc.begin)

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

@@ -18,11 +18,11 @@ module RuboCop
       #   path = __dir__
       class Dir < Cop
         MSG = 'Use `__dir__` to get an absolute path to the current ' \
-              "file's directory.".freeze
+              "file's directory."
 
-        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?))}
+        def_node_matcher :dir_replacement?, <<~PATTERN
+          {(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)
@@ -31,14 +31,14 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, '__dir__')
+            corrector.replace(node, '__dir__')
           end
         end
 
+        private
+
         def file_keyword?(node)
           node.str_type? && node.source_range.is?('__FILE__')
         end

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

@@ -0,0 +1,49 @@
+# 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 < Cop
+        # rubocop:enable Lint/RedundantCopDisableDirective
+        MSG = 'Comment to disable/enable RuboCop.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless rubocop_directive_comment?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          lambda do |corrector|
+            corrector.replace(comment, '')
+          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,33 +3,77 @@
 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
       # same for all its children.
+      #
+      # @example
+      #   # bad
+      #   class Person
+      #     # ...
+      #   end
+      #
+      #   module Math
+      #   end
+      #
+      #   # good
+      #   # Description/Explanation of Person class
+      #   class Person
+      #     # ...
+      #   end
+      #
+      #   # 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 < Cop
         include DocumentationComment
 
-        MSG = 'Missing top-level %s documentation comment.'.freeze
+        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)
-          _, _, body = *node
-
-          return unless body
+          return unless node.body
 
-          check(node, body, :class)
+          check(node, node.body, :class)
         end
 
         def on_module(node)
-          _, body = *node
-
-          check(node, body, :module)
+          check(node, node.body, :module)
         end
 
         private
@@ -37,27 +81,39 @@ module RuboCop
         def check(node, body, type)
           return if namespace?(body)
           return if documentation_comment?(node) || nodoc_comment?(node)
+          return if compact_namespace?(node) &&
+                    nodoc_comment?(outer_module(node).first)
 
-          add_offense(node, location: :keyword, message: format(MSG, type))
+          add_offense(node,
+                      location: :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)
+          /::/.match?(node.loc.name.source)
+        end
+
         # First checks if the :nodoc: comment is associated with the
         # class/module. Unless the element is tagged with :nodoc:, the search
         # 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)
-          return false unless node && node.children.first
+          return false unless node&.children&.first
 
           nodoc = nodoc(node)
 
@@ -67,7 +123,7 @@ module RuboCop
         end
 
         def nodoc?(comment, require_all = false)
-          comment.text =~ /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
+          /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/.match?(comment.text)
         end
 
         def nodoc(node)

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

@@ -47,14 +47,63 @@ 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.'.freeze
+        MSG = 'Missing method documentation comment.'
+
+        def_node_matcher :module_function_node?, <<~PATTERN
+          (send nil? :module_function ...)
+        PATTERN
 
         def on_def(node)
-          check(node)
+          parent = node.parent
+          module_function_node?(parent) ? check(parent) : check(node)
         end
         alias on_defs on_def
 

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,
+                              comment.text[/#{prefix} \S+/])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,32 +3,69 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of double negation (!!) to convert something
-      # to a boolean value. As this is both cryptic and usually redundant, it
-      # should be avoided.
+      # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
-      # @example
+      # When using `EnforcedStyle: allowed_in_returns`, allow double nagation in contexts
+      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double nagation
+      # should be forbidden always.
       #
+      # @example
       #   # bad
       #   !!something
       #
       #   # good
       #   !something.nil?
       #
+      # @example EnforcedStyle: allowed_in_returns (default)
+      #   # good
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
       # Please, note that when something is a boolean value
       # !!something and !something.nil? are not the same thing.
       # As you're unlikely to write code that can accept values of any type
       # this is rarely a problem in practice.
       class DoubleNegation < Cop
-        MSG = 'Avoid the use of double negation (`!!`).'.freeze
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Avoid the use of double negation (`!!`).'
 
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)
-          return unless double_negative?(node) && node.keyword_bang?
+          return unless double_negative?(node) && node.prefix_bang?
+          return if style == :allowed_in_returns && allowed_in_returns?(node)
 
           add_offense(node, location: :selector)
         end
+
+        private
+
+        def allowed_in_returns?(node)
+          node.parent&.return_type? || end_of_method_definition?(node)
+        end
+
+        def end_of_method_definition?(node)
+          return false unless (def_node = find_def_node_from_ascendant(node))
+
+          last_child = def_node.child_nodes.last
+
+          last_child.last_line == node.last_line
+        end
+
+        def find_def_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.def_type? || parent.defs_type?
+
+          find_def_node_from_ascendant(node.parent)
+        end
       end
     end
   end