# -*- ruby -*- #-- # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. # All rights reserved. # See LICENSE.txt for permissions. #++ require 'rbconfig' module Gem VERSION = '2.0.14.1' end # Must be first since it unloads the prelude from 1.9.2 require 'rubygems/compatibility' require 'rubygems/defaults' require 'rubygems/deprecate' require 'rubygems/errors' ## # RubyGems is the Ruby standard for publishing and managing third party # libraries. # # For user documentation, see: # # * <tt>gem help</tt> and <tt>gem help [command]</tt> # * {RubyGems User Guide}[http://docs.rubygems.org/read/book/1] # * {Frequently Asked Questions}[http://docs.rubygems.org/read/book/3] # # For gem developer documentation see: # # * {Creating Gems}[http://docs.rubygems.org/read/chapter/5] # * Gem::Specification # * Gem::Version for version dependency notes # # Further RubyGems documentation can be found at: # # * {RubyGems Guides}[http://guides.rubygems.org] # * {RubyGems API}[http://rubygems.rubyforge.org/rdoc] (also available from # <tt>gem server</tt>) # # == RubyGems Plugins # # As of RubyGems 1.3.2, RubyGems will load plugins installed in gems 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 discovered via # Gem::find_files then loaded. Take care when implementing a plugin as your # plugin file may be loaded multiple times if multiple versions of your gem # are installed. # # For an example plugin, see the graph gem which adds a `gem graph` command. # # == RubyGems Defaults, Packaging # # RubyGems defaults are stored in rubygems/defaults.rb. If you're packaging # RubyGems or implementing Ruby you can change RubyGems' defaults. # # For RubyGems packagers, provide lib/rubygems/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 and 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}[https://github.com/rubygems/rubygems/issues] # on GitHub # # == Credits # # RubyGems is currently maintained by Eric Hodel. # # RubyGems was originally developed at RubyConf 2003 by: # # * Rich Kilmer -- rich(at)infoether.com # * Chad Fowler -- chad(at)chadfowler.com # * David Black -- dblack(at)wobblini.net # * Paul Brannan -- paul(at)atdesk.com # * Jim Weirch -- jim(at)weirichhouse.org # # Contributors: # # * Gavin Sinclair -- gsinclair(at)soyabean.com.au # * George Marrows -- george.marrows(at)ntlworld.com # * Dick Davies -- rasputnik(at)hellooperator.net # * Mauricio Fernandez -- batsman.geo(at)yahoo.com # * Simon Strandgaard -- neoneye(at)adslhome.dk # * Dave Glasser -- glasser(at)mit.edu # * Paul Duncan -- pabs(at)pablotron.org # * Ville Aine -- vaine(at)cs.helsinki.fi # * Eric Hodel -- drbrain(at)segment7.net # * Daniel Berger -- djberg96(at)gmail.com # * Phil Hagelberg -- technomancy(at)gmail.com # * Ryan Davis -- ryand-ruby(at)zenspider.com # * Evan Phoenix -- evan(at)fallingsnow.net # * Steve Klabnik -- steve(at)steveklabnik.com # # (If your name is missing, PLEASE let us know!) # # See {LICENSE.txt}[rdoc-ref:lib/rubygems/LICENSE.txt] for permissions. # # Thanks! # # -The RubyGems Team module Gem RUBYGEMS_DIR = File.dirname File.expand_path(__FILE__) ## # An Array of Regexps that match windows ruby platforms. WIN_PATTERNS = [ /bccwin/i, /cygwin/i, /djgpp/i, /mingw/i, /mswin/i, /wince/i, ] GEM_DEP_FILES = %w[ gem.deps.rb Gemfile Isolate ] ## # Subdirectories in a gem repository REPOSITORY_SUBDIRECTORIES = %w[ build_info cache doc gems specifications ] @@win_platform = nil @configuration = nil @loaded_specs = {} @path_to_default_spec_map = {} @platforms = [] @ruby = nil @sources = nil @post_build_hooks ||= [] @post_install_hooks ||= [] @post_uninstall_hooks ||= [] @pre_uninstall_hooks ||= [] @pre_install_hooks ||= [] @pre_reset_hooks ||= [] @post_reset_hooks ||= [] ## # 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. def self.try_activate path # finds the _latest_ version... regardless of loaded specs and their deps # if another gem had a requirement that would mean we shouldn't # activate the latest version, then either it would alreaby be activated # or if it was ambigious (and thus unresolved) the code in our custom # require will try to activate the more specific version. spec = Gem::Specification.find_inactive_by_path path unless spec spec = Gem::Specification.find_by_path path return true if spec && spec.activated? return false end begin spec.activate rescue Gem::LoadError # this could fail due to gem dep collisions, go lax Gem::Specification.find_by_name(spec.name).activate end return true end def self.needs rs = Gem::RequestSet.new yield rs finish_resolve rs end def self.finish_resolve(request_set=Gem::RequestSet.new) request_set.import Gem::Specification.unresolved_deps.values request_set.resolve_current.each do |s| s.full_spec.activate end end def self.detect_gemdeps if path = ENV['RUBYGEMS_GEMDEPS'] path = path.dup.untaint if path == "-" here = Dir.pwd.untaint start = here begin while true path = GEM_DEP_FILES.find { |f| File.file?(f) } if path path = File.join here, path break end Dir.chdir ".." # If we're at a toplevel, stop. return if Dir.pwd == here here = Dir.pwd end ensure Dir.chdir start end end path.untaint return unless File.file? path rs = Gem::RequestSet.new rs.load_gemdeps path rs.resolve_current.map do |s| sp = s.full_spec sp.activate sp end end end ## # Find the full path to the executable for gem +name+. If the +exec_name+ # is not given, the gem's default_executable is chosen, otherwise the # specified executable's path is returned. +requirements+ allows # you to specify specific gem versions. def self.bin_path(name, exec_name = nil, *requirements) # TODO: fails test_self_bin_path_bin_file_gone_in_latest # Gem::Specification.find_by_name(name, *requirements).bin_file exec_name raise ArgumentError, "you must supply exec_name" unless exec_name requirements = Gem::Requirement.default if requirements.empty? specs = Gem::Dependency.new(name, requirements).matching_specs(true) raise Gem::GemNotFoundException, "can't find gem #{name} (#{requirements})" if specs.empty? specs = specs.find_all { |spec| spec.executables.include? exec_name } if exec_name unless spec = specs.last msg = "can't find gem #{name} (#{requirements}) with executable #{exec_name}" raise Gem::GemNotFoundException, msg end spec.bin_file exec_name end ## # The mode needed to read a file as straight binary. def self.binary_mode 'rb' end ## # The path where gem executables are to be installed. def self.bindir(install_dir=Gem.dir) # TODO: move to Gem::Dirs return File.join install_dir, 'bin' unless install_dir.to_s == Gem.default_dir.to_s Gem.default_bindir 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. def self.clear_paths @paths = nil @user_home = nil Gem::Specification.reset Gem::Security.reset if defined?(Gem::Security) end ## # The path to standard location of the user's .gemrc file. def self.config_file @config_file ||= File.join Gem.user_home, '.gemrc' end ## # The standard configuration object for gems. def self.configuration @configuration ||= Gem::ConfigFile.new [] end ## # Use the given configuration object (which implements the ConfigFile # protocol) as the standard configuration object. def self.configuration=(config) @configuration = config end ## # The path the the data directory specified by the gem name. If the # package is not available as a gem, return nil. def self.datadir(gem_name) # TODO: deprecate and move to Gem::Specification # and drop the extra ", gem_name" which is uselessly redundant spec = @loaded_specs[gem_name] return nil if spec.nil? File.join spec.full_gem_path, "data", gem_name end ## # A Zlib::Deflate.deflate wrapper def self.deflate(data) require 'zlib' Zlib::Deflate.deflate data end # DOC: needs doc'd or :nodoc'd def self.paths @paths ||= Gem::PathSupport.new end # DOC: needs doc'd or :nodoc'd def self.paths=(env) clear_paths @paths = Gem::PathSupport.new env Gem::Specification.dirs = @paths.path # FIX: home is at end end ## # The path where gems are to be installed. #-- # FIXME deprecate these once everything else has been done -ebh def self.dir # TODO: raise "no" paths.home end def self.path # TODO: raise "no" paths.path 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. def self.ensure_gem_subdirectories dir = Gem.dir, mode = nil old_umask = File.umask File.umask old_umask | 002 require 'fileutils' options = {} options[:mode] = mode if mode REPOSITORY_SUBDIRECTORIES.each do |name| subdir = File.join dir, name next if File.exist? subdir FileUtils.mkdir_p subdir, options rescue nil end ensure File.umask old_umask 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. def self.find_files(glob, check_load_path=true) files = [] if check_load_path files = $LOAD_PATH.map { |load_path| Dir["#{File.expand_path glob, load_path}#{Gem.suffix_pattern}"] }.flatten.select { |file| File.file? file.untaint } end files.concat Gem::Specification.map { |spec| spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}") }.flatten # $LOAD_PATH might contain duplicate entries or reference # the spec dirs directly, so we prune. files.uniq! if check_load_path return files end ## # Finds the user's home directory. #-- # Some comments from the ruby-talk list regarding finding the home # directory: # # I have HOME, USERPROFILE and HOMEDRIVE + HOMEPATH. Ruby seems # to be depending on HOME in those code samples. I propose that # it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at # least on Win32). #++ #-- # # FIXME move to pathsupport # #++ def self.find_home windows = File::ALT_SEPARATOR if not windows or RUBY_VERSION >= '1.9' then File.expand_path "~" else ['HOME', 'USERPROFILE'].each do |key| return File.expand_path ENV[key] if ENV[key] end if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then File.expand_path "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" end end rescue if windows then File.expand_path File.join(ENV['HOMEDRIVE'] || ENV['SystemDrive'], '/') else File.expand_path "/" end end private_class_method :find_home ## # Zlib::GzipReader wrapper that unzips +data+. def self.gunzip(data) # TODO: move to utils require 'stringio' require 'zlib' data = StringIO.new data unzipped = Zlib::GzipReader.new(data).read unzipped.force_encoding Encoding::BINARY if Object.const_defined? :Encoding unzipped end ## # Zlib::GzipWriter wrapper that zips +data+. def self.gzip(data) # TODO: move to utils require 'stringio' require 'zlib' zipped = StringIO.new zipped.set_encoding Encoding::BINARY if Object.const_defined? :Encoding Zlib::GzipWriter.wrap zipped do |io| io.write data end zipped.string end ## # A Zlib::Inflate#inflate wrapper def self.inflate(data) # TODO: move to utils require 'zlib' Zlib::Inflate.inflate data end ## # Top level install helper method. Allows you to install gems interactively: # # % irb # >> Gem.install "minitest" # Fetching: minitest-3.0.1.gem (100%) # => [#<Gem::Specification:0x1013b4528 @name="minitest", ...>] def self.install name, version = Gem::Requirement.default require "rubygems/dependency_installer" inst = Gem::DependencyInstaller.new inst.install name, version inst.installed_gems end ## # Get the default RubyGems API host. This is normally # <tt>https://rubygems.org</tt>. def self.host # TODO: move to utils @host ||= Gem::DEFAULT_HOST end ## Set the default RubyGems API host. def self.host= host # TODO: move to utils @host = host end ## # The index to insert activated gem paths into the $LOAD_PATH. # # Defaults to the site lib directory unless gem_prelude.rb has loaded paths, # then it inserts the activated gem's paths before the gem_prelude.rb paths # so you can override the gem_prelude.rb default $LOAD_PATH paths. def self.load_path_insert_index index = $LOAD_PATH.index ConfigMap[:sitelibdir] index end @yaml_loaded = false ## # Loads YAML, preferring Psych def self.load_yaml return if @yaml_loaded return unless defined?(gem) test_syck = ENV['TEST_SYCK'] unless test_syck begin gem 'psych', '>= 2.0.0' rescue Gem::LoadError # It's OK if the user does not have the psych gem installed. We will # attempt to require the stdlib version end begin # Try requiring the gem version *or* stdlib version of psych. require 'psych' rescue ::LoadError # If we can't load psych, thats fine, go on. else # If 'yaml' has already been required, then we have to # be sure to switch it over to the newly loaded psych. if defined?(YAML::ENGINE) && YAML::ENGINE.yamler != "psych" YAML::ENGINE.yamler = "psych" end require 'rubygems/psych_additions' require 'rubygems/psych_tree' end end require 'yaml' require 'rubygems/safe_yaml' # If we're supposed to be using syck, then we may have to force # activate it via the YAML::ENGINE API. if test_syck and defined?(YAML::ENGINE) YAML::ENGINE.yamler = "syck" unless YAML::ENGINE.syck? end # Now that we're sure some kind of yaml library is loaded, pull # in our hack to deal with Syck's DefaultKey ugliness. require 'rubygems/syck_hack' @yaml_loaded = true end ## # The file name and line number of the caller of the caller of this method. def self.location_of_caller caller[1] =~ /(.*?):(\d+).*?$/i file = $1 lineno = $2.to_i # TODO: it is ALWAYS joined! STUPID! [file, lineno] end ## # The version of the Marshal format for your Ruby. def self.marshal_version "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}" end ## # Set array of platforms this RubyGems supports (primarily for testing). def self.platforms=(platforms) @platforms = platforms end ## # Array of platforms this RubyGems supports. def self.platforms @platforms ||= [] if @platforms.empty? @platforms = [Gem::Platform::RUBY, Gem::Platform.local] end @platforms 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. def self.post_build(&hook) @post_build_hooks << hook end ## # Adds a post-install hook that will be passed an Gem::Installer instance # when Gem::Installer#install is called def self.post_install(&hook) @post_install_hooks << hook end ## # Adds a post-installs hook that will be passed a Gem::DependencyInstaller # and a list of installed specifications when # Gem::DependencyInstaller#install is complete def self.done_installing(&hook) @done_installing_hooks << hook end ## # Adds a hook that will get run after Gem::Specification.reset is # run. def self.post_reset(&hook) @post_reset_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 def self.post_uninstall(&hook) @post_uninstall_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. def self.pre_install(&hook) @pre_install_hooks << hook end ## # Adds a hook that will get run before Gem::Specification.reset is # run. def self.pre_reset(&hook) @pre_reset_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 def self.pre_uninstall(&hook) @pre_uninstall_hooks << hook 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. def self.prefix prefix = File.dirname RUBYGEMS_DIR if prefix != File.expand_path(ConfigMap[:sitelibdir]) and prefix != File.expand_path(ConfigMap[:libdir]) and 'lib' == File.basename(RUBYGEMS_DIR) then prefix end end ## # Refresh available gems from disk. def self.refresh Gem::Specification.reset end ## # Safely read a file in binary mode on all platforms. def self.read_binary(path) File.open path, binary_mode do |f| f.read end end ## # The path to the running Ruby interpreter. def self.ruby if @ruby.nil? then @ruby = File.join(ConfigMap[:bindir], "#{ConfigMap[:ruby_install_name]}#{ConfigMap[:EXEEXT]}") @ruby = "\"#{@ruby}\"" if @ruby =~ /\s/ end @ruby end ## # Returns the latest release-version specification for the gem +name+. 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.first spec end ## # Returns the latest release version of RubyGems. def self.latest_rubygems_version latest_version_for('rubygems-update') or raise "Can't find 'rubygems-update' in any repo. Check `gem source list`." end ## # Returns the version of the latest release-version of gem +name+ def self.latest_version_for name spec = latest_spec_for name spec and spec.version end ## # A Gem::Version for the currently running ruby. def self.ruby_version return @ruby_version if defined? @ruby_version version = RUBY_VERSION.dup if defined?(RUBY_PATCHLEVEL) && RUBY_PATCHLEVEL != -1 then version << ".#{RUBY_PATCHLEVEL}" elsif defined?(RUBY_REVISION) then version << ".dev.#{RUBY_REVISION}" end @ruby_version = Gem::Version.new version end ## # A Gem::Version for the currently running RubyGems def self.rubygems_version return @rubygems_version if defined? @rubygems_version @rubygems_version = Gem::Version.new Gem::VERSION end ## # Returns an Array of sources to fetch remote gems from. Uses # default_sources if the sources list is empty. def self.sources @sources ||= Gem::SourceList.from(default_sources) 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. def self.sources= new_sources if !new_sources @sources = nil else @sources = Gem::SourceList.from(new_sources) end end ## # Glob pattern for require-able path suffixes. def self.suffix_pattern @suffix_pattern ||= "{#{suffixes.join(',')}}" end ## # Suffixes for require-able paths. def self.suffixes @suffixes ||= ['', '.rb', *%w(DLEXT DLEXT2).map { |key| val = RbConfig::CONFIG[key] next unless val and not val.empty? ".#{val}" } ].compact.uniq end ## # Prints the amount of time the supplied block takes to run using the debug # UI output. def self.time(msg, width = 0, display = Gem.configuration.verbose) now = Time.now value = yield elapsed = Time.now - now ui.say "%2$*1$s: %3$3.3fs" % [-width, msg, elapsed] if display value end ## # Lazily loads DefaultUserInteraction and returns the default UI. def self.ui require 'rubygems/user_interaction' Gem::DefaultUserInteraction.ui end ## # Use the +home+ and +paths+ values for Gem.dir and Gem.path. Used mainly # by the unit tests to provide environment isolation. def self.use_paths(home, *paths) paths = nil if paths == [nil] paths = paths.first if Array === Array(paths).first self.paths = { "GEM_HOME" => home, "GEM_PATH" => paths } # TODO: self.paths = home, paths end ## # The home directory for the user. def self.user_home @user_home ||= find_home.untaint end ## # Is this a windows platform? def self.win_platform? if @@win_platform.nil? then ruby_platform = RbConfig::CONFIG['host_os'] @@win_platform = !!WIN_PATTERNS.find { |r| ruby_platform =~ r } end @@win_platform end ## # Load +plugins+ as ruby files def self.load_plugin_files(plugins) plugins.each do |plugin| # Skip older versions of the GemCutter plugin: Its commands are in # RubyGems proper now. next if plugin =~ /gemcutter-0\.[0-3]/ begin load plugin rescue ::Exception => e details = "#{plugin.inspect}: #{e.message} (#{e.class})" warn "Error loading RubyGems plugin #{details}" end end end ## # Find all 'rubygems_plugin' files in installed gems and load them def self.load_plugins load_plugin_files find_files('rubygems_plugin', false) end ## # Find all 'rubygems_plugin' files in $LOAD_PATH and load them def self.load_env_plugins path = "rubygems_plugin" files = [] $LOAD_PATH.each do |load_path| globbed = Dir["#{File.expand_path path, load_path}#{Gem.suffix_pattern}"] globbed.each do |load_path_file| files << load_path_file if File.file?(load_path_file.untaint) end end load_plugin_files files end # FIX: Almost everywhere else we use the `def self.` way of defining class # methods, and then we switch over to `class << self` here. Pick one or the # other. class << self ## # Hash of loaded Gem::Specification keyed by name attr_reader :loaded_specs ## # Register a Gem::Specification for default gem def register_default_spec(spec) spec.files.each do |file| @path_to_default_spec_map[file] = spec end end ## # Find a Gem::Specification of default gem from +path+ def find_unresolved_default_spec(path) Gem.suffixes.each do |suffix| spec = @path_to_default_spec_map["#{path}#{suffix}"] return spec if spec end nil end ## # Remove needless Gem::Specification of default gem from # unresolved default gem list def remove_unresolved_default_spec(spec) spec.files.each do |file| @path_to_default_spec_map.delete(file) end end ## # Clear default gem related varibles. It is for test def clear_default_specs @path_to_default_spec_map.clear end ## # The list of hooks to be run after Gem::Installer#install extracts files # and builds extensions attr_reader :post_build_hooks ## # The list of hooks to be run after Gem::Installer#install completes # installation attr_reader :post_install_hooks ## # The list of hooks to be run after Gem::DependencyInstaller installs a # set of gems attr_reader :done_installing_hooks ## # The list of hooks to be run after Gem::Specification.reset is run. attr_reader :post_reset_hooks ## # The list of hooks to be run after Gem::Uninstaller#uninstall completes # installation attr_reader :post_uninstall_hooks ## # The list of hooks to be run before Gem::Installer#install does any work attr_reader :pre_install_hooks ## # The list of hooks to be run before Gem::Specification.reset is run. attr_reader :pre_reset_hooks ## # The list of hooks to be run before Gem::Uninstaller#uninstall does any # work attr_reader :pre_uninstall_hooks end ## # Location of Marshal quick gemspecs on remote repositories MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/" autoload :ConfigFile, 'rubygems/config_file' autoload :Dependency, 'rubygems/dependency' autoload :DependencyList, 'rubygems/dependency_list' autoload :DependencyResolver, 'rubygems/dependency_resolver' autoload :PathSupport, 'rubygems/path_support' autoload :Platform, 'rubygems/platform' autoload :RequestSet, 'rubygems/request_set' autoload :Requirement, 'rubygems/requirement' autoload :SourceList, 'rubygems/source_list' autoload :SpecFetcher, 'rubygems/spec_fetcher' autoload :Specification, 'rubygems/specification' autoload :Version, 'rubygems/version' autoload :Source, 'rubygems/source' require "rubygems/specification" end require 'rubygems/exceptions' # REFACTOR: This should be pulled out into some kind of hacks file. gem_preluded = Gem::GEM_PRELUDE_SUCKAGE and defined? Gem unless gem_preluded then # TODO: remove guard after 1.9.2 dropped begin ## # Defaults the operating system (or packager) wants to provide for RubyGems. require 'rubygems/defaults/operating_system' rescue LoadError end if defined?(RUBY_ENGINE) then begin ## # Defaults the ruby implementation wants to provide for RubyGems require "rubygems/defaults/#{RUBY_ENGINE}" rescue LoadError end end end ## # Loads the default specs. Gem::Specification.load_defaults require 'rubygems/core_ext/kernel_gem' require 'rubygems/core_ext/kernel_require' Gem.detect_gemdeps

💾 SAVE CHANGES CANCEL