Module: Gem

Extended by:
Deprecate
Defined in:
lib/rubygems.rb,
lib/rubygems.rb,
lib/rubygems/defaults.rb,
lib/rubygems/deprecate.rb,
lib/rubygems/syck_hack.rb,
lib/rubygems/syck_hack.rb,
lib/rubygems/test_case.rb,
lib/rubygems/psych_tree.rb,
lib/rubygems/psych_tree.rb,
lib/rubygems/gem_openssl.rb,
lib/rubygems/source_index.rb,
lib/rubygems.rb

Overview

:stopdoc:

Defined Under Namespace

Modules: Commands, DefaultUserInteraction, Deprecate, Ext, GemcutterUtilities, InstallUpdateOptions, LocalRemoteOptions, Package, RequirePathsBuilder, SSL, Security, Text, UserInteraction, VersionOption Classes: Builder, Command, CommandLineError, CommandManager, ConfigFile, ConsoleUI, Dependency, DependencyError, DependencyInstaller, DependencyList, DependencyRemovalException, DocManager, DocumentError, EndOfYAMLException, ErrorReason, Exception, FakeFetcher, FilePermissionError, Format, FormatException, GemNotFoundException, GemNotInHomeException, GemPathSearcher, GemRunner, Indexer, InstallError, Installer, InstallerTestCase, InvalidSpecificationException, LoadError, MockGemUi, NoAliasYAMLTree, OldFormat, OperationNotSupportedError, PackageTask, PathSupport, Platform, PlatformMismatch, RemoteError, RemoteFetcher, RemoteInstallationCancelled, RemoteInstallationSkipped, RemoteSourceException, Requirement, Server, SilentUI, SourceIndex, SpecFetcher, Specification, StreamUI, SystemExitException, TestCase, Uninstaller, Validator, VerificationError, Version

Constant Summary collapse

QUICKLOADER_SUCKAGE = 
RUBY_VERSION =~ /^1\.9\.1/
GEM_PRELUDE_SUCKAGE =

Only MRI 1.9.2 has the custom prelude.

RUBY_VERSION =~ /^1\.9\.2/ && RUBY_ENGINE == "ruby"
VERSION = 
'1.8.23'
RubyGemsVersion =

:stopdoc:

VERSION
RbConfigPriorities = 
%w[
EXEEXT RUBY_SO_NAME arch bindir datadir libdir ruby_install_name
ruby_version rubylibprefix sitedir sitelibdir vendordir vendorlibdir
ConfigMap =

Configuration settings from ::RbConfig

Hash.new do |cm, key|
  cm[key] = RbConfig::CONFIG[key.to_s]
end
RubyGemsPackageVersion = 
VERSION
RUBYGEMS_DIR = 
File.dirname File.expand_path(__FILE__)
WIN_PATTERNS =

An Array of Regexps that match windows ruby platforms.

[
  /bccwin/i,
  /cygwin/i,
  /djgpp/i,
  /mingw/i,
  /mswin/i,
  /wince/i,
]
MARSHAL_SPEC_DIR =

Location of Marshal quick gemspecs on remote repositories

"quick/Marshal.#{Gem.marshal_version}/"
SyckDefaultKey = 
YAML::Syck::DefaultKey
Cache =

Cache is an alias for SourceIndex to allow older YAMLized source index objects to load properly.

SourceIndex
@@source_index = 
nil
@@win_platform = 
nil

Class Attribute Summary collapse

Class Method Summary collapse

Methods included from Deprecate

deprecate, skip, skip=, skip_during

Class Attribute Details

.loaded_specs ⇒ Object (readonly)

Hash of loaded Gem::Specification keyed by name



1134
1135
1136
 
# File 'lib/rubygems.rb', line 1134

def loaded_specs
  @loaded_specs
end

.post_build_hooks ⇒ Object (readonly)

The list of hooks to be run before Gem::Install#install finishes installation



1140
1141
1142
 
# File 'lib/rubygems.rb', line 1140

def post_build_hooks
  @post_build_hooks
end

.post_install_hooks ⇒ Object (readonly)

The list of hooks to be run before Gem::Install#install does any work



1145
1146
1147
 
# File 'lib/rubygems.rb', line 1145

def post_install_hooks
  @post_install_hooks
end

.post_reset_hooks ⇒ Object (readonly)

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



1150
1151
1152
 
# File 'lib/rubygems.rb', line 1150

def post_reset_hooks
  @post_reset_hooks
end

.post_uninstall_hooks ⇒ Object (readonly)

The list of hooks to be run before Gem::Uninstall#uninstall does any work



1156
1157
1158
 
# File 'lib/rubygems.rb', line 1156

def post_uninstall_hooks
  @post_uninstall_hooks
end

.pre_install_hooks ⇒ Object (readonly)

The list of hooks to be run after Gem::Install#install is finished



1161
1162
1163
 
# File 'lib/rubygems.rb', line 1161

def pre_install_hooks
  @pre_install_hooks
end

.pre_reset_hooks ⇒ Object (readonly)

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



1166
1167
1168
 
# File 'lib/rubygems.rb', line 1166

def pre_reset_hooks
  @pre_reset_hooks
end

.pre_uninstall_hooks ⇒ Object (readonly)

The list of hooks to be run after Gem::Uninstall#uninstall is finished



1171
1172
1173
 
# File 'lib/rubygems.rb', line 1171

def pre_uninstall_hooks
  @pre_uninstall_hooks
end

.ssl_available=(value) ⇒ Object (writeonly)

Is SSL available?



26
27
28
 
# File 'lib/rubygems/gem_openssl.rb', line 26

def ssl_available=(value)
  @ssl_available = value
end

Class Method Details

.activate(dep, *requirements) ⇒ Object

Activates an installed gem matching dep. The gem must satisfy requirements.

Returns true if the gem is activated, false if it is already loaded, or an exception otherwise.

Gem#activate adds the library paths in dep to $LOAD_PATH. Before a Gem is activated its required Gems are activated. If the version information is omitted, the highest version Gem of the supplied name is loaded. If a Gem is not found that meets the version requirements or a required Gem is not found, a Gem::LoadError is raised.

More information on version requirements can be found in the Gem::Requirement and Gem::Version documentation.

Raises:

  • (ArgumentError) 


234
235
236
237
238
239
 
# File 'lib/rubygems.rb', line 234

def self.activate(dep, *requirements)
  raise ArgumentError, "Deprecated use of Gem.activate(dep)" if
    Gem::Dependency === dep

  Gem::Specification.find_by_name(dep, *requirements).activate
end

.activate_dep(dep, *requirements) ⇒ Object

:nodoc:



241
242
243
 
# File 'lib/rubygems.rb', line 241

def self.activate_dep dep, *requirements # :nodoc:
  dep.to_spec.activate
end

.activate_spec(spec) ⇒ Object

:nodoc:



245
246
247
 
# File 'lib/rubygems.rb', line 245

def self.activate_spec spec # :nodoc:
  spec.activate
end

.all_load_paths ⇒ Object

An Array of all possible load paths for all versions of all gems in the Gem installation.



257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/rubygems.rb', line 257

def self.all_load_paths
  result = []

  Gem.path.each do |gemdir|
    each_load_path all_partials(gemdir) do |load_path|
      result << load_path
    end
  end

  result
end

.all_partials(gemdir) ⇒ Object

Return all the partial paths in gemdir.



272
273
274
 
# File 'lib/rubygems.rb', line 272

def self.all_partials(gemdir)
  Dir[File.join(gemdir, "gems/*")]
end

.available?(dep, *requirements) ⇒ Boolean

See if a given gem is available.

Returns:

  • (Boolean) 


281
282
283
284
285
286
287
288
289
 
# File 'lib/rubygems.rb', line 281

def self.available?(dep, *requirements)
  requirements = Gem::Requirement.default if requirements.empty?

  unless dep.respond_to?(:name) and dep.respond_to?(:requirement) then
    dep = Gem::Dependency.new dep, requirements
  end

  not dep.matching_specs(true).empty?
end

.bin_path(name, exec_name = nil, *requirements) ⇒ Object

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.

Raises:

  • (ArgumentError) 


297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/rubygems.rb', line 297

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

.binary_mode ⇒ Object

The mode needed to read a file as straight binary.



326
327
328
 
# File 'lib/rubygems.rb', line 326

def self.binary_mode
  'rb'
end

.bindir(install_dir = Gem.dir) ⇒ Object

The path where gem executables are to be installed.



333
334
335
336
337
338
 
# File 'lib/rubygems.rb', line 333

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

.cache ⇒ Object

:nodoc:



1174
1175
1176
 
# File 'lib/rubygems.rb', line 1174

def self.cache # :nodoc:
  source_index
end

.cache_dir(custom_dir = false) ⇒ Object

Get the appropriate cache path.

Pass a string to use a different base path, or nil/false (default) for Gem.dir.



721
722
723
 
# File 'lib/rubygems.rb', line 721

def self.cache_dir(custom_dir=false)
  File.join(custom_dir || Gem.dir, "cache")
end

.cache_gem(filename, user_dir = false) ⇒ Object

Given a gem path, find the gem in cache.

Pass a string as the second argument to use a different base path, or nil/false (default) for Gem.dir.



731
732
733
 
# File 'lib/rubygems.rb', line 731

def self.cache_gem(filename, user_dir=false)
  cache_dir(user_dir).add(filename)
end

.clear_paths ⇒ Object

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.



345
346
347
348
349
350
351
 
# File 'lib/rubygems.rb', line 345

def self.clear_paths
  @@source_index = nil
  @paths         = nil
  @user_home     = nil
  @searcher      = nil
  Gem::Specification.reset
end

.config_file ⇒ Object

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



356
357
358
 
# File 'lib/rubygems.rb', line 356

def self.config_file
  @config_file ||= File.join Gem.user_home, '.gemrc'
end

.configuration ⇒ Object

The standard configuration object for gems.



363
364
365
 
# File 'lib/rubygems.rb', line 363

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

.configuration=(config) ⇒ Object

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



371
372
373
 
# File 'lib/rubygems.rb', line 371

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

.datadir(gem_name) ⇒ Object

The path the the data directory specified by the gem name. If the package is not available as a gem, return nil.



379
380
381
382
383
384
 
# File 'lib/rubygems.rb', line 379

def self.datadir(gem_name)
# TODO: deprecate
  spec = @loaded_specs[gem_name]
  return nil if spec.nil?
  File.join spec.full_gem_path, "data", gem_name
end

.default_bindir ⇒ Object

The default directory for binaries



88
89
90
91
92
93
94
 
# File 'lib/rubygems/defaults.rb', line 88

def self.default_bindir
  if defined? RUBY_FRAMEWORK_VERSION then # mac framework support
    '/usr/bin'
  else # generic install
    ConfigMap[:bindir]
  end
end

.default_dir ⇒ Object

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



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/rubygems/defaults.rb', line 21

def self.default_dir
  path = if defined? RUBY_FRAMEWORK_VERSION then
           [
             File.dirname(ConfigMap[:sitedir]),
             'Gems',
             ConfigMap[:ruby_version]
           ]
         elsif ConfigMap[:rubylibprefix] then
           [
            ConfigMap[:rubylibprefix],
            'gems',
            ConfigMap[:ruby_version]
           ]
         else
           [
             ConfigMap[:libdir],
             ruby_engine,
             'gems',
             ConfigMap[:ruby_version]
           ]
         end

  @default_dir ||= File.join(*path)
end

.default_exec_format ⇒ Object

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



74
75
76
77
78
79
80
81
82
83
 
# File 'lib/rubygems/defaults.rb', line 74

def self.default_exec_format
  exec_format = ConfigMap[:ruby_install_name].sub('ruby', '%s') rescue '%s'

  unless exec_format =~ /%s/ then
    raise Gem::Exception,
      "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
  end

  exec_format
end

.default_path ⇒ Object

Default gem load path



63
64
65
66
67
68
69
 
# File 'lib/rubygems/defaults.rb', line 63

def self.default_path
  if File.exist? Gem.user_home then
    [user_dir, default_dir]
  else
    [default_dir]
  end
end

.default_rubygems_dirs ⇒ Object

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



49
50
51
 
# File 'lib/rubygems/defaults.rb', line 49

def self.default_rubygems_dirs
  nil # default to standard layout
end

.default_sources ⇒ Object

An Array of the default sources that come with RubyGems



13
14
15
 
# File 'lib/rubygems/defaults.rb', line 13

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

.default_system_source_cache_dir ⇒ Object

The default system-wide source info cache directory



99
100
101
 
# File 'lib/rubygems/defaults.rb', line 99

def self.default_system_source_cache_dir
  File.join(Gem.dir, 'source_cache')
end

.default_user_source_cache_dir ⇒ Object

The default user-specific source info cache directory



106
107
108
109
110
111
112
 
# File 'lib/rubygems/defaults.rb', line 106

def self.default_user_source_cache_dir
  #
  # NOTE Probably an argument for moving this to per-ruby supported dirs like
  # user_dir
  #
  File.join(Gem.user_home, '.gem', 'source_cache')
end

.deflate(data) ⇒ Object

A Zlib::Deflate.deflate wrapper



389
390
391
392
 
# File 'lib/rubygems.rb', line 389

def self.deflate(data)
  require 'zlib'
  Zlib::Deflate.deflate data
end

.dir ⇒ Object

The path where gems are to be installed. -- FIXME deprecate these once everything else has been done -ebh



409
410
411
412
 
# File 'lib/rubygems.rb', line 409

def self.dir
  # TODO: raise "no"
  paths.home
end

.each_load_path(partials) ⇒ Object

Expand each partial gem path with each of the required paths specified in the Gem spec. Each expanded path is yielded.



423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/rubygems.rb', line 423

def self.each_load_path(partials)
  partials.each do |gp|
    base = File.basename gp
    specfn = File.join(dir, "specifications", "#{base}.gemspec")
    if File.exists? specfn
      spec = eval(File.read(specfn))
      spec.require_paths.each do |rp|
        yield File.join(gp,rp)
      end
    else
      filename = File.join(gp, 'lib')
      yield(filename) if File.exists? filename
    end
  end
end

.ensure_gem_subdirectories(dir = Gem.dir) ⇒ Object

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



447
448
449
450
451
452
453
454
455
456
457
458
459
460
 
# File 'lib/rubygems.rb', line 447

def self.ensure_gem_subdirectories dir = Gem.dir
  old_umask = File.umask
  File.umask old_umask | 002

  require 'fileutils'

  %w[cache doc gems specifications].each do |name|
    subdir = File.join dir, name
    next if File.exist? subdir
    FileUtils.mkdir_p subdir rescue nil # in case of perms issues -- lame
  end
ensure
  File.umask old_umask
end

.ensure_ssl_available ⇒ Object

Ensure that SSL is available. Throw an exception if it is not.



31
32
33
34
35
 
# File 'lib/rubygems/gem_openssl.rb', line 31

def ensure_ssl_available
  unless ssl_available?
    raise Gem::Exception, "SSL is not installed on this system"
  end
end

.find_files(glob, check_load_path = true) ⇒ Object

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.



474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
 
# File 'lib/rubygems.rb', line 474

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

.find_home ⇒ Object

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

++



511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
 
# File 'lib/rubygems.rb', line 511

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

.gunzip(data) ⇒ Object

Zlib::GzipReader wrapper that unzips data.



537
538
539
540
541
542
543
544
 
# File 'lib/rubygems.rb', line 537

def self.gunzip(data)
  # TODO: move to utils
  require 'stringio'
  require 'zlib'
  data = StringIO.new data

  Zlib::GzipReader.new(data).read
end

.gzip(data) ⇒ Object

Zlib::GzipWriter wrapper that zips data.



549
550
551
552
553
554
555
556
557
558
 
# File 'lib/rubygems.rb', line 549

def self.gzip(data)
  # TODO: move to utils
  require 'stringio'
  require 'zlib'
  zipped = StringIO.new

  Zlib::GzipWriter.wrap zipped do |io| io.write data end

  zipped.string
end

.host ⇒ Object

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



573
574
575
576
 
# File 'lib/rubygems.rb', line 573

def self.host
  # TODO: move to utils
  @host ||= "https://rubygems.org"
end

.host=(host) ⇒ Object

Set the default RubyGems API host.



580
581
582
583
 
# File 'lib/rubygems.rb', line 580

def self.host= host
  # TODO: move to utils
  @host = host
end

.inflate(data) ⇒ Object

A Zlib::Inflate#inflate wrapper



563
564
565
566
567
 
# File 'lib/rubygems.rb', line 563

def self.inflate(data)
  # TODO: move to utils
  require 'zlib'
  Zlib::Inflate.inflate data
end

.latest_load_paths ⇒ Object

Return a list of all possible load paths for the latest version for all gems in the Gem installation.



589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/rubygems.rb', line 589

def self.latest_load_paths
  result = []

  Gem.path.each do |gemdir|
    each_load_path(latest_partials(gemdir)) do |load_path|
      result << load_path
    end
  end

  result
end

.latest_partials(gemdir) ⇒ Object

Return only the latest partial paths in the given gemdir.



604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/rubygems.rb', line 604

def self.latest_partials(gemdir)
  latest = {}
  all_partials(gemdir).each do |gp|
    base = File.basename gp

    if base.to_s =~ /(.*)-((\d+\.)*\d+)/ then
      name, version = $1, $2
      ver = Gem::Version.new(version)
      if latest[name].nil? || ver > latest[name][0]
        latest[name] = [ver, gp]
      end
    end
  end
  latest.collect { |k,v| v[1] }
end

.latest_rubygems_version ⇒ Object 



950
951
952
 
# File 'lib/rubygems.rb', line 950

def self.latest_rubygems_version
  latest_version_for "rubygems-update"
end

.latest_spec_for(name) ⇒ Object 



931
932
933
934
935
936
937
938
939
940
941
942
943
 
# File 'lib/rubygems.rb', line 931

def self.latest_spec_for name
  dependency  = Gem::Dependency.new name
  fetcher     = Gem::SpecFetcher.fetcher
  spec_tuples = fetcher.find_matching dependency

  match = spec_tuples.select { |(n, _, p), _|
    n == name and Gem::Platform.match p
  }.sort_by { |(_, version, _), _|
    version
  }.last

  match and fetcher.fetch_spec(*match)
end

.latest_version_for(name) ⇒ Object 



945
946
947
948
 
# File 'lib/rubygems.rb', line 945

def self.latest_version_for name
  spec = latest_spec_for name
  spec and spec.version
end

.load_env_plugins ⇒ Object

Find all 'rubygems_plugin' files in $LOAD_PATH and load them



1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
 
# File 'lib/rubygems.rb', line 1114

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

.load_path_insert_index ⇒ Object

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.



629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
 
# File 'lib/rubygems.rb', line 629

def self.load_path_insert_index
  index = $LOAD_PATH.index ConfigMap[:sitelibdir]

  if QUICKLOADER_SUCKAGE then
    $LOAD_PATH.each_with_index do |path, i|
      if path.instance_variables.include?(:@gem_prelude_index) or
          path.instance_variables.include?('@gem_prelude_index') then
        index = i
        break
      end
    end
  end

  index
end

.load_plugin_files(plugins) ⇒ Object

Load plugins as ruby files



1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
 
# File 'lib/rubygems.rb', line 1087

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

.load_plugins ⇒ Object

Find all 'rubygems_plugin' files in installed gems and load them



1107
1108
1109
 
# File 'lib/rubygems.rb', line 1107

def self.load_plugins
  load_plugin_files find_files('rubygems_plugin', false)
end

.load_yaml ⇒ Object

Loads YAML, preferring Psych



650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
 
# File 'lib/rubygems.rb', line 650

def self.load_yaml
  return if @yaml_loaded

  test_syck = ENV['TEST_SYCK']

  unless test_syck
    begin
      gem 'psych', '~> 1.2', '>= 1.2.1'
    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'

  # 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

.loaded_path?(path) ⇒ Boolean

Returns:

  • (Boolean) 


1010
1011
1012
1013
1014
 
# File 'lib/rubygems.rb', line 1010

def self.loaded_path? path
  # TODO: ruby needs a feature to let us query what's loaded in 1.8 and 1.9
  re = /(^|\/)#{Regexp.escape path}#{Regexp.union(*Gem.suffixes)}$/
  $LOADED_FEATURES.any? { |s| s =~ re }
end

.location_of_caller ⇒ Object

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



698
699
700
701
702
703
704
705
 
# File 'lib/rubygems.rb', line 698

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

  # TODO: it is ALWAYS joined! STUPID!
  [file, lineno]
end

.marshal_version ⇒ Object

The version of the Marshal format for your Ruby.



710
711
712
 
# File 'lib/rubygems.rb', line 710

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

.path ⇒ Object 



414
415
416
417
 
# File 'lib/rubygems.rb', line 414

def self.path
  # TODO: raise "no"
  paths.path
end

.paths ⇒ Object 



394
395
396
 
# File 'lib/rubygems.rb', line 394

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

.paths=(env) ⇒ Object 



398
399
400
401
402
 
# File 'lib/rubygems.rb', line 398

def self.paths=(env)
  clear_paths
  @paths = Gem::PathSupport.new env
  Gem::Specification.dirs = @paths.path # FIX: home is at end
end

.platforms ⇒ Object

Array of platforms this RubyGems supports.



745
746
747
748
749
750
751
 
# File 'lib/rubygems.rb', line 745

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

.platforms=(platforms) ⇒ Object

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



738
739
740
 
# File 'lib/rubygems.rb', line 738

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

.post_build(&hook) ⇒ Object

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.



760
761
762
 
# File 'lib/rubygems.rb', line 760

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

.post_install(&hook) ⇒ Object

Adds a post-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is called



768
769
770
 
# File 'lib/rubygems.rb', line 768

def self.post_install(&hook)
  @post_install_hooks << hook
end

.post_reset(&hook) ⇒ Object

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



776
777
778
 
# File 'lib/rubygems.rb', line 776

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

.post_uninstall(&hook) ⇒ Object

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



785
786
787
 
# File 'lib/rubygems.rb', line 785

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

.pre_install(&hook) ⇒ Object

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.



794
795
796
 
# File 'lib/rubygems.rb', line 794

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

.pre_reset(&hook) ⇒ Object

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



802
803
804
 
# File 'lib/rubygems.rb', line 802

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

.pre_uninstall(&hook) ⇒ Object

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



811
812
813
 
# File 'lib/rubygems.rb', line 811

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

.prefix ⇒ Object

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.



820
821
822
823
824
825
826
827
828
 
# File 'lib/rubygems.rb', line 820

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

.promote_load_path(gem_name, over_name) ⇒ Object

Promotes the load paths of the gem_name over the load paths of over_name. Useful for allowing one gem to override features in another using #find_files.

Raises:

  • (ArgumentError) 


835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
 
# File 'lib/rubygems.rb', line 835

def self.promote_load_path(gem_name, over_name)
  gem = Gem.loaded_specs[gem_name]
  over = Gem.loaded_specs[over_name]

  raise ArgumentError, "gem #{gem_name} is not activated" if gem.nil?
  raise ArgumentError, "gem #{over_name} is not activated" if over.nil?

  last_gem_path = Gem::Path.path(gem.full_gem_path).add(gem.require_paths.last)

  over_paths = over.require_paths.map do |path|
    Gem::Path.path(over.full_gem_path).add(path).to_s
  end

  over_paths.each do |path|
    $LOAD_PATH.delete path
  end

  gem = $LOAD_PATH.index(last_gem_path) + 1

  $LOAD_PATH.insert(gem, *over_paths)
end

.read_binary(path) ⇒ Object

Safely read a file in binary mode on all platforms.



869
870
871
 
# File 'lib/rubygems.rb', line 869

def self.read_binary(path)
  File.open path, binary_mode do |f| f.read end
end

.refresh ⇒ Object

Refresh source_index from disk and clear searcher.



860
861
862
863
864
 
# File 'lib/rubygems.rb', line 860

def self.refresh
  Gem::Specification.reset
  @source_index = nil
  @searcher = nil
end

.report_activate_error(gem) ⇒ Object

Report a load error during activation. The message of load error depends on whether it was a version mismatch or if there are not gems of any version by the requested name.



878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
 
# File 'lib/rubygems.rb', line 878

def self.report_activate_error(gem)
  matches = Gem::Specification.find_by_name(gem.name)

  if matches.empty? then
    error = Gem::LoadError.new(
        "Could not find RubyGem #{gem.name} (#{gem.requirement})\n")
  else
    error = Gem::LoadError.new(
        "RubyGem version error: " +
        "#{gem.name}(#{matches.first.version} not #{gem.requirement})\n")
  end

  error.name = gem.name
  error.requirement = gem.requirement
  raise error
end

.required_location(gemname, libfile, *requirements) ⇒ Object

Full path to libfile in gemname. Searches for the latest gem unless requirements is given.



901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
 
# File 'lib/rubygems.rb', line 901

def self.required_location(gemname, libfile, *requirements)
  requirements = Gem::Requirement.default if requirements.empty?

  matches = Gem::Specification.find_all_by_name gemname, *requirements

  return nil if matches.empty?

  spec = matches.last
  spec.require_paths.each do |path|
    result = Gem::Path.path(spec.full_gem_path).add(path, libfile)
    return result if result.exist?
  end

  nil
end

.ruby ⇒ Object

The path to the running Ruby interpreter.



920
921
922
923
924
925
926
927
928
929
 
# File 'lib/rubygems.rb', line 920

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

.ruby=(ruby) ⇒ Object

Allows setting path to ruby. This method is available when requiring 'rubygems/test_case'



60
61
62
 
# File 'lib/rubygems/test_case.rb', line 60

def self.ruby= ruby
  @ruby = ruby
end

.ruby_engine ⇒ Object

A wrapper around RUBY_ENGINE const that may not be defined



117
118
119
120
121
122
123
 
# File 'lib/rubygems/defaults.rb', line 117

def self.ruby_engine
  if defined? RUBY_ENGINE then
    RUBY_ENGINE
  else
    'ruby'
  end
end

.ruby_version ⇒ Object

A Gem::Version for the currently running ruby.



957
958
959
960
961
962
963
964
965
966
967
968
 
# File 'lib/rubygems.rb', line 957

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

.searcher ⇒ Object

The GemPathSearcher object used to search for matching installed gems.



973
974
975
 
# File 'lib/rubygems.rb', line 973

def self.searcher
  @searcher ||= Gem::GemPathSearcher.new
end

.searcher=(searcher) ⇒ Object

Allows setting the gem path searcher. This method is available when requiring 'rubygems/test_case'



34
35
36
 
# File 'lib/rubygems/test_case.rb', line 34

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

.source_index ⇒ Object

Returns the Gem::SourceIndex of specifications that are in the Gem.path



980
981
982
983
984
 
# File 'lib/rubygems.rb', line 980

def self.source_index
  @@source_index ||= Gem::Deprecate.skip_during do
    SourceIndex.new Gem::Specification.dirs
  end
end

.source_index=(si) ⇒ Object

Allows setting the default SourceIndex. This method is available when requiring 'rubygems/test_case'



42
43
44
45
46
 
# File 'lib/rubygems/test_case.rb', line 42

def self.source_index=(si)
  raise "This method is not supported"
  Gem::Specification.reset if si # HACK
  @@source_index = si
end

.sources ⇒ Object

Returns an Array of sources to fetch remote gems from. If the sources list is empty, attempts to load the "sources" gem, then uses default_sources if it is not installed.



991
992
993
 
# File 'lib/rubygems.rb', line 991

def self.sources
  @sources ||= default_sources
end

.sources=(new_sources) ⇒ Object

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



999
1000
1001
 
# File 'lib/rubygems.rb', line 999

def self.sources= new_sources
  @sources = new_sources
end

.ssl_available? ⇒ Boolean

Is SSL (used by the signing commands) available on this platform?

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/rubygems/gem_openssl.rb', line 19

def ssl_available?
  @ssl_available
end

.suffix_pattern ⇒ Object

Glob pattern for require-able path suffixes.



1006
1007
1008
 
# File 'lib/rubygems.rb', line 1006

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

.suffixes ⇒ Object

Suffixes for require-able paths.



1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
 
# File 'lib/rubygems.rb', line 1019

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

.time(msg, width = 0, display = Gem.configuration.verbose) ⇒ Object

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



1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
 
# File 'lib/rubygems.rb', line 1034

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

.try_activate(path) ⇒ Object

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.



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/rubygems.rb', line 200

def self.try_activate path
  # TODO: deprecate when 1.9.3 comes out.
  # finds the _latest_ version... regardless of loaded specs and their deps

  # TODO: use find_all and bork if ambiguous

  spec = Gem::Specification.find_by_path path
  return false unless spec

  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

.ui ⇒ Object

Lazily loads DefaultUserInteraction and returns the default UI.



1049
1050
1051
1052
1053
 
# File 'lib/rubygems.rb', line 1049

def self.ui
  require 'rubygems/user_interaction'

  Gem::DefaultUserInteraction.ui
end

.unresolved_deps ⇒ Object 



249
250
251
 
# File 'lib/rubygems.rb', line 249

def self.unresolved_deps
  @unresolved_deps ||= Hash.new { |h, n| h[n] = Gem::Dependency.new n }
end

.use_paths(home, *paths) ⇒ Object

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



1059
1060
1061
1062
1063
1064
 
# File 'lib/rubygems.rb', line 1059

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

.user_dir ⇒ Object

Path for gems in the user's home directory



56
57
58
 
# File 'lib/rubygems/defaults.rb', line 56

def self.user_dir
  File.join Gem.user_home, '.gem', ruby_engine, ConfigMap[:ruby_version]
end

.user_home ⇒ Object

The home directory for the user.



1069
1070
1071
 
# File 'lib/rubygems.rb', line 1069

def self.user_home
  @user_home ||= find_home
end

.win_platform=(val) ⇒ Object

Allows toggling Windows behavior. This method is available when requiring 'rubygems/test_case'



52
53
54
 
# File 'lib/rubygems/test_case.rb', line 52

def self.win_platform=(val)
  @@win_platform = val
end

.win_platform? ⇒ Boolean

Is this a windows platform?

Returns:

  • (Boolean) 


1076
1077
1078
1079
1080
1081
1082
 
# File 'lib/rubygems.rb', line 1076

def self.win_platform?
  if @@win_platform.nil? then
    @@win_platform = !!WIN_PATTERNS.find { |r| RUBY_PLATFORM =~ r }
  end

  @@win_platform
end