rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where the `#__dir__` method can replace more
+      # complex constructs to retrieve a canonicalized absolute path to the
+      # current file.
+      #
+      # @example
+      #   # bad
+      #   path = File.expand_path(File.dirname(__FILE__))
+      #
+      #   # bad
+      #   path = File.dirname(File.realpath(__FILE__))
+      #
+      #   # good
+      #   path = __dir__
+      class Dir < Cop
+        MSG = 'Use `__dir__` to get an absolute path to the current ' \
+              "file's directory.".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?))}
+        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__')
+          end
+        end
+
+        private
+
+        def file_keyword?(node)
+          node.str_type? && node.source_range.is?('__FILE__')
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -12,95 +11,82 @@ module RuboCop
       # 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
+      #
+      #   # good
+      #   # Description/Explanation of Person class
+      #   class Person
+      #     # ...
+      #   end
+      #
       class Documentation < Cop
-        include AnnotationComment
+        include DocumentationComment
 
-        MSG = 'Missing top-level %s documentation comment.'.freeze
+        MSG = 'Missing top-level %<type>s documentation comment.'.freeze
 
         def_node_matcher :constant_definition?, '{class module casgn}'
 
         def on_class(node)
-          _name, _superclass, body = *node
+          _, _, body = *node
+
           return unless body
-          return if namespace?(body)
 
-          ast_with_comments = processed_source.ast_with_comments
-          return if associated_comment?(node, ast_with_comments)
-          return if nodoc_comment?(node, ast_with_comments)
-          add_offense(node, :keyword, format(MSG, :class))
+          check(node, body, :class)
         end
 
         def on_module(node)
-          _name, body = *node
-          return if namespace?(body)
+          _, body = *node
 
-          ast_with_comments = processed_source.ast_with_comments
-          return if associated_comment?(node, ast_with_comments)
-          return if nodoc_comment?(node, ast_with_comments)
-          add_offense(node, :keyword, format(MSG, :module))
+          check(node, body, :module)
         end
 
         private
 
-        def namespace?(body_node)
-          return false unless body_node
+        def check(node, body, type)
+          return if namespace?(body)
+          return if documentation_comment?(node) || nodoc_comment?(node)
 
-          case body_node.type
-          when :begin
-            body_node.children.all? { |node| constant_definition?(node) }
-          else
-            constant_definition?(body_node)
-          end
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, type: type))
         end
 
-        # Returns true if the node has a comment on the line above it that
-        # isn't an annotation.
-        def associated_comment?(node, ast_with_comments)
-          preceding_comments = preceding_comments(node, ast_with_comments)
-          return false if preceding_comments.empty?
-
-          distance = node.loc.keyword.line - preceding_comments.last.loc.line
-          return false if distance > 1
-          return false unless comment_line_only?(preceding_comments.last)
+        def namespace?(node)
+          return false unless node
 
-          # As long as there's at least one comment line that isn't an
-          # annotation, it's OK.
-          preceding_comments.any? do |comment|
-            !annotation?(comment) && !interpreter_directive_comment?(comment)
+          if node.begin_type?
+            node.children.all? { |child| constant_definition?(child) }
+          else
+            constant_definition?(node)
           end
         end
 
-        def preceding_comments(node, ast_with_comments)
-          ast_with_comments[node].select { |c| c.loc.line < node.loc.line }
-        end
-
-        def comment_line_only?(comment)
-          source_buffer = comment.loc.expression.source_buffer
-          comment_line = source_buffer.source_line(comment.loc.line)
-          comment_line =~ /^\s*#/
-        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, ast_with_comments, require_all = false)
-          return false unless node
-          nodoc_node = node.children.first
-          return false unless nodoc_node
-          comment = ast_with_comments[nodoc_node].first
+        def nodoc_comment?(node, require_all = false)
+          return false unless node && node.children.first
 
-          if comment && comment.loc.line == node.loc.line
-            regex = /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
-            return true if comment.text =~ regex
-          end
+          nodoc = nodoc(node)
+
+          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all)
+
+          nodoc_comment?(node.parent, true)
+        end
 
-          nodoc_comment?(node.ancestors.first, ast_with_comments, true)
+        def nodoc?(comment, require_all = false)
+          comment.text =~ /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
         end
 
-        def interpreter_directive_comment?(comment)
-          comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        def nodoc(node)
+          processed_source.ast_with_comments[node.children.first].first
         end
       end
     end

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

@@ -0,0 +1,76 @@
+# 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
+      class DocumentationMethod < Cop
+        include DocumentationComment
+        include DefNode
+
+        MSG = 'Missing method documentation comment.'.freeze
+
+        def on_def(node)
+          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_negation.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -26,8 +25,9 @@ module RuboCop
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)
-          return unless double_negative?(node) && node.loc.selector.is?('!')
-          add_offense(node, :selector)
+          return unless double_negative?(node) && node.keyword_bang?
+
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -11,31 +10,31 @@ module RuboCop
       # This check only applies if the block takes no parameters.
       #
       # @example
-      #   @bad
+      #   # bad
       #   (1..5).each { }
       #
-      #   @good
+      #   # good
       #   5.times { }
       #
       # @example
-      #   @bad
+      #   # bad
       #   (0...10).each {}
       #
-      #   @good
+      #   # good
       #   10.times {}
       class EachForSimpleLoop < Cop
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
               'number of times.'.freeze
 
         def on_block(node)
-          if offending_each_range(node)
-            send_node, = *node
-            range = send_node.receiver.source_range.join(send_node.loc.selector)
-            add_offense(node, range)
-          end
-        end
+          return unless offending_each_range(node)
 
-        private
+          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|
@@ -43,11 +42,13 @@ module RuboCop
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.children.first.source_range,
+            corrector.replace(node.send_node.source_range,
                               "#{max - min}.times")
           end
         end
 
+        private
+
         def_node_matcher :offending_each_range, <<-PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -18,43 +17,47 @@ module RuboCop
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
       class EachWithObject < Cop
-        MSG = 'Use `each_with_object` instead of `%s`.'.freeze
-        METHODS = [:inject, :reduce].freeze
+        MSG = 'Use `each_with_object` instead of `%<method>s`.'.freeze
+        METHODS = %i[inject reduce].freeze
 
-        def on_block(node)
-          method, args, body = *node
-          return unless reduce_method?(method)
+        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
 
-          _, method_name, method_arg = *method
-          return if simple_method_arg?(method_arg)
+        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)
+            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, method.loc.selector, format(MSG, method_name))
+            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|
-            method, args, _body = *node
-            corrector.replace(method.loc.selector, 'each_with_object')
-            first_arg, second_arg = *args
+            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)
+
+            return_value = return_value(node.body)
+
+            corrector.remove(return_value.loc.expression)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
-        def reduce_method?(method)
-          return false unless method.send_type?
-
-          _, method_name, _method_arg = *method
-          METHODS.include? method_name
-        end
-
         def simple_method_arg?(method_arg)
           method_arg && method_arg.basic_literal?
         end
@@ -76,8 +79,8 @@ module RuboCop
         def return_value(body)
           return unless body
 
-          return_value = body.type == :begin ? body.children.last : body
-          return_value if return_value && return_value.type == :lvar
+          return_value = body.begin_type? ? body.children.last : body
+          return_value if return_value && return_value.lvar_type?
         end
 
         def first_argument_returned?(args, return_value)

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

@@ -0,0 +1,47 @@
+# 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
+
+        MSG = 'Omit pipes for the empty block parameters.'.freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          check(node) unless send_node.send_type? && send_node.stabby_lambda?
+        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

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -41,53 +40,42 @@ module RuboCop
               'expression.'.freeze
 
         def on_case(case_node)
-          condition_node = case_node.children.first
+          return if case_node.condition
 
-          add_offense(case_node, :keyword, MSG) if condition_node.nil?
+          add_offense(case_node, location: :keyword)
         end
 
-        private
-
         def autocorrect(case_node)
-          lambda do |corrector|
-            _cond_node, *when_nodes, _else_node = *case_node
-
-            correct_case_whens(corrector, case_node, when_nodes)
+          when_branches = case_node.when_branches
 
-            correct_multiple_alternative_whens(corrector, when_nodes)
+          lambda do |corrector|
+            correct_case_when(corrector, case_node, when_branches)
+            correct_when_conditions(corrector, when_branches)
           end
         end
 
-        def correct_case_whens(corrector, case_node, when_nodes)
-          case_to_first_when =
-            case_node.loc.keyword.join(when_nodes.first.loc.keyword)
+        private
+
+        def correct_case_when(corrector, case_node, when_nodes)
+          case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 
-          corrector.replace(case_to_first_when, 'if')
+          corrector.replace(case_range, 'if')
 
-          when_nodes.drop(1).each do |when_node|
+          when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end
 
-        # Since an if condition containing commas is not syntactically valid, we
-        # correct `when x, y` to `if x || y`.
-        def correct_multiple_alternative_whens(corrector, when_nodes)
+        def correct_when_conditions(corrector, when_nodes)
           when_nodes.each do |when_node|
-            # In `when a; r` we have two children: [a, r].
-            # In `when a, b, c; r` we have 4.
-            # In `when a, b then r` we have 3.
-            *children, _ = when_node.children
+            conditions = when_node.conditions
 
-            next unless children.size > 1
+            next unless conditions.size > 1
 
-            first = children.first
-            last = children.last
-            range =
-              Parser::Source::Range.new(when_node.loc.expression.source_buffer,
-                                        first.loc.expression.begin_pos,
-                                        last.loc.expression.end_pos)
+            range = range_between(conditions.first.loc.expression.begin_pos,
+                                  conditions.last.loc.expression.end_pos)
 
-            corrector.replace(range, children.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map(&:source).join(' || '))
           end
         end
       end