rubocop 0.42.0 → 0.43.0

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

@@ -76,11 +76,7 @@ module RuboCop
             "match Notice /#{notice}/" unless autocorrect_notice =~ regex
 
           lambda do |corrector|
-            range = if token.nil?
-                      Parser::Source::Range.new('', 0, 0)
-                    else
-                      token.pos
-                    end
+            range = token.nil? ? range_between(0, 0) : token.pos
             corrector.insert_before(range, "#{autocorrect_notice}\n")
           end
         end

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

@@ -14,12 +14,10 @@ module RuboCop
               'any arguments.'.freeze
 
         def on_method_def(node, _method_name, args, _body)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
+          return if node.single_line?
+          return unless args.children.empty? && args.loc.begin
 
-          return if start_line == end_line
-
-          add_offense(args, :begin) if args.children == [] && args.loc.begin
+          add_offense(args, :begin)
         end
 
         def autocorrect(node)

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

@@ -13,94 +13,66 @@ module RuboCop
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
       # same for all its children.
       class Documentation < Cop
-        include AnnotationComment
+        include DocumentationComment
 
         MSG = 'Missing top-level %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, :keyword, format(MSG, 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,80 @@
+# encoding: utf-8
+# 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
+      #
+      #   # Documenation
+      #   def foo.bar
+      #     puts baz
+      #   end
+      class DocumentationMethod < Cop
+        include DocumentationComment
+        include OnMethodDef
+        include DefNode
+
+        MSG = 'Missing method documentation comment.'.freeze
+
+        def on_def(node)
+          check(node)
+        end
+
+        def on_method_def(node, *)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if non_public?(node) && !require_for_non_public_methods?
+          return if documentation_comment?(node)
+
+          add_offense(node, :expression, MSG)
+        end
+
+        def require_for_non_public_methods?
+          cop_config['RequireForNonPublicMethods']
+        end
+      end
+    end
+  end
+end

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

@@ -28,11 +28,12 @@ module RuboCop
               '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
+          return unless offending_each_range(node)
+
+          send_node, = *node
+          range = send_node.receiver.source_range.join(send_node.loc.selector)
+
+          add_offense(node, range)
         end
 
         private

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

@@ -76,8 +76,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/else_alignment.rb

@@ -12,25 +12,26 @@ module RuboCop
         include EndKeywordAlignment
         include AutocorrectAlignment
         include CheckAssignment
+        include IfNode
 
         MSG = 'Align `%s` with `%s`.'.freeze
 
         def on_if(node, base = nil)
           return if ignored_node?(node)
-          return unless node.loc.respond_to?(:else)
-          return if node.loc.else.nil?
+          return unless if_else?(node)
 
           else_range = node.loc.else
           return unless begins_its_line?(else_range)
 
           check_alignment(base_range(node, base), else_range)
 
-          return if else_range.source != 'elsif'
+          _, _, else_body = *node
+
+          return unless else_body && elsif?(else_body)
 
           # If the `else` part is actually an `elsif`, we check the `elsif`
           # node in case it contains an `else` within, because that `else`
           # should have the same alignment (base).
-          _condition, _if_body, else_body = *node
           on_if(else_body, base)
           # The `elsif` node will get an `on_if` call from the framework later,
           # but we're done here, so we set it to ignored.
@@ -38,10 +39,10 @@ module RuboCop
         end
 
         def on_rescue(node)
-          return unless node.loc.else
+          return unless if_else?(node)
 
           parent = node.parent
-          parent = parent.parent if parent.type == :ensure
+          parent = parent.parent if parent.ensure_type?
           base = case parent.type
                  when :def, :defs then base_for_method_definition(parent)
                  when :kwbegin then parent.loc.begin
@@ -52,7 +53,7 @@ module RuboCop
 
         def on_case(node)
           _cond, *whens, _else = *node
-          return unless node.loc.else
+          return unless if_else?(node)
           check_alignment(whens.last.loc.keyword, node.loc.else)
         end
 
@@ -72,7 +73,7 @@ module RuboCop
 
         def base_for_method_definition(node)
           parent = node.parent
-          if parent && parent.type == :send
+          if parent && parent.send_type?
             parent.loc.selector # For example "private def ..."
           else
             node.loc.keyword
@@ -90,7 +91,7 @@ module RuboCop
           style = end_config['AlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
-          return if rhs.type != :if
+          return unless rhs.if_type?
 
           on_if(rhs, base)
           ignore_node(rhs)

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

@@ -82,10 +82,8 @@ module RuboCop
 
             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(first.loc.expression.begin_pos,
+                                  last.loc.expression.end_pos)
 
             corrector.replace(range, children.map(&:source).join(' || '))
           end

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

@@ -117,10 +117,7 @@ module RuboCop
                         node.parent.loc.end.begin_pos
                       end
 
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              node.loc.else.begin_pos,
-                                              end_pos)
-            corrector.remove(range)
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
           end
         end
 

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

@@ -65,9 +65,7 @@ module RuboCop
           end_pos = prev_def.loc.end.end_pos
           source_buffer = prev_def.loc.end.source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
-          newline = Parser::Source::Range.new(source_buffer,
-                                              newline_pos,
-                                              newline_pos + 1)
+          newline = range_between(newline_pos, newline_pos + 1)
           ->(corrector) { corrector.insert_after(newline, "\n") }
         end
       end

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

@@ -38,11 +38,8 @@ module RuboCop
         private
 
         def line_range(node)
-          Parser::Source::Range.new(
-            processed_source.buffer,
-            node.source_range.begin_pos - node.loc.column,
-            node.source_range.end_pos
-          )
+          range_between(node.source_range.begin_pos - node.loc.column,
+                        node.source_range.end_pos)
         end
 
         def previous_line_ignoring_comments(processed_source, send_line)

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

@@ -35,13 +35,10 @@ module RuboCop
 
         def autocorrect(range)
           if @message == MSG_MISSING
-            encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
-            if encoding && encoding =~ ENCODING_PATTERN
-              lambda do |corrector|
-                corrector.insert_before(range, "#{encoding}\n")
-              end
-            else
-              raise "#{encoding} does not match #{ENCODING_PATTERN}"
+            raise encoding_mismatch_message unless matching_encoding?
+
+            lambda do |corrector|
+              corrector.insert_before(range, "#{encoding}\n")
             end
           else
             # Need to remove unnecessary encoding comment
@@ -53,21 +50,38 @@ module RuboCop
 
         private
 
+        def encoding
+          cop_config[AUTO_CORRECT_ENCODING_COMMENT]
+        end
+
+        def matching_encoding?
+          encoding =~ ENCODING_PATTERN
+        end
+
+        def encoding_mismatch_message
+          "#{encoding} does not match #{ENCODING_PATTERN}"
+        end
+
         def offense(processed_source, line_number)
           line = processed_source[line_number]
-          encoding_present = line =~ ENCODING_PATTERN
-          ascii_only = processed_source.buffer.source.ascii_only?
-          always_encode = style == :always
-          never_encode = style == :never
-          encoding_omitable = never_encode || (!always_encode && ascii_only)
 
-          if !encoding_present && !encoding_omitable
+          if !encoding_present?(line) && !encoding_omitable?
             MSG_MISSING
-          elsif encoding_present && encoding_omitable
+          elsif encoding_present?(line) && encoding_omitable?
             MSG_UNNECESSARY
           end
         end
 
+        def encoding_present?(line)
+          line =~ ENCODING_PATTERN
+        end
+
+        def encoding_omitable?
+          return true if style == :never
+
+          style != :always && processed_source.buffer.source.ascii_only?
+        end
+
         def encoding_line_number(processed_source)
           line_number = 0
           line_number += 1 if processed_source[line_number].start_with?(SHEBANG)