rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Before Ruby 3.0, interpolated strings followed the frozen string literal
+      # magic comment which sometimes made it necessary to explicitly unfreeze them.
+      # Ruby 3.0 changed interpolated strings to always be unfrozen which makes
+      # unfreezing them redundant.
+      #
+      # @example
+      #   # bad
+      #   +"#{foo} bar"
+      #
+      #   # bad
+      #   "#{foo} bar".dup
+      #
+      #   # good
+      #   "#{foo} bar"
+      #
+      class RedundantInterpolationUnfreeze < Base
+        include FrozenStringLiteral
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't unfreeze interpolated strings as they are already unfrozen."
+
+        RESTRICT_ON_SEND = %i[+@ dup].freeze
+
+        minimum_target_ruby_version 3.0
+
+        def on_send(node)
+          return if node.arguments?
+          return unless (receiver = node.receiver)
+          return unless receiver.dstr_type?
+          return if uninterpolated_string?(receiver) || uninterpolated_heredoc?(receiver)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot) unless node.unary_operation?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_line_continuation.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for redundant line continuation.
+      #
+      # This cop marks a line continuation as redundant if removing the backslash
+      # does not result in a syntax error.
+      # However, a backslash at the end of a comment or
+      # for string concatenation is not redundant and is not considered an offense.
+      #
+      # @example
+      #   # bad
+      #   foo. \
+      #     bar
+      #   foo \
+      #     &.bar \
+      #       .baz
+      #
+      #   # good
+      #   foo.
+      #     bar
+      #   foo
+      #     &.bar
+      #       .baz
+      #
+      #   # bad
+      #   [foo, \
+      #     bar]
+      #   {foo: \
+      #     bar}
+      #
+      #   # good
+      #   [foo,
+      #     bar]
+      #   {foo:
+      #     bar}
+      #
+      #   # bad
+      #   foo(bar, \
+      #     baz)
+      #
+      #   # good
+      #   foo(bar,
+      #     baz)
+      #
+      #   # also good - backslash in string concatenation is not redundant
+      #   foo('bar' \
+      #     'baz')
+      #
+      #   # also good - backslash at the end of a comment is not redundant
+      #   foo(bar, # \
+      #     baz)
+      #
+      #   # also good - backslash at the line following the newline begins with a + or -,
+      #   # it is not redundant
+      #   1 \
+      #     + 2 \
+      #       - 3
+      #
+      #   # also good - backslash with newline between the method name and its arguments,
+      #   # it is not redundant.
+      #   some_method \
+      #     (argument)
+      #
+      class RedundantLineContinuation < Base
+        include MatchRange
+        extend AutoCorrector
+
+        MSG = 'Redundant line continuation.'
+        LINE_CONTINUATION = '\\'
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
+        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
+        ARGUMENT_TYPES = %i[
+          kDEF kDEFINED kFALSE kNIL kSELF kTRUE tAMPER tBANG tCARET tCHARACTER tCOLON3 tCONSTANT
+          tCVAR tDOT2 tDOT3 tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR tLAMBDA tLBRACK tLCURLY
+          tLPAREN_ARG tPIPE tQSYMBOLS_BEG tQWORDS_BEG tREGEXP_BEG tSTAR tSTRING tSTRING_BEG tSYMBEG
+          tSYMBOL tSYMBOLS_BEG tTILDE tUMINUS tUNARY_NUM tUPLUS tWORDS_BEG tXSTRING_BEG
+        ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[
+          tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
+        ].freeze
+        ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
+
+        def on_new_investigation
+          return unless processed_source.ast
+
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
+            next if require_line_continuation?(range)
+            next unless redundant_line_continuation?(range)
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+
+          inspect_end_of_ruby_code_line_continuation
+        end
+
+        private
+
+        def require_line_continuation?(range)
+          !ends_with_uncommented_backslash?(range) ||
+            string_concatenation?(range.source_line) ||
+            start_with_arithmetic_operator?(range) ||
+            inside_string_literal_or_method_with_argument?(range) ||
+            leading_dot_method_chain_with_blank_line?(range)
+        end
+
+        def ends_with_uncommented_backslash?(range)
+          # A line continuation always needs to be the last character on the line, which
+          # means that it is impossible to have a comment following a continuation.
+          # Therefore, if the line contains a comment, it cannot end with a continuation.
+          return false if processed_source.line_with_comment?(range.line)
+
+          range.source_line.end_with?(LINE_CONTINUATION)
+        end
+
+        def string_concatenation?(source_line)
+          /["']\s*\\\z/.match?(source_line)
+        end
+
+        def inside_string_literal_or_method_with_argument?(range)
+          line_range = range_by_whole_lines(range)
+
+          processed_source.tokens.each_cons(2).any? do |token, next_token|
+            next if token.line == next_token.line
+
+            inside_string_literal?(range, token) ||
+              method_with_argument?(line_range, token, next_token)
+          end
+        end
+
+        def leading_dot_method_chain_with_blank_line?(range)
+          return false unless range.source_line.strip.start_with?('.', '&.')
+
+          processed_source[range.line].strip.empty?
+        end
+
+        def redundant_line_continuation?(range)
+          return true unless (node = find_node_for_line(range.last_line))
+          return false if argument_newline?(node)
+
+          # Check if source is still valid without the continuation
+          source = processed_source.raw_source.dup
+          source[range.begin_pos, range.length] = "\n"
+          parse(source).valid_syntax?
+        end
+
+        def inspect_end_of_ruby_code_line_continuation
+          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          return unless code_ends_with_continuation?(last_line)
+
+          last_column = last_line.length
+          line_continuation_range = range_between(last_column - 1, last_column)
+
+          add_offense(line_continuation_range) do |corrector|
+            corrector.remove_trailing(line_continuation_range, 1)
+          end
+        end
+
+        def code_ends_with_continuation?(last_line)
+          return false if processed_source.line_with_comment?(processed_source.ast.last_line)
+
+          last_line.end_with?(LINE_CONTINUATION)
+        end
+
+        def inside_string_literal?(range, token)
+          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
+        end
+
+        # A method call without parentheses such as the following cannot remove `\`:
+        #
+        #   do_something \
+        #     argument
+        def method_with_argument?(line_range, current_token, next_token)
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+          return false unless current_token.pos.overlaps?(line_range)
+
+          ARGUMENT_TYPES.include?(next_token.type)
+        end
+
+        def argument_newline?(node)
+          return false if node.parenthesized_call?
+
+          node = node.children.first if node.root? && node.begin_type?
+
+          if argument_is_method?(node)
+            argument_newline?(node.first_argument)
+          else
+            return false unless method_call_with_arguments?(node)
+
+            node.loc.selector.line != node.first_argument.loc.line
+          end
+        end
+
+        def find_node_for_line(last_line)
+          processed_source.ast.each_node do |node|
+            return node if same_line?(node, last_line)
+          end
+        end
+
+        def same_line?(node, line)
+          return false unless (source_range = node.source_range)
+
+          if node.is_a?(AST::StrNode)
+            if node.heredoc?
+              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
+            else
+              (source_range.line..source_range.last_line).cover?(line)
+            end
+          else
+            source_range.line == line
+          end
+        end
+
+        def argument_is_method?(node)
+          return false unless node.send_type?
+          return false unless (first_argument = node.first_argument)
+
+          method_call_with_arguments?(first_argument)
+        end
+
+        def method_call_with_arguments?(node)
+          node.call_type? && !node.arguments.empty?
+        end
+
+        def start_with_arithmetic_operator?(range)
+          line_range = processed_source.buffer.line_range(range.line + 1)
+          ARITHMETIC_OPERATOR_TOKENS.include?(processed_source.first_token_of(line_range).type)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   (x) if ((y.z).nil?)
+      #
+      #   # good
+      #   x if y.z.nil?
+      #
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
+        include Parentheses
+        extend AutoCorrector
+
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
+
+        # @!method square_brackets?(node)
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
+        PATTERN
+
+        # @!method method_node_and_args(node)
+        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
+
+        # @!method rescue?(node)
+        def_node_matcher :rescue?, '{^resbody ^^resbody}'
+
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
+        def on_begin(node)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
+
+          check(node)
+        end
+
+        private
+
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
+        def parens_allowed?(node)
+          empty_parentheses?(node) ||
+            first_arg_begins_with_hash_literal?(node) ||
+            rescue?(node) ||
+            allowed_pin_operator?(node) ||
+            allowed_expression?(node)
+        end
+
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.type?(:while_post, :until_post, :match_with_lvasgn) ||
+            like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
+        end
+
+        def allowed_expression?(node)
+          allowed_ancestor?(node) ||
+            allowed_multiple_expression?(node) ||
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
+        end
+
+        def allowed_ancestor?(node)
+          # Don't flag `break(1)`, etc
+          keyword_ancestor?(node) && parens_required?(node)
+        end
+
+        def allowed_multiple_expression?(node)
+          return false if node.children.one?
+
+          ancestor = node.ancestors.first
+          return false unless ancestor
+
+          !ancestor.type?(:begin, :any_def, :any_block)
+        end
+
+        def allowed_ternary?(node)
+          return false unless node&.parent&.if_type?
+
+          node.parent.ternary? && ternary_parentheses_required?
+        end
+
+        def ternary_parentheses_required?
+          config = @config.for_cop('Style/TernaryParentheses')
+          allowed_styles = %w[require_parentheses require_parentheses_when_complex]
+
+          config.fetch('Enabled') && allowed_styles.include?(config['EnforcedStyle'])
+        end
+
+        def like_method_argument_parentheses?(node)
+          return false unless node.type?(:send, :super, :yield)
+
+          node.arguments.one? && !node.parenthesized? &&
+            !node.operator_method? && node.first_argument.begin_type?
+        end
+
+        def multiline_control_flow_statements?(node)
+          return false unless (parent = node.parent)
+          return false if parent.single_line?
+
+          parent.type?(:return, :next, :break)
+        end
+
+        def empty_parentheses?(node)
+          # Don't flag `()`
+          node.children.empty?
+        end
+
+        def first_arg_begins_with_hash_literal?(node)
+          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
+        end
+
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
+
+          method_chain_begins_with_hash_literal(node.children.first)
+        end
+
+        def check(begin_node)
+          node = begin_node.children.first
+
+          if (message = find_offense_message(begin_node, node))
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node)
+              begin_node = begin_node.parent
+            end
+
+            return offense(begin_node, message)
+          end
+
+          check_send(begin_node, node) if node.call_type?
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
+            return 'an assignment'
+          end
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
+          return 'an interpolated expression' if interpolation?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node)
+
+          return if begin_node.chained?
+
+          if node.operator_keyword?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
+            return if begin_node.parent&.if_type? && begin_node.parent.ternary?
+
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        # @!method interpolation?(node)
+        def_node_matcher :interpolation?, '[^begin ^^dstr]'
+
+        def argument_of_parenthesized_method_call?(node)
+          return false unless (parent = node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != node
+        end
+
+        def allow_in_multiline_conditions?
+          !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
+        end
+
+        def check_send(begin_node, node)
+          return check_unary(begin_node, node) if node.unary_operation?
+
+          return unless method_call_with_redundant_parentheses?(node)
+          return if call_chain_starts_with_int?(begin_node, node) ||
+                    do_end_block_in_method_chain?(begin_node, node)
+
+          offense(begin_node, 'a method call')
+        end
+
+        def check_unary(begin_node, node)
+          return if begin_node.chained?
+
+          node = node.children.first while suspect_unary?(node)
+
+          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+
+          offense(begin_node, 'a unary operation')
+        end
+
+        def offense(node, msg)
+          add_offense(node, message: "Don't use parentheses around #{msg}.") do |corrector|
+            ParenthesesCorrector.correct(corrector, node)
+          end
+        end
+
+        def suspect_unary?(node)
+          node.send_type? && node.unary_operation? && !node.prefix_not?
+        end
+
+        def keyword_ancestor?(node)
+          node.parent&.keyword?
+        end
+
+        def disallowed_literal?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
+        end
+
+        def raised_to_power_negative_numeric?(begin_node, node)
+          return false unless node.numeric_type?
+
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
+
+          base_value = node.children.first
+
+          base_value.negative? && next_sibling == :**
+        end
+
+        def keyword_with_redundant_parentheses?(node)
+          return false unless node.keyword?
+          return true if node.special_keyword?
+
+          args = *node
+
+          if only_begin_arg?(args)
+            parentheses?(args.first)
+          else
+            args.empty? || parentheses?(node)
+          end
+        end
+
+        def method_call_with_redundant_parentheses?(node)
+          return false unless node.call_type?
+          return false if node.prefix_not?
+
+          send_node, args = method_node_and_args(node)
+
+          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+        end
+
+        def only_begin_arg?(args)
+          args.one? && args.first&.begin_type?
+        end
+
+        def first_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
+        end
+
+        # @!method first_send_argument?(node)
+        def_node_matcher :first_send_argument?, <<~PATTERN
+          ^(send _ _ equal?(%0) ...)
+        PATTERN
+
+        # @!method first_super_argument?(node)
+        def_node_matcher :first_super_argument?, <<~PATTERN
+          ^(super equal?(%0) ...)
+        PATTERN
+
+        # @!method first_yield_argument?(node)
+        def_node_matcher :first_yield_argument?, <<~PATTERN
+          ^(yield equal?(%0) ...)
+        PATTERN
+
+        def call_chain_starts_with_int?(begin_node, send_node)
+          recv = first_part_of_call_chain(send_node)
+          recv&.int_type? && (parent = begin_node.parent) &&
+            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
+        end
+
+        def do_end_block_in_method_chain?(begin_node, node)
+          return false unless (block = node.each_descendant(:any_block).first)
+
+          block.keywords? && begin_node.each_ancestor(:call).any?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_percent_q.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of the %q/%Q syntax when '' or "" would do.
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
+      class RedundantPercentQ < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+        SINGLE_QUOTE = "'"
+        QUOTE = '"'
+        EMPTY = ''
+        PERCENT_Q = '%q'
+        PERCENT_CAPITAL_Q = '%Q'
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
+
+        def on_dstr(node)
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
+
+          add_offense(node) do |corrector|
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
+
+        def allowed_percent_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
+        end
+
+        def message(node)
+          src = node.source
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
+                  else
+                    EMPTY
+                  end
+          format(MSG, q_type: src[0, 2], extra: extra)
+        end
+
+        def string_literal?(node)
+          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
+            node.loc.begin && node.loc.end
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+        end
+
+        def acceptable_q?(node)
+          src = node.source
+
+          return true if STRING_INTERPOLATION_REGEXP.match?(src)
+
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
+        end
+
+        def acceptable_capital_q?(node)
+          src = node.source
+          src.include?(QUOTE) &&
+            (STRING_INTERPOLATION_REGEXP.match?(src) ||
+            (node.str_type? && double_quotes_required?(src)))
+        end
+      end
+    end
+  end
+end