rubocop 0.87.1

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

@@ -0,0 +1,23 @@
+# 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
+      include AllowedMethods
+
+      private
+
+      def nil_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
+      end
+
+      def other_stdlib_methods
+        [:to_d]
+      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,61 @@
+# 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 gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
+      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,16 @@
+# 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
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
+      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(find_offense_node_by(d),
+                      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)
+        /\s\S/.match?(line[range.column - 1, 2])
+      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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literal delimiters.
+    class PreferredDelimiters
+      attr_reader :type, :config
+
+      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+
+      def initialize(type, config, preferred_delimiters)
+        @type = type
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def delimiters
+        preferred_delimiters[type].split(//)
+      end
+
+      private
+
+      def ensure_valid_preferred_delimiters
+        invalid = preferred_delimiters_config.keys -
+                  (PERCENT_LITERAL_TYPES + %w[default])
+        return if invalid.empty?
+
+        raise ArgumentError,
+              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+      end
+
+      def preferred_delimiters
+        @preferred_delimiters ||=
+          begin
+            ensure_valid_preferred_delimiters
+
+            if preferred_delimiters_config.key?('default')
+              Hash[PERCENT_LITERAL_TYPES.map do |type|
+                [type, preferred_delimiters_config[type] ||
+                  preferred_delimiters_config['default']]
+              end]
+            else
+              preferred_delimiters_config
+            end
+          end
+      end
+
+      def preferred_delimiters_config
+        config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+      end
+    end
+  end
+end