FM / ruby-2.7.8

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8

Name	Size	Mode	Actions
benchmark/	-	0755	rm
bigdecimal/	-	0755	rm
bundler/	-	0755	rm
cgi/	-	0755	rm
csv/	-	0755	rm
delegate/	-	0755	rm
did_you_mean/	-	0755	rm
digest/	-	0755	rm
drb/	-	0755	rm
fiddle/	-	0755	rm
forwardable/	-	0755	rm
getoptlong/	-	0755	rm
io/	-	0755	rm
irb/	-	0755	rm
json/	-	0755	rm
logger/	-	0755	rm
matrix/	-	0755	rm
net/	-	0755	rm
observer/	-	0755	rm
open3/	-	0755	rm
openssl/	-	0755	rm
optparse/	-	0755	rm
ostruct/	-	0755	rm
pstore/	-	0755	rm
psych/	-	0755	rm
racc/	-	0755	rm
rdoc/	-	0755	rm
reline/	-	0755	rm
rexml/	-	0755	rm
rinda/	-	0755	rm
ripper/	-	0755	rm
rss/	-	0755	rm
rubygems/	-	0755	rm
singleton/	-	0755	rm
syslog/	-	0755	rm
timeout/	-	0755	rm
tracer/	-	0755	rm
unicode_normalize/	-	0755	rm
uri/	-	0755	rm
webrick/	-	0755	rm
yaml/	-	0755	rm
abbrev.rb	3529	0644	edit dl rm
base64.rb	3379	0644	edit dl rm
benchmark.rb	18453	0644	edit dl rm
bigdecimal.rb	24	0644	edit dl rm
bundler.rb	23718	0644	edit dl rm
cgi.rb	10037	0644	edit dl rm
coverage.rb	368	0644	edit dl rm
csv.rb	55643	0644	edit dl rm
date.rb	1066	0644	edit dl rm
debug.rb	30624	0644	edit dl rm
delegate.rb	11343	0644	edit dl rm
did_you_mean.rb	3806	0644	edit dl rm
digest.rb	2894	0644	edit dl rm
drb.rb	50	0644	edit dl rm
English.rb	6258	0644	edit dl rm
erb.rb	29504	0644	edit dl rm
expect.rb	2217	0644	edit dl rm
fiddle.rb	1722	0644	edit dl rm
fileutils.rb	49271	0644	edit dl rm
find.rb	2526	0644	edit dl rm
forwardable.rb	9130	0644	edit dl rm
getoptlong.rb	15787	0644	edit dl rm
ipaddr.rb	19989	0644	edit dl rm
irb.rb	27603	0644	edit dl rm
json.rb	1809	0644	edit dl rm
kconv.rb	5861	0644	edit dl rm
logger.rb	16792	0644	edit dl rm
matrix.rb	61703	0644	edit dl rm
mkmf.rb	88539	0644	edit dl rm
monitor.rb	6920	0644	edit dl rm
mutex_m.rb	2214	0644	edit dl rm
observer.rb	5971	0644	edit dl rm
open-uri.rb	26088	0644	edit dl rm
open3.rb	22336	0644	edit dl rm
openssl.rb	469	0644	edit dl rm
optionparser.rb	59	0644	edit dl rm
optparse.rb	60919	0644	edit dl rm
ostruct.rb	10785	0644	edit dl rm
pathname.rb	16558	0644	edit dl rm
pp.rb	15978	0644	edit dl rm
prettyprint.rb	16276	0644	edit dl rm
prime.rb	12670	0644	edit dl rm
pstore.rb	15063	0644	edit dl rm
psych.rb	21718	0644	edit dl rm
racc.rb	137	0644	edit dl rm
rdoc.rb	5000	0644	edit dl rm
readline.rb	113	0644	edit dl rm
reline.rb	13253	0644	edit dl rm
resolv-replace.rb	1805	0644	edit dl rm
resolv.rb	75280	0644	edit dl rm
ripper.rb	2494	0644	edit dl rm
rss.rb	2963	0644	edit dl rm
rubygems.rb	39108	0644	edit dl rm
securerandom.rb	9528	0644	edit dl rm
set.rb	24622	0644	edit dl rm
shellwords.rb	6816	0644	edit dl rm
singleton.rb	4158	0644	edit dl rm
socket.rb	44702	0644	edit dl rm
tempfile.rb	11213	0644	edit dl rm
time.rb	24590	0644	edit dl rm
timeout.rb	4075	0644	edit dl rm
tmpdir.rb	4142	0644	edit dl rm
tracer.rb	6640	0644	edit dl rm
tsort.rb	14642	0644	edit dl rm
un.rb	10202	0644	edit dl rm
uri.rb	3039	0644	edit dl rm
weakref.rb	1473	0644	edit dl rm
webrick.rb	6890	0644	edit dl rm
yaml.rb	1845	0644	edit dl rm

Edit: /opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/ostruct.rb (10785B)

# frozen_string_literal: true
#
# = ostruct.rb: OpenStruct implementation
#
# Author:: Yukihiro Matsumoto
# Documentation:: Gavin Sinclair
#
# OpenStruct allows the creation of data objects with arbitrary attributes.
# See OpenStruct for an example.
#

#
# An OpenStruct is a data structure, similar to a Hash, that allows the
# definition of arbitrary attributes with their accompanying values. This is
# accomplished by using Ruby's metaprogramming to define methods on the class
# itself.
#
# == Examples
#
#   require "ostruct"
#
#   person = OpenStruct.new
#   person.name = "John Smith"
#   person.age  = 70
#
#   person.name      # => "John Smith"
#   person.age       # => 70
#   person.address   # => nil
#
# An OpenStruct employs a Hash internally to store the attributes and values
# and can even be initialized with one:
#
#   australia = OpenStruct.new(:country => "Australia", :capital => "Canberra")
#     # => #<OpenStruct country="Australia", capital="Canberra">
#
# Hash keys with spaces or characters that could normally not be used for
# method calls (e.g. <code>()[]*</code>) will not be immediately available
# on the OpenStruct object as a method for retrieval or assignment, but can
# still be reached through the Object#send method.
#
#   measurements = OpenStruct.new("length (in inches)" => 24)
#   measurements.send("length (in inches)")   # => 24
#
#   message = OpenStruct.new(:queued? => true)
#   message.queued?                           # => true
#   message.send("queued?=", false)
#   message.queued?                           # => false
#
# Removing the presence of an attribute requires the execution of the
# delete_field method as setting the property value to +nil+ will not
# remove the attribute.
#
#   first_pet  = OpenStruct.new(:name => "Rowdy", :owner => "John Smith")
#   second_pet = OpenStruct.new(:name => "Rowdy")
#
#   first_pet.owner = nil
#   first_pet                 # => #<OpenStruct name="Rowdy", owner=nil>
#   first_pet == second_pet   # => false
#
#   first_pet.delete_field(:owner)
#   first_pet                 # => #<OpenStruct name="Rowdy">
#   first_pet == second_pet   # => true
#
#
# == Implementation
#
# An OpenStruct utilizes Ruby's method lookup structure to find and define the
# necessary methods for properties. This is accomplished through the methods
# method_missing and define_singleton_method.
#
# This should be a consideration if there is a concern about the performance of
# the objects that are created, as there is much more overhead in the setting
# of these properties compared to using a Hash or a Struct.
#

require_relative 'ostruct/version'

class OpenStruct

#
  # Creates a new OpenStruct object.  By default, the resulting OpenStruct
  # object will have no attributes.
  #
  # The optional +hash+, if given, will generate attributes and values
  # (can be a Hash, an OpenStruct or a Struct).
  # For example:
  #
  #   require "ostruct"
  #   hash = { "country" => "Australia", :capital => "Canberra" }
  #   data = OpenStruct.new(hash)
  #
  #   data   # => #<OpenStruct country="Australia", capital="Canberra">
  #
  def initialize(hash=nil)
    @table = {}
    if hash
      hash.each_pair do |k, v|
        k = k.to_sym
        @table[k] = v
      end
    end
  end

# Duplicates an OpenStruct object's Hash table.
  def initialize_copy(orig) # :nodoc:
    super
    @table = @table.dup
  end

#
  # call-seq:
  #   ostruct.to_h                        -> hash
  #   ostruct.to_h {|name, value| block } -> hash
  #
  # Converts the OpenStruct to a hash with keys representing
  # each attribute (as symbols) and their corresponding values.
  #
  # If a block is given, the results of the block on each pair of
  # the receiver will be used as pairs.
  #
  #   require "ostruct"
  #   data = OpenStruct.new("country" => "Australia", :capital => "Canberra")
  #   data.to_h   # => {:country => "Australia", :capital => "Canberra" }
  #   data.to_h {|name, value| [name.to_s, value.upcase] }
  #               # => {"country" => "AUSTRALIA", "capital" => "CANBERRA" }
  #
  def to_h(&block)
    if block_given?
      @table.to_h(&block)
    else
      @table.dup
    end
  end

#
  # :call-seq:
  #   ostruct.each_pair {|name, value| block }  -> ostruct
  #   ostruct.each_pair                         -> Enumerator
  #
  # Yields all attributes (as symbols) along with the corresponding values
  # or returns an enumerator if no block is given.
  #
  #   require "ostruct"
  #   data = OpenStruct.new("country" => "Australia", :capital => "Canberra")
  #   data.each_pair.to_a   # => [[:country, "Australia"], [:capital, "Canberra"]]
  #
  def each_pair
    return to_enum(__method__) { @table.size } unless block_given?
    @table.each_pair{|p| yield p}
    self
  end

#
  # Provides marshalling support for use by the Marshal library.
  #
  def marshal_dump
    @table
  end

#
  # Provides marshalling support for use by the Marshal library.
  #
  def marshal_load(x)
    @table = x
  end

#
  # Used internally to check if the OpenStruct is able to be
  # modified before granting access to the internal Hash table to be modified.
  #
  def modifiable? # :nodoc:
    begin
      @modifiable = true
    rescue
      exception_class = defined?(FrozenError) ? FrozenError : RuntimeError
      raise exception_class, "can't modify frozen #{self.class}", caller(3)
    end
    @table
  end
  private :modifiable?

#
  # Used internally to defined properties on the
  # OpenStruct. It does this by using the metaprogramming function
  # define_singleton_method for both the getter method and the setter method.
  #
  def new_ostruct_member!(name) # :nodoc:
    name = name.to_sym
    unless singleton_class.method_defined?(name)
      define_singleton_method(name) { @table[name] }
      define_singleton_method("#{name}=") {|x| modifiable?[name] = x}
    end
    name
  end
  private :new_ostruct_member!

def freeze
    @table.each_key {|key| new_ostruct_member!(key)}
    super
  end

def respond_to_missing?(mid, include_private = false) # :nodoc:
    mname = mid.to_s.chomp("=").to_sym
    defined?(@table) && @table.key?(mname) || super
  end

def method_missing(mid, *args) # :nodoc:
    len = args.length
    if mname = mid[/.*(?==\z)/m]
      if len != 1
        raise ArgumentError, "wrong number of arguments (given #{len}, expected 1)", caller(1)
      end
      modifiable?[new_ostruct_member!(mname)] = args[0]
    elsif len == 0 # and /\A[a-z_]\w*\z/ =~ mid #
      if @table.key?(mid)
        new_ostruct_member!(mid) unless frozen?
        @table[mid]
      end
    elsif @table.key?(mid)
      raise ArgumentError, "wrong number of arguments (given #{len}, expected 0)"
    else
      begin
        super
      rescue NoMethodError => err
        err.backtrace.shift
        raise
      end
    end
  end

#
  # :call-seq:
  #   ostruct[name]  -> object
  #
  # Returns the value of an attribute.
  #
  #   require "ostruct"
  #   person = OpenStruct.new("name" => "John Smith", "age" => 70)
  #   person[:age]   # => 70, same as person.age
  #
  def [](name)
    @table[name.to_sym]
  end

#
  # :call-seq:
  #   ostruct[name] = obj  -> obj
  #
  # Sets the value of an attribute.
  #
  #   require "ostruct"
  #   person = OpenStruct.new("name" => "John Smith", "age" => 70)
  #   person[:age] = 42   # equivalent to person.age = 42
  #   person.age          # => 42
  #
  def []=(name, value)
    modifiable?[new_ostruct_member!(name)] = value
  end

#
  # :call-seq:
  #   ostruct.dig(name, ...)  -> object
  #
  # Extracts the nested value specified by the sequence of +name+
  # objects by calling +dig+ at each step, returning +nil+ if any
  # intermediate step is +nil+.
  #
  #   require "ostruct"
  #   address = OpenStruct.new("city" => "Anytown NC", "zip" => 12345)
  #   person  = OpenStruct.new("name" => "John Smith", "address" => address)
  #
  #   person.dig(:address, "zip")            # => 12345
  #   person.dig(:business_address, "zip")   # => nil
  #
  #   data = OpenStruct.new(:array => [1, [2, 3]])
  #
  #   data.dig(:array, 1, 0)   # => 2
  #   data.dig(:array, 0, 0)   # TypeError: Integer does not have #dig method
  #
  def dig(name, *names)
    begin
      name = name.to_sym
    rescue NoMethodError
      raise TypeError, "#{name} is not a symbol nor a string"
    end
    @table.dig(name, *names)
  end

#
  # Removes the named field from the object. Returns the value that the field
  # contained if it was defined.
  #
  #   require "ostruct"
  #
  #   person = OpenStruct.new(name: "John", age: 70, pension: 300)
  #
  #   person.delete_field("age")   # => 70
  #   person                       # => #<OpenStruct name="John", pension=300>
  #
  # Setting the value to +nil+ will not remove the attribute:
  #
  #   person.pension = nil
  #   person                 # => #<OpenStruct name="John", pension=nil>
  #
  def delete_field(name)
    sym = name.to_sym
    begin
      singleton_class.remove_method(sym, "#{sym}=")
    rescue NameError
    end
    @table.delete(sym) do
      raise NameError.new("no field `#{sym}' in #{self}", sym)
    end
  end

InspectKey = :__inspect_key__ # :nodoc:

#
  # Returns a string containing a detailed summary of the keys and values.
  #
  def inspect
    ids = (Thread.current[InspectKey] ||= [])
    if ids.include?(object_id)
      detail = ' ...'
    else
      ids << object_id
      begin
        detail = @table.map do |key, value|
          " #{key}=#{value.inspect}"
        end.join(',')
      ensure
        ids.pop
      end
    end
    ['#<', self.class, detail, '>'].join
  end
  alias :to_s :inspect

attr_reader :table # :nodoc:
  protected :table
  alias table! table

#
  # Compares this object and +other+ for equality.  An OpenStruct is equal to
  # +other+ when +other+ is an OpenStruct and the two objects' Hash tables are
  # equal.
  #
  #   require "ostruct"
  #   first_pet  = OpenStruct.new("name" => "Rowdy")
  #   second_pet = OpenStruct.new(:name  => "Rowdy")
  #   third_pet  = OpenStruct.new("name" => "Rowdy", :age => nil)
  #
  #   first_pet == second_pet   # => true
  #   first_pet == third_pet    # => false
  #
  def ==(other)
    return false unless other.kind_of?(OpenStruct)
    @table == other.table!
  end

#
  # Compares this object and +other+ for equality.  An OpenStruct is eql? to
  # +other+ when +other+ is an OpenStruct and the two objects' Hash tables are
  # eql?.
  #
  def eql?(other)
    return false unless other.kind_of?(OpenStruct)
    @table.eql?(other.table!)
  end

# Computes a hash code for this OpenStruct.
  # Two OpenStruct objects with the same content will have the same hash code
  # (and will compare using #eql?).
  #
  # See also Object#hash.
  def hash
    @table.hash
  end
end

cmd: