rubocop 0.76.0 → 1.50.0

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.
+      # 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,55 +19,133 @@ 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
+      #
+      #     # Macro calls
+      #     module Namespace
+      #       extend Foo
+      #     end
+      #
+      # @example AllowedConstants: ['ClassMethods']
+      #
+      #    # good
+      #    module A
+      #      module ClassMethods
+      #        # ...
+      #      end
+      #     end
+      #
+      class Documentation < Base
         include DocumentationComment
+        include RangeHelp
 
-        MSG = 'Missing top-level %<type>s documentation comment.'
+        MSG = 'Missing top-level documentation comment for `%<type>s %<identifier>s`.'
 
+        # @!method constant_definition?(node)
         def_node_matcher :constant_definition?, '{class module casgn}'
+
+        # @!method outer_module(node)
         def_node_search :outer_module, '(const (const nil? _) _)'
 
+        # @!method constant_visibility_declaration?(node)
+        def_node_matcher :constant_visibility_declaration?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} _))
+        PATTERN
+
+        # @!method include_statement?(node)
+        def_node_matcher :include_statement?, <<~PATTERN
+          (send nil? {:include :extend :prepend} const)
+        PATTERN
+
         def on_class(node)
           return unless node.body
 
-          check(node, node.body, :class)
+          check(node, node.body)
         end
 
         def on_module(node)
-          check(node, node.body, :module)
+          check(node, node.body)
         end
 
         private
 
-        def check(node, body, type)
+        def check(node, body)
           return if namespace?(body)
-          return if documentation_comment?(node) || nodoc_comment?(node)
-          return if compact_namespace?(node) &&
-                    nodoc_comment?(outer_module(node).first)
+          return if documentation_comment?(node)
+          return if constant_allowed?(node)
+          return if nodoc_self_or_outer_module?(node)
+          return if include_statement_only?(body)
+
+          range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
+          message = format(MSG, type: node.type, identifier: identifier(node))
+          add_offense(range, message: message)
+        end
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, type: type))
+        def nodoc_self_or_outer_module?(node)
+          nodoc_comment?(node) ||
+            (compact_namespace?(node) && nodoc_comment?(outer_module(node).first))
+        end
+
+        def include_statement_only?(body)
+          return true if include_statement?(body)
+
+          body.respond_to?(:children) && body.children.all? { |node| include_statement_only?(node) }
         end
 
         def namespace?(node)
           return false unless node
 
           if node.begin_type?
-            node.children.all? { |child| constant_definition?(child) }
+            node.children.all? { |child| constant_declaration?(child) }
           else
             constant_definition?(node)
           end
         end
 
+        def constant_declaration?(node)
+          constant_definition?(node) || constant_visibility_declaration?(node)
+        end
+
+        def constant_allowed?(node)
+          allowed_constants.include?(node.identifier.short_name)
+        end
+
         def compact_namespace?(node)
-          node.loc.name.source =~ /::/
+          node.loc.name.source.include?('::')
         end
 
         # First checks if the :nodoc: comment is associated with the
@@ -74,23 +153,45 @@ 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)
           processed_source.ast_with_comments[node.children.first].first
         end
+
+        def allowed_constants
+          @allowed_constants ||= cop_config.fetch('AllowedConstants', []).map(&:intern)
+        end
+
+        def identifier(node)
+          # Get the fully qualified identifier for a class/module
+          nodes = [node, *node.each_ancestor(:class, :module)]
+          identifier = nodes.reverse_each.flat_map { |n| qualify_const(n.identifier) }.join('::')
+
+          identifier.sub('::::', '::')
+        end
+
+        def qualify_const(node)
+          return if node.nil?
+
+          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+            node.source
+          else
+            [qualify_const(node.namespace), node.short_name].compact
+          end
+        end
       end
     end
   end

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

@@ -3,10 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for missing documentation comment for public methods.
+      # Checks for missing documentation comment for public methods.
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #
+      # NOTE: This cop allows `initialize` method because `initialize` is
+      # a special method called from `new`. In some programming languages
+      # they are called constructor to distinguish it from method.
+      #
       # @example
       #
       #   # bad
@@ -91,19 +95,22 @@ module RuboCop
       #     end
       #   end
       #
-      class DocumentationMethod < Cop
+      class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
 
         MSG = 'Missing method documentation comment.'
 
-        def_node_matcher :module_function_node?, <<~PATTERN
-          (send nil? :module_function ...)
+        # @!method modifier_node?(node)
+        def_node_matcher :modifier_node?, <<~PATTERN
+          (send nil? {:module_function :ruby2_keywords} ...)
         PATTERN
 
         def on_def(node)
+          return if node.method?(:initialize)
+
           parent = node.parent
-          module_function_node?(parent) ? check(parent) : check(node)
+          modifier_node?(parent) ? check(parent) : check(node)
         end
         alias on_defs on_def
 

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

@@ -24,29 +24,20 @@ 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/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
-
-          lambda do |corrector|
-            corrector.replace(comment.loc.expression,
-                              comment.text[/#{prefix} \S+/])
+            add_offense(comment) do |corrector|
+              corrector.replace(comment, comment.text.gsub(%r{ # rubocop:(disable|todo)}, ','))
+            end
           end
         end
       end

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

@@ -3,31 +3,155 @@
 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.
+      # Checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
-      # @example
+      # When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
+      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation
+      # should be forbidden always.
+      #
+      # NOTE: 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.
+      #
+      # @safety
+      #   Autocorrection is unsafe when the value is `false`, because the result
+      #   of the expression will change.
+      #
+      #   [source,ruby]
+      #   ----
+      #   !!false     #=> false
+      #   !false.nil? #=> true
+      #   ----
       #
+      # @example
       #   # bad
       #   !!something
       #
       #   # good
       #   !something.nil?
       #
-      # 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
+      # @example EnforcedStyle: allowed_in_returns (default)
+      #   # good
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   def foo?
+      #     !!return_value
+      #   end
+      #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      class DoubleNegation < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MSG = 'Avoid the use of double negation (`!!`).'
+        RESTRICT_ON_SEND = %i[!].freeze
 
+        # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)
           return unless double_negative?(node) && node.prefix_bang?
+          return if style == :allowed_in_returns && allowed_in_returns?(node)
+
+          location = node.loc.selector
+          add_offense(location) do |corrector|
+            corrector.remove(location)
+            corrector.insert_after(node, '.nil?')
+          end
+        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))
+
+          conditional_node = find_conditional_node_from_ascendant(node)
+          last_child = find_last_child(def_node.send_type? ? def_node : def_node.body)
+
+          if conditional_node
+            double_negative_condition_return_value?(node, last_child, conditional_node)
+          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+            false
+          else
+            last_child.last_line <= node.last_line
+          end
+        end
+
+        def find_def_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.def_type? || parent.defs_type?
+          return node.parent.child_nodes.first if define_method?(parent)
+
+          find_def_node_from_ascendant(node.parent)
+        end
+
+        def define_method?(node)
+          return false unless node.block_type?
+
+          child = node.child_nodes.first
+          return false unless child.send_type?
+
+          child.method?(:define_method) || child.method?(:define_singleton_method)
+        end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
+        end
+
+        def find_last_child(node)
+          case node.type
+          when :rescue
+            find_last_child(node.body)
+          when :ensure
+            find_last_child(node.child_nodes.first)
+          else
+            node.child_nodes.last
+          end
+        end
+
+        def double_negative_condition_return_value?(node, last_child, conditional_node)
+          parent = find_parent_not_enumerable(node)
+          if parent.begin_type?
+            node.loc.line == parent.loc.last_line
+          else
+            last_child.last_line <= conditional_node.last_line
+          end
+        end
+
+        def find_parent_not_enumerable(node)
+          return unless (parent = node.parent)
 
-          add_offense(node, location: :selector)
+          if parent.pair_type? || parent.hash_type? || parent.array_type?
+            find_parent_not_enumerable(parent)
+          else
+            parent
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for loops which iterate a constant number of times,
+      # Checks for loops which iterate a constant number of times,
       # using a Range literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
@@ -22,35 +22,67 @@ module RuboCop
       #
       #   # good
       #   10.times {}
-      class EachForSimpleLoop < Cop
-        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
-              'number of times.'
+      class EachForSimpleLoop < Base
+        extend AutoCorrector
 
-        def on_block(node)
-          return unless offending_each_range(node)
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless offending?(node)
 
           send_node = node.send_node
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
-          add_offense(node, location: range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            range_type, min, max = offending_each_range(node)
+          add_offense(range) do |corrector|
+            range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node.source_range,
-                              "#{max - min}.times")
+            corrector.replace(node.send_node, "#{max - min}.times")
           end
         end
 
         private
 
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        def offending?(node)
+          each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
+        end
+
+        # @!method each_range(node)
+        def_node_matcher :each_range, <<~PATTERN
+          (block
+            (send
+              (begin
+                (${irange erange}
+                  (int $_) (int $_)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_with_zero_origin?(node)
+        def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int 0) (int _)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_without_block_argument?(node)
+        def_node_matcher :each_range_without_block_argument?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int _) (int _)))
+              :each)
+            (args)
+            ...)
         PATTERN
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for inject / reduce calls where the passed in object is
+      # Looks for inject / reduce calls where the passed in object is
       # returned at the end and so could be replaced by each_with_object without
       # the need to return the object at the end.
       #
@@ -16,18 +16,15 @@ module RuboCop
       #
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
-      class EachWithObject < Cop
+      class EachWithObject < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
-        PATTERN
-
         def on_block(node)
-          each_with_object_candidate?(node) do |method, args, body|
+          each_with_object_block_candidate?(node) do |method, args, body|
             _, method_name, method_arg = *method
             return if simple_method_arg?(method_arg)
 
@@ -36,34 +33,66 @@ module RuboCop
             return unless first_argument_returned?(args, return_value)
             return if accumulator_param_assigned_to?(body, args)
 
-            add_offense(node, location: method.loc.selector,
-                              message: format(MSG, method: method_name))
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_block(corrector, node, return_value)
+            end
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'each_with_object')
-
-            first_arg, second_arg = *node.arguments
-
-            corrector.replace(first_arg.loc.expression, second_arg.source)
-            corrector.replace(second_arg.loc.expression, first_arg.source)
+        def on_numblock(node)
+          each_with_object_numblock_candidate?(node) do |method, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
 
-            return_value = return_value(node.body)
+            return unless return_value(body)&.source == '_1'
 
-            if return_value_occupies_whole_line?(return_value)
-              corrector.remove(whole_line_expression(return_value))
-            else
-              corrector.remove(return_value.loc.expression)
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_numblock(corrector, node)
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
+        # @!method each_with_object_block_candidate?(node)
+        def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
+
+        # @!method each_with_object_numblock_candidate?(node)
+        def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
+          (numblock $(send _ {:inject :reduce} _) 2 $_)
+        PATTERN
+
+        def autocorrect_block(corrector, node, return_value)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          first_arg, second_arg = *node.arguments
+
+          corrector.replace(first_arg, second_arg.source)
+          corrector.replace(second_arg, first_arg.source)
+
+          if return_value_occupies_whole_line?(return_value)
+            corrector.remove(whole_line_expression(return_value))
+          else
+            corrector.remove(return_value)
+          end
+        end
+
+        def autocorrect_numblock(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          # We don't remove the return value to avoid a clobbering error.
+          node.body.each_descendant do |var|
+            next unless var.lvar_type?
+
+            corrector.replace(var, '_2') if var.source == '_1'
+            corrector.replace(var, '_1') if var.source == '_2'
+          end
+        end
+
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?
         end
@@ -102,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end