rubocop 0.87.1

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for missing documentation comment for public methods.
+      # It can optionally be configured to also require documentation for
+      # non-public methods.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class Foo
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   def foo.bar
+      #     puts baz
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #     # Documentation
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     # Documentation
+      #     def bar
+      #       puts baz
+      #     end
+      #   end
+      #
+      #   # Documentation
+      #   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
+          (send nil? :module_function ...)
+        PATTERN
+
+        def on_def(node)
+          parent = node.parent
+          module_function_node?(parent) ? check(parent) : check(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def check(node)
+          return if non_public?(node) && !require_for_non_public_methods?
+          return if documentation_comment?(node)
+
+          add_offense(node)
+        end
+
+        def require_for_non_public_methods?
+          cop_config['RequireForNonPublicMethods']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
+      #
+      # 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
+        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.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
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop 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`.
+      #
+      # This check only applies if the block takes no parameters.
+      #
+      # @example
+      #   # bad
+      #   (1..5).each { }
+      #
+      #   # good
+      #   5.times { }
+      #
+      # @example
+      #   # bad
+      #   (0...10).each {}
+      #
+      #   # good
+      #   10.times {}
+      class EachForSimpleLoop < Cop
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
+              'number of times.'
+
+        def on_block(node)
+          return unless offending_each_range(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)
+
+            max += 1 if range_type == :irange
+
+            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) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop 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.
+      #
+      # However, we can't replace with each_with_object if the accumulator
+      # parameter is assigned to within the block.
+      #
+      # @example
+      #   # bad
+      #   [1, 2].inject({}) { |a, e| a[e] = e; a }
+      #
+      #   # good
+      #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
+      class EachWithObject < Cop
+        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|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
+
+            return_value = return_value(body)
+            return unless return_value
+            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))
+          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, second_arg.source)
+            corrector.replace(second_arg, first_arg.source)
+
+            return_value = return_value(node.body)
+
+            if return_value_occupies_whole_line?(return_value)
+              corrector.remove(whole_line_expression(return_value))
+            else
+              corrector.remove(return_value)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def simple_method_arg?(method_arg)
+          method_arg&.basic_literal?
+        end
+
+        # if the accumulator parameter is assigned to in the block,
+        # then we can't convert to each_with_object
+        def accumulator_param_assigned_to?(body, args)
+          first_arg, = *args
+          accumulator_var, = *first_arg
+
+          body.each_descendant.any? do |n|
+            next unless n.assignment?
+
+            lhs, _rhs = *n
+            lhs.equal?(accumulator_var)
+          end
+        end
+
+        def return_value(body)
+          return unless body
+
+          return_value = body.begin_type? ? body.children.last : body
+          return_value if return_value&.lvar_type?
+        end
+
+        def first_argument_returned?(args, return_value)
+          first_arg, = *args
+          accumulator_var, = *first_arg
+          return_var, = *return_value
+
+          accumulator_var == return_var
+        end
+
+        def return_value_occupies_whole_line?(node)
+          whole_line_expression(node).source.strip == node.source
+        end
+
+        def whole_line_expression(node)
+          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for pipes for empty block parameters. Pipes for empty
+      # block parameters do not cause syntax errors, but they are redundant.
+      #
+      # @example
+      #   # bad
+      #   a do ||
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   a { || do_something }
+      #
+      #   # good
+      #   a do
+      #   end
+      #
+      #   # good
+      #   a { do_something }
+      class EmptyBlockParameter < Cop
+        include EmptyParameter
+        include RangeHelp
+
+        MSG = 'Omit pipes for the empty block parameters.'
+
+        def on_block(node)
+          send_node = node.send_node
+          check(node) unless send_node.send_type? && send_node.lambda_literal?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            block = node.parent
+            range = range_between(
+              block.loc.begin.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end