@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/prism/pack.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-# typed: ignore
-
-#
-module Prism
-  # A parser for the pack template language.
-  module Pack
-    %i[
-      SPACE
-      COMMENT
-      INTEGER
-      UTF8
-      BER
-      FLOAT
-      STRING_SPACE_PADDED
-      STRING_NULL_PADDED
-      STRING_NULL_TERMINATED
-      STRING_MSB
-      STRING_LSB
-      STRING_HEX_HIGH
-      STRING_HEX_LOW
-      STRING_UU
-      STRING_MIME
-      STRING_BASE64
-      STRING_FIXED
-      STRING_POINTER
-      MOVE
-      BACK
-      NULL
-
-      UNSIGNED
-      SIGNED
-      SIGNED_NA
-
-      AGNOSTIC_ENDIAN
-      LITTLE_ENDIAN
-      BIG_ENDIAN
-      NATIVE_ENDIAN
-      ENDIAN_NA
-
-      SIZE_SHORT
-      SIZE_INT
-      SIZE_LONG
-      SIZE_LONG_LONG
-      SIZE_8
-      SIZE_16
-      SIZE_32
-      SIZE_64
-      SIZE_P
-      SIZE_NA
-
-      LENGTH_FIXED
-      LENGTH_MAX
-      LENGTH_RELATIVE
-      LENGTH_NA
-    ].each do |const|
-      const_set(const, const)
-    end
-
-    # A directive in the pack template language.
-    class Directive
-      # A symbol representing the version of Ruby.
-      attr_reader :version
-
-      # A symbol representing whether or not we are packing or unpacking.
-      attr_reader :variant
-
-      # A byteslice of the source string that this directive represents.
-      attr_reader :source
-
-      # The type of the directive.
-      attr_reader :type
-
-      # The type of signedness of the directive.
-      attr_reader :signed
-
-      # The type of endianness of the directive.
-      attr_reader :endian
-
-      # The size of the directive.
-      attr_reader :size
-
-      # The length type of this directive (used for integers).
-      attr_reader :length_type
-
-      # The length of this directive (used for integers).
-      attr_reader :length
-
-      # Initialize a new directive with the given values.
-      def initialize(version, variant, source, type, signed, endian, size, length_type, length)
-        @version = version
-        @variant = variant
-        @source = source
-        @type = type
-        @signed = signed
-        @endian = endian
-        @size = size
-        @length_type = length_type
-        @length = length
-      end
-
-      # The descriptions of the various types of endianness.
-      ENDIAN_DESCRIPTIONS = {
-        AGNOSTIC_ENDIAN: "agnostic",
-        LITTLE_ENDIAN: "little-endian (VAX)",
-        BIG_ENDIAN: "big-endian (network)",
-        NATIVE_ENDIAN: "native-endian",
-        ENDIAN_NA: "n/a"
-      }
-
-      # The descriptions of the various types of signedness.
-      SIGNED_DESCRIPTIONS = {
-        UNSIGNED: "unsigned",
-        SIGNED: "signed",
-        SIGNED_NA: "n/a"
-      }
-
-      # The descriptions of the various types of sizes.
-      SIZE_DESCRIPTIONS = {
-        SIZE_SHORT: "short",
-        SIZE_INT: "int-width",
-        SIZE_LONG: "long",
-        SIZE_LONG_LONG: "long long",
-        SIZE_8: "8-bit",
-        SIZE_16: "16-bit",
-        SIZE_32: "32-bit",
-        SIZE_64: "64-bit",
-        SIZE_P: "pointer-width"
-      }
-
-      # Provide a human-readable description of the directive.
-      def describe
-        case type
-        when SPACE
-          "whitespace"
-        when COMMENT
-          "comment"
-        when INTEGER
-          if size == SIZE_8
-            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} integer"
-          else
-            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} integer"
-          end
-          case length_type
-          when LENGTH_FIXED
-            if length > 1
-              base + ", x#{length}"
-            else
-              base
-            end
-          when LENGTH_MAX
-            base + ", as many as possible"
-          else
-            raise
-          end
-        when UTF8
-          "UTF-8 character"
-        when BER
-          "BER-compressed integer"
-        when FLOAT
-          "#{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} float"
-        when STRING_SPACE_PADDED
-          "arbitrary binary string (space padded)"
-        when STRING_NULL_PADDED
-          "arbitrary binary string (null padded, count is width)"
-        when STRING_NULL_TERMINATED
-          "arbitrary binary string (null padded, count is width), except that null is added with *"
-        when STRING_MSB
-          "bit string (MSB first)"
-        when STRING_LSB
-          "bit string (LSB first)"
-        when STRING_HEX_HIGH
-          "hex string (high nibble first)"
-        when STRING_HEX_LOW
-          "hex string (low nibble first)"
-        when STRING_UU
-          "UU-encoded string"
-        when STRING_MIME
-          "quoted printable, MIME encoding"
-        when STRING_BASE64
-          "base64 encoded string"
-        when STRING_FIXED
-          "pointer to a structure (fixed-length string)"
-        when STRING_POINTER
-          "pointer to a null-terminated string"
-        when MOVE
-          "move to absolute position"
-        when BACK
-          "back up a byte"
-        when NULL
-          "null byte"
-        else
-          raise
-        end
-      end
-    end
-
-    # The result of parsing a pack template.
-    class Format
-      # A list of the directives in the template.
-      attr_reader :directives
-
-      # The encoding of the template.
-      attr_reader :encoding
-
-      # Create a new Format with the given directives and encoding.
-      def initialize(directives, encoding)
-        @directives = directives
-        @encoding = encoding
-      end
-
-      # Provide a human-readable description of the format.
-      def describe
-        source_width = directives.map { |d| d.source.inspect.length }.max
-        directive_lines = directives.map do |directive|
-          if directive.type == SPACE
-            source = directive.source.inspect
-          else
-            source = directive.source
-          end
-          # @type var source_width: Integer
-          "  #{source.ljust(source_width)}  #{directive.describe}"
-        end
-
-        (["Directives:"] + directive_lines + ["Encoding:", "  #{encoding}"]).join("\n")
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/parse_result/comments.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-module Prism
-  class ParseResult < Result
-    # When we've parsed the source, we have both the syntax tree and the list of
-    # comments that we found in the source. This class is responsible for
-    # walking the tree and finding the nearest location to attach each comment.
-    #
-    # It does this by first finding the nearest locations to each comment.
-    # Locations can either come from nodes directly or from location fields on
-    # nodes. For example, a `ClassNode` has an overall location encompassing the
-    # entire class, but it also has a location for the `class` keyword.
-    #
-    # Once the nearest locations are found, it determines which one to attach
-    # to. If it's a trailing comment (a comment on the same line as other source
-    # code), it will favor attaching to the nearest location that occurs before
-    # the comment. Otherwise it will favor attaching to the nearest location
-    # that is after the comment.
-    class Comments
-      # A target for attaching comments that is based on a specific node's
-      # location.
-      class NodeTarget # :nodoc:
-        attr_reader :node
-
-        def initialize(node)
-          @node = node
-        end
-
-        def start_offset
-          node.start_offset
-        end
-
-        def end_offset
-          node.end_offset
-        end
-
-        def encloses?(comment)
-          start_offset <= comment.location.start_offset &&
-            comment.location.end_offset <= end_offset
-        end
-
-        def leading_comment(comment)
-          node.location.leading_comment(comment)
-        end
-
-        def trailing_comment(comment)
-          node.location.trailing_comment(comment)
-        end
-      end
-
-      # A target for attaching comments that is based on a location field on a
-      # node. For example, the `end` token of a ClassNode.
-      class LocationTarget # :nodoc:
-        attr_reader :location
-
-        def initialize(location)
-          @location = location
-        end
-
-        def start_offset
-          location.start_offset
-        end
-
-        def end_offset
-          location.end_offset
-        end
-
-        def encloses?(comment)
-          false
-        end
-
-        def leading_comment(comment)
-          location.leading_comment(comment)
-        end
-
-        def trailing_comment(comment)
-          location.trailing_comment(comment)
-        end
-      end
-
-      # The parse result that we are attaching comments to.
-      attr_reader :parse_result
-
-      # Create a new Comments object that will attach comments to the given
-      # parse result.
-      def initialize(parse_result)
-        @parse_result = parse_result
-      end
-
-      # Attach the comments to their respective locations in the tree by
-      # mutating the parse result.
-      def attach!
-        parse_result.comments.each do |comment|
-          preceding, enclosing, following = nearest_targets(parse_result.value, comment)
-
-          if comment.trailing?
-            if preceding
-              preceding.trailing_comment(comment)
-            else
-              (following || enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
-            end
-          else
-            # If a comment exists on its own line, prefer a leading comment.
-            if following
-              following.leading_comment(comment)
-            elsif preceding
-              preceding.trailing_comment(comment)
-            else
-              (enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
-            end
-          end
-        end
-      end
-
-      private
-
-      # Responsible for finding the nearest targets to the given comment within
-      # the context of the given encapsulating node.
-      def nearest_targets(node, comment)
-        comment_start = comment.location.start_offset
-        comment_end = comment.location.end_offset
-
-        targets = [] #: Array[_Target]
-        node.comment_targets.map do |value|
-          case value
-          when StatementsNode
-            targets.concat(value.body.map { |node| NodeTarget.new(node) })
-          when Node
-            targets << NodeTarget.new(value)
-          when Location
-            targets << LocationTarget.new(value)
-          end
-        end
-
-        targets.sort_by!(&:start_offset)
-        preceding = nil #: _Target?
-        following = nil #: _Target?
-
-        left = 0
-        right = targets.length
-
-        # This is a custom binary search that finds the nearest nodes to the
-        # given comment. When it finds a node that completely encapsulates the
-        # comment, it recurses downward into the tree.
-        while left < right
-          middle = (left + right) / 2
-          target = targets[middle]
-
-          target_start = target.start_offset
-          target_end = target.end_offset
-
-          if target.encloses?(comment)
-            # @type var target: NodeTarget
-            # The comment is completely contained by this target. Abandon the
-            # binary search at this level.
-            return nearest_targets(target.node, comment)
-          end
-
-          if target_end <= comment_start
-            # This target falls completely before the comment. Because we will
-            # never consider this target or any targets before it again, this
-            # target must be the closest preceding target we have encountered so
-            # far.
-            preceding = target
-            left = middle + 1
-            next
-          end
-
-          if comment_end <= target_start
-            # This target falls completely after the comment. Because we will
-            # never consider this target or any targets after it again, this
-            # target must be the closest following target we have encountered so
-            # far.
-            following = target
-            right = middle
-            next
-          end
-
-          # This should only happen if there is a bug in this parser.
-          raise "Comment location overlaps with a target location"
-        end
-
-        [preceding, NodeTarget.new(node), following]
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/parse_result/errors.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-require "stringio"
-
-module Prism
-  class ParseResult < Result
-    # An object to represent the set of errors on a parse result. This object
-    # can be used to format the errors in a human-readable way.
-    class Errors
-      # The parse result that contains the errors.
-      attr_reader :parse_result
-
-      # Initialize a new set of errors from the given parse result.
-      def initialize(parse_result)
-        @parse_result = parse_result
-      end
-
-      # Formats the errors in a human-readable way and return them as a string.
-      def format
-        error_lines = {} #: Hash[Integer, Array[ParseError]]
-        parse_result.errors.each do |error|
-          location = error.location
-          (location.start_line..location.end_line).each do |line|
-            error_lines[line] ||= []
-            error_lines[line] << error
-          end
-        end
-
-        source_lines = parse_result.source.source.lines
-        source_lines << "" if error_lines.key?(source_lines.size + 1)
-
-        io = StringIO.new
-        source_lines.each.with_index(1) do |line, line_number|
-          io.puts(line)
-
-          (error_lines.delete(line_number) || []).each do |error|
-            location = error.location
-
-            case line_number
-            when location.start_line
-              io.print(" " * location.start_column + "^")
-
-              if location.start_line == location.end_line
-                if location.start_column != location.end_column
-                  io.print("~" * (location.end_column - location.start_column - 1))
-                end
-
-                io.puts(" " + error.message)
-              else
-                io.puts("~" * (line.bytesize - location.start_column))
-              end
-            when location.end_line
-              io.puts("~" * location.end_column + " " + error.message)
-            else
-              io.puts("~" * line.bytesize)
-            end
-          end
-        end
-
-        io.puts
-        io.string
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/parse_result/newlines.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-module Prism
-  class ParseResult < Result
-    # The :line tracepoint event gets fired whenever the Ruby VM encounters an
-    # expression on a new line. The types of expressions that can trigger this
-    # event are:
-    #
-    # * if statements
-    # * unless statements
-    # * nodes that are children of statements lists
-    #
-    # In order to keep track of the newlines, we have a list of offsets that
-    # come back from the parser. We assign these offsets to the first nodes that
-    # we find in the tree that are on those lines.
-    #
-    # Note that the logic in this file should be kept in sync with the Java
-    # MarkNewlinesVisitor, since that visitor is responsible for marking the
-    # newlines for JRuby/TruffleRuby.
-    #
-    # This file is autoloaded only when `mark_newlines!` is called, so the
-    # re-opening of the various nodes in this file will only be performed in
-    # that case. We do that to avoid storing the extra `@newline` instance
-    # variable on every node if we don't need it.
-    class Newlines < Visitor
-      # Create a new Newlines visitor with the given newline offsets.
-      def initialize(lines)
-        # @type var lines: Integer
-        @lines = Array.new(1 + lines, false)
-      end
-
-      # Permit block/lambda nodes to mark newlines within themselves.
-      def visit_block_node(node)
-        old_lines = @lines
-        @lines = Array.new(old_lines.size, false)
-
-        begin
-          super(node)
-        ensure
-          @lines = old_lines
-        end
-      end
-
-      alias_method :visit_lambda_node, :visit_block_node
-
-      # Mark if/unless nodes as newlines.
-      def visit_if_node(node)
-        node.newline_flag!(@lines)
-        super(node)
-      end
-
-      alias_method :visit_unless_node, :visit_if_node
-
-      # Permit statements lists to mark newlines within themselves.
-      def visit_statements_node(node)
-        node.body.each do |child|
-          child.newline_flag!(@lines)
-        end
-        super(node)
-      end
-    end
-  end
-
-  class Node
-    def newline_flag? # :nodoc:
-      !!defined?(@newline_flag)
-    end
-
-    def newline_flag!(lines) # :nodoc:
-      line = location.start_line
-      unless lines[line]
-        lines[line] = true
-        @newline_flag = true
-      end
-    end
-  end
-
-  class BeginNode < Node
-    def newline_flag!(lines) # :nodoc:
-      # Never mark BeginNode with a newline flag, mark children instead.
-    end
-  end
-
-  class ParenthesesNode < Node
-    def newline_flag!(lines) # :nodoc:
-      # Never mark ParenthesesNode with a newline flag, mark children instead.
-    end
-  end
-
-  class IfNode < Node
-    def newline_flag!(lines) # :nodoc:
-      predicate.newline_flag!(lines)
-    end
-  end
-
-  class UnlessNode < Node
-    def newline_flag!(lines) # :nodoc:
-      predicate.newline_flag!(lines)
-    end
-  end
-
-  class UntilNode < Node
-    def newline_flag!(lines) # :nodoc:
-      predicate.newline_flag!(lines)
-    end
-  end
-
-  class WhileNode < Node
-    def newline_flag!(lines) # :nodoc:
-      predicate.newline_flag!(lines)
-    end
-  end
-
-  class RescueModifierNode < Node
-    def newline_flag!(lines) # :nodoc:
-      expression.newline_flag!(lines)
-    end
-  end
-
-  class InterpolatedMatchLastLineNode < Node
-    def newline_flag!(lines) # :nodoc:
-      first = parts.first
-      first.newline_flag!(lines) if first
-    end
-  end
-
-  class InterpolatedRegularExpressionNode < Node
-    def newline_flag!(lines) # :nodoc:
-      first = parts.first
-      first.newline_flag!(lines) if first
-    end
-  end
-
-  class InterpolatedStringNode < Node
-    def newline_flag!(lines) # :nodoc:
-      first = parts.first
-      first.newline_flag!(lines) if first
-    end
-  end
-
-  class InterpolatedSymbolNode < Node
-    def newline_flag!(lines) # :nodoc:
-      first = parts.first
-      first.newline_flag!(lines) if first
-    end
-  end
-
-  class InterpolatedXStringNode < Node
-    def newline_flag!(lines) # :nodoc:
-      first = parts.first
-      first.newline_flag!(lines) if first
-    end
-  end
-end