A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://docs.ruby-lang.org/en/master/Gem.html below:

module Gem - Documentation for Ruby 3.5

module Gem

RubyGems is the Ruby standard for publishing and managing third party libraries.

For user documentation, see:

For gem developer documentation see:

Further RubyGems documentation can be found at:

RubyGems Plugins ↑

RubyGems will load plugins in the latest version of each installed gem or $LOAD_PATH. Plugins must be named ‘rubygems_plugin’ (.rb, .so, etc) and placed at the root of your gem’s require_path. Plugins are installed at a special location and loaded on boot.

For an example plugin, see the Graph gem which adds a gem graph command.

RubyGems Defaults, Packaging ↑

RubyGems defaults are stored in lib/rubygems/defaults.rb. If you’re packaging RubyGems or implementing Ruby you can change RubyGems’ defaults.

For RubyGems packagers, provide lib/rubygems/defaults/operating_system.rb and override any defaults from lib/rubygems/defaults.rb.

For Ruby implementers, provide lib/rubygems/defaults/#{RUBY_ENGINE}.rb and override any defaults from lib/rubygems/defaults.rb.

If you need RubyGems to perform extra work on install or uninstall, your defaults override file can set pre/post install and uninstall hooks. See Gem::pre_install, Gem::pre_uninstall, Gem::post_install, Gem::post_uninstall.

Bugs ↑

You can submit bugs to the RubyGems bug tracker on GitHub

Credits ↑

RubyGems is currently maintained by Eric Hodel.

RubyGems was originally developed at RubyConf 2003 by:

Contributors:

(If your name is missing, PLEASE let us know!)

License ↑

See LICENSE.txt for permissions.

Thanks!

-The RubyGems Team

Provides 3 methods for declaring when something is going away.

+deprecate(name, repl, year, month)+:

Indicate something may be removed on/after a certain date.

+rubygems_deprecate(name, replacement=:none)+:

Indicate something will be removed in the next major RubyGems version,
and (optionally) a replacement for it.

rubygems_deprecate_command:

Indicate a RubyGems command (in +lib/rubygems/commands/*.rb+) will be
removed in the next RubyGems version.

Also provides skip_during for temporarily turning off deprecation warnings. This is intended to be used in the test suite, so deprecation warnings don’t cause test failures if you need to make sure stderr is otherwise empty.

Example usage of deprecate and rubygems_deprecate:

class Legacy
  def self.some_class_method
    
  end

  def some_instance_method
    
  end

  def some_old_method
    
  end

  extend Gem::Deprecate
  deprecate :some_instance_method, "X.z", 2011, 4
  rubygems_deprecate :some_old_method, "Modern#some_new_method"

  class << self
    extend Gem::Deprecate
    deprecate :some_class_method, :none, 2011, 4
  end
end

Example usage of rubygems_deprecate_command:

class Gem::Commands::QueryCommand < Gem::Command
  extend Gem::Deprecate
  rubygems_deprecate_command

  
end

Example usage of skip_during:

class TestSomething < Gem::Testcase
  def test_some_thing_with_deprecations
    Gem::Deprecate.skip_during do
      actual_stdout, actual_stderr = capture_output do
        Gem.something_deprecated
      end
      assert_empty actual_stdout
      assert_equal(expected, actual_stderr)
    end
  end
end
Constants
DEFAULT_HOST
DEFAULT_SOURCE_DATE_EPOCH

The default value for SOURCE_DATE_EPOCH if not specified. We want a date after 1980-01-01, to prevent issues with Zip files. This particular timestamp is for 1980-01-02 00:00:00 GMT.

GEM_DEP_FILES
LOADED_SPECS_MUTEX
MARSHAL_SPEC_DIR

Location of Marshal quick gemspecs on remote repositories

RDoc
REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES

Subdirectories in a gem repository for default gems

REPOSITORY_SUBDIRECTORIES

Subdirectories in a gem repository

RUBYGEMS_DIR
VERSION
WIN_PATTERNS

An Array of Regexps that match windows Ruby platforms.

Attributes

RubyGems distributors (like operating system package managers) can disable RubyGems update by setting this to error message printed to end-users on gem update –system instead of actual update.

Whether RubyGems should enhance builtin ‘require` to automatically check whether the path required is present in installed gems, and automatically activate them and add them to `$LOAD_PATH`.

GemDependencyAPI object, which is set when .use_gemdeps is called. This contains all the information from the Gemfile.

The list of hooks to be run after Gem::Installer#install extracts files and builds extensions

The list of hooks to be run after Gem::Installer#install completes installation

The list of hooks to be run after Gem::Specification.reset is run.

The list of hooks to be run after Gem::Uninstaller#uninstall completes installation

Public Class Methods

Source 

def self.activated_gem_paths
  @activated_gem_paths ||= 0
end

The number of paths in the +$LOAD_PATH+ from activated gems. Used to prioritize -I and ENV['RUBYLIB'] entries during require.

Source 

def self.add_to_load_path(*paths)
  @activated_gem_paths = activated_gem_paths + paths.size

  
  $LOAD_PATH.insert(Gem.load_path_insert_index, *paths)
end

Add a list of paths to the $LOAD_PATH at the proper place.

Source 

def self.bin_path(name, exec_name = nil, *requirements)
  requirements = Gem::Requirement.default if
    requirements.empty?

  find_spec_for_exe(name, exec_name, requirements).bin_file exec_name
end

Find the full path to the executable for gem name. If the exec_name is not given, an exception will be raised, otherwise the specified executable’s path is returned. requirements allows you to specify specific gem versions.

Source 

def self.binary_mode
  "rb"
end

The mode needed to read a file as straight binary.

Source 

def self.bindir(install_dir=Gem.dir)
  return File.join install_dir, "bin" unless
    install_dir.to_s == Gem.default_dir.to_s
  Gem.default_bindir
end

The path where gem executables are to be installed.

Source 

def self.cache_home
  @cache_home ||= ENV["XDG_CACHE_HOME"] || File.join(Gem.user_home, ".cache")
end

The path to standard location of the user’s cache directory.

Source 

def clear_default_specs
  @path_to_default_spec_map.clear
end

Clear default gem related variables. It is for test

Source 

def self.clear_paths
  @paths         = nil
  @user_home     = nil
  Gem::Specification.reset
  Gem::Security.reset if defined?(Gem::Security)
end

Reset the dir and path values. The next time dir or path is requested, the values will be calculated from scratch. This is mainly used by the unit tests to provide test isolation.

Source 

def self.config_file
  @config_file ||= find_config_file
end

The path to standard location of the user’s .gemrc file.

Source 

def self.config_home
  @config_home ||= ENV["XDG_CONFIG_HOME"] || File.join(Gem.user_home, ".config")
end

The path to standard location of the user’s configuration directory.

Source 

def self.configuration
  @configuration ||= Gem::ConfigFile.new []
end

The standard configuration object for gems.

Source 

def self.configuration=(config)
  @configuration = config
end

Use the given configuration object (which implements the ConfigFile protocol) as the standard configuration object.

Source 

def self.data_home
  @data_home ||= ENV["XDG_DATA_HOME"] || File.join(Gem.user_home, ".local", "share")
end

The path to standard location of the user’s data directory.

Source 

def self.default_bindir
  RbConfig::CONFIG["bindir"]
end

The default directory for binaries

Source 

def self.default_cert_path
  default_cert_path = File.join Gem.user_home, ".gem", "gem-public_cert.pem"

  unless File.exist?(default_cert_path)
    default_cert_path = File.join Gem.data_home, "gem", "gem-public_cert.pem"
  end

  default_cert_path
end

The default signing certificate chain path

Source 

def self.default_dir
  @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version"])
end

Default home directory path to be used if an alternate value is not specified in the environment

Source 

def self.default_exec_format
  exec_format = begin
                  RbConfig::CONFIG["ruby_install_name"].sub("ruby", "%s")
                rescue StandardError
                  "%s"
                end

  unless exec_format.include?("%s")
    raise Gem::Exception,
      "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
  end

  exec_format
end

Deduce Ruby’s –program-prefix and –program-suffix from its install name

Source 

def self.default_ext_dir_for(base_dir)
  nil
end

Returns binary extensions dir for specified RubyGems base dir or nil if such directory cannot be determined.

By default, the binary extensions are located side by side with their Ruby counterparts, therefore nil is returned

Source 

def self.default_key_path
  default_key_path = File.join Gem.user_home, ".gem", "gem-private_key.pem"

  unless File.exist?(default_key_path)
    default_key_path = File.join Gem.data_home, "gem", "gem-private_key.pem"
  end

  default_key_path
end

The default signing key path

Source 

def self.default_path
  path = []
  path << user_dir if user_home && File.exist?(user_home)
  path << default_dir
  path << vendor_dir if vendor_dir && File.directory?(vendor_dir)
  path
end

Default gem load path

Source 

def self.default_rubygems_dirs
  nil 
end

Paths where RubyGems’ .rb files and bin files are installed

Source 

def self.default_sources
  %w[https://rubygems.org/]
end

An Array of the default sources that come with RubyGems

Source 

def self.default_spec_cache_dir
  default_spec_cache_dir = File.join Gem.user_home, ".gem", "specs"

  unless File.exist?(default_spec_cache_dir)
    default_spec_cache_dir = File.join Gem.cache_home, "gem", "specs"
  end

  default_spec_cache_dir
end

Default spec directory path to be used if an alternate value is not specified in the environment

Source 

def self.default_specifications_dir
  @default_specifications_dir ||= File.join(Gem.default_dir, "specifications", "default")
end

Path to specification files of default gems.

Source 

def self.dir
  paths.home
end

The path where gems are to be installed.

Source 

def self.dynamic_library_suffixes
  @dynamic_library_suffixes ||= suffixes - [".rb"]
end

Suffixes for dynamic library require-able paths.

Source 

def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil)
  ensure_subdirectories(dir, mode, REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES)
end

Quietly ensure the Gem directory dir contains all the proper subdirectories for handling default gems. If we can’t create a directory due to a permission problem, then we will silently continue.

If mode is given, missing directories are created with this mode.

World-writable directories will never be created.

Source 

def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil)
  ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES)
end

Quietly ensure the Gem directory dir contains all the proper subdirectories. If we can’t create a directory due to a permission problem, then we will silently continue.

If mode is given, missing directories are created with this mode.

World-writable directories will never be created.

Source 

def self.env_requirement(gem_name)
  @env_requirements_by_name ||= {}
  @env_requirements_by_name[gem_name] ||= begin
    req = ENV["GEM_REQUIREMENT_#{gem_name.upcase}"] || ">= 0"
    Gem::Requirement.create(req)
  end
end

Source 

def self.find_config_file
  gemrc = File.join Gem.user_home, ".gemrc"
  if File.exist? gemrc
    gemrc
  else
    File.join Gem.config_home, "gem", "gemrc"
  end
end

Finds the user’s config file

Source 

def find_default_spec(path)
  @path_to_default_spec_map[path]
end

Find a Gem::Specification of default gem from path

Source 

def self.find_files(glob, check_load_path=true)
  files = []

  files = find_files_from_load_path glob if check_load_path

  gem_specifications = @gemdeps ? Gem.loaded_specs.values : Gem::Specification.stubs

  files.concat gem_specifications.flat_map {|spec|
    spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
  }

  
  
  files.uniq! if check_load_path

  files
end

Returns a list of paths matching glob that can be used by a gem to pick up features from other gems. For example:

Gem.find_files('rdoc/discover').each do |path| load path end

if check_load_path is true (the default), then find_files also searches $LOAD_PATH for files as well as gems.

Note that find_files will return all files even if they are from different versions of the same gem. See also find_latest_files

Source 

def self.find_latest_files(glob, check_load_path=true)
  files = []

  files = find_files_from_load_path glob if check_load_path

  files.concat Gem::Specification.latest_specs(true).flat_map {|spec|
    spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
  }

  
  
  files.uniq! if check_load_path

  files
end

Returns a list of paths matching glob from the latest gems that can be used by a gem to pick up features from other gems. For example:

Gem.find_latest_files('rdoc/discover').each do |path| load path end

if check_load_path is true (the default), then find_latest_files also searches $LOAD_PATH for files as well as gems.

Unlike find_files, find_latest_files will return only files from the latest version of a gem.

Source 

def find_unresolved_default_spec(path)
  default_spec = @path_to_default_spec_map[path]
  default_spec if default_spec && loaded_specs[default_spec.name] != default_spec
end

Find an unresolved Gem::Specification of default gem from path

Source 

def self.finish_resolve(request_set=Gem::RequestSet.new)
  request_set.import Gem::Specification.unresolved_deps.values
  request_set.import Gem.loaded_specs.values.map {|s| Gem::Dependency.new(s.name, s.version) }

  request_set.resolve_current.each do |s|
    s.full_spec.activate
  end
end

Source 

def self.freebsd_platform?
  RbConfig::CONFIG["host_os"].to_s.include?("bsd")
end

Is this platform FreeBSD

Source 

def self.host
  @host ||= Gem::DEFAULT_HOST
end

Get the default RubyGems API host. This is normally https://rubygems.org.

Source 

def self.host=(host)
  @host = host
end

Set the default RubyGems API host.

Source 

def self.install(name, version = Gem::Requirement.default, *options)
  require_relative "rubygems/dependency_installer"
  inst = Gem::DependencyInstaller.new(*options)
  inst.install name, version
  inst.installed_gems
end

Top level install helper method. Allows you to install gems interactively:

% irb
>> Gem.install "minitest"
Fetching: minitest-5.14.0.gem (100%)
=> [#<Gem::Specification:0x1013b4528 @name="minitest", ...>]

Source 

def self.java_platform?
  RUBY_PLATFORM == "java"
end

Is this a java platform?

Source 

def self.latest_rubygems_version
  latest_version_for("rubygems-update") ||
    raise("Can't find 'rubygems-update' in any repo. Check `gem source list`.")
end

Returns the latest release version of RubyGems.

Source 

def self.latest_spec_for(name)
  dependency   = Gem::Dependency.new name
  fetcher      = Gem::SpecFetcher.fetcher
  spec_tuples, = fetcher.spec_for_dependency dependency

  spec, = spec_tuples.last

  spec
end

Returns the latest release-version specification for the gem name.

Source 

def self.latest_version_for(name)
  latest_spec_for(name)&.version
end

Returns the version of the latest release-version of gem name

Source 

def self.load_env_plugins
  load_plugin_files find_files_from_load_path("rubygems_plugin")
end

Find all ‘rubygems_plugin’ files in $LOAD_PATH and load them

Source 

def self.load_path_insert_index
  $LOAD_PATH.each_with_index do |path, i|
    return i if path.instance_variable_defined?(:@gem_prelude_index)
  end

  index = $LOAD_PATH.index RbConfig::CONFIG["sitelibdir"]

  index || 0
end

The index to insert activated gem paths into the $LOAD_PATH. The activated gem’s paths are inserted before site lib directory by default.

Source 

def self.load_plugins
  Gem.path.each do |gem_path|
    load_plugin_files Gem::Util.glob_files_in_dir("*#{Gem.plugin_suffix_pattern}", plugindir(gem_path))
  end
end

Find rubygems plugin files in the standard location and load them

Source 

def self.load_safe_marshal
  return if @safe_marshal_loaded

  require_relative "rubygems/safe_marshal"

  @safe_marshal_loaded = true
end

Source 

def self.load_yaml
  return if @yaml_loaded

  require "psych"
  require_relative "rubygems/psych_tree"

  require_relative "rubygems/safe_yaml"

  @yaml_loaded = true
end

Loads YAML, preferring Psych

Source 

def self.location_of_caller(depth = 1)
  caller[depth] =~ /(.*?):(\d+).*?$/i
  file = $1
  lineno = $2.to_i

  [file, lineno]
end

The file name and line number of the caller of the caller of this method.

depth is how many layers up the call stack it should go.

e.g.,

def a; Gem.location_of_caller; end a #=> [“x.rb”, 2] # (it’ll vary depending on file name and line number)

def b; c; end def c; Gem.location_of_caller(2); end b #=> [“x.rb”, 6] # (it’ll vary depending on file name and line number)

Source 

def self.marshal_version
  "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
end

The version of the Marshal format for your Ruby.

Source 

def self.needs
  rs = Gem::RequestSet.new

  yield rs

  finish_resolve rs
end

Source 

def self.open_file(path, flags, &block)
  File.open(path, flags, &block)
end

Open a file with given flags

Source 

def self.open_file_with_flock(path, &block)
  
  mode = IO::RDWR | IO::APPEND | IO::CREAT | IO::BINARY
  mode |= IO::SHARE_DELETE if IO.const_defined?(:SHARE_DELETE)

  File.open(path, mode) do |io|
    begin
      
      
      
      if io.flock(File::LOCK_EX | File::LOCK_NB) != 0
        warn "Waiting for another process to let go of lock: #{path}"
        io.flock(File::LOCK_EX)
      end
      io.puts(Process.pid)
    rescue Errno::ENOSYS, Errno::ENOTSUP
    end
    yield io
  end
end

Open a file with given flags, and protect access with flock

Source 

def self.open_file_with_lock(path, &block)
  file_lock = "#{path}.lock"
  open_file_with_flock(file_lock, &block)
ensure
  require "fileutils"
  FileUtils.rm_f file_lock
end

Open a file with given flags, and protect access with a file lock

Source 

def self.operating_system_defaults
  {}
end

Default options for gem commands for Ruby packagers.

The options here should be structured as an array of string “gem” command names as keys and a string of the default options as values.

Example:

def self.operating_system_defaults

{
    'install' => '--no-rdoc --no-ri --env-shebang',
    'update' => '--no-rdoc --no-ri --env-shebang'
}

end

Source 

def self.path
  paths.path
end

Source 

def self.path_separator
  File::PATH_SEPARATOR
end

How String Gem paths should be split. Overridable for esoteric platforms.

Source 

def self.paths
  @paths ||= Gem::PathSupport.new(ENV)
end

Retrieve the PathSupport object that RubyGems uses to lookup files.

Source 

  def self.paths=(env)
    clear_paths
    target = {}
    env.each_pair do |k,v|
      case k
      when "GEM_HOME", "GEM_PATH", "GEM_SPEC_CACHE"
        case v
        when nil, String
          target[k] = v
        when Array
          unless Gem::Deprecate.skip
            warn <<-EOWARN
Array values in the parameter to `Gem.paths=` are deprecated.
Please use a String or nil.
An Array (#{env.inspect}) was passed in from #{caller[3]}
            EOWARN
          end
          target[k] = v.join File::PATH_SEPARATOR
        end
      else
        target[k] = v
      end
    end
    @paths = Gem::PathSupport.new ENV.to_hash.merge(target)
    Gem::Specification.dirs = @paths.path
  end

Initialize the filesystem paths to use from env. env is a hash-like object (typically ENV) that is queried for ‘GEM_HOME’, ‘GEM_PATH’, and ‘GEM_SPEC_CACHE’ Keys for the env hash should be Strings, and values of the hash should be Strings or nil.

Source 

def self.platform_defaults
  {}
end

Default options for gem commands for Ruby implementers.

The options here should be structured as an array of string “gem” command names as keys and a string of the default options as values.

Example:

def self.platform_defaults

{
    'install' => '--no-rdoc --no-ri --env-shebang',
    'update' => '--no-rdoc --no-ri --env-shebang'
}

end

Source 

def self.platforms
  @platforms ||= []
  if @platforms.empty?
    @platforms = [Gem::Platform::RUBY, Gem::Platform.local]
  end
  @platforms
end

Array of platforms this RubyGems supports.

Source 

def self.platforms=(platforms)
  @platforms = platforms
end

Set array of platforms this RubyGems supports (primarily for testing).

Source 

def self.plugin_suffix_pattern
  @plugin_suffix_pattern ||= "_plugin#{suffix_pattern}"
end

Glob pattern for require-able plugin suffixes.

Source 

def self.plugin_suffix_regexp
  @plugin_suffix_regexp ||= /_plugin#{suffix_regexp}\z/
end

Regexp for require-able plugin suffixes.

Source 

def self.plugindir(install_dir=Gem.dir)
  File.join install_dir, "plugins"
end

The path were rubygems plugins are to be installed.

Source 

def self.post_build(&hook)
  @post_build_hooks << hook
end

Adds a post-build hook that will be passed an Gem::Installer instance when Gem::Installer#install is called. The hook is called after the gem has been extracted and extensions have been built but before the executables or gemspec has been written. If the hook returns false then the gem’s files will be removed and the install will be aborted.

Source 

def self.post_reset(&hook)
  @post_reset_hooks << hook
end

Adds a hook that will get run after Gem::Specification.reset is run.

Source 

def self.post_uninstall(&hook)
  @post_uninstall_hooks << hook
end

Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance and the spec that was uninstalled when Gem::Uninstaller#uninstall is called

Source 

def self.pre_install(&hook)
  @pre_install_hooks << hook
end

Adds a pre-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called. If the hook returns false then the install will be aborted.

Source 

def self.pre_reset(&hook)
  @pre_reset_hooks << hook
end

Adds a hook that will get run before Gem::Specification.reset is run.

Source 

def self.pre_uninstall(&hook)
  @pre_uninstall_hooks << hook
end

Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance and the spec that will be uninstalled when Gem::Uninstaller#uninstall is called

Source 

def self.prefix
  prefix = File.dirname RUBYGEMS_DIR

  if prefix != File.expand_path(RbConfig::CONFIG["sitelibdir"]) &&
     prefix != File.expand_path(RbConfig::CONFIG["libdir"]) &&
     File.basename(RUBYGEMS_DIR) == "lib"
    prefix
  end
end

The directory prefix this RubyGems was installed at. If your prefix is in a standard location (ie, rubygems is installed where you’d expect it to be), then prefix returns nil.

Source 

def self.rdoc_hooks_defined_via_plugin?
  Gem::Version.new(::RDoc::VERSION) >= Gem::Version.new("6.9.0")
end

Returns whether RDoc defines its own install hooks through a RubyGems plugin. This and whatever is guarded by it can be removed once no supported Ruby ships with RDoc older than 6.9.0.

Source 

def self.read_binary(path)
  File.binread(path)
end

Safely read a file in binary mode on all platforms.

Source 

def self.refresh
  Gem::Specification.reset
end

Refresh available gems from disk.

Source 

def register_default_spec(spec)
  extended_require_paths = spec.require_paths.map {|f| f + "/" }
  new_format = extended_require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } }

  if new_format
    prefix_group = extended_require_paths.join("|")
    prefix_pattern = /^(#{prefix_group})/
  end

  spec.files.each do |file|
    if new_format
      file = file.sub(prefix_pattern, "")
      next unless $~
    end

    spec.activate if already_loaded?(file)

    @path_to_default_spec_map[file] = spec
    @path_to_default_spec_map[file.sub(suffix_regexp, "")] = spec
  end
end

Register a Gem::Specification for default gem.

Two formats for the specification are supported:

Source 

def self.ruby
  if @ruby.nil?
    @ruby = RbConfig.ruby

    @ruby = "\"#{@ruby}\"" if /\s/.match?(@ruby)
  end

  @ruby
end

The path to the running Ruby interpreter.

Source 

def self.ruby_api_version
  @ruby_api_version ||= target_rbconfig["ruby_version"].dup
end

Returns a String containing the API compatibility version of Ruby

Source 

def self.ruby_engine
  RUBY_ENGINE
end

Source 

def self.ruby_version
  return @ruby_version if defined? @ruby_version
  version = RUBY_VERSION.dup

  if RUBY_PATCHLEVEL == -1
    if RUBY_ENGINE == "ruby"
      desc = RUBY_DESCRIPTION[/\Aruby #{Regexp.quote(RUBY_VERSION)}([^ ]+) /, 1]
    else
      desc = RUBY_DESCRIPTION[/\A#{RUBY_ENGINE} #{Regexp.quote(RUBY_ENGINE_VERSION)} \(#{RUBY_VERSION}([^ ]+)\) /, 1]
    end
    version << ".#{desc}" if desc
  end

  @ruby_version = Gem::Version.new version
end

A Gem::Version for the currently running Ruby.

Source 

def self.rubygems_version
  return @rubygems_version if defined? @rubygems_version
  @rubygems_version = Gem::Version.new Gem::VERSION
end

A Gem::Version for the currently running RubyGems

Source 

def self.set_target_rbconfig(rbconfig_path)
  @target_rbconfig = Gem::TargetRbConfig.from_path(rbconfig_path)
  Gem::Platform.local(refresh: true)
  Gem.platforms << Gem::Platform.local unless Gem.platforms.include? Gem::Platform.local
  @target_rbconfig
end

Source 

def self.solaris_platform?
  RUBY_PLATFORM.include?("solaris")
end

Is this platform Solaris?

Source 

def self.source_date_epoch
  Time.at(source_date_epoch_string.to_i).utc.freeze
end

Returns the value of Gem.source_date_epoch_string, as a Time object.

This is used throughout RubyGems for enabling reproducible builds.

Source 

def self.source_date_epoch_string
  specified_epoch = ENV["SOURCE_DATE_EPOCH"]

  
  specified_epoch = nil if !specified_epoch.nil? && specified_epoch.strip.empty?

  epoch = specified_epoch || DEFAULT_SOURCE_DATE_EPOCH.to_s

  epoch.strip
end

If the SOURCE_DATE_EPOCH environment variable is set, returns it’s value. Otherwise, returns DEFAULT_SOURCE_DATE_EPOCH as a string.

NOTE(@duckinator): The implementation is a tad weird because we want to:

1. Make builds reproducible by default, by having this function always
   return the same result during a given run.
2. Allow changing ENV['SOURCE_DATE_EPOCH'] at runtime, since multiple
   tests that set this variable will be run in a single process.

If you simplify this function and a lot of tests fail, that is likely due to #2 above.

Details on SOURCE_DATE_EPOCH: reproducible-builds.org/specs/source-date-epoch/

Source 

def self.sources
  source_list = configuration.sources || default_sources
  @sources ||= Gem::SourceList.from(source_list)
end

Returns an Array of sources to fetch remote gems from. Uses default_sources if the sources list is empty.

Source 

def self.sources=(new_sources)
  if !new_sources
    @sources = nil
  else
    @sources = Gem::SourceList.from(new_sources)
  end
end

Need to be able to set the sources without calling Gem.sources.replace since that would cause an infinite loop.

DOC: This comment is not documentation about the method itself, it’s more of a code comment about the implementation.

Source 

def self.spec_cache_dir
  paths.spec_cache_dir
end

Source 

def self.state_file
  @state_file ||= File.join(Gem.state_home, "gem", "last_update_check")
end

The path to standard location of the user’s state file.

Source 

def self.state_home
  @state_home ||= ENV["XDG_STATE_HOME"] || File.join(Gem.user_home, ".local", "state")
end

The path to standard location of the user’s state directory.

Source 

def self.suffix_pattern
  @suffix_pattern ||= "{#{suffixes.join(",")}}"
end

Glob pattern for require-able path suffixes.

Source 

def self.suffix_regexp
  @suffix_regexp ||= /#{Regexp.union(suffixes)}\z/
end

Regexp for require-able path suffixes.

Source 

def self.suffixes
  @suffixes ||= ["",
                 ".rb",
                 *%w[DLEXT DLEXT2].map do |key|
                   val = RbConfig::CONFIG[key]
                   next unless val && !val.empty?
                   ".#{val}"
                 end].compact.uniq
end

Suffixes for require-able paths.

Source 

def self.target_rbconfig
  @target_rbconfig || Gem::TargetRbConfig.for_running_ruby
end

The RbConfig object for the deployment target platform.

This is usually the same as the running platform, but may be different if you are cross-compiling.

Source 

def self.time(msg, width = 0, display = Gem.configuration.verbose)
  now = Time.now

  value = yield

  elapsed = Time.now - now

  ui.say format("%2$*1$s: %3$3.3fs", -width, msg, elapsed) if display

  value
end

Prints the amount of time the supplied block takes to run using the debug UI output.

Source 

def self.try_activate(path)
  
  
  
  
  

  spec = Gem::Specification.find_by_path path
  return false unless spec
  return true if spec.activated?

  begin
    spec.activate
  rescue Gem::LoadError => e 
    spec_by_name = Gem::Specification.find_by_name(spec.name)
    if spec_by_name.nil?
      raise e
    else
      spec_by_name.activate
    end
  end

  true
end

Try to activate a gem containing path. Returns true if activation succeeded or wasn’t needed because it was already activated. Returns false if it can’t find the path in a gem.

Source 

def self.ui
  require_relative "rubygems/user_interaction"

  Gem::DefaultUserInteraction.ui
end

Lazily loads DefaultUserInteraction and returns the default UI.

Source 

def self.use_gemdeps(path = nil)
  raise_exception = path

  path ||= ENV["RUBYGEMS_GEMDEPS"]
  return unless path

  path = path.dup

  if path == "-"
    Gem::Util.traverse_parents Dir.pwd do |directory|
      dep_file = GEM_DEP_FILES.find {|f| File.file?(f) }

      next unless dep_file

      path = File.join directory, dep_file
      break
    end
  end

  unless File.file? path
    return unless raise_exception

    raise ArgumentError, "Unable to find gem dependencies file at #{path}"
  end

  ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)
  require_relative "rubygems/user_interaction"
  require "bundler"
  begin
    Gem::DefaultUserInteraction.use_ui(ui) do
      Bundler.ui.silence do
        @gemdeps = Bundler.setup
      end
    ensure
      Gem::DefaultUserInteraction.ui.close
    end
  rescue Bundler::BundlerError => e
    warn e.message
    warn "You may need to `bundle install` to install missing gems"
    warn ""
  end
end

Looks for a gem dependency file at path and activates the gems in the file if found. If the file is not found an ArgumentError is raised.

If path is not given the RUBYGEMS_GEMDEPS environment variable is used, but if no file is found no exception is raised.

If ‘-’ is given for path RubyGems searches up from the current working directory for gem dependency files (gem.deps.rb, Gemfile, Isolate) and activates the gems in the first one found.

You can run this automatically when rubygems starts. To enable, set the RUBYGEMS_GEMDEPS environment variable to either the path of your gem dependencies file or “-” to auto-discover in parent directories.

NOTE: Enabling automatic discovery on multiuser systems can lead to execution of arbitrary code when used from directories outside your control.

Source 

def self.use_paths(home, *paths)
  paths.flatten!
  paths.compact!
  hash = { "GEM_HOME" => home, "GEM_PATH" => paths.empty? ? home : paths.join(File::PATH_SEPARATOR) }
  hash.delete_if {|_, v| v.nil? }
  self.paths = hash
end

Use the home and paths values for Gem.dir and Gem.path. Used mainly by the unit tests to provide environment isolation.

Source 

def self.user_dir
  gem_dir = File.join(Gem.user_home, ".gem")
  gem_dir = File.join(Gem.data_home, "gem") unless File.exist?(gem_dir)
  parts = [gem_dir, ruby_engine]
  parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
  File.join parts
end

Path for gems in the user’s home directory

Source 

def self.user_home
  @user_home ||= find_home
end

The home directory for the user.

Source 

def self.win_platform?
  if @@win_platform.nil?
    ruby_platform = RbConfig::CONFIG["host_os"]
    @@win_platform = !WIN_PATTERNS.find {|r| ruby_platform =~ r }.nil?
  end

  @@win_platform
end

Is this a windows platform?

Source 

def self.write_binary(path, data)
  File.binwrite(path, data)
rescue Errno::ENOSPC
  
  File.delete(path) if File.exist?(path)
  raise
end

Safely write a file in binary mode on all platforms.

Private Class Methods

Source 

def already_loaded?(file)
  $LOADED_FEATURES.any? do |feature_path|
    feature_path.end_with?(file) && default_gem_load_paths.any? {|load_path_entry| feature_path == "#{load_path_entry}/#{file}" }
  end
end

Source 

def default_gem_load_paths
  @default_gem_load_paths ||= $LOAD_PATH[load_path_insert_index..-1].map do |lp|
    expanded = File.expand_path(lp)
    next expanded unless File.exist?(expanded)

    File.realpath(expanded)
  end
end

Source 

def self.find_home
  Dir.home.dup
rescue StandardError
  if Gem.win_platform?
    File.expand_path File.join(ENV["HOMEDRIVE"] || ENV["SystemDrive"], "/")
  else
    File.expand_path "/"
  end
end

Finds the user’s home directory.

Source 

def self.find_spec_for_exe(name, exec_name, requirements)
  raise ArgumentError, "you must supply exec_name" unless exec_name

  dep = Gem::Dependency.new name, requirements

  loaded = Gem.loaded_specs[name]

  return loaded if loaded && dep.matches_spec?(loaded)

  specs = dep.matching_specs(true)

  specs = specs.find_all do |spec|
    spec.executables.include? exec_name
  end if exec_name

  unless spec = specs.first
    msg = "can't find gem #{dep} with executable #{exec_name}"
    raise Gem::GemNotFoundException, msg
  end

  spec
end

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.3