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/bundler/spec_set.rb DELETED Viewed

@@ -1,395 +0,0 @@
-# frozen_string_literal: true
-require_relative "vendored_tsort"
-module Bundler
-  class SpecSet
-    include Enumerable
-    include TSort
-    def initialize(specs)
-      @specs = specs
-    end
-    def for(dependencies, platforms_or_legacy_check = [nil], legacy_platforms = [nil], skips: [])
-      platforms = if [true, false].include?(platforms_or_legacy_check)
-        Bundler::SharedHelpers.major_deprecation 2,
-          "SpecSet#for received a `check` parameter, but that's no longer used and deprecated. " \
-          "SpecSet#for always implicitly performs validation. Please remove this parameter",
-          print_caller_location: true
-        legacy_platforms
-      else
-        platforms_or_legacy_check
-      end
-      materialize_dependencies(dependencies, platforms, skips: skips)
-      @materializations.flat_map(&:specs).uniq
-    end
-    def normalize_platforms!(deps, platforms)
-      remove_invalid_platforms!(deps, platforms)
-      add_extra_platforms!(platforms)
-      platforms.map! do |platform|
-        next platform if platform == Gem::Platform::RUBY
-        begin
-          Integer(platform.version)
-        rescue ArgumentError, TypeError
-          next platform
-        end
-        less_specific_platform = Gem::Platform.new([platform.cpu, platform.os, nil])
-        next platform if incomplete_for_platform?(deps, less_specific_platform)
-        less_specific_platform
-      end.uniq!
-    end
-    def add_originally_invalid_platforms!(platforms, originally_invalid_platforms)
-      originally_invalid_platforms.each do |originally_invalid_platform|
-        platforms << originally_invalid_platform if complete_platform(originally_invalid_platform)
-      end
-    end
-    def remove_invalid_platforms!(deps, platforms, skips: [])
-      invalid_platforms = []
-      platforms.reject! do |platform|
-        next false if skips.include?(platform)
-        invalid = incomplete_for_platform?(deps, platform)
-        invalid_platforms << platform if invalid
-        invalid
-      end
-      invalid_platforms
-    end
-    def add_extra_platforms!(platforms)
-      if @specs.empty?
-        platforms.concat([Gem::Platform::RUBY]).uniq
-        return
-      end
-      new_platforms = all_platforms.select do |platform|
-        next if platforms.include?(platform)
-        next unless GemHelpers.generic(platform) == Gem::Platform::RUBY
-        complete_platform(platform)
-      end
-      return if new_platforms.empty?
-      platforms.concat(new_platforms)
-      return if new_platforms.include?(Bundler.local_platform)
-      less_specific_platform = new_platforms.find {|platform| platform != Gem::Platform::RUBY && Bundler.local_platform === platform && platform === Bundler.local_platform }
-      platforms.delete(Bundler.local_platform) if less_specific_platform
-    end
-    def validate_deps(s)
-      s.runtime_dependencies.each do |dep|
-        next if dep.name == "bundler"
-        return :missing unless names.include?(dep.name)
-        return :invalid if none? {|spec| dep.matches_spec?(spec) }
-      end
-      :valid
-    end
-    def [](key)
-      key = key.name if key.respond_to?(:name)
-      lookup[key]&.reverse || []
-    end
-    def []=(key, value)
-      delete_by_name(key)
-      add_spec(value)
-    end
-    def delete(specs)
-      Array(specs).each {|spec| remove_spec(spec) }
-    end
-    def sort!
-      self
-    end
-    def to_a
-      sorted.dup
-    end
-    def to_hash
-      lookup.dup
-    end
-    def materialize(deps)
-      materialize_dependencies(deps)
-      SpecSet.new(materialized_specs)
-    end
-    # Materialize for all the specs in the spec set, regardless of what platform they're for
-    # @return [Array<Gem::Specification>]
-    def materialized_for_all_platforms
-      @specs.map do |s|
-        next s unless s.is_a?(LazySpecification)
-        spec = s.materialize_for_cache
-        raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
-        spec
-      end
-    end
-    def incomplete_for_platform?(deps, platform)
-      incomplete_specs_for_platform(deps, platform).any?
-    end
-    def incomplete_specs_for_platform(deps, platform)
-      return [] if @specs.empty?
-      validation_set = self.class.new(@specs)
-      validation_set.for(deps, [platform])
-      validation_set.incomplete_specs
-    end
-    def missing_specs_for(deps)
-      materialize_dependencies(deps)
-      missing_specs
-    end
-    def missing_specs
-      @materializations.flat_map(&:completely_missing_specs)
-    end
-    def partially_missing_specs
-      @materializations.flat_map(&:partially_missing_specs)
-    end
-    def incomplete_specs
-      @materializations.flat_map(&:incomplete_specs)
-    end
-    def insecurely_materialized_specs
-      materialized_specs.select(&:insecurely_materialized?)
-    end
-    def -(other)
-      SpecSet.new(to_a - other.to_a)
-    end
-    def find_by_name_and_platform(name, platform)
-      @specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
-    end
-    def specs_with_additional_variants_from(other)
-      sorted | additional_variants_from(other)
-    end
-    def delete_by_name(name)
-      @specs.reject! {|spec| spec.name == name }
-      @sorted&.reject! {|spec| spec.name == name }
-      return if @lookup.nil?
-      @lookup[name] = nil
-    end
-    def version_for(name)
-      exemplary_spec(name)&.version
-    end
-    def what_required(spec)
-      unless req = find {|s| s.runtime_dependencies.any? {|d| d.name == spec.name } }
-        return [spec]
-      end
-      what_required(req) << spec
-    end
-    def <<(spec)
-      @specs << spec
-    end
-    def length
-      @specs.length
-    end
-    def size
-      @specs.size
-    end
-    def empty?
-      @specs.empty?
-    end
-    def each(&b)
-      sorted.each(&b)
-    end
-    def names
-      lookup.keys
-    end
-    def valid?(s)
-      s.matches_current_metadata? && valid_dependencies?(s)
-    end
-    def to_s
-      map(&:full_name).to_s
-    end
-    private
-    def materialize_dependencies(dependencies, platforms = [nil], skips: [])
-      handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
-      deps = dependencies.product(platforms)
-      @materializations = []
-      loop do
-        break unless dep = deps.shift
-        dependency = dep[0]
-        platform = dep[1]
-        name = dependency.name
-        key = [name, platform]
-        next if handled.key?(key)
-        handled[key] = true
-        materialization = Materialization.new(dependency, platform, candidates: lookup[name])
-        deps.concat(materialization.dependencies) if materialization.complete?
-        @materializations << materialization unless skips.include?(name)
-      end
-      @materializations
-    end
-    def materialized_specs
-      @materializations.filter_map(&:materialized_spec)
-    end
-    def complete_platform(platform)
-      new_specs = []
-      valid_platform = lookup.all? do |_, specs|
-        spec = specs.first
-        matching_specs = spec.source.specs.search([spec.name, spec.version])
-        platform_spec = GemHelpers.select_best_platform_match(matching_specs, platform).find do |s|
-          valid?(s)
-        end
-        if platform_spec
-          new_specs << LazySpecification.from_spec(platform_spec) unless specs.include?(platform_spec)
-          true
-        else
-          false
-        end
-      end
-      if valid_platform && new_specs.any?
-        new_specs.each {|spec| add_spec(spec) }
-      end
-      valid_platform
-    end
-    def all_platforms
-      @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq
-    end
-    def additional_variants_from(other)
-      other.select do |other_spec|
-        spec = exemplary_spec(other_spec.name)
-        next unless spec
-        selected = spec.version == other_spec.version && valid_dependencies?(other_spec)
-        other_spec.source = spec.source if selected
-        selected
-      end
-    end
-    def valid_dependencies?(s)
-      validate_deps(s) == :valid
-    end
-    def sorted
-      @sorted ||= ([@specs.find {|s| s.name == "rake" }] + tsort).compact.uniq
-    rescue TSort::Cyclic => error
-      cgems = extract_circular_gems(error)
-      raise CyclicDependencyError, "Your bundle requires gems that depend" \
-        " on each other, creating an infinite loop. Please remove either" \
-        " gem '#{cgems[0]}' or gem '#{cgems[1]}' and try again."
-    end
-    def extract_circular_gems(error)
-      error.message.scan(/@name="(.*?)"/).flatten
-    end
-    def lookup
-      @lookup ||= begin
-        lookup = {}
-        @specs.each do |s|
-          index_spec(lookup, s.name, s)
-        end
-        lookup
-      end
-    end
-    def tsort_each_node
-      # MUST sort by name for backwards compatibility
-      @specs.sort_by(&:name).each {|s| yield s }
-    end
-    def tsort_each_child(s)
-      s.dependencies.sort_by(&:name).each do |d|
-        next if d.type == :development
-        specs_for_name = lookup[d.name]
-        next unless specs_for_name
-        specs_for_name.each {|s2| yield s2 }
-      end
-    end
-    def add_spec(spec)
-      @specs << spec
-      name = spec.name
-      @sorted&.insert(@sorted.bsearch_index {|s| s.name >= name } || @sorted.size, spec)
-      return if @lookup.nil?
-      index_spec(@lookup, name, spec)
-    end
-    def remove_spec(spec)
-      @specs.delete(spec)
-      @sorted&.delete(spec)
-      return if @lookup.nil?
-      indexed_specs = @lookup[spec.name]
-      return unless indexed_specs
-      if indexed_specs.size > 1
-        @lookup[spec.name].delete(spec)
-      else
-        @lookup[spec.name] = nil
-      end
-    end
-    def index_spec(hash, key, value)
-      hash[key] ||= []
-      hash[key] << value
-    end
-    def exemplary_spec(name)
-      self[name].first
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/stub_specification.rb DELETED Viewed

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-module Bundler
-  class StubSpecification < RemoteSpecification
-    def self.from_stub(stub)
-      return stub if stub.is_a?(Bundler::StubSpecification)
-      spec = new(stub.name, stub.version, stub.platform, nil)
-      spec.stub = stub
-      spec
-    end
-    def insecurely_materialized?
-      false
-    end
-    attr_reader :checksum
-    attr_accessor :stub, :ignored
-    def source=(source)
-      super
-      # Stub has no concept of source, which means that extension_dir may be wrong
-      # This is the case for git-based gems. So, instead manually assign the extension dir
-      return unless source.respond_to?(:extension_dir_name)
-      unique_extension_dir = [source.extension_dir_name, File.basename(full_gem_path)].uniq.join("-")
-      path = File.join(stub.extensions_dir, unique_extension_dir)
-      stub.extension_dir = File.expand_path(path)
-    end
-    def to_yaml
-      _remote_specification.to_yaml
-    end
-    # @!group Stub Delegates
-    def ignored?
-      return @ignored unless @ignored.nil?
-      @ignored = missing_extensions?
-      return false unless @ignored
-      warn "Source #{source} is ignoring #{self} because it is missing extensions"
-      true
-    end
-    def manually_installed?
-      # This is for manually installed gems which are gems that were fixed in place after a
-      # failed installation. Once the issue was resolved, the user then manually created
-      # the gem specification using the instructions provided by `gem help install`
-      installed_by_version == Gem::Version.new(0)
-    end
-    # This is defined directly to avoid having to loading the full spec
-    def missing_extensions?
-      return false if default_gem?
-      return false if extensions.empty?
-      return false if File.exist? gem_build_complete_path
-      return false if manually_installed?
-      true
-    end
-    def activated?
-      stub.activated?
-    end
-    def activated=(activated)
-      stub.instance_variable_set(:@activated, activated)
-    end
-    def extensions
-      stub.extensions
-    end
-    def gem_build_complete_path
-      stub.gem_build_complete_path
-    end
-    def default_gem?
-      stub.default_gem?
-    end
-    def full_gem_path
-      stub.full_gem_path
-    end
-    def full_gem_path=(path)
-      stub.full_gem_path = path
-    end
-    def full_require_paths
-      stub.full_require_paths
-    end
-    def require_paths
-      stub.require_paths
-    end
-    def base_dir=(path)
-      stub.base_dir = path
-    end
-    def load_paths
-      full_require_paths
-    end
-    def loaded_from
-      stub.loaded_from
-    end
-    def matches_for_glob(glob)
-      stub.matches_for_glob(glob)
-    end
-    def raw_require_paths
-      stub.raw_require_paths
-    end
-    def inspect
-      "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
-    end
-    private
-    def _remote_specification
-      @_remote_specification ||= begin
-        rs = stub.to_spec
-        if rs.equal?(self) # happens when to_spec gets the spec from Gem.loaded_specs
-          rs = Gem::Specification.load(loaded_from)
-          Bundler.rubygems.stub_set_spec(stub, rs)
-        end
-        unless rs
-          raise GemspecError, "The gemspec for #{full_name} at #{loaded_from}" \
-            " was missing or broken. Try running `gem pristine #{name} -v #{version}`" \
-            " to fix the cached spec."
-        end
-        rs.source = source
-        rs.base_dir = stub.base_dir
-        rs
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/templates/.document DELETED Viewed

	@@ -1 +0,0 @@
1	- # Ignore all files in this directory

package/lib/ruby/3.4.11/bundler/templates/Executable DELETED Viewed

@@ -1,27 +0,0 @@
-#!/usr/bin/env <%= Bundler.settings[:shebang] || RbConfig::CONFIG["ruby_install_name"] %>
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application '<%= executable %>' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("<%= relative_gemfile_path %>", __dir__)
-bundle_binstub = File.expand_path("bundle", __dir__)
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-require "rubygems"
-require "bundler/setup"
-load Gem.bin_path("<%= spec.name %>", "<%= executable %>")

package/lib/ruby/3.4.11/bundler/templates/Executable.bundler DELETED Viewed

@@ -1,109 +0,0 @@
-#!/usr/bin/env <%= Bundler.settings[:shebang] || RbConfig::CONFIG["ruby_install_name"] %>
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application '<%= executable %>' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-require "rubygems"
-m = Module.new do
-  module_function
-  def invoked_as_script?
-    File.expand_path($0) == File.expand_path(__FILE__)
-  end
-  def env_var_version
-    ENV["BUNDLER_VERSION"]
-  end
-  def cli_arg_version
-    return unless invoked_as_script? # don't want to hijack other binstubs
-    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
-    bundler_version = nil
-    update_index = nil
-    ARGV.each_with_index do |a, i|
-      if update_index && update_index.succ == i && a.match?(Gem::Version::ANCHORED_VERSION_PATTERN)
-        bundler_version = a
-      end
-      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
-      bundler_version = $1
-      update_index = i
-    end
-    bundler_version
-  end
-  def gemfile
-    gemfile = ENV["BUNDLE_GEMFILE"]
-    return gemfile if gemfile && !gemfile.empty?
-    File.expand_path("<%= relative_gemfile_path %>", __dir__)
-  end
-  def lockfile
-    lockfile =
-      case File.basename(gemfile)
-      when "gems.rb" then gemfile.sub(/\.rb$/, ".locked")
-      else "#{gemfile}.lock"
-      end
-    File.expand_path(lockfile)
-  end
-  def lockfile_version
-    return unless File.file?(lockfile)
-    lockfile_contents = File.read(lockfile)
-    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
-    Regexp.last_match(1)
-  end
-  def bundler_requirement
-    @bundler_requirement ||=
-      env_var_version ||
-      cli_arg_version ||
-      bundler_requirement_for(lockfile_version)
-  end
-  def bundler_requirement_for(version)
-    return "#{Gem::Requirement.default}.a" unless version
-    bundler_gem_version = Gem::Version.new(version)
-    bundler_gem_version.approximate_recommendation
-  end
-  def load_bundler!
-    ENV["BUNDLE_GEMFILE"] ||= gemfile
-    activate_bundler
-  end
-  def activate_bundler
-    gem_error = activation_error_handling do
-      gem "bundler", bundler_requirement
-    end
-    return if gem_error.nil?
-    require_error = activation_error_handling do
-      require "bundler/version"
-    end
-    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
-    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
-    exit 42
-  end
-  def activation_error_handling
-    yield
-    nil
-  rescue StandardError, LoadError => e
-    e
-  end
-end
-m.load_bundler!
-if m.invoked_as_script?
-  load Gem.bin_path("<%= spec.name %>", "<%= executable %>")
-end

package/lib/ruby/3.4.11/bundler/templates/Executable.standalone DELETED Viewed

@@ -1,14 +0,0 @@
-#!/usr/bin/env <%= Bundler.settings[:shebang] || RbConfig::CONFIG["ruby_install_name"] %>
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application '<%= executable %>' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-$:.unshift File.expand_path "<%= standalone_path %>", __dir__
-require "bundler/setup"
-load File.expand_path "<%= executable_path %>", __dir__

package/lib/ruby/3.4.11/bundler/templates/Gemfile DELETED Viewed

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-source "https://rubygems.org"
-# gem "rails"

package/lib/ruby/3.4.11/bundler/templates/newgem/CHANGELOG.md.tt DELETED Viewed

@@ -1,5 +0,0 @@
-## [Unreleased]
-## [0.1.0] - <%= Time.now.strftime('%F') %>
-- Initial release