rubocop 0.78.0

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements or a new line.
+    module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
+      private
+
+      def check_brace_layout(node)
+        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?(node.children.last)
+
+        check(node)
+      end
+
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        last_element_line =
+          last_element_range_with_trailing_comma(node).last_line
+
+        last_element_commented =
+          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented && (node.chained? || node.argument?)
+      end
+
+      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 check_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+      end
+
+      def check_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+      end
+
+      def check_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, location: :end,
+                            message: self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, location: :end,
+                            message: self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def children(node)
+        node.children
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def opening_brace_on_same_line?(node)
+        node.loc.begin.line == children(node).first.first_line
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.last_line
+      end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
+    module NegativeConditional
+      extend NodePattern::Macros
+
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'
+
+      private
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      def_node_matcher :empty_condition?, '(begin)'
+
+      def check_negative_conditional(node)
+        condition = node.condition
+
+        return if empty_condition?(condition)
+
+        condition = condition.children.last while condition.begin_type?
+
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
+
+        add_offense(node)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides a list of methods that are:
+    # 1. In the NilClass by default
+    # 2. Added to NilClass by explicitly requiring any standard libraries
+    # 3. Cop's configuration parameter AllowedMethods.
+    module NilMethods
+      private
+
+      def nil_methods
+        nil.methods + other_stdlib_methods + allowed_methods
+      end
+
+      def other_stdlib_methods
+        [:to_d]
+      end
+
+      def allowed_methods
+        cop_config['AllowedMethods'].map(&:to_sym)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking if and unless expressions.
+    module OnNormalIfUnless
+      def on_if(node)
+        return if node.modifier_form? || node.ternary?
+
+        on_normal_if_unless(node)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Bundler/OrderedGems and
+    # Gemspec/OrderedDependencies.
+    module OrderedGemNode
+      private
+
+      def get_source_range(node, comments_as_separators)
+        unless comments_as_separators
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.loc.expression unless first_comment.nil?
+        end
+        node.source_range
+      end
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        string_a.downcase < string_b.downcase
+      end
+
+      def consecutive_lines(previous, current)
+        first_line = get_source_range(
+          current,
+          treat_comments_as_separators
+        ).first_line
+        previous.source_range.last_line == first_line - 1
+      end
+
+      def register_offense(previous, current)
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
+        add_offense(current, message: message)
+      end
+
+      def gem_name(declaration_node)
+        gem_node = declaration_node.first_argument
+
+        find_gem_name(gem_node)
+      end
+
+      def find_gem_name(gem_node)
+        return gem_node.str_content if gem_node.str_type?
+
+        find_gem_name(gem_node.receiver)
+      end
+
+      def treat_comments_as_separators
+        cop_config['TreatCommentsAsGroupSeparators']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling parentheses.
+    module Parentheses
+      private
+
+      def parens_required?(node)
+        range  = node.source_range
+        source = range.source_buffer.source
+        source[range.begin_pos - 1] =~ /[a-z]/ ||
+          source[range.end_pos] =~ /[a-z]/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops which processes Parser's diagnostics.
+    # This mixin requires its user class to define `#relevant_diagnostic?`.
+    #
+    #     def relevant_diagnostic?(diagnostic)
+    #       diagnostic.reason == :my_interested_diagnostic_type
+    #     end
+    #
+    # If you want to use an alternative offense message rather than the one in
+    # Parser's diagnostic, define `#alternative_message`.
+    #
+    #     def alternative_message(diagnostic)
+    #       'My custom message'
+    #     end
+    module ParserDiagnostic
+      def investigate(processed_source)
+        processed_source.diagnostics.each do |d|
+          next unless relevant_diagnostic?(d)
+
+          message = if respond_to?(:alternative_message, true)
+                      alternative_message(d)
+                    else
+                      d.message.capitalize
+                    end
+
+          add_offense(nil,
+                      location: d.location,
+                      message: message,
+                      severity: d.level)
+        end
+      end
+    end
+  end
+end

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&.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/percent_literal.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literals.
+    module PercentLiteral
+      include RangeHelp
+
+      private
+
+      def percent_literal?(node)
+        return unless (begin_source = begin_source(node))
+
+        begin_source.start_with?('%')
+      end
+
+      def process(node, *types)
+        return unless percent_literal?(node) && types.include?(type(node))
+
+        on_percent_literal(node)
+      end
+
+      def begin_source(node)
+        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def type(node)
+        node.loc.begin.source[0..-2]
+      end
+
+      # A range containing only the contents of the percent literal (e.g. in
+      # %i{1 2 3} this will be the range covering '1 2 3' only)
+      def contents_range(node)
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether an AST node/token is aligned
+    # with something on a preceding or following line
+    module PrecedingFollowingAlignment
+      private
+
+      def allow_for_alignment?
+        cop_config['AllowForAlignment']
+      end
+
+      def aligned_with_something?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_token?))
+      end
+
+      def aligned_with_operator?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_operator?))
+      end
+
+      def aligned_with_preceding_assignment(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_assignment(token, preceding_line_range)
+      end
+
+      def aligned_with_subsequent_assignment(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_assignment(token, subsequent_line_range)
+      end
+
+      def aligned_with_adjacent_line?(range, predicate)
+        # minus 2 because node.loc.line is zero-based
+        pre  = (range.line - 2).downto(0)
+        post = range.line.upto(processed_source.lines.size - 1)
+
+        aligned_with_any_line_range?([pre, post], range, &predicate)
+      end
+
+      def aligned_with_any_line_range?(line_ranges, range, &predicate)
+        return true if aligned_with_any_line?(line_ranges, range, &predicate)
+
+        # If no aligned token was found, search for an aligned token on the
+        # nearest line with the same indentation as the checked line.
+        base_indentation = processed_source.lines[range.line - 1] =~ /\S/
+
+        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
+        line_ranges.any? do |line_nos|
+          aligned_with_line?(line_nos, range, indent, &predicate)
+        end
+      end
+
+      def aligned_with_line?(line_nos, range, indent = nil)
+        line_nos.each do |lineno|
+          next if aligned_comment_lines.include?(lineno + 1)
+
+          line = processed_source.lines[lineno]
+          index = line =~ /\S/
+          next unless index
+          next if indent && indent != index
+
+          return yield(range, line)
+        end
+        false
+      end
+
+      def aligned_comment_lines
+        @aligned_comment_lines ||=
+          processed_source.comments.map(&:loc).select do |r|
+            begins_its_line?(r.expression)
+          end.map(&:line)
+      end
+
+      def aligned_token?(range, line)
+        aligned_words?(range, line) ||
+          aligned_char?(range, line) ||
+          aligned_assignment?(range, line)
+      end
+
+      def aligned_operator?(range, line)
+        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      end
+
+      def aligned_words?(range, line)
+        line[range.column - 1, 2] =~ /\s\S/
+      end
+
+      def aligned_char?(range, line)
+        line[range.column] == range.source[0]
+      end
+
+      def aligned_assignment?(range, line)
+        range.source[-1] == '=' && line[range.last_column - 1] == '='
+      end
+
+      def aligned_identical?(range, line)
+        range.source == line[range.column, range.size]
+      end
+
+      def aligned_with_assignment(token, line_range)
+        token_line_indent    = processed_source
+                               .line_indentation(token.line)
+        assignment_lines     = relevant_assignment_lines(line_range)
+        relevant_line_number = assignment_lines[1]
+
+        return :none unless relevant_line_number
+
+        relevant_indent = processed_source
+                          .line_indentation(relevant_line_number)
+
+        return :none if relevant_indent < token_line_indent
+
+        assignment_line = processed_source.lines[relevant_line_number - 1]
+
+        return :none unless assignment_line
+
+        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+      end
+
+      def assignment_lines
+        @assignment_lines ||= assignment_tokens.map(&:line)
+      end
+
+      def assignment_tokens
+        @assignment_tokens ||= begin
+          tokens = processed_source.tokens.select(&:equal_sign?)
+
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+      def relevant_assignment_lines(line_range)
+        result                        = []
+        original_line_indent          = processed_source
+                                        .line_indentation(line_range.first)
+        relevant_line_indent_at_level = true
+
+        line_range.each do |line_number|
+          current_line_indent = processed_source.line_indentation(line_number)
+          blank_line          = processed_source.lines[line_number - 1].blank?
+
+          if (current_line_indent < original_line_indent && !blank_line) ||
+             (relevant_line_indent_at_level && blank_line)
+            break
+          end
+
+          result << line_number if assignment_lines.include?(line_number) &&
+                                   current_line_indent == original_line_indent
+
+          unless blank_line
+            relevant_line_indent_at_level = \
+              current_line_indent == original_line_indent
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+
+      def remove_optarg_equals(asgn_tokens, processed_source)
+        optargs    = processed_source.ast.each_node(:optarg)
+        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      end
+    end
+  end
+end