super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/style/redundant_initialize.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `initialize` methods that are redundant.
+      #
+      # An initializer is redundant if it does not do anything, or if it only
+      # calls `super` with the same arguments given to it. If the initializer takes
+      # an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it
+      # will not register an offense, because it allows the initializer to take a different
+      # number of arguments as its superclass potentially does.
+      #
+      # NOTE: If an initializer takes any arguments and has an empty body, RuboCop
+      # assumes it to *not* be redundant. This is to prevent potential `ArgumentError`.
+      #
+      # NOTE: If an initializer argument has a default value, RuboCop assumes it
+      # to *not* be redundant.
+      #
+      # NOTE: Empty initializers are registered as offenses, but it is possible
+      # to purposely create an empty `initialize` method to override a superclass's
+      # initializer.
+      #
+      # @safety
+      #   This cop is unsafe because removing an empty initializer may alter
+      #   the behavior of the code, particularly if the superclass initializer
+      #   raises an exception. In such cases, the empty initializer may act as
+      #   a safeguard to prevent unintended errors from propagating.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #   end
+      #
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super(a, b)
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #     super
+      #   end
+      #
+      #   # good (different number of parameters)
+      #   def initialize(a, b)
+      #     super(a)
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b = 5)
+      #     super
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b: 5)
+      #     super
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(_)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(*)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(**)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(...)
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      class RedundantInitialize < Base
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove unnecessary `initialize` method.'
+        MSG_EMPTY = 'Remove unnecessary empty `initialize` method.'
+
+        # @!method initialize_forwards?(node)
+        def_node_matcher :initialize_forwards?, <<~PATTERN
+          (def _ (args $arg*) $({super zsuper} ...))
+        PATTERN
+
+        def on_def(node)
+          return if acceptable?(node)
+
+          if node.body.nil?
+            register_offense(node, MSG_EMPTY) if node.arguments.empty?
+          else
+            return if node.body.begin_type?
+
+            if (args, super_node = initialize_forwards?(node))
+              return unless same_args?(super_node, args)
+
+              register_offense(node, MSG)
+            end
+          end
+        end
+
+        private
+
+        def register_offense(node, message)
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        def acceptable?(node)
+          !node.method?(:initialize) || forwards?(node) || allow_comments?(node)
+        end
+
+        def forwards?(node)
+          node.arguments.each_child_node(:restarg, :kwrestarg, :forward_args, :forward_arg).any?
+        end
+
+        def allow_comments?(node)
+          return false unless cop_config['AllowComments']
+
+          contains_comments?(node) && !comments_contain_disables?(node, name)
+        end
+
+        def same_args?(super_node, args)
+          return true if super_node.zsuper_type?
+
+          args.map(&:name) == super_node.arguments.map { |a| a.children[0] }
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/redundant_interpolation.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for strings that are just an interpolated expression.
+      #
+      # @safety
+      #   Autocorrection is unsafe because when calling a destructive method to string,
+      #   the resulting string may have different behavior or raise `FrozenError`.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = 'a'
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'a'
+      #   y = x.to_s
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'ab'
+      #
+      #   x = 'a'.freeze
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'.
+      #   y = x.to_s
+      #   y << 'b'   # raise `FrozenError`.
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   "#{@var}"
+      #
+      #   # good
+      #   @var.to_s
+      #
+      #   # good if @var is already a String
+      #   @var
+      class RedundantInterpolation < Base
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Prefer `to_s` over string interpolation.'
+
+        def self.autocorrect_incompatible_with
+          [Style::LineEndConcatenation]
+        end
+
+        def on_dstr(node)
+          return unless single_interpolation?(node)
+
+          embedded_node = node.children.first
+          return if use_match_pattern?(embedded_node)
+
+          add_offense(node) do |corrector|
+            if variable_interpolation?(embedded_node)
+              autocorrect_variable_interpolation(corrector, embedded_node, node)
+            elsif single_variable_interpolation?(embedded_node)
+              autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+            else
+              autocorrect_other(corrector, embedded_node, node)
+            end
+          end
+        end
+
+        private
+
+        def single_interpolation?(node)
+          node.children.one? &&
+            interpolation?(node.children.first) &&
+            !implicit_concatenation?(node) &&
+            !embedded_in_percent_array?(node)
+        end
+
+        def use_match_pattern?(node)
+          return false if target_ruby_version <= 2.7
+
+          node.children.any? do |child|
+            child.respond_to?(:match_pattern_type?) && child.match_pattern_type?
+          end
+        end
+
+        def single_variable_interpolation?(node)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            (first_child.send_type? && !first_child.operator_method?)
+        end
+
+        def interpolation?(node)
+          variable_interpolation?(node) || node.begin_type?
+        end
+
+        def variable_interpolation?(node)
+          node.variable? || node.reference?
+        end
+
+        def implicit_concatenation?(node)
+          node.parent&.dstr_type?
+        end
+
+        def embedded_in_percent_array?(node)
+          node.parent&.array_type? && percent_literal?(node.parent)
+        end
+
+        def autocorrect_variable_interpolation(corrector, embedded_node, node)
+          replacement = "#{embedded_node.source}.to_s"
+
+          corrector.replace(node, replacement)
+        end
+
+        def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+          embedded_var = embedded_node.children.first
+
+          source = if require_parentheses?(embedded_var)
+                     receiver = range_between(
+                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
+                     )
+                     arguments = embedded_var.arguments.map(&:source).join(', ')
+
+                     "#{receiver.source}(#{arguments})"
+                   else
+                     embedded_var.source
+                   end
+
+          corrector.replace(node, "#{source}.to_s")
+        end
+
+        def autocorrect_other(corrector, embedded_node, node)
+          loc = node.loc
+          embedded_loc = embedded_node.loc
+
+          corrector.replace(loc.begin, '')
+          corrector.replace(loc.end, '')
+          corrector.replace(embedded_loc.begin, '(')
+          corrector.replace(embedded_loc.end, ').to_s')
+        end
+
+        def require_parentheses?(node)
+          node.send_type? && node.arguments.any? && !node.parenthesized_call?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# 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
+      #
+      #   # bad
+      #   String.new("#{foo} bar")
+      #
+      #   # good
+      #   "#{foo} bar"
+      #
+      class RedundantInterpolationUnfreeze < Base
+        include FrozenStringLiteral
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't unfreeze interpolated strings as they are already unfrozen."
+
+        minimum_target_ruby_version 3.0
+
+        # @!method redundant_unfreeze?(node)
+        def_node_matcher :redundant_unfreeze?, <<~PATTERN
+          {
+            (send dstr_type? {:+@ :dup})
+            (send (const nil? :String) :new dstr_type?)
+          }
+        PATTERN
+
+        def on_dstr(node)
+          return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+          return unless redundant_unfreeze?(node.parent)
+
+          add_offense(offense_range(node.parent)) do |corrector|
+            corrector.replace(node.parent, node.source)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          if node.method?(:new)
+            node.source_range.begin.join(node.loc.selector)
+          else
+            node.loc.selector
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks 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
+        STRING_LITERAL_BEGIN_TOKENS = %i[tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tSYMBEG].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) ||
+            inside_string_literal_with_interpolation?(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 inside_string_literal_with_interpolation?(range)
+          string_depth = 0
+          processed_source.tokens.each do |token|
+            break if token.pos.begin_pos >= range.begin_pos
+
+            if STRING_LITERAL_BEGIN_TOKENS.include?(token.type)
+              string_depth += 1
+            elsif token.type == :tSTRING_END
+              string_depth -= 1
+            end
+          end
+          string_depth.positive?
+        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_number = processed_source.ast.last_line
+          last_line = processed_source.lines[last_line_number - 1]
+          return unless code_ends_with_continuation?(last_line)
+
+          line_continuation_range = trailing_line_continuation_range(last_line_number)
+
+          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
+
+        # The backslash is the last character of the line; locate it by the line's
+        # position in the buffer rather than treating the column as an absolute offset
+        # (which corrupts an earlier line in multi-line files).
+        def trailing_line_continuation_range(line_number)
+          line_range = processed_source.buffer.line_range(line_number)
+          range_between(line_range.end_pos - 1, line_range.end_pos)
+        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