rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      include RangeHelp
+
+      MSG = 'Space found before %<token>s.'
+
+      def on_new_investigation
+        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
+          add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.remove_space(corrector, pos_before)
+          end
+        end
+      end
+
+      private
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token2)
+          next unless space_missing?(token1, token2)
+          next if space_required_after?(token1)
+
+          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
+
+          yield token2, pos_before_punctuation
+        end
+      end
+
+      def space_missing?(token1, token2)
+        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
+      end
+
+      def space_required_after?(token)
+        token.left_curly_brace? && space_required_after_lcurly?
+      end
+
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
+        style = cfg['EnforcedStyle'] || 'space'
+        style == 'space'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for modifier cops.
+    module StatementModifier
+      include LineLengthHelp
+
+      private
+
+      def single_line_as_modifier?(node)
+        return false if non_eligible_node?(node) ||
+                        non_eligible_body?(node.body) ||
+                        non_eligible_condition?(node.condition)
+
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
+      end
+
+      def non_eligible_body?(body)
+        body.nil? ||
+          body.empty_source? ||
+          body.begin_type? ||
+          processed_source.contains_comment?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
+
+      def modifier_fits_on_single_line?(node)
+        return true unless max_line_length
+
+        length_in_modifier_form(node) <= max_line_length
+      end
+
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after(node)}")
+      end
+
+      def to_modifier_form(node)
+        body = if_body_source(node.body)
+        expression = [body, node.keyword, node.condition.source].compact.join(' ')
+        parenthesized = parenthesize?(node) ? "(#{expression})" : expression
+        [parenthesized, first_line_comment(node)].compact.join(' ')
+      end
+
+      def if_body_source(if_body)
+        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+          "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        else
+          if_body.source
+        end
+      end
+
+      def omitted_value_in_last_hash_arg?(if_body)
+        return false unless (last_argument = if_body.last_argument)
+
+        last_argument.hash_type? && last_argument.pairs.last&.value_omission?
+      end
+
+      def method_source(if_body)
+        end_range = if_body.implicit_call? ? if_body.loc.dot.end : if_body.loc.selector
+
+        if_body.source_range.begin.join(end_range).source
+      end
+
+      def first_line_comment(node)
+        comment = processed_source.comments.find { |c| same_line?(c, node) }
+        return unless comment
+
+        comment_source = comment.source
+        comment_source unless comment_disables_cop?(comment_source)
+      end
+
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..]
+        code unless code.empty?
+      end
+
+      def parenthesize?(node)
+        # Parenthesize corrected expression if changing to modifier-if form
+        # would change the meaning of the parent expression
+        # (due to the low operator precedence of modifier-if)
+        parent = node.parent
+        return false if parent.nil?
+        return true if parent.assignment? || parent.operator_keyword?
+        return true if %i[array pair].include?(parent.type)
+
+        node.parent.send_type?
+      end
+
+      def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
+        config.for_cop('Layout/LineLength')['Max']
+      end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions to determine
+    # what is an offense and how to do autocorrection. They get help with
+    # adding offenses for the faulty string nodes, and with filtering out
+    # nodes.
+    module StringHelp
+      def on_str(node)
+        # Constants like __FILE__ are handled as strings,
+        # but don't respond to begin.
+        return unless node.loc?(:begin)
+        return if part_of_ignored_node?(node)
+
+        if offense?(node)
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
+        else
+          correct_style_detected
+        end
+      end
+
+      def on_regexp(node)
+        ignore_node(node)
+      end
+
+      private
+
+      def inside_interpolation?(node)
+        # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
+        node.ancestors
+            .drop_while { |a| !a.begin_type? }
+            .any? { |a| a.type?(:dstr, :dsym, :regexp) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking single/double quotes.
+    module StringLiteralsHelp
+      private
+
+      def wrong_quotes?(src_or_node)
+        src = src_or_node.is_a?(RuboCop::AST::Node) ? src_or_node.source : src_or_node
+        return false if src.start_with?('%', '?')
+
+        if style == :single_quotes
+          !double_quotes_required?(src)
+        else
+          !/" | \\[^'\\] | \#[@{$]/x.match?(src)
+        end
+      end
+
+      def preferred_string_literal
+        enforce_double_quotes? ? '""' : "''"
+      end
+
+      def enforce_double_quotes?
+        string_literals_config['EnforcedStyle'] == 'double_quotes'
+      end
+
+      def string_literals_config
+        config.for_enabled_cop('Style/StringLiterals')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking and correcting surrounding whitespace.
+    module SurroundingSpace
+      include RangeHelp
+
+      NO_SPACE_COMMAND = 'Do not use'
+      SPACE_COMMAND = 'Use'
+
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
+
+      private
+
+      def side_space_range(range:, side:, include_newlines: false)
+        buffer = processed_source.buffer
+        src = buffer.source
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        if side == :left
+          end_pos = begin_pos
+          begin_pos = reposition(src, begin_pos, -1, include_newlines: include_newlines)
+        end
+        if side == :right
+          begin_pos = end_pos
+          end_pos = reposition(src, end_pos, 1, include_newlines: include_newlines)
+        end
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def on_new_investigation
+        @token_table = nil
+        super
+      end
+
+      def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                            left_token,
+                            right_token,
+                            message,
+                            start_ok: false,
+                            end_ok: false)
+        if extra_space?(left_token, :left) && !start_ok
+          space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
+        end
+        return if (!extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
+
+        space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
+      end
+
+      def space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                         left_token,
+                         right_token,
+                         message,
+                         start_ok: false,
+                         end_ok: false)
+        unless extra_space?(left_token, :left) || start_ok
+          space_offense(node, left_token, :none, message, SPACE_COMMAND)
+        end
+        return if (extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
+
+        space_offense(node, right_token, :none, message, SPACE_COMMAND)
+      end
+
+      def extra_space?(token, side)
+        return false unless token
+
+        if side == :left
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
+        else
+          SINGLE_SPACE_REGEXP.match?(String(token.space_before?))
+        end
+      end
+
+      def reposition(src, pos, step, include_newlines: false)
+        offset = step == -1 ? -1 : 0
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset]) ||
+                          (include_newlines && src[pos + offset] == "\n")
+        pos.negative? ? 0 : pos
+      end
+
+      def space_offense(node, token, side, message, command)
+        range = side_space_range(range: token.pos, side: side)
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node) unless ignored_node?(node)
+
+          ignore_node(node)
+        end
+      end
+
+      def empty_offenses(node, left, right, message)
+        range = range_between(left.begin_pos, right.end_pos)
+        if offending_empty_space?(empty_config, left, right)
+          empty_offense(node, range, message, 'Use one')
+        end
+        return unless offending_empty_no_space?(empty_config, left, right)
+
+        empty_offense(node, range, message, 'Do not use')
+      end
+
+      def empty_offense(node, range, message, command)
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node)
+        end
+      end
+
+      def empty_brackets?(left_bracket_token, right_bracket_token, tokens: processed_source.tokens)
+        left_index = tokens.index(left_bracket_token)
+        right_index = tokens.index(right_bracket_token)
+        right_index && left_index == right_index - 1
+      end
+
+      def offending_empty_space?(config, left_token, right_token)
+        config == 'space' && !space_between?(left_token, right_token)
+      end
+
+      def offending_empty_no_space?(config, left_token, right_token)
+        config == 'no_space' && !no_character_between?(left_token, right_token)
+      end
+
+      def space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos &&
+          processed_source.buffer.source[left_bracket_token.end_pos] == ' '
+      end
+
+      def no_character_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos == right_bracket_token.begin_pos
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions for working
+    # with symbol nodes.
+    module SymbolHelp
+      def hash_key?(node)
+        node.parent&.pair_type? && node == node.parent.child_nodes.first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target ruby version.
+    module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
+      def required_maximum_ruby_version
+        @maximum_target_ruby_version
+      end
+
+      def minimum_target_ruby_version(version)
+        @minimum_target_ruby_version = version
+      end
+
+      def maximum_target_ruby_version(version)
+        @maximum_target_ruby_version = version
+      end
+
+      def support_target_ruby_version?(version)
+        # By default, no minimum or maximum versions of ruby are required
+        # to run any cop. In order to do a simple numerical comparison of
+        # the requested version against any requirements, we use 0 and
+        # Infinity as the default values to indicate no minimum (0) and no
+        # maximum (Infinity).
+        min = required_minimum_ruby_version || 0
+        max = required_maximum_ruby_version || Float::INFINITY
+
+        version.between?(min, max)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by TrailingBody cops
+    module TrailingBody
+      def trailing_body?(node)
+        body = node.to_a.reverse[0]
+        body && node.multiline? && body_on_first_line?(node, body)
+      end
+
+      def body_on_first_line?(node, body)
+        same_line?(node, body)
+      end
+
+      def first_part_of(body)
+        if body.begin_type?
+          body.children.first.source_range
+        else
+          body.source_range
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by Style/TrailingCommaInArguments,
+    # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable Metrics/ModuleLength
+    module TrailingComma
+      include ConfigurableEnforcedStyle
+      include RangeHelp
+
+      MSG = '%<command>s comma after the last %<unit>s.'
+
+      private
+
+      def style_parameter_name
+        'EnforcedStyleForMultiline'
+      end
+
+      def check(node, items, kind, begin_pos, end_pos)
+        after_last_item = range_between(begin_pos, end_pos)
+        comma_offset = comma_offset(items, after_last_item)
+
+        if comma_offset && !inside_comment?(after_last_item, comma_offset)
+          check_comma(node, kind, after_last_item.begin_pos + comma_offset)
+        elsif should_have_comma?(style, node)
+          put_comma(items, kind)
+        end
+      end
+
+      def comma_offset(items, range)
+        # If there is any heredoc in items, then match the comma succeeding
+        # any whitespace (except newlines), otherwise allow for newlines
+        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
+        comma_regex.match?(range.source) && range.source.index(',')
+      end
+
+      def check_comma(node, kind, comma_pos)
+        return if should_have_comma?(style, node)
+
+        avoid_comma(kind, comma_pos, extra_avoid_comma_info)
+      end
+
+      def check_literal(node, kind)
+        return if node.children.empty?
+        # A braceless hash is the last parameter of a method call and will be
+        # checked as such.
+        return unless brackets?(node)
+
+        check(node, node.children, kind,
+              node.children.last.source_range.end_pos,
+              node.loc.end.begin_pos)
+      end
+
+      def extra_avoid_comma_info
+        case style
+        when :comma
+          ', unless each item is on its own line'
+        when :consistent_comma
+          ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
+        else
+          ''
+        end
+      end
+
+      def should_have_comma?(style, node)
+        case style
+        when :comma
+          multiline?(node) && no_elements_on_same_line?(node)
+        when :consistent_comma
+          multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
+        else
+          false
+        end
+      end
+
+      def inside_comment?(range, comma_offset)
+        comment = processed_source.comment_at_line(range.line)
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
+      end
+
+      # Returns true if the node has round/square/curly brackets.
+      def brackets?(node)
+        node.loc.end
+      end
+
+      # Returns true if the round/square/curly brackets of the given node are
+      # on different lines, each item within is on its own line, and the
+      # closing bracket is on its own line.
+      def multiline?(node)
+        node.multiline? && !allowed_multiline_argument?(node)
+      end
+
+      def method_name_and_arguments_on_same_line?(node)
+        return false unless node.call_type?
+
+        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+
+        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
+      end
+
+      # A single argument with the closing bracket on the same line as the end
+      # of the argument is not considered multiline, even if the argument
+      # itself might span multiple lines.
+      def allowed_multiline_argument?(node)
+        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+      end
+
+      def elements(node)
+        return node.children unless node.call_type?
+
+        node.arguments.flat_map do |argument|
+          # For each argument, if it is a multi-line hash without braces,
+          # then promote the hash elements to method arguments
+          # for the purpose of determining multi-line-ness.
+          if argument.hash_type? && argument.multiline? && !argument.braces?
+            argument.children
+          else
+            argument
+          end
+        end
+      end
+
+      def no_elements_on_same_line?(node)
+        items = elements(node).map(&:source_range)
+        items << node.loc.end
+        items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
+      end
+
+      def on_same_line?(range1, range2)
+        range1.last_line == range2.line
+      end
+
+      def last_item_precedes_newline?(node)
+        after_last_item = node.children.last.source_range.end.join(node.loc.end.begin)
+
+        after_last_item.source.start_with?(/,?\s*(#.*)?\n/)
+      end
+
+      def avoid_comma(kind, comma_begin_pos, extra_info)
+        range = range_between(comma_begin_pos, comma_begin_pos + 1)
+        article = kind.include?('array') ? 'an' : 'a'
+        msg = format(
+          MSG,
+          command: 'Avoid',
+          unit: format(kind, article: article) + extra_info.to_s
+        )
+
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
+      end
+
+      def put_comma(items, kind)
+        last_item = items.last
+        return if last_item.block_pass_type?
+
+        range = autocorrect_range(last_item)
+        msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))
+
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
+      end
+
+      def autocorrect_range(item)
+        expr = item.source_range
+        ix = expr.source.rindex("\n") || 0
+        ix += expr.source[ix..] =~ /\S/
+
+        range_between(expr.begin_pos + ix, expr.end_pos)
+      end
+
+      def any_heredoc?(items)
+        items.any? { |item| heredoc?(item) }
+      end
+
+      def heredoc?(node)
+        return false unless node.is_a?(RuboCop::AST::Node)
+        return true if node.loc.respond_to?(:heredoc_body)
+
+        return heredoc_send?(node) if node.send_type?
+
+        # handle hash values
+        #
+        #   some_method({
+        #     'auth' => <<-SOURCE
+        #       ...
+        #     SOURCE
+        #   })
+        return heredoc?(node.children.last) if node.type?(:pair, :hash)
+
+        false
+      end
+
+      def heredoc_send?(node)
+        # handle heredocs with methods
+        #
+        #   some_method(<<-CODE.strip.chomp)
+        #     ...
+        #   CODE
+        return heredoc?(node.children.first) if node.children.size == 2
+        # handle nested methods
+        #
+        #   some_method(
+        #     another_method(<<-CODE.strip.chomp)
+        #       ...
+        #     CODE
+        #   )
+        return heredoc?(node.children.last) if node.children.size > 2
+
+        false
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end