rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cop/mixin/array_hash_indentation.rb

@@ -26,21 +26,21 @@ module RuboCop
         expected_column = base_column(left_brace, left_parenthesis) +
                           configured_indentation_width + offset
         @column_delta = expected_column - actual_column
+        styles =
+          detected_styles(actual_column, offset, left_parenthesis, left_brace)
 
         if @column_delta.zero?
-          # which column was actually used as 'base column' for indentation?
-          # (not the column which we think should be the 'base column',
-          # but the one which has actually been used for that purpose)
-          base_column = actual_column - configured_indentation_width - offset
-          styles = detected_styles(base_column, left_parenthesis, left_brace)
-          if styles.size > 1
-            ambiguous_style_detected(*styles)
-          else
-            correct_style_detected
-          end
+          check_expected_style(styles)
+        else
+          incorrect_style_detected(styles, first, left_parenthesis)
+        end
+      end
+
+      def check_expected_style(styles)
+        if styles.size > 1
+          ambiguous_style_detected(*styles)
         else
-          incorrect_style_detected(actual_column, offset, first,
-                                   left_parenthesis, left_brace)
+          correct_style_detected
         end
       end
 
@@ -54,7 +54,12 @@ module RuboCop
         end
       end
 
-      def detected_styles(column, left_parenthesis, left_brace)
+      def detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        base_column = actual_column - configured_indentation_width - offset
+        detected_styles_for_column(base_column, left_parenthesis, left_brace)
+      end
+
+      def detected_styles_for_column(column, left_parenthesis, left_brace)
         styles = []
         if column == (left_brace.source_line =~ /\S/)
           styles << :consistent
@@ -67,12 +72,9 @@ module RuboCop
         styles
       end
 
-      def incorrect_style_detected(column, offset, first, left_parenthesis,
-                                   left_brace)
+      def incorrect_style_detected(styles, first, left_parenthesis)
         add_offense(first, :expression,
                     message(base_description(left_parenthesis))) do
-          base_column = column - configured_indentation_width - offset
-          styles = detected_styles(base_column, left_parenthesis, left_brace)
           ambiguous_style_detected(*styles)
         end
       end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -123,8 +123,8 @@ module RuboCop
                         else
                           line_begin_pos - column_delta.abs
                         end
-        Parser::Source::Range.new(expr.source_buffer, pos_to_remove,
-                                  pos_to_remove + column_delta.abs)
+
+        range_between(pos_to_remove, pos_to_remove + column_delta.abs)
       end
 
       def remove(range, corrector)
@@ -132,9 +132,7 @@ module RuboCop
         $stderr = StringIO.new # Avoid error messages on console
         corrector.remove(range)
       rescue RuntimeError
-        range = Parser::Source::Range.new(range.source_buffer,
-                                          range.begin_pos + 1,
-                                          range.end_pos + 1)
+        range = range_between(range.begin_pos + 1, range.end_pos + 1)
         retry if range.source =~ /^ +$/
       ensure
         $stderr = original_stderr

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -31,14 +31,13 @@ module RuboCop
       # A class emitter method is a singleton method in a class/module, where
       # the method has the same name as a class defined in the class/module.
       def class_emitter_method?(node, name)
-        return false unless node.defs_type?
+        return false unless node.parent && node.defs_type?
         # a class emitter method may be defined inside `def self.included`,
         # `def self.extended`, etc.
-        node = node.parent while node.parent && node.parent.defs_type?
-        return false unless node.parent
+        node = node.parent while node.parent.defs_type?
 
-        node.parent.children.compact.any? do |c|
-          c.class_type? && c.loc.name.is?(name.to_s)
+        node.parent.each_child_node(:class).any? do |c|
+          c.loc.name.is?(name.to_s)
         end
       end
     end

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides functionality for checking if numbering match the
+    # configured EnforcedStyle.
+    module ConfigurableNumbering
+      include ConfigurableEnforcedStyle
+
+      SNAKE_CASE = /^@{0,2}[-_a-z]+[_\D]*(_\d)*[!?=]?$/
+      NORMAL_CASE = /^@{0,2}-{0,1}_{0,1}[a-zA-Z\d]*[_\D]*[!?=]?$/
+      NON_INTEGER = /^@{0,2}[-_a-z]+[_\D]*[!?=]?$/
+
+      def check_name(node, name, name_range)
+        return if operator?(name)
+
+        if valid_name?(node, name)
+          correct_style_detected
+        else
+          add_offense(node, name_range, message(style))
+        end
+      end
+
+      def valid_name?(node, name)
+        pattern =
+          case style
+          when :snake_case
+            SNAKE_CASE
+          when :normalcase
+            NORMAL_CASE
+          when :non_integer
+            NON_INTEGER
+          end
+        name.match(pattern) || class_emitter_method?(node, name)
+      end
+
+      # A class emitter method is a singleton method in a class/module, where
+      # the method has the same name as a class defined in the class/module.
+      def class_emitter_method?(node, name)
+        return false unless node.parent && node.defs_type?
+        # a class emitter method may be defined inside `def self.included`,
+        # `def self.extended`, etc.
+        node = node.parent while node.parent.defs_type?
+
+        node.parent.each_child_node(:class).any? do |c|
+          c.loc.name.is?(name.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/def_node.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking if nodes.
+    module DefNode
+      extend NodePattern::Macros
+
+      NON_PUBLIC_MODIFIERS = %w(private protected).freeze
+
+      def non_public?(node)
+        non_public_modifier?(node.parent) ||
+          preceding_non_public_modifier?(node)
+      end
+
+      def preceding_non_public_modifier?(node)
+        stripped_source_upto(node.loc.line).any? do |line|
+          NON_PUBLIC_MODIFIERS.include?(line)
+        end
+      end
+
+      def_node_matcher :non_public_modifier?, <<-PATTERN
+        (send nil {:private :protected} ({def defs} ...))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking documentation.
+    module DocumentationComment
+      extend NodePattern::Macros
+      include Style::AnnotationComment
+
+      def_node_matcher :constant_definition?, '{class module casgn}'
+
+      private
+
+      def documentation_comment?(node)
+        preceding_lines = preceding_lines(node)
+
+        return false unless preceding_comment?(node, preceding_lines.last)
+
+        preceding_lines.any? do |comment|
+          !annotation?(comment) && !interpreter_directive_comment?(comment)
+        end
+      end
+
+      def preceding_comment?(n1, n2)
+        n1 && n2 && preceed?(n2, n1) &&
+          comment_line?(n2.loc.expression.source)
+      end
+
+      def preceding_lines(node)
+        processed_source.ast_with_comments[node].select do |line|
+          line.loc.line < node.loc.line
+        end
+      end
+
+      def interpreter_directive_comment?(comment)
+        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -59,23 +59,28 @@ module RuboCop
       end
 
       def align(node, align_to)
-        source_buffer = node.source_range.source_buffer
-        begin_pos = node.loc.end.begin_pos
-        whitespace = Parser::Source::Range.new(source_buffer,
-                                               begin_pos - node.loc.end.column,
-                                               begin_pos)
+        whitespace = whitespace_range(node)
         return false unless whitespace.source.strip.empty?
 
-        column = if !align_to
-                   0
-                 elsif align_to.respond_to?(:loc)
-                   align_to.source_range.column
-                 else
-                   align_to.column
-                 end
-
+        column = alignment_column(align_to)
         ->(corrector) { corrector.replace(whitespace, ' ' * column) }
       end
+
+      def whitespace_range(node)
+        begin_pos = node.loc.end.begin_pos
+
+        range_between(begin_pos - node.loc.end.column, begin_pos)
+      end
+
+      def alignment_column(align_to)
+        if !align_to
+          0
+        elsif align_to.respond_to?(:loc)
+          align_to.source_range.column
+        else
+          align_to.column
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/if_node.rb

@@ -5,6 +5,8 @@ module RuboCop
   module Cop
     # Common functionality for checking if nodes.
     module IfNode
+      extend NodePattern::Macros
+
       def ternary?(node)
         node.loc.respond_to?(:question)
       end
@@ -32,6 +34,10 @@ module RuboCop
 
         [condition, body, else_clause]
       end
+
+      def_node_matcher :guard_clause?, <<-PATTERN
+          [{(send nil {:raise :fail} ...) return break next} single_line?]
+      PATTERN
     end
   end
 end

data/lib/rubocop/cop/mixin/match_range.rb

@@ -15,11 +15,8 @@ module RuboCop
 
       # For a `match` inside `range`, return a new `Range` covering the match
       def match_range(range, match)
-        Parser::Source::Range.new(
-          range.source_buffer,
-          range.begin_pos + match.begin(1),
-          range.begin_pos + match.end(1)
-        )
+        range_between(range.begin_pos + match.begin(1),
+                      range.begin_pos + match.end(1))
       end
     end
   end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -177,12 +177,12 @@ module RuboCop
       end
 
       def grouped_expression?(node)
-        node.type == :begin && node.loc.respond_to?(:begin) && node.loc.begin
+        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
       end
 
       def inside_arg_list_parentheses?(node, ancestor)
         a = ancestor.loc
-        return false unless ancestor.type == :send && a.begin &&
+        return false unless ancestor.send_type? && a.begin &&
                             a.begin.is?('(')
         n = node.source_range
         n.begin_pos > a.begin.begin_pos && n.end_pos < a.end.end_pos

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -9,19 +9,13 @@ module RuboCop
       include ConfigurableEnforcedStyle
 
       def check_brace_layout(node)
-        return unless node.loc.begin # Ignore implicit literals.
-        return if children(node).empty? # Ignore empty literals.
-        return if node.single_line? # Ignore single-line literals.
+        return if ignored_literal?(node)
 
         # If the last node is or contains a conflicting HEREDOC, we don't want
         # to adjust the brace layout because this will result in invalid code.
-        return if last_line_heredoc?(children(node).last)
+        return if last_line_heredoc?(node.children.last)
 
-        case style
-        when :symmetrical then handle_symmetrical(node)
-        when :new_line then handle_new_line(node)
-        when :same_line then handle_same_line(node)
-        end
+        check(node)
       end
 
       def autocorrect(node)
@@ -42,34 +36,27 @@ module RuboCop
 
       private
 
-      def last_element_range_with_trailing_comma(node)
-        trailing_comma_range = last_element_trailing_comma_range(node)
-        if trailing_comma_range
-          children(node).last.source_range.join(trailing_comma_range)
-        else
-          children(node).last.source_range
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
         end
       end
 
-      def last_element_trailing_comma_range(node)
-        range = range_with_surrounding_space(children(node).last.source_range,
-                                             :right).end.resize(1)
-        range.source == ',' ? range : nil
-      end
-
-      def handle_new_line(node)
+      def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
         add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
       end
 
-      def handle_same_line(node)
+      def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
         add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
       end
 
-      def handle_symmetrical(node)
+      def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
@@ -81,6 +68,33 @@ module RuboCop
         end
       end
 
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
+        end
+      end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(children(node).last.source_range,
+                                             :right).end.resize(1)
+        range.source == ',' ? range : nil
+      end
+
       def children(node)
         node.children
       end
@@ -124,15 +138,13 @@ module RuboCop
       def last_line_heredoc?(node, parent = nil)
         parent ||= node
 
-        return false unless node.respond_to?(:loc)
-
-        if node.loc.respond_to?(:heredoc_end) &&
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
            node.loc.heredoc_end.last_line >= parent.loc.last_line
           return true
         end
 
         return false unless node.respond_to?(:children)
-        return false if node.children.empty?
 
         node.children.any? { |child| last_line_heredoc?(child, parent) }
       end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -6,19 +6,19 @@ module RuboCop
     # Some common code shared between FavorUnlessOverNegatedIf and
     # FavorUntilOverNegatedWhile.
     module NegativeConditional
-      def self.included(mod)
-        mod.def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
-      end
+      extend NodePattern::Macros
+      include IfNode
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
 
       def check_negative_conditional(node)
         condition, _body, _rest = *node
 
         # Look at last expression of contents if there are parentheses
         # around condition.
-        condition = condition.children.last while condition.type == :begin
+        condition = condition.children.last while condition.begin_type?
 
-        return unless single_negative?(condition) &&
-                      !(node.loc.respond_to?(:else) && node.loc.else)
+        return unless single_negative?(condition) && !if_else?(node)
 
         add_offense(node, :expression)
       end