From fbf59bdbea63efd34ccc144e648467d2f52e7345 Mon Sep 17 00:00:00 2001 From: drbrain Date: Sat, 10 Nov 2007 07:48:56 +0000 Subject: Import RubyGems trunk revision 1493. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13862 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- lib/rubygems.rb | 561 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 561 insertions(+) create mode 100644 lib/rubygems.rb (limited to 'lib/rubygems.rb') diff --git a/lib/rubygems.rb b/lib/rubygems.rb new file mode 100644 index 0000000000..3ee9593ce3 --- /dev/null +++ b/lib/rubygems.rb @@ -0,0 +1,561 @@ +# -*- ruby -*- +#-- +# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. +# All rights reserved. +# See LICENSE.txt for permissions. +#++ + +require 'rbconfig' +require 'rubygems/rubygems_version' +require 'thread' + +module Gem + class LoadError < ::LoadError + attr_accessor :name, :version_requirement + end +end + +module Kernel + + # Adds a Ruby Gem to the $LOAD_PATH. Before a Gem is loaded, its + # required Gems are loaded. 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 requirement and/or a required + # Gem is not found, a Gem::LoadError is raised. More information on + # version requirements can be found in the Gem::Version + # documentation. + # + # The +gem+ directive should be executed *before* any require + # statements (otherwise rubygems might select a conflicting library + # version). + # + # You can define the environment variable GEM_SKIP as a way to not + # load specified gems. you might do this to test out changes that + # haven't been intsalled yet. Example: + # + # GEM_SKIP=libA:libB ruby-I../libA -I../libB ./mycode.rb + # + # gem:: [String or Gem::Dependency] The gem name or dependency + # instance. + # + # version_requirement:: [default=">= 0"] The version + # requirement. + # + # return:: [Boolean] true if the Gem is loaded, otherwise false. + # + # raises:: [Gem::LoadError] if Gem cannot be found, is listed in + # GEM_SKIP, or version requirement not met. + # + def gem(gem_name, *version_requirements) + active_gem_with_options(gem_name, version_requirements) + end + + # Same as the +gem+ command, but will also require a file if the gem + # provides an auto-required file name. + # + # DEPRECATED! Use +gem+ instead. + # + def require_gem(gem_name, *version_requirements) + file, lineno = location_of_caller + warn "#{file}:#{lineno}:Warning: require_gem is obsolete. Use gem instead." + active_gem_with_options(gem_name, version_requirements, :auto_require=>true) + end + + # Return the file name (string) and line number (integer) of the caller of + # the caller of this method. + def location_of_caller + file, lineno = caller[1].split(':') + lineno = lineno.to_i + [file, lineno] + end + private :location_of_caller + + def active_gem_with_options(gem_name, version_requirements, options={}) + skip_list = (ENV['GEM_SKIP'] || "").split(/:/) + raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name + Gem.activate(gem_name, options[:auto_require], *version_requirements) + end + private :active_gem_with_options +end + +# Main module to hold all RubyGem classes/modules. +# +module Gem + + MUTEX = Mutex.new + + RubyGemsPackageVersion = RubyGemsVersion + + DIRECTORIES = %w[cache doc gems specifications] + + @@source_index = nil + @@win_platform = nil + + @configuration = nil + @loaded_specs = {} + @platforms = nil + @ruby = nil + @sources = [] + + # 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 + @gem_home = nil + @gem_path = nil + @@source_index = nil + MUTEX.synchronize do + @searcher = nil + end + end + + # The version of the Marshal format for your Ruby. + def self.marshal_version + "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}" + end + + ## + # The directory prefix this RubyGems was installed at. + + def self.prefix + prefix = File.dirname File.expand_path(__FILE__) + if prefix == Config::CONFIG['sitelibdir'] then + nil + else + File.dirname prefix + end + end + + # Returns an Cache of specifications that are in the Gem.path + # + # return:: [Gem::SourceIndex] Index of installed Gem::Specifications + # + def self.source_index + @@source_index ||= SourceIndex.from_installed_gems + end + + ## + # An Array of Regexps that match windows ruby platforms. + + WIN_PATTERNS = [/mswin/i, /mingw/i, /bccwin/i, /wince/i] + + ## + # Is this a windows platform? + + def self.win_platform? + if @@win_platform.nil? then + @@win_platform = !!WIN_PATTERNS.find { |r| RUBY_PLATFORM =~ r } + end + + @@win_platform + end + + class << self + + attr_reader :loaded_specs + + # 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. + def ensure_gem_subdirectories(gemdir) + require 'fileutils' + + Gem::DIRECTORIES.each do |filename| + fn = File.join gemdir, filename + FileUtils.mkdir_p fn rescue nil unless File.exist? fn + end + end + + def platforms + @platforms ||= [Gem::Platform::RUBY, Gem::Platform.local] + end + + # 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. + def sources + if @sources.empty? then + begin + gem 'sources', '> 0.0.1' + require 'sources' + rescue LoadError + @sources = default_sources + end + end + + @sources + end + + # An Array of the default sources that come with RubyGems. + def default_sources + %w[http://gems.rubyforge.org] + end + + # Provide an alias for the old name. + alias cache source_index + + # The directory path where Gems are to be installed. + # + # return:: [String] The directory path + # + def dir + @gem_home ||= nil + set_home(ENV['GEM_HOME'] || default_dir) unless @gem_home + @gem_home + end + + # The directory path where executables are to be installed. + # + def bindir(install_dir=Gem.dir) + return File.join(install_dir, 'bin') unless + install_dir.to_s == Gem.default_dir + + if defined? RUBY_FRAMEWORK_VERSION then # mac framework support + File.join(File.dirname(Config::CONFIG["sitedir"]), + File.basename(Config::CONFIG["bindir"])) + else # generic install + Config::CONFIG['bindir'] + end + end + + # List of directory paths to search for Gems. + # + # return:: [List] List of directory paths. + # + def path + @gem_path ||= nil + set_paths(ENV['GEM_PATH']) unless @gem_path + @gem_path + end + + # The home directory for the user. + def user_home + @user_home ||= find_home + end + + # Return the path to standard location of the users .gemrc file. + def config_file + File.join(Gem.user_home, '.gemrc') + end + + # The standard configuration object for gems. + def configuration + return @configuration if @configuration + require 'rubygems/config_file' + @configuration = Gem::ConfigFile.new [] + end + + # Use the given configuration object (which implements the + # ConfigFile protocol) as the standard configuration object. + def configuration=(config) + @configuration = config + end + + # Return the path the the data directory specified by the gem + # name. If the package is not available as a gem, return nil. + def datadir(gem_name) + spec = @loaded_specs[gem_name] + return nil if spec.nil? + File.join(spec.full_gem_path, 'data', gem_name) + end + + # Return the searcher object to search for matching gems. + def searcher + MUTEX.synchronize do + @searcher ||= Gem::GemPathSearcher.new + end + end + + # Return the Ruby command to use to execute the Ruby interpreter. + def ruby + if @ruby.nil? then + @ruby = File.join(Config::CONFIG['bindir'], + Config::CONFIG['ruby_install_name']) + @ruby << Config::CONFIG['EXEEXT'] + end + + @ruby + end + + # Activate a gem (i.e. add it to the Ruby load path). The gem + # must satisfy all the specified version constraints. If + # +autorequire+ is true, then automatically require the specified + # autorequire file in the gem spec. + # + # Returns true if the gem is loaded by this call, false if it is + # already loaded, or an exception otherwise. + # + def activate(gem, autorequire, *version_requirements) + if version_requirements.empty? then + version_requirements = Gem::Requirement.default + end + + unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements) + gem = Gem::Dependency.new(gem, version_requirements) + end + + matches = Gem.source_index.find_name(gem.name, gem.version_requirements) + report_activate_error(gem) if matches.empty? + + if @loaded_specs[gem.name] + # This gem is already loaded. If the currently loaded gem is + # not in the list of candidate gems, then we have a version + # conflict. + existing_spec = @loaded_specs[gem.name] + if ! matches.any? { |spec| spec.version == existing_spec.version } + fail Gem::Exception, "can't activate #{gem}, already activated #{existing_spec.full_name}]" + end + return false + end + + # new load + spec = matches.last + if spec.loaded? + return false unless autorequire + result = spec.autorequire ? require(spec.autorequire) : false + return result || false + end + + spec.loaded = true + @loaded_specs[spec.name] = spec + + # Load dependent gems first + spec.dependencies.each do |dep_gem| + activate(dep_gem, autorequire) + end + + # bin directory must come before library directories + spec.require_paths.unshift spec.bindir if spec.bindir + + require_paths = spec.require_paths.map do |path| + File.join spec.full_gem_path, path + end + + sitelibdir = Config::CONFIG['sitelibdir'] + + # gem directories must come after -I and ENV['RUBYLIB'] + $:.insert($:.index(sitelibdir), *require_paths) + + # Now autorequire + if autorequire && spec.autorequire then # DEPRECATED + Array(spec.autorequire).each do |a_lib| + require a_lib + end + end + + return true + end + + # 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. + def report_activate_error(gem) + matches = Gem.source_index.find_name(gem.name) + + if matches.empty? then + error = Gem::LoadError.new( + "Could not find RubyGem #{gem.name} (#{gem.version_requirements})\n") + else + error = Gem::LoadError.new( + "RubyGem version error: " + + "#{gem.name}(#{matches.first.version} not #{gem.version_requirements})\n") + end + + error.name = gem.name + error.version_requirement = gem.version_requirements + raise error + end + private :report_activate_error + + # Use the +home+ and (optional) +paths+ values for +dir+ and +path+. + # Used mainly by the unit tests to provide environment isolation. + # + def use_paths(home, paths=[]) + clear_paths + set_home(home) if home + set_paths(paths.join(File::PATH_SEPARATOR)) if paths + end + + # Return a list of all possible load paths for all versions for + # all gems in the Gem installation. + # + def 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 + + # Return a list of all possible load paths for the latest version + # for all gems in the Gem installation. + def 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 + + def required_location(gemname, libfile, *version_constraints) + version_constraints = Gem::Requirement.default if version_constraints.empty? + matches = Gem.source_index.find_name(gemname, version_constraints) + return nil if matches.empty? + spec = matches.last + spec.require_paths.each do |path| + result = File.join(spec.full_gem_path, path, libfile) + return result if File.exist?(result) + end + nil + end + + def suffixes + ['', '.rb', '.rbw', '.so', '.bundle', '.dll', '.sl', '.jar'] + end + + def suffix_pattern + @suffix_pattern ||= "{#{suffixes.join(',')}}" + end + + # manage_gems is useless and deprecated. Don't call it anymore. This + # will warn in two releases. + def manage_gems + # do nothing + end + + private + + # Return all the partial paths in the given +gemdir+. + def all_partials(gemdir) + Dir[File.join(gemdir, 'gems/*')] + end + + # Return only the latest partial paths in the given +gemdir+. + def latest_partials(gemdir) + latest = {} + all_partials(gemdir).each do |gp| + base = File.basename(gp) + if base =~ /(.*)-((\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 + + # Expand each partial gem path with each of the required paths + # specified in the Gem spec. Each expanded path is yielded. + def each_load_path(partials) + partials.each do |gp| + base = File.basename(gp) + specfn = File.join(dir, "specifications", base + ".gemspec") + if File.exist?(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.exist?(filename) + end + end + end + + # Set the Gem home directory (as reported by +dir+). + def set_home(home) + @gem_home = home + ensure_gem_subdirectories(@gem_home) + end + + # Set the Gem search path (as reported by +path+). + def set_paths(gpaths) + if gpaths + @gem_path = gpaths.split(File::PATH_SEPARATOR) + @gem_path << Gem.dir + else + @gem_path = [Gem.dir] + end + @gem_path.uniq! + @gem_path.each do |gp| ensure_gem_subdirectories(gp) end + end + + # 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). + # + def find_home + ['HOME', 'USERPROFILE'].each do |homekey| + return ENV[homekey] if ENV[homekey] + end + if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] + return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}" + end + begin + File.expand_path("~") + rescue StandardError => ex + if File::ALT_SEPARATOR + "C:/" + else + "/" + end + end + end + + public + + # Default home directory path to be used if an alternate value is + # not specified in the environment. + def default_dir + if defined? RUBY_FRAMEWORK_VERSION + return File.join(File.dirname(Config::CONFIG["sitedir"]), "Gems") + else + File.join(Config::CONFIG['libdir'], 'ruby', 'gems', Config::CONFIG['ruby_version']) + end + end + + end + +end + +# Modify the non-gem version of datadir to handle gem package names. + +require 'rbconfig/datadir' +module Config # :nodoc: + class << self + alias gem_original_datadir datadir + + # Return the path to the data directory associated with the named + # package. If the package is loaded as a gem, return the gem + # specific data directory. Otherwise return a path to the share + # area as define by "#{Config::CONFIG['datadir']}/#{package_name}". + def datadir(package_name) + Gem.datadir(package_name) || Config.gem_original_datadir(package_name) + end + end +end + +require 'rubygems/exceptions' +require 'rubygems/version' +require 'rubygems/requirement' +require 'rubygems/dependency' +require 'rubygems/gem_path_searcher' # Needed for Kernel#gem +require 'rubygems/source_index' # Needed for Kernel#gem +require 'rubygems/platform' +require 'rubygems/builder' # HACK: Needed for rake's package task. + +if RUBY_VERSION < '1.9' then + require 'rubygems/custom_require' +end + -- cgit v1.2.3