npm - @ai-ecoverse/wasix-ruby - Versions diffs - 3.4.11-3 → 3.4.11-4 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1127) hide show

package/lib/ruby/3.4.11/rubygems/request_set/lockfile/parser.rb DELETED Viewed

@@ -1,344 +0,0 @@
-# frozen_string_literal: true
-class Gem::RequestSet::Lockfile::Parser
-  ###
-  # Parses lockfiles
-  def initialize(tokenizer, set, platforms, filename = nil)
-    @tokens    = tokenizer
-    @filename  = filename
-    @set       = set
-    @platforms = platforms
-  end
-  def parse
-    until @tokens.empty? do
-      token = get
-      case token.type
-      when :section then
-        @tokens.skip :newline
-        case token.value
-        when "DEPENDENCIES" then
-          parse_DEPENDENCIES
-        when "GIT" then
-          parse_GIT
-        when "GEM" then
-          parse_GEM
-        when "PATH" then
-          parse_PATH
-        when "PLATFORMS" then
-          parse_PLATFORMS
-        else
-          token = get until @tokens.empty? || peek.first == :section
-        end
-      else
-        raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"
-      end
-    end
-  end
-  ##
-  # Gets the next token for a Lockfile
-  def get(expected_types = nil, expected_value = nil) # :nodoc:
-    token = @tokens.shift
-    if expected_types && !Array(expected_types).include?(token.type)
-      unget token
-      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
-                "expected #{expected_types.inspect}"
-      raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
-    end
-    if expected_value && expected_value != token.value
-      unget token
-      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
-                "expected [#{expected_types.inspect}, " \
-                "#{expected_value.inspect}]"
-      raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
-    end
-    token
-  end
-  def parse_DEPENDENCIES # :nodoc:
-    while !@tokens.empty? && peek.type == :text do
-      token = get :text
-      requirements = []
-      case peek[0]
-      when :bang then
-        get :bang
-        requirements << pinned_requirement(token.value)
-      when :l_paren then
-        get :l_paren
-        loop do
-          op      = get(:requirement).value
-          version = get(:text).value
-          requirements << "#{op} #{version}"
-          break unless peek.type == :comma
-          get :comma
-        end
-        get :r_paren
-        if peek[0] == :bang
-          requirements.clear
-          requirements << pinned_requirement(token.value)
-          get :bang
-        end
-      end
-      @set.gem token.value, *requirements
-      skip :newline
-    end
-  end
-  def parse_GEM # :nodoc:
-    sources = []
-    while peek.first(2) == [:entry, "remote"] do
-      get :entry, "remote"
-      data = get(:text).value
-      skip :newline
-      sources << Gem::Source.new(data)
-    end
-    sources << Gem::Source.new(Gem::DEFAULT_HOST) if sources.empty?
-    get :entry, "specs"
-    skip :newline
-    set = Gem::Resolver::LockSet.new sources
-    last_specs = nil
-    while !@tokens.empty? && peek.type == :text do
-      token = get :text
-      name = token.value
-      column = token.column
-      case peek[0]
-      when :newline then
-        last_specs.each do |spec|
-          spec.add_dependency Gem::Dependency.new name if column == 6
-        end
-      when :l_paren then
-        get :l_paren
-        token = get [:text, :requirement]
-        type = token.type
-        data = token.value
-        if type == :text && column == 4
-          version, platform = data.split "-", 2
-          platform =
-            platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
-          last_specs = set.add name, version, platform
-        else
-          dependency = parse_dependency name, data
-          last_specs.each do |spec|
-            spec.add_dependency dependency
-          end
-        end
-        get :r_paren
-      else
-        raise "BUG: unknown token #{peek}"
-      end
-      skip :newline
-    end
-    @set.sets << set
-  end
-  def parse_GIT # :nodoc:
-    get :entry, "remote"
-    repository = get(:text).value
-    skip :newline
-    get :entry, "revision"
-    revision = get(:text).value
-    skip :newline
-    type = peek.type
-    value = peek.value
-    if type == :entry && %w[branch ref tag].include?(value)
-      get
-      get :text
-      skip :newline
-    end
-    get :entry, "specs"
-    skip :newline
-    set = Gem::Resolver::GitSet.new
-    set.root_dir = @set.install_dir
-    last_spec = nil
-    while !@tokens.empty? && peek.type == :text do
-      token = get :text
-      name = token.value
-      column = token.column
-      case peek[0]
-      when :newline then
-        last_spec.add_dependency Gem::Dependency.new name if column == 6
-      when :l_paren then
-        get :l_paren
-        token = get [:text, :requirement]
-        type = token.type
-        data = token.value
-        if type == :text && column == 4
-          last_spec = set.add_git_spec name, data, repository, revision, true
-        else
-          dependency = parse_dependency name, data
-          last_spec.add_dependency dependency
-        end
-        get :r_paren
-      else
-        raise "BUG: unknown token #{peek}"
-      end
-      skip :newline
-    end
-    @set.sets << set
-  end
-  def parse_PATH # :nodoc:
-    get :entry, "remote"
-    directory = get(:text).value
-    skip :newline
-    get :entry, "specs"
-    skip :newline
-    set = Gem::Resolver::VendorSet.new
-    last_spec = nil
-    while !@tokens.empty? && peek.first == :text do
-      token = get :text
-      name = token.value
-      column = token.column
-      case peek[0]
-      when :newline then
-        last_spec.add_dependency Gem::Dependency.new name if column == 6
-      when :l_paren then
-        get :l_paren
-        token = get [:text, :requirement]
-        type = token.type
-        data = token.value
-        if type == :text && column == 4
-          last_spec = set.add_vendor_gem name, directory
-        else
-          dependency = parse_dependency name, data
-          last_spec.dependencies << dependency
-        end
-        get :r_paren
-      else
-        raise "BUG: unknown token #{peek}"
-      end
-      skip :newline
-    end
-    @set.sets << set
-  end
-  def parse_PLATFORMS # :nodoc:
-    while !@tokens.empty? && peek.first == :text do
-      name = get(:text).value
-      @platforms << name
-      skip :newline
-    end
-  end
-  ##
-  # Parses the requirements following the dependency +name+ and the +op+ for
-  # the first token of the requirements and returns a Gem::Dependency object.
-  def parse_dependency(name, op) # :nodoc:
-    return Gem::Dependency.new name, op unless peek[0] == :text
-    version = get(:text).value
-    requirements = ["#{op} #{version}"]
-    while peek.type == :comma do
-      get :comma
-      op      = get(:requirement).value
-      version = get(:text).value
-      requirements << "#{op} #{version}"
-    end
-    Gem::Dependency.new name, requirements
-  end
-  private
-  def skip(type) # :nodoc:
-    @tokens.skip type
-  end
-  ##
-  # Peeks at the next token for Lockfile
-  def peek # :nodoc:
-    @tokens.peek
-  end
-  def pinned_requirement(name) # :nodoc:
-    requirement = Gem::Dependency.new name
-    specification = @set.sets.flat_map do |set|
-      set.find_all(requirement)
-    end.compact.first
-    specification&.version
-  end
-  ##
-  # Ungets the last token retrieved by #get
-  def unget(token) # :nodoc:
-    @tokens.unshift token
-  end
-end

package/lib/ruby/3.4.11/rubygems/request_set/lockfile/tokenizer.rb DELETED Viewed

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-# ) frozen_string_literal: true
-require_relative "parser"
-class Gem::RequestSet::Lockfile::Tokenizer
-  Token = Struct.new :type, :value, :column, :line
-  EOF   = Token.new :EOF
-  def self.from_file(file)
-    new File.read(file), file
-  end
-  def initialize(input, filename = nil, line = 0, pos = 0)
-    @line     = line
-    @line_pos = pos
-    @tokens   = []
-    @filename = filename
-    tokenize input
-  end
-  def make_parser(set, platforms)
-    Gem::RequestSet::Lockfile::Parser.new self, set, platforms, @filename
-  end
-  def to_a
-    @tokens.map {|token| [token.type, token.value, token.column, token.line] }
-  end
-  def skip(type)
-    @tokens.shift while !@tokens.empty? && peek.type == type
-  end
-  ##
-  # Calculates the column (by byte) and the line of the current token based on
-  # +byte_offset+.
-  def token_pos(byte_offset) # :nodoc:
-    [byte_offset - @line_pos, @line]
-  end
-  def empty?
-    @tokens.empty?
-  end
-  def unshift(token)
-    @tokens.unshift token
-  end
-  def next_token
-    @tokens.shift
-  end
-  alias_method :shift, :next_token
-  def peek
-    @tokens.first || EOF
-  end
-  private
-  def tokenize(input)
-    require "strscan"
-    s = StringScanner.new input
-    until s.eos? do
-      pos = s.pos
-      pos = s.pos if leading_whitespace = s.scan(/ +/)
-      if s.scan(/[<|=>]{7}/)
-        message = "your #{@filename} contains merge conflict markers"
-        column, line = token_pos pos
-        raise Gem::RequestSet::Lockfile::ParseError.new message, column, line, @filename
-      end
-      @tokens <<
-        if s.scan(/\r?\n/)
-          token = Token.new(:newline, nil, *token_pos(pos))
-          @line_pos = s.pos
-          @line += 1
-          token
-        elsif s.scan(/[A-Z]+/)
-          if leading_whitespace
-            text = s.matched
-            text += s.scan(/[^\s)]*/).to_s # in case of no match
-            Token.new(:text, text, *token_pos(pos))
-          else
-            Token.new(:section, s.matched, *token_pos(pos))
-          end
-        elsif s.scan(/([a-z]+):\s/)
-          s.pos -= 1 # rewind for possible newline
-          Token.new(:entry, s[1], *token_pos(pos))
-        elsif s.scan(/\(/)
-          Token.new(:l_paren, nil, *token_pos(pos))
-        elsif s.scan(/\)/)
-          Token.new(:r_paren, nil, *token_pos(pos))
-        elsif s.scan(/<=|>=|=|~>|<|>|!=/)
-          Token.new(:requirement, s.matched, *token_pos(pos))
-        elsif s.scan(/,/)
-          Token.new(:comma, nil, *token_pos(pos))
-        elsif s.scan(/!/)
-          Token.new(:bang, nil, *token_pos(pos))
-        elsif s.scan(/[^\s),!]*/)
-          Token.new(:text, s.matched, *token_pos(pos))
-        else
-          raise "BUG: can't create token for: #{s.string[s.pos..-1].inspect}"
-        end
-    end
-    @tokens
-  end
-end

package/lib/ruby/3.4.11/rubygems/request_set/lockfile.rb DELETED Viewed

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-##
-# Parses a gem.deps.rb.lock file and constructs a LockSet containing the
-# dependencies found inside.  If the lock file is missing no LockSet is
-# constructed.
-class Gem::RequestSet::Lockfile
-  ##
-  # Raised when a lockfile cannot be parsed
-  class ParseError < Gem::Exception
-    ##
-    # The column where the error was encountered
-    attr_reader :column
-    ##
-    # The line where the error was encountered
-    attr_reader :line
-    ##
-    # The location of the lock file
-    attr_reader :path
-    ##
-    # Raises a ParseError with the given +message+ which was encountered at a
-    # +line+ and +column+ while parsing.
-    def initialize(message, column, line, path)
-      @line   = line
-      @column = column
-      @path   = path
-      super "#{message} (at line #{line} column #{column})"
-    end
-  end
-  ##
-  # Creates a new Lockfile for the given +request_set+ and +gem_deps_file+
-  # location.
-  def self.build(request_set, gem_deps_file, dependencies = nil)
-    request_set.resolve
-    dependencies ||= requests_to_deps request_set.sorted_requests
-    new request_set, gem_deps_file, dependencies
-  end
-  def self.requests_to_deps(requests) # :nodoc:
-    deps = {}
-    requests.each do |request|
-      spec        = request.spec
-      name        = request.name
-      requirement = request.request.dependency.requirement
-      deps[name] = if [Gem::Resolver::VendorSpecification,
-                       Gem::Resolver::GitSpecification].include? spec.class
-        Gem::Requirement.source_set
-      else
-        requirement
-      end
-    end
-    deps
-  end
-  ##
-  # The platforms for this Lockfile
-  attr_reader :platforms
-  def initialize(request_set, gem_deps_file, dependencies)
-    @set           = request_set
-    @dependencies  = dependencies
-    @gem_deps_file = File.expand_path(gem_deps_file)
-    @gem_deps_dir  = File.dirname(@gem_deps_file)
-    @platforms = []
-  end
-  def add_DEPENDENCIES(out) # :nodoc:
-    out << "DEPENDENCIES"
-    out.concat @dependencies.sort.map {|name, requirement|
-      "  #{name}#{requirement.for_lockfile}"
-    }
-    out << nil
-  end
-  def add_GEM(out, spec_groups) # :nodoc:
-    return if spec_groups.empty?
-    source_groups = spec_groups.values.flatten.group_by do |request|
-      request.spec.source.uri
-    end
-    source_groups.sort_by {|group,| group.to_s }.map do |group, requests|
-      out << "GEM"
-      out << "  remote: #{group}"
-      out << "  specs:"
-      requests.sort_by(&:name).each do |request|
-        next if request.spec.name == "bundler"
-        platform = "-#{request.spec.platform}" unless
-          request.spec.platform == Gem::Platform::RUBY
-        out << "    #{request.name} (#{request.version}#{platform})"
-        request.full_spec.dependencies.sort.each do |dependency|
-          next if dependency.type == :development
-          requirement = dependency.requirement
-          out << "      #{dependency.name}#{requirement.for_lockfile}"
-        end
-      end
-      out << nil
-    end
-  end
-  def add_GIT(out, git_requests)
-    return if git_requests.empty?
-    by_repository_revision = git_requests.group_by do |request|
-      source = request.spec.source
-      [source.repository, source.rev_parse]
-    end
-    by_repository_revision.each do |(repository, revision), requests|
-      out << "GIT"
-      out << "  remote: #{repository}"
-      out << "  revision: #{revision}"
-      out << "  specs:"
-      requests.sort_by(&:name).each do |request|
-        out << "    #{request.name} (#{request.version})"
-        dependencies = request.spec.dependencies.sort_by(&:name)
-        dependencies.each do |dep|
-          out << "      #{dep.name}#{dep.requirement.for_lockfile}"
-        end
-      end
-      out << nil
-    end
-  end
-  def relative_path_from(dest, base) # :nodoc:
-    dest = File.expand_path(dest)
-    base = File.expand_path(base)
-    if dest.index(base) == 0
-      offset = dest[base.size + 1..-1]
-      return "." unless offset
-      offset
-    else
-      dest
-    end
-  end
-  def add_PATH(out, path_requests) # :nodoc:
-    return if path_requests.empty?
-    out << "PATH"
-    path_requests.each do |request|
-      directory = File.expand_path(request.spec.source.uri)
-      out << "  remote: #{relative_path_from directory, @gem_deps_dir}"
-      out << "  specs:"
-      out << "    #{request.name} (#{request.version})"
-    end
-    out << nil
-  end
-  def add_PLATFORMS(out) # :nodoc:
-    out << "PLATFORMS"
-    platforms = requests.map {|request| request.spec.platform }.uniq
-    platforms = platforms.sort_by(&:to_s)
-    platforms.each do |platform|
-      out << "  #{platform}"
-    end
-    out << nil
-  end
-  def spec_groups
-    requests.group_by {|request| request.spec.class }
-  end
-  ##
-  # The contents of the lock file.
-  def to_s
-    out = []
-    groups = spec_groups
-    add_PATH out, groups.delete(Gem::Resolver::VendorSpecification) { [] }
-    add_GIT out, groups.delete(Gem::Resolver::GitSpecification) { [] }
-    add_GEM out, groups
-    add_PLATFORMS out
-    add_DEPENDENCIES out
-    out.join "\n"
-  end
-  ##
-  # Writes the lock file alongside the gem dependencies file
-  def write
-    content = to_s
-    File.open "#{@gem_deps_file}.lock", "w" do |io|
-      io.write content
-    end
-  end
-  private
-  def requests
-    @set.sorted_requests
-  end
-end
-require_relative "lockfile/tokenizer"