rubocop 0.49.1 → 0.50.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Common functionality for working with heredoc strings.
+module Heredoc
+  OPENING_DELIMITER = /<<[~-]?'?(\w+)'?\b/
+
+  def on_str(node)
+    return unless heredoc?(node)
+
+    on_heredoc(node)
+  end
+  alias on_dstr on_str
+  alias on_xstr on_str
+
+  def on_heredoc(_node)
+    raise NotImplementedError
+  end
+
+  private
+
+  def heredoc?(node)
+    node.loc.is_a?(Parser::Source::Map::Heredoc)
+  end
+
+  def delimiter_string(node)
+    node.source.match(OPENING_DELIMITER).captures.first
+  end
+end

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

@@ -4,21 +4,24 @@ module RuboCop
   module Cop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include OnMethodDef
       include ConfigurableMax
 
-      private
-
-      def on_method_def(node, method_name, _args, _body)
+      def on_def(node)
         max = cop_config['Max']
         complexity = complexity(node)
+
         return unless complexity > max
 
-        add_offense(node, :keyword,
-                    format(self.class::MSG, method_name, complexity, max)) do
+        add_offense(node, :keyword, format(self.class::MSG,
+                                           node.method_name,
+                                           complexity,
+                                           max)) do
           self.max = complexity.ceil
         end
       end
+      alias on_defs on_def
+
+      private
 
       def complexity(node)
         node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|

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

@@ -5,6 +5,14 @@ module RuboCop
     # Common functionality for checking multiline method calls and binary
     # operations.
     module MultilineExpressionIndentation
+      KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return
+                                   array kwbegin].freeze
+      ASSIGNMENT_RHS_TYPES    = [:send, *Util::ASGN_NODES].freeze
+      DEFAULT_MESSAGE_TAIL    = 'an expression'.freeze
+      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'.freeze
+      KEYWORD_MESSAGE_TAIL    = 'a %s in %s `%s` statement'.freeze
+
       def on_send(node)
         return if !node.receiver || node.method?(:[])
         return unless relevant_node?(node)
@@ -79,30 +87,46 @@ module RuboCop
       end
 
       def operation_description(node, rhs)
-        ancestor = kw_node_with_special_indentation(node)
-        if ancestor
-          kw = ancestor.loc.keyword.source
-          kind = kw == 'for' ? 'collection' : 'condition'
-          article = kw =~ /^[iu]/ ? 'an' : 'a'
-          "a #{kind} in #{article} `#{kw}` statement"
-        else
-          'an expression' +
-            (part_of_assignment_rhs(node, rhs) ? ' in an assignment' : '')
+        kw_node_with_special_indentation(node) do |ancestor|
+          return keyword_message_tail(ancestor)
+        end
+
+        part_of_assignment_rhs(node, rhs) do |_node|
+          return ASSIGNMENT_MESSAGE_TAIL
         end
+
+        DEFAULT_MESSAGE_TAIL
       end
 
-      def kw_node_with_special_indentation(node)
-        node.each_ancestor.find do |a|
-          next unless a.loc.respond_to?(:keyword)
+      def keyword_message_tail(node)
+        keyword = node.loc.keyword.source
+        kind    = keyword == 'for' ? 'collection' : 'condition'
+        article = keyword =~ /^[iu]/ ? 'an' : 'a'
 
-          case a.type
-          when :for                  then _, expression, = *a
-          when :return               then expression, = *a
-          when *Util::MODIFIER_NODES then expression, = *a
+        format(KEYWORD_MESSAGE_TAIL, kind, article, keyword)
+      end
+
+      def kw_node_with_special_indentation(node)
+        keyword_node =
+          node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            within_node?(node, indented_keyword_expression(ancestor))
           end
 
-          within_node?(node, expression) if expression
+        if keyword_node && block_given?
+          yield keyword_node
+        else
+          keyword_node
+        end
+      end
+
+      def indented_keyword_expression(node)
+        if node.for_type?
+          expression = node.collection
+        else
+          expression, = *node
         end
+
+        expression
       end
 
       def argument_in_method_call(node, kind)
@@ -122,17 +146,31 @@ module RuboCop
       end
 
       def part_of_assignment_rhs(node, candidate)
-        node.each_ancestor.find do |a|
-          case a.type
-          when :if, :while, :until, :for, :return, :array, :kwbegin
-            break # other kinds of alignment
-          when :block
-            break if part_of_block_body?(candidate, a)
-          when :send
-            valid_method_rhs_candidate?(candidate, a)
-          when *Util::ASGN_NODES
-            valid_rhs_candidate?(candidate, assignment_rhs(a))
-          end
+        rhs_node = node.each_ancestor.find do |ancestor|
+          break if disqualified_rhs?(candidate, ancestor)
+
+          valid_rhs?(candidate, ancestor)
+        end
+
+        if rhs_node && block_given?
+          yield rhs_node
+        else
+          rhs_node
+        end
+      end
+
+      def disqualified_rhs?(candidate, ancestor)
+        UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
+          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+      end
+
+      def valid_rhs?(candidate, ancestor)
+        if ancestor.send_type?
+          valid_method_rhs_candidate?(candidate, ancestor)
+        elsif Util::ASGN_NODES.include?(ancestor.type)
+          valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
+        else
+          false
         end
       end
 
@@ -146,9 +184,8 @@ module RuboCop
         !candidate || within_node?(candidate, node)
       end
 
-      def part_of_block_body?(candidate, node)
-        _method, _args, body = *node
-        body && within_node?(candidate, body)
+      def part_of_block_body?(candidate, block_node)
+        block_node.body && within_node?(candidate, block_node.body)
       end
 
       def assignment_rhs(node)

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

@@ -23,6 +23,12 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n".freeze)
           end
         else
+          # When a comment immediately before the closing brace gets in the way
+          # of an easy correction, the offense is reported but not auto-
+          # corrected. The user must handle the delicate decision of where to
+          # put the comment.
+          return if new_line_needed_before_closing_brace?(node)
+
           lambda do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.end,
                                                           :left))
@@ -35,6 +41,18 @@ module RuboCop
 
       private
 
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        return unless node.chained?
+
+        last_element_line =
+          last_element_range_with_trailing_comma(node).last_line
+        processed_source.comments.any? { |c| c.loc.line == last_element_line }
+      end
+
       def check(node)
         case style
         when :symmetrical then check_symmetrical(node)

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

@@ -20,7 +20,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node, :expression)
+        add_offense(node)
       end
 
       def negative_conditional_corrector(node)

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent arrays.
+    module PercentArray
+      private
+
+      # Ruby does not allow percent arrays in an ambiguous block context.
+      #
+      # @example
+      #
+      #   foo %i[bar baz] { qux }
+      def invalid_percent_array_context?(node)
+        parent = node.parent
+
+        parent && parent.send_type? && parent.arguments.include?(node) &&
+          !parent.parenthesized? && parent.block_literal?
+      end
+
+      def allowed_bracket_array?(node)
+        comments_in_array?(node) || below_array_length?(node) ||
+          invalid_percent_array_context?(node)
+      end
+
+      def message(_node)
+        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
+      end
+
+      def comments_in_array?(node)
+        comments = processed_source.comments
+        array_range = node.source_range.to_a
+
+        comments.any? do |comment|
+          !(comment.loc.expression.to_a & array_range).empty?
+        end
+      end
+
+      def check_percent_array(node)
+        array_style_detected(:percent, node.values.size)
+        add_offense(node) if style == :brackets
+      end
+
+      def check_bracketed_array(node)
+        return if allowed_bracket_array?(node)
+
+        array_style_detected(:brackets, node.values.size)
+        add_offense(node) if style == :percent
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node, :expression) { opposite_style_detected }
+          add_offense(node) { opposite_style_detected }
         else
           correct_style_detected
         end

data/lib/rubocop/cop/{style → naming}/accessor_method_name.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that accessor methods are named properly.
       #
       # @example
@@ -18,26 +18,25 @@ module RuboCop
       #   # good
       #   def attribute ...
       class AccessorMethodName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, args, _body)
-          if bad_reader_name?(method_name.to_s, args)
+        def on_def(node)
+          if bad_reader_name?(node)
             add_offense(node, :name,
                         'Do not prefix reader method names with `get_`.')
-          elsif bad_writer_name?(method_name.to_s, args)
+          elsif bad_writer_name?(node)
             add_offense(node, :name,
                         'Do not prefix writer method names with `set_`.')
           end
         end
+        alias on_defs on_def
+
+        private
 
-        def bad_reader_name?(method_name, args)
-          method_name.start_with?('get_') && args.to_a.empty?
+        def bad_reader_name?(node)
+          node.method_name.to_s.start_with?('get_') && !node.arguments?
         end
 
-        def bad_writer_name?(method_name, args)
-          method_name.start_with?('set_') && args.to_a.one?
+        def bad_writer_name?(node)
+          node.method_name.to_s.start_with?('set_') && node.arguments.one?
         end
       end
     end

data/lib/rubocop/cop/{style → naming}/ascii_identifiers.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop checks for non-ascii characters in identifier names.
       class AsciiIdentifiers < Cop
         MSG = 'Use only ascii symbols in identifiers.'.freeze

data/lib/rubocop/cop/{style/op_method.rb → naming/binary_operator_parameter_name.rb}

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that certain binary operator methods have their
       # sole  parameter named `other`.
       #
@@ -13,7 +13,7 @@ module RuboCop
       #
       #   # good
       #   def +(other); end
-      class OpMethod < Cop
+      class BinaryOperatorParameterName < Cop
         MSG = 'When defining the `%s` operator, ' \
               'name its argument `other`.'.freeze
 

data/lib/rubocop/cop/{style → naming}/class_and_module_camel_case.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cops checks for class and module names with
       # an underscore in them.
       class ClassAndModuleCamelCase < Cop

data/lib/rubocop/cop/{style → naming}/constant_name.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop checks whether constant names are written using
       # SCREAMING_SNAKE_CASE.
       #

data/lib/rubocop/cop/{style → naming}/file_name.rb

@@ -4,7 +4,7 @@ require 'pathname'
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that Ruby source files have snake_case
       # names. Ruby scripts (i.e. source files with a shebang in the
       # first line) are ignored.
@@ -87,8 +87,10 @@ module RuboCop
           basename =~ (regex || SNAKE_CASE)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
-          return nil if node.nil?
+          return nil unless node
+
           name = namespace.pop
 
           on_node(%i[class module casgn], node) do |child|
@@ -96,13 +98,15 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
+            next unless namespace.empty? ||
+                        match_namespace(child, const_namespace, namespace)
 
-            return node if namespace.empty?
-            return node if match_namespace(child, const_namespace, namespace)
+            return node
           end
 
           nil
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks that your heredocs are using the configured case.
+      # By default it is configured to enforce uppercase heredocs.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: uppercase (default)
+      #
+      #   # good
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      #
+      #   # bad
+      #   <<-sql
+      #     SELECT * FROM foo
+      #   sql
+      #
+      # @example
+      #
+      #   # EnforcedStyle: lowercase
+      #
+      #   # good
+      #   <<-sql
+      #     SELECT * FROM foo
+      #   sql
+      #
+      #   # bad
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      class HeredocDelimiterCase < Cop
+        include Heredoc
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use %s heredoc delimiters.'.freeze
+
+        def on_heredoc(node)
+          return if correct_case_delimiters?(node)
+
+          add_offense(node, :heredoc_end)
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, style)
+        end
+
+        def correct_case_delimiters?(node)
+          delimiter_string(node) == correct_delimiters(node)
+        end
+
+        def correct_delimiters(node)
+          if style == :uppercase
+            delimiter_string(node).upcase
+          else
+            delimiter_string(node).downcase
+          end
+        end
+      end
+    end
+  end
+end