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

package/lib/ruby/3.4.11/yaml/dbm.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: false
-require 'yaml'
-
-begin
-  require 'dbm'
-rescue LoadError
-end
-
-module YAML
-
-# YAML + DBM = YDBM
-#
-# YAML::DBM provides the same interface as ::DBM.
-#
-# However, while DBM only allows strings for both keys and values,
-# this library allows one to use most Ruby objects for values
-# by first converting them to YAML. Keys must be strings.
-#
-# Conversion to and from YAML is performed automatically.
-#
-# See the documentation for ::DBM and ::YAML for more information.
-class DBM < ::DBM
-
-    # :call-seq:
-    #   ydbm[key] -> value
-    #
-    # Return value associated with +key+ from database.
-    #
-    # Returns +nil+ if there is no such +key+.
-    #
-    # See #fetch for more information.
-    def []( key )
-        fetch( key )
-    end
-
-    # :call-seq:
-    #   ydbm[key] = value
-    #
-    # Set +key+ to +value+ in database.
-    #
-    # +value+ will be converted to YAML before storage.
-    #
-    # See #store for more information.
-    def []=( key, val )
-        store( key, val )
-    end
-
-    # :call-seq:
-    #   ydbm.fetch( key, ifnone = nil )
-    #   ydbm.fetch( key ) { |key| ... }
-    #
-    # Return value associated with +key+.
-    #
-    # If there is no value for +key+ and no block is given, returns +ifnone+.
-    #
-    # Otherwise, calls block passing in the given +key+.
-    #
-    # See ::DBM#fetch for more information.
-    def fetch( keystr, ifnone = nil )
-        begin
-            val = super( keystr )
-            if String === val
-                if YAML.respond_to?(:safe_load)
-                    return YAML.safe_load( val )
-                else
-                    return YAML.load( val )
-                end
-            end
-        rescue IndexError
-        end
-        if block_given?
-            yield keystr
-        else
-            ifnone
-        end
-    end
-
-    # Deprecated, used YAML::DBM#key instead.
-    # ----
-    # Note:
-    # YAML::DBM#index makes warning from internal of ::DBM#index.
-    # It says 'DBM#index is deprecated; use DBM#key', but DBM#key
-    # behaves not same as DBM#index.
-    #
-    def index( keystr )
-        super( keystr.to_yaml )
-    end
-
-    # :call-seq:
-    #   ydbm.key(value) -> string
-    #
-    # Returns the key for the specified value.
-    def key( keystr )
-        invert[keystr]
-    end
-
-    # :call-seq:
-    #   ydbm.values_at(*keys)
-    #
-    # Returns an array containing the values associated with the given keys.
-    def values_at( *keys )
-        keys.collect { |k| fetch( k ) }
-    end
-
-    # :call-seq:
-    #   ydbm.delete(key)
-    #
-    # Deletes value from database associated with +key+.
-    #
-    # Returns value or +nil+.
-    def delete( key )
-        v = super( key )
-        if String === v
-            if YAML.respond_to?(:safe_load)
-                v = YAML.safe_load( v )
-            else
-                v = YAML.load( v )
-            end
-        end
-        v
-    end
-
-    # :call-seq:
-    #   ydbm.delete_if { |key, value| ... }
-    #
-    # Calls the given block once for each +key+, +value+ pair in the database.
-    # Deletes all entries for which the block returns true.
-    #
-    # Returns +self+.
-    def delete_if # :yields: [key, value]
-        del_keys = keys.dup
-        del_keys.delete_if { |k| yield( k, fetch( k ) ) == false }
-        del_keys.each { |k| delete( k ) }
-        self
-    end
-
-    # :call-seq:
-    #   ydbm.reject { |key, value| ... }
-    #
-    # Converts the contents of the database to an in-memory Hash, then calls
-    # Hash#reject with the specified code block, returning a new Hash.
-    def reject
-        hsh = self.to_hash
-        hsh.reject { |k,v| yield k, v }
-    end
-
-    # :call-seq:
-    #   ydbm.each_pair { |key, value| ... }
-    #
-    # Calls the given block once for each +key+, +value+ pair in the database.
-    #
-    # Returns +self+.
-    def each_pair # :yields: [key, value]
-        keys.each { |k| yield k, fetch( k ) }
-        self
-    end
-
-    # :call-seq:
-    #   ydbm.each_value { |value| ... }
-    #
-    # Calls the given block for each value in database.
-    #
-    # Returns +self+.
-    def each_value # :yields: value
-        super { |v| yield YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
-        self
-    end
-
-    # :call-seq:
-    #   ydbm.values
-    #
-    # Returns an array of values from the database.
-    def values
-        super.collect { |v| YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
-    end
-
-    # :call-seq:
-    #   ydbm.has_value?(value)
-    #
-    # Returns true if specified +value+ is found in the database.
-    def has_value?( val )
-        each_value { |v| return true if v == val }
-        return false
-    end
-
-    # :call-seq:
-    #   ydbm.invert -> hash
-    #
-    # Returns a Hash (not a DBM database) created by using each value in the
-    # database as a key, with the corresponding key as its value.
-    #
-    # Note that all values in the hash will be Strings, but the keys will be
-    # actual objects.
-    def invert
-        h = {}
-        keys.each { |k| h[ self.fetch( k ) ] = k }
-        h
-    end
-
-    # :call-seq:
-    #   ydbm.replace(hash) -> ydbm
-    #
-    # Replaces the contents of the database with the contents of the specified
-    # object. Takes any object which implements the each_pair method, including
-    # Hash and DBM objects.
-    def replace( hsh )
-        clear
-        update( hsh )
-    end
-
-    # :call-seq:
-    #   ydbm.shift -> [key, value]
-    #
-    # Removes a [key, value] pair from the database, and returns it.
-    # If the database is empty, returns +nil+.
-    #
-    # The order in which values are removed/returned is not guaranteed.
-    def shift
-        a = super
-        if a
-          a[1] = YAML.respond_to?(:safe_load) ? YAML.safe_load( a[1] ) : YAML.load( a[1] )
-        end
-        a
-    end
-
-    # :call-seq:
-    #   ydbm.select { |key, value| ... }
-    #   ydbm.select(*keys)
-    #
-    # If a block is provided, returns a new array containing [key, value] pairs
-    # for which the block returns true.
-    #
-    # Otherwise, same as #values_at
-    def select( *keys )
-        if block_given?
-            self.keys.collect { |k| v = self[k]; [k, v] if yield k, v }.compact
-        else
-            values_at( *keys )
-        end
-    end
-
-    # :call-seq:
-    #   ydbm.store(key, value) -> value
-    #
-    # Stores +value+ in database with +key+ as the index. +value+ is converted
-    # to YAML before being stored.
-    #
-    # Returns +value+
-    def store( key, val )
-        super( key, val.to_yaml )
-        val
-    end
-
-    # :call-seq:
-    #   ydbm.update(hash) -> ydbm
-    #
-    # Updates the database with multiple values from the specified object.
-    # Takes any object which implements the each_pair method, including
-    # Hash and DBM objects.
-    #
-    # Returns +self+.
-    def update( hsh )
-        hsh.each_pair do |k,v|
-            self.store( k, v )
-        end
-        self
-    end
-
-    # :call-seq:
-    #   ydbm.to_a -> array
-    #
-    # Converts the contents of the database to an array of [key, value] arrays,
-    # and returns it.
-    def to_a
-        a = []
-        keys.each { |k| a.push [ k, self.fetch( k ) ] }
-        a
-    end
-
-
-    # :call-seq:
-    #   ydbm.to_hash -> hash
-    #
-    # Converts the contents of the database to an in-memory Hash object, and
-    # returns it.
-    def to_hash
-        h = {}
-        keys.each { |k| h[ k ] = self.fetch( k ) }
-        h
-    end
-
-    alias :each :each_pair
-end
-
-end if defined?(DBM)

package/lib/ruby/3.4.11/yaml/store.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: false
-#
-# YAML::Store
-#
-require 'yaml'
-
-begin
-  require 'pstore'
-rescue LoadError
-end
-
-# YAML::Store provides the same functionality as PStore, except it uses YAML
-# to dump objects instead of Marshal.
-#
-# == Example
-#
-#   require 'yaml/store'
-#
-#   Person = Struct.new :first_name, :last_name
-#
-#   people = [Person.new("Bob", "Smith"), Person.new("Mary", "Johnson")]
-#
-#   store = YAML::Store.new "test.store"
-#
-#   store.transaction do
-#     store["people"] = people
-#     store["greeting"] = { "hello" => "world" }
-#   end
-#
-# After running the above code, the contents of "test.store" will be:
-#
-#   ---
-#   people:
-#   - !ruby/struct:Person
-#     first_name: Bob
-#     last_name: Smith
-#   - !ruby/struct:Person
-#     first_name: Mary
-#     last_name: Johnson
-#   greeting:
-#     hello: world
-
-class YAML::Store < PStore
-
-  # :call-seq:
-  #   initialize( file_name, yaml_opts = {} )
-  #   initialize( file_name, thread_safe = false, yaml_opts = {} )
-  #
-  # Creates a new YAML::Store object, which will store data in +file_name+.
-  # If the file does not already exist, it will be created.
-  #
-  # YAML::Store objects are always reentrant. But if _thread_safe_ is set to true,
-  # then it will become thread-safe at the cost of a minor performance hit.
-  #
-  # Options passed in through +yaml_opts+ will be used when converting the
-  # store to YAML via Hash#to_yaml().
-  def initialize( *o )
-    @opt = {}
-    if o.last.is_a? Hash
-      @opt.update(o.pop)
-    end
-    super(*o)
-  end
-
-  # :stopdoc:
-
-  def dump(table)
-    table.to_yaml(@opt)
-  end
-
-  def load(content)
-    table =  if YAML.respond_to?(:safe_load)
-      if Psych::VERSION >= "3.1"
-        YAML.safe_load(content, permitted_classes: [Symbol])
-      else
-        YAML.safe_load(content, [Symbol])
-      end
-    else
-      YAML.load(content)
-    end
-    if table == false || table == nil
-      {}
-    else
-      table
-    end
-  end
-
-  def marshal_dump_supports_canonical_option?
-    false
-  end
-
-  def empty_marshal_data
-    {}.to_yaml(@opt)
-  end
-  def empty_marshal_checksum
-    CHECKSUM_ALGO.digest(empty_marshal_data)
-  end
-end if defined?(::PStore)

package/lib/ruby/3.4.11/yaml/yaml.gemspec

@@ -1,30 +0,0 @@
-name = File.basename(__FILE__, ".gemspec")
-version = ["lib", Array.new(name.count("-")+1, "..").join("/")].find do |dir|
-  break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
-    /^\s*LOADER_VERSION\s*=\s*"(.*)"/ =~ line and break $1
-  end rescue nil
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = name
-  spec.version       = version
-  spec.authors       = ["Aaron Patterson", "SHIBATA Hiroshi"]
-  spec.email         = ["aaron@tenderlovemaking.com", "hsbt@ruby-lang.org"]
-
-  spec.summary       = "YAML Ain't Markup Language"
-  spec.description   = spec.summary
-  spec.homepage      = "https://github.com/ruby/yaml"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z 2>#{IO::NULL}`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-end

package/lib/ruby/3.4.11/yaml.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: false
-
-begin
-  require 'psych'
-rescue LoadError
-  case RUBY_ENGINE
-  when 'jruby'
-    warn "The Psych YAML extension failed to load.\n" \
-      "Check your env for conflicting versions of SnakeYAML\n" \
-      "See https://github.com/jruby/jruby/wiki/FAQs#why-does-the-psych-yaml-extension-fail-to-load-in-my-environment",
-         uplevel: 1
-  else
-    warn "It seems your ruby installation is missing psych (for YAML output).\n" \
-      "To eliminate this warning, please install libyaml and reinstall your ruby.\n",
-         uplevel: 1
-  end
-  raise
-end
-
-YAML = Psych # :nodoc:
-
-# YAML Ain't Markup Language
-#
-# This module provides a Ruby interface for data serialization in YAML format.
-#
-# The YAML module is an alias of Psych, the YAML engine for Ruby.
-#
-# == Usage
-#
-# Working with YAML can be very simple, for example:
-#
-#     require 'yaml'
-#     # Parse a YAML string
-#     YAML.load("--- foo") #=> "foo"
-#
-#     # Emit some YAML
-#     YAML.dump("foo")     # => "--- foo\n...\n"
-#     { :a => 'b'}.to_yaml  # => "---\n:a: b\n"
-#
-# As the implementation is provided by the Psych library, detailed documentation
-# can be found in that library's docs (also part of standard library).
-#
-# == Security
-#
-# Do not use YAML to load untrusted data. Doing so is unsafe and could allow
-# malicious input to execute arbitrary code inside your application. Please see
-# doc/security.rdoc for more information.
-#
-# == History
-#
-# Syck was the original YAML implementation in Ruby's standard library
-# developed by why the lucky stiff.
-#
-# You can still use Syck, if you prefer, for parsing and emitting YAML, but you
-# must install the 'syck' gem now in order to use it.
-#
-# In older Ruby versions, ie. <= 1.9, Syck is still provided, however it was
-# completely removed with the release of Ruby 2.0.0.
-#
-# == More info
-#
-# For more advanced details on the implementation see Psych, and also check out
-# http://yaml.org for spec details and other helpful information.
-#
-# Psych is maintained by Aaron Patterson on github: https://github.com/ruby/psych
-#
-# Syck can also be found on github: https://github.com/ruby/syck
-module YAML
-  LOADER_VERSION = "0.4.0"
-end