super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/mixin/percent_literal.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literals.
+    module PercentLiteral
+      include RangeHelp
+
+      private
+
+      def percent_literal?(node)
+        return false 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?(:begin)
+      end
+
+      def type(node)
+        node.loc.begin.source[0..-2]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# 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
+    # rubocop:disable Metrics/ModuleLength
+    module PrecedingFollowingAlignment
+      # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
+      # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
+      ASSIGNMENT_OR_COMPARISON_TOKENS = %i[tEQL tEQ tEQQ tNEQ tLEQ tGEQ tOP_ASGN tLSHFT].freeze
+
+      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
+
+      # Allows alignment with a preceding operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_preceding_equals_operator(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_equals_sign(token, preceding_line_range)
+      end
+
+      # Allows alignment with a subsequent operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_subsequent_equals_operator(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_equals_sign(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? { |line_nos| aligned_with_line?(line_nos, range, indent, &predicate) }
+      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, lineno + 1)
+        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, lineno)
+        aligned_words?(range, line) || aligned_equals_operator?(range, lineno)
+      end
+
+      def aligned_operator?(range, line, lineno)
+        aligned_identical?(range, line) || aligned_equals_operator?(range, lineno)
+      end
+
+      def aligned_words?(range, line)
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
+
+        token = range.source
+        token == line[left_edge, token.length]
+      end
+
+      def aligned_equals_operator?(range, lineno)
+        # Check that the operator is aligned with a previous assignment or comparison operator
+        # ie. an equals sign, an operator assignment (eg. `+=`), a comparison (`==`, `<=`, etc.).
+        # Since append operators (`<<`) are a type of assignment, they are allowed as well,
+        # despite not ending with a literal equals character.
+        line_range = processed_source.buffer.line_range(lineno)
+        return false unless line_range
+
+        # Find the specific token to avoid matching up to operators inside strings
+        operator_token = processed_source.tokens_within(line_range).detect do |token|
+          ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+        end
+
+        aligned_with_preceding_equals?(range, operator_token) ||
+          aligned_with_append_operator?(range, operator_token)
+      end
+
+      def aligned_with_preceding_equals?(range, token)
+        return false unless token
+
+        range.source[-1] == '=' && range.last_column == token.pos.last_column
+      end
+
+      def aligned_with_append_operator?(range, token)
+        return false unless token
+
+        ((range.source == '<<' && token.equal_sign?) ||
+          (range.source[-1] == '=' && token.type == :tLSHFT)) &&
+          token && range.last_column == token.pos.last_column
+      end
+
+      def aligned_identical?(range, line)
+        range.source == line[range.column, range.size]
+      end
+
+      def aligned_with_equals_sign(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
+        return :none unless processed_source.lines[relevant_line_number - 1]
+
+        aligned_equals_operator?(token.pos, relevant_line_number) ? :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, or the separator of an endless method definition.
+          # For example (the equals sign to ignore is highlighted with ^):
+          #     def method(optarg = default_val); end
+          #                       ^
+          #     def method = foo
+          #                ^
+          tokens = remove_equals_in_def(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_equals_in_def(asgn_tokens, processed_source)
+        nodes = processed_source.ast.each_node(:optarg, :def)
+        eqls_to_ignore = nodes.with_object([]) do |node, arr|
+          loc = if node.def_type?
+                  node.loc.assignment if node.endless?
+                else
+                  node.loc.operator
+                end
+          arr << loc.begin_pos if loc
+        end
+
+        asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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].chars
+      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')
+              PERCENT_LITERAL_TYPES.to_h 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

data/rubocop-1.88.1/lib/rubocop/cop/mixin/project_index_help.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common helpers for cops that consult the project-wide static-analysis index
+    # via `Cop::Base#project_index`.
+    #
+    # Mixed-in cops gain the `external_dependency_checksum` override that invalidates
+    # the `ResultCache` whenever the indexed project files change on disk.
+    # To run index-backed analysis, cops should simply check whether `project_index` is non-nil;
+    # the runner only exposes a non-nil index when the user opted in via `AllCops/UseProjectIndex`
+    # and the underlying gem is available.
+    module ProjectIndexHelp
+      BUILTIN_DOCUMENT_URI = 'rubydex:built-in'
+      FILE_URI_PREFIX = 'file://'
+      # Matches the spurious leading slash before a Windows drive letter that
+      # remains after stripping `file://` from a `file:///C:/...` URI.
+      WINDOWS_DRIVE_PREFIX = %r{\A/(?=[A-Za-z]:[/\\])}.freeze
+
+      def external_dependency_checksum
+        return nil unless project_index
+
+        @external_dependency_checksum ||= Digest::SHA1.hexdigest(
+          project_index_signature.join("\n")
+        )
+      end
+
+      private
+
+      def project_index_signature
+        project_index.documents.filter_map do |doc|
+          uri = doc.uri
+          next if uri == BUILTIN_DOCUMENT_URI
+
+          path = uri.delete_prefix(FILE_URI_PREFIX).sub(WINDOWS_DRIVE_PREFIX, '')
+          mtime, size = begin
+            stat = File.stat(path)
+            [stat.mtime.to_f, stat.size]
+          rescue StandardError
+            [0, 0]
+          end
+
+          "#{path}:#{mtime}:#{size}"
+        end.sort
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/mixin/range_help.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return Parser::Source::Ranges
+    module RangeHelp
+      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
+
+      def source_range(source_buffer, line_number, column, length = 1)
+        if column.is_a?(Range)
+          column_index = column.begin
+          length = column.size
+        else
+          column_index = column
+        end
+
+        line_begin_pos = if line_number.zero?
+                           0
+                         else
+                           source_buffer.line_range(line_number).begin_pos
+                         end
+        begin_pos = line_begin_pos + column_index
+        end_pos = begin_pos + length
+
+        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+      end
+
+      # A range containing only the contents of a literal with delimiters (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
+
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
+      def range_between(start_pos, end_pos)
+        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
+      end
+
+      def range_with_surrounding_comma(range, side = :both)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
+        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
+                                       range: NOT_GIVEN, side: :both, newlines: true,
+                                       whitespace: false, continuations: false,
+                                       buffer: @processed_source.buffer)
+        range = range_positional unless range_positional == NOT_GIVEN
+
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        begin_pos = final_pos(src, begin_pos, -1, continuations, newlines, whitespace) if go_left
+        end_pos = range.end_pos
+        end_pos = final_pos(src, end_pos, 1, continuations, newlines, whitespace) if go_right
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_by_whole_lines(range, include_final_newline: false,
+                               buffer: @processed_source.buffer)
+        last_line = buffer.source_line(range.last_line)
+        end_offset = last_line.length - range.last_column
+        end_offset += 1 if include_final_newline
+
+        range.adjust(begin_pos: -range.column, end_pos: end_offset).intersect(buffer.source_range)
+      end
+
+      def column_offset_between(base_range, range)
+        effective_column(base_range) - effective_column(range)
+      end
+
+      ## Helpers for above range methods. Do not use inside Cops.
+
+      # Returns the column attribute of the range, except if the range is on
+      # the first line and there's a byte order mark at the beginning of that
+      # line, in which case 1 is subtracted from the column value. This gives
+      # the column as it appears when viewing the file in an editor.
+      def effective_column(range)
+        if range.line == 1 && @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+          range.column - 1
+        else
+          range.column
+        end
+      end
+
+      def directions(side)
+        if side == :both
+          [true, true]
+        else
+          [side == :left, side == :right]
+        end
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def final_pos(src, pos, increment, continuations, newlines, whitespace)
+        pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos_str(src, pos, increment, continuations, "\\\n")
+        pos = move_pos(src, pos, increment, newlines, /\n/)
+        move_pos(src, pos, increment, whitespace, /\s/)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def move_pos(src, pos, step, condition, regexp)
+        offset = step == -1 ? -1 : 0
+        pos += step while condition && regexp.match?(src[pos + offset])
+        pos.negative? ? 0 : pos
+      end
+
+      def move_pos_str(src, pos, step, condition, needle)
+        size = needle.length
+        offset = step == -1 ? -size : 0
+        pos += size * step while condition && src[pos + offset, size] == needle
+        pos.negative? ? 0 : pos
+      end
+
+      def range_with_comments_and_lines(node)
+        range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+      end
+
+      def range_with_comments(node)
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
+        ranges.reduce do |result, range|
+          add_range(result, range)
+        end
+      end
+
+      def add_range(range1, range2)
+        range1.with(
+          begin_pos: [range1.begin_pos, range2.begin_pos].min,
+          end_pos: [range1.end_pos, range2.end_pos].max
+        )
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/mixin/rational_literal.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      # @!method rational_literal?(node)
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/mixin/require_library.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Ensure a require statement is present for a standard library determined
+    # by variable library_name
+    module RequireLibrary
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = [:require].freeze
+
+      def ensure_required(corrector, node, library_name)
+        node = node.parent while node.parent&.parent?
+
+        if node.parent&.begin_type?
+          return if @required_libs.include?(library_name)
+
+          remove_subsequent_requires(corrector, node, library_name)
+        end
+
+        RequireLibraryCorrector.correct(corrector, node, library_name)
+      end
+
+      def remove_subsequent_requires(corrector, node, library_name)
+        node.right_siblings.each do |sibling|
+          next unless require_library_name?(sibling, library_name)
+
+          range = range_by_whole_lines(sibling.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+
+      def on_send(node)
+        return if node.parent&.parent?
+
+        name = require_any_library?(node)
+        return if name.nil?
+
+        @required_libs.add(name)
+      end
+
+      private
+
+      def on_new_investigation
+        # Holds the required files at top-level
+        @required_libs = Set.new
+        super
+      end
+
+      # @!method require_any_library?(node)
+      def_node_matcher :require_any_library?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str $_))
+      PATTERN
+
+      # @!method require_library_name?(node, library_name)
+      def_node_matcher :require_library_name?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str %1))
+      PATTERN
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/mixin/rescue_node.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def modifier_locations
+        @modifier_locations ||= processed_source.tokens.select(&:rescue_modifier?).map!(&:pos)
+      end
+
+      private
+
+      def rescue_modifier?(node)
+        return false unless node.respond_to?(:resbody_type?)
+
+        node.resbody_type? && modifier_locations.include?(node.loc.keyword)
+      end
+
+      # @deprecated Use ResbodyNode#exceptions instead
+      def rescued_exceptions(resbody)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `rescued_exceptions` is deprecated. Use `ResbodyNode#exceptions` instead.
+        WARNING
+
+        rescue_group, = *resbody
+        if rescue_group
+          rescue_group.values
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    module SafeAssignment
+      extend NodePattern::Macros
+
+      private
+
+      # @!method empty_condition?(node)
+      def_node_matcher :empty_condition?, '(begin)'
+
+      # @!method setter_method?(node)
+      def_node_matcher :setter_method?, '[(call ...) setter_method?]'
+
+      # @!method safe_assignment?(node)
+      def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end