diff options
Diffstat (limited to 'lib')
70 files changed, 5206 insertions, 2738 deletions
diff --git a/lib/gauntlet_rubygems.rb b/lib/gauntlet_rubygems.rb new file mode 100644 index 0000000000..f6c4827129 --- /dev/null +++ b/lib/gauntlet_rubygems.rb @@ -0,0 +1,50 @@ +require 'rubygems' +require 'gauntlet' + +## +# GemGauntlet validates all current gems. Currently these packages are +# borked: +# +# Asami-0.04 : No such file or directory - bin/Asami.rb +# ObjectGraph-1.0.1 : No such file or directory - bin/objectgraph +# evil-ruby-0.1.0 : authors must be Array of Strings +# fresh_cookies-1.0.0 : authors must be Array of Strings +# plugems_deploy-0.2.0 : authors must be Array of Strings +# pmsrb-0.2.0 : authors must be Array of Strings +# pqa-1.6 : authors must be Array of Strings +# rant-0.5.7 : authors must be Array of Strings +# rvsh-0.4.5 : No such file or directory - bin/rvsh +# xen-0.1.2.1 : authors must be Array of Strings + +class GemGauntlet < Gauntlet + def run(name) + warn name + + spec = begin + Gem::Specification.load 'gemspec' + rescue SyntaxError + Gem::Specification.from_yaml File.read('gemspec') + end + spec.validate + + self.data[name] = false + self.dirty = true + rescue SystemCallError, Gem::InvalidSpecificationException => e + self.data[name] = e.message + self.dirty = true + end + + def should_skip?(name) + self.data[name] == false + end + + def report + self.data.sort.reject { |k,v| !v }.each do |k,v| + puts "%-21s: %s" % [k, v] + end + end +end + +gauntlet = GemGauntlet.new +gauntlet.run_the_gauntlet ARGV.shift +gauntlet.report diff --git a/lib/rbconfig/datadir.rb b/lib/rbconfig/datadir.rb index 74c014e0aa..554b7fead7 100644 --- a/lib/rbconfig/datadir.rb +++ b/lib/rbconfig/datadir.rb @@ -4,20 +4,17 @@ # See LICENSE.txt for permissions. #++ - module RbConfig - # Only define datadir if it doesn't already exist. - unless RbConfig.respond_to?(:datadir) + ## + # Return the path to the data directory associated with the given package + # name. Normally this is just + # "#{RbConfig::CONFIG['datadir']}/#{package_name}", but may be modified by + # packages like RubyGems to handle versioned data directories. - # Return the path to the data directory associated with the given - # package name. Normally this is just - # "#{RbConfig::CONFIG['datadir']}/#{package_name}", but may be - # modified by packages like RubyGems to handle versioned data - # directories. - def RbConfig.datadir(package_name) - File.join(CONFIG['datadir'], package_name) - end + def self.datadir(package_name) + File.join(CONFIG['datadir'], package_name) + end unless RbConfig.respond_to?(:datadir) - end end + diff --git a/lib/rubygems.rb b/lib/rubygems.rb index 3be98d3c56..a4ce9b0a80 100644 --- a/lib/rubygems.rb +++ b/lib/rubygems.rb @@ -8,11 +8,29 @@ require 'rubygems/rubygems_version' require 'rubygems/defaults' require 'thread' +require 'etc' module Gem + + ## + # Raised when RubyGems is unable to load or activate a gem. Contains the + # name and version requirements of the gem that either conflicts with + # already activated gems or that RubyGems is otherwise unable to activate. + class LoadError < ::LoadError - attr_accessor :name, :version_requirement + + ## + # Name of gem + + attr_accessor :name + + ## + # Version requirement of gem + + attr_accessor :version_requirement + end + end module Kernel @@ -54,18 +72,102 @@ module Kernel end ## -# Main module to hold all RubyGem classes/modules. +# 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 +# +# Further RubyGems documentation can be found at: +# +# * {RubyGems API}[http://rubygems.rubyforge.org/rdoc] (also available from +# <tt>gem server</tt>) +# * {RubyGems Bookshelf}[http://rubygem.org] +# +# == RubyGems Plugins +# +# As of RubyGems 1.3.2, RubyGems will load plugins installed in gems or +# $LOAD_PATH. Plugins must be named 'rubygems_plugin' 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/#{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}[http://rubyforge.org/tracker/?atid=575&group_id=126&func=browse] +# on RubyForge +# +# == 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}[mailto:jim@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 +# +# (If your name is missing, PLEASE let us know!) +# +# Thanks! +# +# -The RubyGems Team module Gem + ## + # Configuration settings from ::RbConfig + ConfigMap = {} unless defined?(ConfigMap) + require 'rbconfig' - RbConfig = Config unless defined? ::RbConfig ConfigMap.merge!( - :BASERUBY => RbConfig::CONFIG["BASERUBY"], :EXEEXT => RbConfig::CONFIG["EXEEXT"], - :RUBY_INSTALL_NAME => RbConfig::CONFIG["RUBY_INSTALL_NAME"], :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"], :arch => RbConfig::CONFIG["arch"], :bindir => RbConfig::CONFIG["bindir"], @@ -79,11 +181,16 @@ module Gem :vendorlibdir => RbConfig::CONFIG["vendorlibdir"] ) + ## + # Default directories in a gem repository + DIRECTORIES = %w[cache doc gems specifications] unless defined?(DIRECTORIES) + # :stopdoc: MUTEX = Mutex.new RubyGemsPackageVersion = RubyGemsVersion + # :startdoc: ## # An Array of Regexps that match windows ruby platforms. @@ -102,6 +209,7 @@ module Gem @configuration = nil @loaded_specs = {} + @loaded_stacks = {} @platforms = [] @ruby = nil @sources = [] @@ -128,6 +236,14 @@ module Gem # Gem::Requirement and Gem::Version documentation. def self.activate(gem, *version_requirements) + if version_requirements.last.is_a?(Hash) + options = version_requirements.pop + else + options = {} + end + + sources = options[:sources] || [] + if version_requirements.empty? then version_requirements = Gem::Requirement.default end @@ -146,8 +262,18 @@ module Gem existing_spec = @loaded_specs[gem.name] unless matches.any? { |spec| spec.version == existing_spec.version } then - raise Gem::Exception, - "can't activate #{gem}, already activated #{existing_spec.full_name}" + sources_message = sources.map { |spec| spec.full_name } + stack_message = @loaded_stacks[gem.name].map { |spec| spec.full_name } + + msg = "can't activate #{gem} for #{sources_message.inspect}, " + msg << "already activated #{existing_spec.full_name} for " + msg << "#{stack_message.inspect}" + + e = Gem::LoadError.new msg + e.name = gem.name + e.version_requirement = gem.version_requirements + + raise e end return false @@ -159,10 +285,11 @@ module Gem spec.loaded = true @loaded_specs[spec.name] = spec + @loaded_stacks[spec.name] = sources.dup # Load dependent gems first spec.runtime_dependencies.each do |dep_gem| - activate dep_gem + activate dep_gem, :sources => [spec, *sources] end # bin directory must come before library directories @@ -228,6 +355,35 @@ module Gem 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 + # specifed executable's path is returned. +version_requirements+ allows you + # to specify specific gem versions. + + def self.bin_path(name, exec_name = nil, *version_requirements) + version_requirements = Gem::Requirement.default if + version_requirements.empty? + spec = Gem.source_index.find_name(name, version_requirements).last + + raise Gem::GemNotFoundException, + "can't find gem #{name} (#{version_requirements})" unless spec + + exec_name ||= spec.default_executable + + unless exec_name + msg = "no default executable for #{spec.full_name}" + raise Gem::Exception, msg + end + + unless spec.executables.include? exec_name + msg = "can't find executable #{exec_name} for #{spec.full_name}" + raise Gem::Exception, msg + end + + File.join(spec.full_gem_path, spec.bindir, exec_name).sub(/.*\s.*/m, '"\&"') + end + + ## # The mode needed to read a file as straight binary. def self.binary_mode @@ -351,14 +507,27 @@ module Gem # # Gem.find_files('rdoc/discover').each do |path| load path end # - # find_files does not search $LOAD_PATH for files, only gems. + # find_files search $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(path) + load_path_files = $LOAD_PATH.map do |load_path| + files = Dir["#{File.expand_path path, load_path}#{Gem.suffix_pattern}"] + + files.select do |load_path_file| + File.file? load_path_file.untaint + end + end.flatten + specs = searcher.find_all path - specs.map do |spec| + specs_files = specs.map do |spec| searcher.matching_files spec, path end.flatten + + (load_path_files + specs_files).flatten.uniq end ## @@ -373,7 +542,17 @@ module Gem # least on Win32). def self.find_home - File.expand_path("~") + unless RUBY_VERSION > '1.9' then + ['HOME', 'USERPROFILE'].each do |homekey| + return ENV[homekey] if ENV[homekey] + end + + if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then + return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" + end + end + + File.expand_path "~" rescue if File::ALT_SEPARATOR then "C:/" @@ -477,7 +656,7 @@ module Gem # The file name and line number of the caller of the caller of this method. def self.location_of_caller - caller[1] =~ /(.*?):(\d+)$/i + caller[1] =~ /(.*?):(\d+).*?$/i file = $1 lineno = $2.to_i @@ -485,15 +664,6 @@ module Gem end ## - # manage_gems is useless and deprecated. Don't call it anymore. - - def self.manage_gems # :nodoc: - file, lineno = location_of_caller - - warn "#{file}:#{lineno}:Warning: Gem::manage_gems is deprecated and will be removed on or after March 2009." - end - - ## # The version of the Marshal format for your Ruby. def self.marshal_version @@ -587,6 +757,33 @@ module Gem end ## + # 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. + + 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 = File.join gem.full_gem_path, gem.require_paths.last + + over_paths = over.require_paths.map do |path| + File.join over.full_gem_path, path + 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 + + ## # Refresh source_index from disk and clear searcher. def self.refresh @@ -628,15 +825,23 @@ module Gem private_class_method :report_activate_error - def self.required_location(gemname, libfile, *version_constraints) - version_constraints = Gem::Requirement.default if version_constraints.empty? - matches = Gem.source_index.find_name(gemname, version_constraints) + ## + # Full path to +libfile+ in +gemname+. Searches for the latest gem unless + # +requirements+ is given. + + def self.required_location(gemname, libfile, *requirements) + requirements = Gem::Requirement.default if requirements.empty? + + matches = Gem.source_index.find_name gemname, requirements + 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) + result = File.join spec.full_gem_path, path, libfile + return result if File.exist? result end + nil end @@ -662,7 +867,13 @@ module Gem def self.ruby_version return @ruby_version if defined? @ruby_version version = RUBY_VERSION.dup - version << ".#{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL + + 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 @@ -679,7 +890,7 @@ module Gem # Set the Gem home directory (as reported by Gem.dir). def self.set_home(home) - home = home.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR + home = home.gsub File::ALT_SEPARATOR, File::SEPARATOR if File::ALT_SEPARATOR @gem_home = home end @@ -757,6 +968,31 @@ module Gem 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. @@ -786,6 +1022,9 @@ module Gem class << self + ## + # Hash of loaded Gem::Specification keyed by name + attr_reader :loaded_specs ## @@ -817,25 +1056,27 @@ module Gem end + ## + # Location of Marshal quick gemspecs on remote repositories + MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/" + ## + # Location of legacy YAML quick gemspecs on remote repositories + YAML_SPEC_DIR = 'quick/' end -module RbConfig - # :stopdoc: - class << self - # 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 "#{ConfigMap[:datadir]}/#{package_name}". - def datadir(package_name) - Gem.datadir(package_name) || - File.join(Gem::ConfigMap[:datadir], package_name) - end - end - # :startdoc: +## +# 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 +# "#{ConfigMap[:datadir]}/#{package_name}". + +def RbConfig.datadir(package_name) + Gem.datadir(package_name) || + File.join(Gem::ConfigMap[:datadir], package_name) end require 'rubygems/exceptions' @@ -866,3 +1107,14 @@ if RUBY_VERSION < '1.9' then end Gem.clear_paths + +plugins = Gem.find_files 'rubygems_plugin' + +plugins.each do |plugin| + begin + load plugin + rescue => e + warn "error loading #{plugin.inspect}: #{e.message} (#{e.class})" + end +end + diff --git a/lib/rubygems/builder.rb b/lib/rubygems/builder.rb index 1c18c38d48..3061b752ce 100644 --- a/lib/rubygems/builder.rb +++ b/lib/rubygems/builder.rb @@ -4,81 +4,83 @@ # See LICENSE.txt for permissions. #++ -module Gem +## +# The Builder class processes RubyGem specification files +# to produce a .gem file. +class Gem::Builder + + include Gem::UserInteraction ## - # The Builder class processes RubyGem specification files - # to produce a .gem file. + # Constructs a builder instance for the provided specification # - class Builder - - include UserInteraction - ## - # Constructs a builder instance for the provided specification - # - # spec:: [Gem::Specification] The specification instance - # - def initialize(spec) - require "yaml" - require "rubygems/package" - require "rubygems/security" - - @spec = spec - end + # spec:: [Gem::Specification] The specification instance - ## - # Builds the gem from the specification. Returns the name of the file - # written. - # - def build - @spec.mark_version - @spec.validate - @signer = sign - write_package - say success - @spec.file_name - end + def initialize(spec) + require "yaml" + require "rubygems/package" + require "rubygems/security" + + @spec = spec + end + + ## + # Builds the gem from the specification. Returns the name of the file + # written. + + def build + @spec.mark_version + @spec.validate + @signer = sign + write_package + say success + @spec.file_name + end - def success - <<-EOM + def success + <<-EOM Successfully built RubyGem Name: #{@spec.name} Version: #{@spec.version} File: #{@spec.full_name+'.gem'} EOM - end + end - private - - def sign - # if the signing key was specified, then load the file, and swap - # to the public key (TODO: we should probably just omit the - # signing key in favor of the signing certificate, but that's for - # the future, also the signature algorithm should be configurable) - signer = nil - if @spec.respond_to?(:signing_key) && @spec.signing_key - signer = Gem::Security::Signer.new(@spec.signing_key, @spec.cert_chain) - @spec.signing_key = nil - @spec.cert_chain = signer.cert_chain.map { |cert| cert.to_s } - end - signer + private + + ## + # If the signing key was specified, then load the file, and swap to the + # public key (TODO: we should probably just omit the signing key in favor of + # the signing certificate, but that's for the future, also the signature + # algorithm should be configurable) + + def sign + signer = nil + + if @spec.respond_to?(:signing_key) and @spec.signing_key then + signer = Gem::Security::Signer.new @spec.signing_key, @spec.cert_chain + @spec.signing_key = nil + @spec.cert_chain = signer.cert_chain.map { |cert| cert.to_s } end - def write_package - open @spec.file_name, 'wb' do |gem_io| - Gem::Package.open gem_io, 'w', @signer do |pkg| - pkg.metadata = @spec.to_yaml + signer + end + + def write_package + open @spec.file_name, 'wb' do |gem_io| + Gem::Package.open gem_io, 'w', @signer do |pkg| + pkg.metadata = @spec.to_yaml - @spec.files.each do |file| - next if File.directory? file + @spec.files.each do |file| + next if File.directory? file + next if file == @spec.file_name # Don't add gem onto itself - stat = File.stat file - mode = stat.mode & 0777 - size = stat.size + stat = File.stat file + mode = stat.mode & 0777 + size = stat.size - pkg.add_file_simple file, mode, size do |tar_io| - tar_io.write open(file, "rb") { |f| f.read } - end + pkg.add_file_simple file, mode, size do |tar_io| + tar_io.write open(file, "rb") { |f| f.read } end end end diff --git a/lib/rubygems/command.rb b/lib/rubygems/command.rb index 860764e6d5..3a1e2ac872 100644 --- a/lib/rubygems/command.rb +++ b/lib/rubygems/command.rb @@ -5,402 +5,507 @@ #++ require 'optparse' - require 'rubygems/user_interaction' -module Gem +## +# Base class for all Gem commands. When creating a new gem command, define +# #new, #execute, #arguments, #defaults_str, #description and #usage +# (as appropriate). See the above mentioned methods for details. +# +# A very good example to look at is Gem::Commands::ContentsCommand - # Base class for all Gem commands. When creating a new gem command, define - # #arguments, #defaults_str, #description and #usage (as appropriate). - class Command +class Gem::Command - include UserInteraction + include Gem::UserInteraction - # The name of the command. - attr_reader :command + ## + # The name of the command. - # The options for the command. - attr_reader :options + attr_reader :command - # The default options for the command. - attr_accessor :defaults + ## + # The options for the command. - # The name of the command for command-line invocation. - attr_accessor :program_name + attr_reader :options - # A short description of the command. - attr_accessor :summary + ## + # The default options for the command. - # Initializes a generic gem command named +command+. +summary+ is a short - # description displayed in `gem help commands`. +defaults+ are the - # default options. Defaults should be mirrored in #defaults_str, unless - # there are none. - # - # Use add_option to add command-line switches. - def initialize(command, summary=nil, defaults={}) - @command = command - @summary = summary - @program_name = "gem #{command}" - @defaults = defaults - @options = defaults.dup - @option_groups = Hash.new { |h,k| h[k] = [] } - @parser = nil - @when_invoked = nil - end + attr_accessor :defaults - # True if +long+ begins with the characters from +short+. - def begins?(long, short) - return false if short.nil? - long[0, short.length] == short - end + ## + # The name of the command for command-line invocation. - # Override to provide command handling. - def execute - fail "Generic command has no actions" - end + attr_accessor :program_name - # Get all gem names from the command line. - def get_all_gem_names - args = options[:args] + ## + # A short description of the command. - if args.nil? or args.empty? then - raise Gem::CommandLineError, - "Please specify at least one gem name (e.g. gem build GEMNAME)" - end + attr_accessor :summary - gem_names = args.select { |arg| arg !~ /^-/ } - end + ## + # Arguments used when building gems - # Get the single gem name from the command line. Fail if there is no gem - # name or if there is more than one gem name given. - def get_one_gem_name - args = options[:args] + def self.build_args + @build_args ||= [] + end + + def self.build_args=(value) + @build_args = value + end - if args.nil? or args.empty? then - raise Gem::CommandLineError, - "Please specify a gem name on the command line (e.g. gem build GEMNAME)" - end + def self.common_options + @common_options ||= [] + end - if args.size > 1 then - raise Gem::CommandLineError, - "Too many gem names (#{args.join(', ')}); please specify only one" - end + def self.add_common_option(*args, &handler) + Gem::Command.common_options << [args, handler] + end - args.first - end + def self.extra_args + @extra_args ||= [] + end - # Get a single optional argument from the command line. If more than one - # argument is given, return only the first. Return nil if none are given. - def get_one_optional_argument - args = options[:args] || [] - args.first + def self.extra_args=(value) + case value + when Array + @extra_args = value + when String + @extra_args = value.split end + end - # Override to provide details of the arguments a command takes. - # It should return a left-justified string, one argument per line. - def arguments - "" - end + ## + # Return an array of extra arguments for the command. The extra arguments + # come from the gem configuration file read at program startup. - # Override to display the default values of the command - # options. (similar to +arguments+, but displays the default - # values). - def defaults_str - "" - end + def self.specific_extra_args(cmd) + specific_extra_args_hash[cmd] + end - # Override to display a longer description of what this command does. - def description - nil - end + ## + # Add a list of extra arguments for the given command. +args+ may be an + # array or a string to be split on white space. - # Override to display the usage for an individual gem command. - def usage - program_name - end + def self.add_specific_extra_args(cmd,args) + args = args.split(/\s+/) if args.kind_of? String + specific_extra_args_hash[cmd] = args + end - # Display the help message for the command. - def show_help - parser.program_name = usage - say parser - end + ## + # Accessor for the specific extra args hash (self initializing). - # Invoke the command with the given list of arguments. - def invoke(*args) - handle_options(args) - if options[:help] - show_help - elsif @when_invoked - @when_invoked.call(options) - else - execute - end + def self.specific_extra_args_hash + @specific_extra_args_hash ||= Hash.new do |h,k| + h[k] = Array.new end - - # Call the given block when invoked. - # - # Normal command invocations just executes the +execute+ method of - # the command. Specifying an invocation block allows the test - # methods to override the normal action of a command to determine - # that it has been invoked correctly. - def when_invoked(&block) - @when_invoked = block + end + + ## + # Initializes a generic gem command named +command+. +summary+ is a short + # description displayed in `gem help commands`. +defaults+ are the default + # options. Defaults should be mirrored in #defaults_str, unless there are + # none. + # + # When defining a new command subclass, use add_option to add command-line + # switches. + # + # Unhandled arguments (gem names, files, etc.) are left in + # <tt>options[:args]</tt>. + + def initialize(command, summary=nil, defaults={}) + @command = command + @summary = summary + @program_name = "gem #{command}" + @defaults = defaults + @options = defaults.dup + @option_groups = Hash.new { |h,k| h[k] = [] } + @parser = nil + @when_invoked = nil + end + + ## + # True if +long+ begins with the characters from +short+. + + def begins?(long, short) + return false if short.nil? + long[0, short.length] == short + end + + ## + # Override to provide command handling. + # + # #options will be filled in with your parsed options, unparsed options will + # be left in <tt>options[:args]</tt>. + # + # See also: #get_all_gem_names, #get_one_gem_name, + # #get_one_optional_argument + + def execute + raise Gem::Exception, "generic command has no actions" + end + + ## + # Get all gem names from the command line. + + def get_all_gem_names + args = options[:args] + + if args.nil? or args.empty? then + raise Gem::CommandLineError, + "Please specify at least one gem name (e.g. gem build GEMNAME)" end - # Add a command-line option and handler to the command. - # - # See OptionParser#make_switch for an explanation of +opts+. - # - # +handler+ will be called with two values, the value of the argument and - # the options hash. - def add_option(*opts, &handler) # :yields: value, options - group_name = Symbol === opts.first ? opts.shift : :options + gem_names = args.select { |arg| arg !~ /^-/ } + end - @option_groups[group_name] << [opts, handler] - end + ## + # Get the single gem name from the command line. Fail if there is no gem + # name or if there is more than one gem name given. - # Remove previously defined command-line argument +name+. - def remove_option(name) - @option_groups.each do |_, option_list| - option_list.reject! { |args, _| args.any? { |x| x =~ /^#{name}/ } } - end - end + def get_one_gem_name + args = options[:args] - # Merge a set of command options with the set of default options - # (without modifying the default option hash). - def merge_options(new_options) - @options = @defaults.clone - new_options.each do |k,v| @options[k] = v end + if args.nil? or args.empty? then + raise Gem::CommandLineError, + "Please specify a gem name on the command line (e.g. gem build GEMNAME)" end - # True if the command handles the given argument list. - def handles?(args) - begin - parser.parse!(args.dup) - return true - rescue - return false - end + if args.size > 1 then + raise Gem::CommandLineError, + "Too many gem names (#{args.join(', ')}); please specify only one" end - # Handle the given list of arguments by parsing them and recording - # the results. - def handle_options(args) - args = add_extra_args(args) - @options = @defaults.clone - parser.parse!(args) - @options[:args] = args + args.first + end + + ## + # Get a single optional argument from the command line. If more than one + # argument is given, return only the first. Return nil if none are given. + + def get_one_optional_argument + args = options[:args] || [] + args.first + end + + ## + # Override to provide details of the arguments a command takes. It should + # return a left-justified string, one argument per line. + # + # For example: + # + # def usage + # "#{program_name} FILE [FILE ...]" + # end + # + # def arguments + # "FILE name of file to find" + # end + + def arguments + "" + end + + ## + # Override to display the default values of the command options. (similar to + # +arguments+, but displays the default values). + # + # For example: + # + # def defaults_str + # --no-gems-first --no-all + # end + + def defaults_str + "" + end + + ## + # Override to display a longer description of what this command does. + + def description + nil + end + + ## + # Override to display the usage for an individual gem command. + # + # The text "[options]" is automatically appended to the usage text. + + def usage + program_name + end + + ## + # Display the help message for the command. + + def show_help + parser.program_name = usage + say parser + end + + ## + # Invoke the command with the given list of arguments. + + def invoke(*args) + handle_options(args) + if options[:help] + show_help + elsif @when_invoked + @when_invoked.call(options) + else + execute end - - def add_extra_args(args) - result = [] - s_extra = Command.specific_extra_args(@command) - extra = Command.extra_args + s_extra - while ! extra.empty? - ex = [] - ex << extra.shift - ex << extra.shift if extra.first.to_s =~ /^[^-]/ - result << ex if handles?(ex) - end - result.flatten! - result.concat(args) - result + end + + ## + # Call the given block when invoked. + # + # Normal command invocations just executes the +execute+ method of the + # command. Specifying an invocation block allows the test methods to + # override the normal action of a command to determine that it has been + # invoked correctly. + + def when_invoked(&block) + @when_invoked = block + end + + ## + # Add a command-line option and handler to the command. + # + # See OptionParser#make_switch for an explanation of +opts+. + # + # +handler+ will be called with two values, the value of the argument and + # the options hash. + # + # If the first argument of add_option is a Symbol, it's used to group + # options in output. See `gem help list` for an example. + + def add_option(*opts, &handler) # :yields: value, options + group_name = Symbol === opts.first ? opts.shift : :options + + @option_groups[group_name] << [opts, handler] + end + + ## + # Remove previously defined command-line argument +name+. + + def remove_option(name) + @option_groups.each do |_, option_list| + option_list.reject! { |args, _| args.any? { |x| x =~ /^#{name}/ } } end - - private - - # Create on demand parser. - def parser - create_option_parser if @parser.nil? - @parser + end + + ## + # Merge a set of command options with the set of default options (without + # modifying the default option hash). + + def merge_options(new_options) + @options = @defaults.clone + new_options.each do |k,v| @options[k] = v end + end + + ## + # True if the command handles the given argument list. + + def handles?(args) + begin + parser.parse!(args.dup) + return true + rescue + return false end + end - def create_option_parser - @parser = OptionParser.new - - @parser.separator("") - regular_options = @option_groups.delete :options - - configure_options "", regular_options - - @option_groups.sort_by { |n,_| n.to_s }.each do |group_name, option_list| - configure_options group_name, option_list - end - - configure_options "Common", Command.common_options + ## + # Handle the given list of arguments by parsing them and recording the + # results. - @parser.separator("") - unless arguments.empty? - @parser.separator(" Arguments:") - arguments.split(/\n/).each do |arg_desc| - @parser.separator(" #{arg_desc}") - end - @parser.separator("") - end + def handle_options(args) + args = add_extra_args(args) + @options = @defaults.clone + parser.parse!(args) + @options[:args] = args + end - @parser.separator(" Summary:") - wrap(@summary, 80 - 4).split("\n").each do |line| - @parser.separator(" #{line.strip}") - end + ## + # Adds extra args from ~/.gemrc - if description then - formatted = description.split("\n\n").map do |chunk| - wrap(chunk, 80 - 4) - end.join("\n") + def add_extra_args(args) + result = [] - @parser.separator "" - @parser.separator " Description:" - formatted.split("\n").each do |line| - @parser.separator " #{line.rstrip}" - end - end + s_extra = Gem::Command.specific_extra_args(@command) + extra = Gem::Command.extra_args + s_extra - unless defaults_str.empty? - @parser.separator("") - @parser.separator(" Defaults:") - defaults_str.split(/\n/).each do |line| - @parser.separator(" #{line}") - end - end + until extra.empty? do + ex = [] + ex << extra.shift + ex << extra.shift if extra.first.to_s =~ /^[^-]/ + result << ex if handles?(ex) end - def configure_options(header, option_list) - return if option_list.nil? or option_list.empty? + result.flatten! + result.concat(args) + result + end - header = header.to_s.empty? ? '' : "#{header} " - @parser.separator " #{header}Options:" + private - option_list.each do |args, handler| - dashes = args.select { |arg| arg =~ /^-/ } - @parser.on(*args) do |value| - handler.call(value, @options) - end - end + ## + # Create on demand parser. - @parser.separator '' - end + def parser + create_option_parser if @parser.nil? + @parser + end - # Wraps +text+ to +width+ - def wrap(text, width) - text.gsub(/(.{1,#{width}})( +|$\n?)|(.{1,#{width}})/, "\\1\\3\n") - end - - ################################################################## - # Class methods for Command. - class << self - def common_options - @common_options ||= [] - end + def create_option_parser + @parser = OptionParser.new - def add_common_option(*args, &handler) - Gem::Command.common_options << [args, handler] - end + @parser.separator("") + regular_options = @option_groups.delete :options - def extra_args - @extra_args ||= [] - end - - def extra_args=(value) - case value - when Array - @extra_args = value - when String - @extra_args = value.split - end - end + configure_options "", regular_options - # Return an array of extra arguments for the command. The extra - # arguments come from the gem configuration file read at program - # startup. - def specific_extra_args(cmd) - specific_extra_args_hash[cmd] - end + @option_groups.sort_by { |n,_| n.to_s }.each do |group_name, option_list| + configure_options group_name, option_list + end - # Add a list of extra arguments for the given command. +args+ - # may be an array or a string to be split on white space. - def add_specific_extra_args(cmd,args) - args = args.split(/\s+/) if args.kind_of? String - specific_extra_args_hash[cmd] = args - end + configure_options "Common", Gem::Command.common_options - # Accessor for the specific extra args hash (self initializing). - def specific_extra_args_hash - @specific_extra_args_hash ||= Hash.new do |h,k| - h[k] = Array.new - end + @parser.separator("") + unless arguments.empty? + @parser.separator(" Arguments:") + arguments.split(/\n/).each do |arg_desc| + @parser.separator(" #{arg_desc}") end + @parser.separator("") end - # ---------------------------------------------------------------- - # Add the options common to all commands. - - add_common_option('-h', '--help', - 'Get help on this command') do - |value, options| - options[:help] = true + @parser.separator(" Summary:") + wrap(@summary, 80 - 4).split("\n").each do |line| + @parser.separator(" #{line.strip}") end - add_common_option('-V', '--[no-]verbose', - 'Set the verbose level of output') do |value, options| - # Set us to "really verbose" so the progress meter works - if Gem.configuration.verbose and value then - Gem.configuration.verbose = 1 - else - Gem.configuration.verbose = value + if description then + formatted = description.split("\n\n").map do |chunk| + wrap(chunk, 80 - 4) + end.join("\n") + + @parser.separator "" + @parser.separator " Description:" + formatted.split("\n").each do |line| + @parser.separator " #{line.rstrip}" end end - add_common_option('-q', '--quiet', 'Silence commands') do |value, options| - Gem.configuration.verbose = false + unless defaults_str.empty? + @parser.separator("") + @parser.separator(" Defaults:") + defaults_str.split(/\n/).each do |line| + @parser.separator(" #{line}") + end end + end - # Backtrace and config-file are added so they show up in the help - # commands. Both options are actually handled before the other - # options get parsed. + def configure_options(header, option_list) + return if option_list.nil? or option_list.empty? - add_common_option('--config-file FILE', - "Use this config file instead of default") do - end + header = header.to_s.empty? ? '' : "#{header} " + @parser.separator " #{header}Options:" - add_common_option('--backtrace', - 'Show stack backtrace on errors') do + option_list.each do |args, handler| + dashes = args.select { |arg| arg =~ /^-/ } + @parser.on(*args) do |value| + handler.call(value, @options) + end end - add_common_option('--debug', - 'Turn on Ruby debugging') do - end + @parser.separator '' + end - # :stopdoc: - HELP = %{ - RubyGems is a sophisticated package manager for Ruby. This is a - basic help message containing pointers to more information. + ## + # Wraps +text+ to +width+ - Usage: - gem -h/--help - gem -v/--version - gem command [arguments...] [options...] + def wrap(text, width) # :doc: + text.gsub(/(.{1,#{width}})( +|$\n?)|(.{1,#{width}})/, "\\1\\3\n") + end - Examples: - gem install rake - gem list --local - gem build package.gemspec - gem help install + # ---------------------------------------------------------------- + # Add the options common to all commands. - Further help: - gem help commands list all 'gem' commands - gem help examples show some examples of usage - gem help platforms show information about platforms - gem help <COMMAND> show help on COMMAND - (e.g. 'gem help install') - Further information: - http://rubygems.rubyforge.org - }.gsub(/^ /, "") + add_common_option('-h', '--help', + 'Get help on this command') do |value, options| + options[:help] = true + end - # :startdoc: + add_common_option('-V', '--[no-]verbose', + 'Set the verbose level of output') do |value, options| + # Set us to "really verbose" so the progress meter works + if Gem.configuration.verbose and value then + Gem.configuration.verbose = 1 + else + Gem.configuration.verbose = value + end + end + + add_common_option('-q', '--quiet', 'Silence commands') do |value, options| + Gem.configuration.verbose = false + end + + # Backtrace and config-file are added so they show up in the help + # commands. Both options are actually handled before the other + # options get parsed. + + add_common_option('--config-file FILE', + 'Use this config file instead of default') do + end + + add_common_option('--backtrace', + 'Show stack backtrace on errors') do + end + + add_common_option('--debug', + 'Turn on Ruby debugging') do + end + + # :stopdoc: + + HELP = %{ + RubyGems is a sophisticated package manager for Ruby. This is a + basic help message containing pointers to more information. + + Usage: + gem -h/--help + gem -v/--version + gem command [arguments...] [options...] + + Examples: + gem install rake + gem list --local + gem build package.gemspec + gem help install + + Further help: + gem help commands list all 'gem' commands + gem help examples show some examples of usage + gem help platforms show information about platforms + gem help <COMMAND> show help on COMMAND + (e.g. 'gem help install') + gem server present a web page at + http://localhost:8808/ + with info about installed gems + Further information: + http://rubygems.rubyforge.org + }.gsub(/^ /, '') + + # :startdoc: - end # class +end - # This is where Commands will be placed in the namespace - module Commands; end +## +# This is where Commands will be placed in the namespace +module Gem::Commands end + diff --git a/lib/rubygems/command_manager.rb b/lib/rubygems/command_manager.rb index 5a8dec451e..0a190161ca 100644 --- a/lib/rubygems/command_manager.rb +++ b/lib/rubygems/command_manager.rb @@ -8,139 +8,167 @@ require 'timeout' require 'rubygems/command' require 'rubygems/user_interaction' -module Gem +## +# The command manager registers and installs all the individual sub-commands +# supported by the gem command. +# +# Extra commands can be provided by writing a rubygems_plugin.rb +# file in an installed gem. You should register your command against the +# Gem::CommandManager instance, like this: +# +# # file rubygems_plugin.rb +# require 'rubygems/command_manager' +# +# class Gem::Commands::EditCommand < Gem::Command +# # ... +# end +# +# Gem::CommandManager.instance.register_command :edit +# +# See Gem::Command for instructions on writing gem commands. + +class Gem::CommandManager + + include Gem::UserInteraction + + ## + # Return the authoritative instance of the command manager. + + def self.instance + @command_manager ||= new + end - #################################################################### - # The command manager registers and installs all the individual - # sub-commands supported by the gem command. - class CommandManager - include UserInteraction + ## + # Register all the subcommands supported by the gem command. + + def initialize + @commands = {} + register_command :build + register_command :cert + register_command :check + register_command :cleanup + register_command :contents + register_command :dependency + register_command :environment + register_command :fetch + register_command :generate_index + register_command :help + register_command :install + register_command :list + register_command :lock + register_command :mirror + register_command :outdated + register_command :pristine + register_command :query + register_command :rdoc + register_command :search + register_command :server + register_command :sources + register_command :specification + register_command :stale + register_command :uninstall + register_command :unpack + register_command :update + register_command :which + end - # Return the authoritative instance of the command manager. - def self.instance - @command_manager ||= CommandManager.new - end + ## + # Register the command object. - # Register all the subcommands supported by the gem command. - def initialize - @commands = {} - register_command :build - register_command :cert - register_command :check - register_command :cleanup - register_command :contents - register_command :dependency - register_command :environment - register_command :fetch - register_command :generate_index - register_command :help - register_command :install - register_command :list - register_command :lock - register_command :mirror - register_command :outdated - register_command :pristine - register_command :query - register_command :rdoc - register_command :search - register_command :server - register_command :sources - register_command :specification - register_command :stale - register_command :uninstall - register_command :unpack - register_command :update - register_command :which - end + def register_command(command_obj) + @commands[command_obj] = false + end - # Register the command object. - def register_command(command_obj) - @commands[command_obj] = false - end + ## + # Return the registered command from the command name. - # Return the registered command from the command name. - def [](command_name) - command_name = command_name.intern - return nil if @commands[command_name].nil? - @commands[command_name] ||= load_and_instantiate(command_name) - end + def [](command_name) + command_name = command_name.intern + return nil if @commands[command_name].nil? + @commands[command_name] ||= load_and_instantiate(command_name) + end - # Return a list of all command names (as strings). - def command_names - @commands.keys.collect {|key| key.to_s}.sort - end + ## + # Return a sorted list of all command names (as strings). + + def command_names + @commands.keys.collect {|key| key.to_s}.sort + end - # Run the config specified by +args+. - def run(args) - process_args(args) - rescue StandardError, Timeout::Error => ex - alert_error "While executing gem ... (#{ex.class})\n #{ex.to_s}" - ui.errs.puts "\t#{ex.backtrace.join "\n\t"}" if - Gem.configuration.backtrace + ## + # Run the config specified by +args+. + + def run(args) + process_args(args) + rescue StandardError, Timeout::Error => ex + alert_error "While executing gem ... (#{ex.class})\n #{ex.to_s}" + ui.errs.puts "\t#{ex.backtrace.join "\n\t"}" if + Gem.configuration.backtrace + terminate_interaction(1) + rescue Interrupt + alert_error "Interrupted" + terminate_interaction(1) + end + + def process_args(args) + args = args.to_str.split(/\s+/) if args.respond_to?(:to_str) + if args.size == 0 + say Gem::Command::HELP terminate_interaction(1) - rescue Interrupt - alert_error "Interrupted" + end + case args[0] + when '-h', '--help' + say Gem::Command::HELP + terminate_interaction(0) + when '-v', '--version' + say Gem::RubyGemsVersion + terminate_interaction(0) + when /^-/ + alert_error "Invalid option: #{args[0]}. See 'gem --help'." terminate_interaction(1) + else + cmd_name = args.shift.downcase + cmd = find_command(cmd_name) + cmd.invoke(*args) end + end - def process_args(args) - args = args.to_str.split(/\s+/) if args.respond_to?(:to_str) - if args.size == 0 - say Gem::Command::HELP - terminate_interaction(1) - end - case args[0] - when '-h', '--help' - say Gem::Command::HELP - terminate_interaction(0) - when '-v', '--version' - say Gem::RubyGemsVersion - terminate_interaction(0) - when /^-/ - alert_error "Invalid option: #{args[0]}. See 'gem --help'." - terminate_interaction(1) - else - cmd_name = args.shift.downcase - cmd = find_command(cmd_name) - cmd.invoke(*args) - end + def find_command(cmd_name) + possibilities = find_command_possibilities cmd_name + if possibilities.size > 1 then + raise "Ambiguous command #{cmd_name} matches [#{possibilities.join(', ')}]" + elsif possibilities.size < 1 then + raise "Unknown command #{cmd_name}" end - def find_command(cmd_name) - possibilities = find_command_possibilities(cmd_name) - if possibilities.size > 1 - raise "Ambiguous command #{cmd_name} matches [#{possibilities.join(', ')}]" - end - if possibilities.size < 1 - raise "Unknown command #{cmd_name}" - end + self[possibilities.first] + end - self[possibilities.first] - end + def find_command_possibilities(cmd_name) + len = cmd_name.length - def find_command_possibilities(cmd_name) - len = cmd_name.length - self.command_names.select { |n| cmd_name == n[0,len] } - end + command_names.select { |n| cmd_name == n[0, len] } + end + + private + + def load_and_instantiate(command_name) + command_name = command_name.to_s + retried = false - private - - def load_and_instantiate(command_name) - command_name = command_name.to_s - retried = false - - begin - const_name = command_name.capitalize.gsub(/_(.)/) { $1.upcase } - Gem::Commands.const_get("#{const_name}Command").new - rescue NameError - if retried then - raise - else - retried = true - require "rubygems/commands/#{command_name}_command" - retry - end + begin + const_name = command_name.capitalize.gsub(/_(.)/) { $1.upcase } + Gem::Commands.const_get("#{const_name}Command").new + rescue NameError + if retried then + raise + else + retried = true + require "rubygems/commands/#{command_name}_command" + retry end end end + end + diff --git a/lib/rubygems/commands/check_command.rb b/lib/rubygems/commands/check_command.rb index 4eefca4232..475aeb3795 100644 --- a/lib/rubygems/commands/check_command.rb +++ b/lib/rubygems/commands/check_command.rb @@ -21,6 +21,10 @@ class Gem::Commands::CheckCommand < Gem::Command options[:alien] = true end + add_option('-v', '--verbose', "Spew more words") do |value, options| + options[:verbose] = true + end + add_option('-t', '--test', "Run unit tests for gem") do |value, options| options[:test] = true end @@ -38,16 +42,17 @@ class Gem::Commands::CheckCommand < Gem::Command if options[:alien] say "Performing the 'alien' operation" - Gem::Validator.new.alien.each do |key, val| - if(val.size > 0) + say + gems = get_all_gem_names rescue [] + Gem::Validator.new.alien(gems).sort.each do |key, val| + unless val.empty? then say "#{key} has #{val.size} problems" val.each do |error_entry| - say "\t#{error_entry.path}:" - say "\t#{error_entry.problem}" - say + say " #{error_entry.path}:" + say " #{error_entry.problem}" end else - say "#{key} is error-free" + say "#{key} is error-free" if options[:verbose] end say end diff --git a/lib/rubygems/commands/cleanup_command.rb b/lib/rubygems/commands/cleanup_command.rb index 40dcb9db34..1b6e405782 100644 --- a/lib/rubygems/commands/cleanup_command.rb +++ b/lib/rubygems/commands/cleanup_command.rb @@ -1,6 +1,7 @@ require 'rubygems/command' require 'rubygems/source_index' require 'rubygems/dependency_list' +require 'rubygems/uninstaller' class Gem::Commands::CleanupCommand < Gem::Command @@ -22,6 +23,13 @@ class Gem::Commands::CleanupCommand < Gem::Command "--no-dryrun" end + def description # :nodoc: + <<-EOF +The cleanup command removes old gems from GEM_HOME. If an older version is +installed elsewhere in GEM_PATH the cleanup command won't touch it. + EOF + end + def usage # :nodoc: "#{program_name} [GEMNAME ...]" end @@ -41,7 +49,8 @@ class Gem::Commands::CleanupCommand < Gem::Command unless options[:args].empty? then options[:args].each do |gem_name| - specs = Gem.cache.search(/^#{gem_name}$/i) + dep = Gem::Dependency.new gem_name, Gem::Requirement.default + specs = Gem.source_index.search dep specs.each do |spec| gems_to_cleanup << spec end @@ -56,7 +65,6 @@ class Gem::Commands::CleanupCommand < Gem::Command primary_gems[spec.name].version != spec.version } - uninstall_command = Gem::CommandManager.instance['uninstall'] deplist = Gem::DependencyList.new gems_to_cleanup.uniq.each do |spec| deplist.add spec end @@ -69,14 +77,21 @@ class Gem::Commands::CleanupCommand < Gem::Command say "Attempting to uninstall #{spec.full_name}" options[:args] = [spec.name] - options[:version] = "= #{spec.version}" - options[:executables] = false - uninstaller = Gem::Uninstaller.new spec.name, options + uninstall_options = { + :executables => false, + :version => "= #{spec.version}", + } + + if Gem.user_dir == spec.installation_path then + uninstall_options[:install_dir] = spec.installation_path + end + + uninstaller = Gem::Uninstaller.new spec.name, uninstall_options begin uninstaller.uninstall - rescue Gem::DependencyRemovalException, + rescue Gem::DependencyRemovalException, Gem::InstallError, Gem::GemNotInHomeException => e say "Unable to uninstall #{spec.full_name}:" say "\t#{e.class}: #{e.message}" diff --git a/lib/rubygems/commands/contents_command.rb b/lib/rubygems/commands/contents_command.rb index bc75fb5c03..ce2c655240 100644 --- a/lib/rubygems/commands/contents_command.rb +++ b/lib/rubygems/commands/contents_command.rb @@ -11,6 +11,11 @@ class Gem::Commands::ContentsCommand < Gem::Command add_version_option + add_option( '--all', + "Contents for all gems") do |all, options| + options[:all] = all + end + add_option('-s', '--spec-dir a,b,c', Array, "Search for gems under specific paths") do |spec_dirs, options| options[:specdirs] = spec_dirs @@ -20,6 +25,11 @@ class Gem::Commands::ContentsCommand < Gem::Command "Only return files in the Gem's lib_dirs") do |lib_only, options| options[:lib_only] = lib_only end + + add_option( '--[no-]prefix', + "Don't include installed path prefix") do |prefix, options| + options[:prefix] = prefix + end end def arguments # :nodoc: @@ -27,46 +37,60 @@ class Gem::Commands::ContentsCommand < Gem::Command end def defaults_str # :nodoc: - "--no-lib-only" + "--no-lib-only --prefix" end def usage # :nodoc: - "#{program_name} GEMNAME" + "#{program_name} GEMNAME [GEMNAME ...]" end def execute version = options[:version] || Gem::Requirement.default - gem = get_one_gem_name - s = options[:specdirs].map do |i| + spec_dirs = options[:specdirs].map do |i| [i, File.join(i, "specifications")] end.flatten - path_kind = if s.empty? then - s = Gem::SourceIndex.installed_spec_directories + path_kind = if spec_dirs.empty? then + spec_dirs = Gem::SourceIndex.installed_spec_directories "default gem paths" else "specified path" end - si = Gem::SourceIndex.from_gems_in(*s) + si = Gem::SourceIndex.from_gems_in(*spec_dirs) - gem_spec = si.find_name(gem, version).last + gem_names = if options[:all] then + si.map { |_, spec| spec.name } + else + get_all_gem_names + end - unless gem_spec then - say "Unable to find gem '#{gem}' in #{path_kind}" + gem_names.each do |name| + gem_spec = si.find_name(name, version).last - if Gem.configuration.verbose then - say "\nDirectories searched:" - s.each { |dir| say dir } + unless gem_spec then + say "Unable to find gem '#{name}' in #{path_kind}" + + if Gem.configuration.verbose then + say "\nDirectories searched:" + spec_dirs.each { |dir| say dir } + end + + terminate_interaction 1 if gem_names.length == 1 end - terminate_interaction - end + files = options[:lib_only] ? gem_spec.lib_files : gem_spec.files - files = options[:lib_only] ? gem_spec.lib_files : gem_spec.files - files.each do |f| - say File.join(gem_spec.full_gem_path, f) + files.each do |f| + path = if options[:prefix] then + File.join gem_spec.full_gem_path, f + else + f + end + + say path + end end end diff --git a/lib/rubygems/commands/generate_index_command.rb b/lib/rubygems/commands/generate_index_command.rb index 1bd87569ed..945d32383c 100644 --- a/lib/rubygems/commands/generate_index_command.rb +++ b/lib/rubygems/commands/generate_index_command.rb @@ -1,55 +1,131 @@ require 'rubygems/command' require 'rubygems/indexer' +## +# Generates a index files for use as a gem server. +# +# See `gem help generate_index` + class Gem::Commands::GenerateIndexCommand < Gem::Command def initialize super 'generate_index', 'Generates the index files for a gem server directory', - :directory => '.' + :directory => '.', :build_legacy => true, :build_modern => true add_option '-d', '--directory=DIRNAME', 'repository base dir containing gems subdir' do |dir, options| options[:directory] = File.expand_path dir end + + add_option '--[no-]legacy', + 'Generate indexes for RubyGems older than', + '1.2.0' do |value, options| + unless options[:build_modern] or value then + raise OptionParser::InvalidOption, 'no indicies will be built' + end + + options[:build_legacy] = value + end + + add_option '--[no-]modern', + 'Generate indexes for RubyGems newer', + 'than 1.2.0' do |value, options| + unless options[:build_legacy] or value then + raise OptionParser::InvalidOption, 'no indicies will be built' + end + + options[:build_modern] = value + end + + add_option '--update', + 'Update modern indexes with gems added', + 'since the last update' do |value, options| + options[:update] = value + end + + add_option :RSS, '--rss-gems-host=GEM_HOST', + 'Host name where gems are served from,', + 'used for GUID and enclosure values' do |value, options| + options[:rss_gems_host] = value + end + + add_option :RSS, '--rss-host=HOST', + 'Host name for more gems information,', + 'used for RSS feed link' do |value, options| + options[:rss_host] = value + end + + add_option :RSS, '--rss-title=TITLE', + 'Set title for RSS feed' do |value, options| + options[:rss_title] = value + end end def defaults_str # :nodoc: - "--directory ." + "--directory . --legacy --modern" end def description # :nodoc: <<-EOF The generate_index command creates a set of indexes for serving gems statically. The command expects a 'gems' directory under the path given to -the --directory option. When done, it will generate a set of files like this: +the --directory option. The given directory will be the directory you serve +as the gem repository. + +For `gem generate_index --directory /path/to/repo`, expose /path/to/repo via +your HTTP server configuration (not /path/to/repo/gems). + +When done, it will generate a set of files like this: + + gems/*.gem # .gem files you want to + # index + + specs.<version>.gz # specs index + latest_specs.<version>.gz # latest specs index + prerelease_specs.<version>.gz # prerelease specs index + quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file - gems/ # .gem files you want to index + # these files support legacy RubyGems quick/index quick/index.rz # quick index manifest - quick/<gemname>.gemspec.rz # legacy YAML quick index file - quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file + quick/<gemname>.gemspec.rz # legacy YAML quick index + # file Marshal.<version> - Marshal.<version>.Z # Marshal full index + Marshal.<version>.Z # Marshal full index yaml - yaml.Z # legacy YAML full index + yaml.Z # legacy YAML full index + +The .Z and .rz extension files are compressed with the inflate algorithm. +The Marshal version number comes from ruby's Marshal::MAJOR_VERSION and +Marshal::MINOR_VERSION constants. It is used to ensure compatibility. +The yaml indexes exist for legacy RubyGems clients and fallback in case of +Marshal version changes. -The .Z and .rz extension files are compressed with the inflate algorithm. The -Marshal version number comes from ruby's Marshal::MAJOR_VERSION and -Marshal::MINOR_VERSION constants. It is used to ensure compatibility. The -yaml indexes exist for legacy RubyGems clients and fallback in case of Marshal -version changes. +If --rss-host and --rss-gem-host are given an RSS feed will be generated at +index.rss containing gems released in the last two days. EOF end def execute + if options[:update] and + (options[:rss_host] or options[:rss_gems_host]) then + alert_error '--update not compatible with RSS generation' + terminate_interaction 1 + end + if not File.exist?(options[:directory]) or not File.directory?(options[:directory]) then alert_error "unknown directory name #{directory}." terminate_interaction 1 else - indexer = Gem::Indexer.new options[:directory] - indexer.generate_index + indexer = Gem::Indexer.new options.delete(:directory), options + + if options[:update] then + indexer.update_index + else + indexer.generate_index + end end end diff --git a/lib/rubygems/commands/install_command.rb b/lib/rubygems/commands/install_command.rb index 1a6eb68a8b..af2d8bd739 100644 --- a/lib/rubygems/commands/install_command.rb +++ b/lib/rubygems/commands/install_command.rb @@ -6,6 +6,11 @@ require 'rubygems/local_remote_options' require 'rubygems/validator' require 'rubygems/version_option' +## +# Gem installer command line tool +# +# See `gem help install` + class Gem::Commands::InstallCommand < Gem::Command include Gem::VersionOption @@ -14,11 +19,11 @@ class Gem::Commands::InstallCommand < Gem::Command def initialize defaults = Gem::DependencyInstaller::DEFAULT_OPTIONS.merge({ - :generate_rdoc => true, - :generate_ri => true, + :generate_rdoc => true, + :generate_ri => true, :format_executable => false, - :test => false, - :version => Gem::Requirement.default, + :test => false, + :version => Gem::Requirement.default, }) super 'install', 'Install a gem into the local repository', defaults @@ -43,11 +48,51 @@ class Gem::Commands::InstallCommand < Gem::Command The install command installs local or remote gem into a gem repository. For gems with executables ruby installs a wrapper file into the executable -directory by deault. This can be overridden with the --no-wrappers option. +directory by default. This can be overridden with the --no-wrappers option. The wrapper allows you to choose among alternate gem versions using _version_. For example `rake _0.7.3_ --version` will run rake version 0.7.3 if a newer version is also installed. + +If an extension fails to compile during gem installation the gem +specification is not written out, but the gem remains unpacked in the +repository. You may need to specify the path to the library's headers and +libraries to continue. You can do this by adding a -- between RubyGems' +options and the extension's build options: + + $ gem install some_extension_gem + [build fails] + Gem files will remain installed in \\ + /path/to/gems/some_extension_gem-1.0 for inspection. + Results logged to /path/to/gems/some_extension_gem-1.0/gem_make.out + $ gem install some_extension_gem -- --with-extension-lib=/path/to/lib + [build succeeds] + $ gem list some_extension_gem + + *** LOCAL GEMS *** + + some_extension_gem (1.0) + $ + +If you correct the compilation errors by editing the gem files you will need +to write the specification by hand. For example: + + $ gem install some_extension_gem + [build fails] + Gem files will remain installed in \\ + /path/to/gems/some_extension_gem-1.0 for inspection. + Results logged to /path/to/gems/some_extension_gem-1.0/gem_make.out + $ [cd /path/to/gems/some_extension_gem-1.0] + $ [edit files or what-have-you and run make] + $ gem spec ../../cache/some_extension_gem-1.0.gem --ruby > \\ + ../../specifications/some_extension_gem-1.0.gemspec + $ gem list some_extension_gem + + *** LOCAL GEMS *** + + some_extension_gem (1.0) + $ + EOF end @@ -65,24 +110,11 @@ version is also installed. ENV.delete 'GEM_PATH' if options[:install_dir].nil? and RUBY_VERSION > '1.9' - install_options = { - :env_shebang => options[:env_shebang], - :domain => options[:domain], - :force => options[:force], - :format_executable => options[:format_executable], - :ignore_dependencies => options[:ignore_dependencies], - :install_dir => options[:install_dir], - :security_policy => options[:security_policy], - :wrappers => options[:wrappers], - :bin_dir => options[:bin_dir], - :development => options[:development], - } - exit_code = 0 get_all_gem_names.each do |gem_name| begin - inst = Gem::DependencyInstaller.new install_options + inst = Gem::DependencyInstaller.new options inst.install gem_name, options[:version] inst.installed_gems.each do |spec| @@ -96,46 +128,40 @@ version is also installed. rescue Gem::GemNotFoundException => e alert_error e.message exit_code |= 2 -# rescue => e -# # TODO: Fix this handle to allow the error to propagate to -# # the top level handler. Examine the other errors as -# # well. This implementation here looks suspicious to me -- -# # JimWeirich (4/Jan/05) -# alert_error "Error installing gem #{gem_name}: #{e.message}" -# return end end unless installed_gems.empty? then gems = installed_gems.length == 1 ? 'gem' : 'gems' say "#{installed_gems.length} #{gems} installed" - end - # NOTE: *All* of the RI documents must be generated first. - # For some reason, RI docs cannot be generated after any RDoc - # documents are generated. + # NOTE: *All* of the RI documents must be generated first. For some + # reason, RI docs cannot be generated after any RDoc documents are + # generated. - if options[:generate_ri] then - installed_gems.each do |gem| - Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri - end + if options[:generate_ri] then + installed_gems.each do |gem| + Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri + end - Gem::DocManager.update_ri_cache - end + Gem::DocManager.update_ri_cache + end - if options[:generate_rdoc] then - installed_gems.each do |gem| - Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc + if options[:generate_rdoc] then + installed_gems.each do |gem| + Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc + end end - end - if options[:test] then - installed_gems.each do |spec| - gem_spec = Gem::SourceIndex.from_installed_gems.search(spec.name, spec.version.version).first - result = Gem::Validator.new.unit_test(gem_spec) - if result and not result.passed? - unless ask_yes_no("...keep Gem?", true) then - Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall + if options[:test] then + installed_gems.each do |spec| + gem_spec = Gem::SourceIndex.from_installed_gems.find_name(spec.name, spec.version.version).first + result = Gem::Validator.new.unit_test(gem_spec) + if result and not result.passed? + unless ask_yes_no("...keep Gem?", true) + require 'rubygems/uninstaller' + Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall + end end end end diff --git a/lib/rubygems/commands/query_command.rb b/lib/rubygems/commands/query_command.rb index 29fe8acb79..88f7f0b54e 100644 --- a/lib/rubygems/commands/query_command.rb +++ b/lib/rubygems/commands/query_command.rb @@ -2,9 +2,11 @@ require 'rubygems/command' require 'rubygems/local_remote_options' require 'rubygems/spec_fetcher' require 'rubygems/version_option' +require 'rubygems/text' class Gem::Commands::QueryCommand < Gem::Command + include Gem::Text include Gem::LocalRemoteOptions include Gem::VersionOption @@ -43,6 +45,11 @@ class Gem::Commands::QueryCommand < Gem::Command options[:all] = value end + add_option( '--prerelease', + 'Display prerelease versions') do |value, options| + options[:prerelease] = value + end + add_local_remote_options end @@ -54,6 +61,7 @@ class Gem::Commands::QueryCommand < Gem::Command exit_code = 0 name = options[:name] + prerelease = options[:prerelease] if options[:installed] then if name.source.empty? then @@ -72,6 +80,10 @@ class Gem::Commands::QueryCommand < Gem::Command dep = Gem::Dependency.new name, Gem::Requirement.default if local? then + if prerelease and not both? then + alert_warning "prereleases are always shown locally" + end + if ui.outs.tty? or both? then say say "*** LOCAL GEMS ***" @@ -98,8 +110,13 @@ class Gem::Commands::QueryCommand < Gem::Command begin fetcher = Gem::SpecFetcher.fetcher - spec_tuples = fetcher.find_matching dep, all, false + spec_tuples = fetcher.find_matching dep, all, false, prerelease rescue Gem::RemoteFetcher::FetchError => e + if prerelease then + raise Gem::OperationNotSupportedError, + "Prereleases not supported on legacy repositories" + end + raise unless fetcher.warn_legacy e do require 'rubygems/source_info_cache' @@ -145,6 +162,12 @@ class Gem::Commands::QueryCommand < Gem::Command version end.reverse + platforms = Hash.new { |h,version| h[version] = [] } + + matching_tuples.map do |(name, version, platform,_),_| + platforms[version] << platform if platform + end + seen = {} matching_tuples.delete_if do |(name, version,_),_| @@ -174,6 +197,28 @@ class Gem::Commands::QueryCommand < Gem::Command end entry << "\n" + + non_ruby = platforms.any? do |_, pls| + pls.any? { |pl| pl != Gem::Platform::RUBY } + end + + if non_ruby then + if platforms.length == 1 then + title = platforms.values.length == 1 ? 'Platform' : 'Platforms' + entry << " #{title}: #{platforms.values.sort.join ', '}\n" + else + entry << " Platforms:\n" + platforms.sort_by do |version,| + version + end.each do |version, pls| + label = " #{version}: " + data = format_text pls.sort.join(', '), 68, label.length + data[0, label.length] = label + entry << data << "\n" + end + end + end + authors = "Author#{spec.authors.length > 1 ? 's' : ''}: " authors << spec.authors.join(', ') entry << format_text(authors, 68, 4) @@ -187,6 +232,12 @@ class Gem::Commands::QueryCommand < Gem::Command entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4) end + if spec.license and not spec.license.empty? then + licenses = "License#{spec.licenses.length > 1 ? 's' : ''}: " + licenses << spec.licenses.join(', ') + entry << "\n" << format_text(licenses, 68, 4) + end + if spec.loaded_from then if matching_tuples.length == 1 then loaded_from = File.dirname File.dirname(spec.loaded_from) @@ -209,25 +260,5 @@ class Gem::Commands::QueryCommand < Gem::Command say output.join(options[:details] ? "\n\n" : "\n") end - ## - # Used for wrapping and indenting text - - def format_text(text, wrap, indent=0) - result = [] - work = text.dup - - while work.length > wrap - if work =~ /^(.{0,#{wrap}})[ \n]/o then - result << $1 - work.slice!(0, $&.length) - else - result << work.slice!(0, wrap) - end - end - - result << work if work.length.nonzero? - result.join("\n").gsub(/^/, " " * indent) - end - end diff --git a/lib/rubygems/commands/rdoc_command.rb b/lib/rubygems/commands/rdoc_command.rb index 2790ae7e3e..92f215705a 100644 --- a/lib/rubygems/commands/rdoc_command.rb +++ b/lib/rubygems/commands/rdoc_command.rb @@ -2,81 +2,75 @@ require 'rubygems/command' require 'rubygems/version_option' require 'rubygems/doc_manager' -module Gem - module Commands - class RdocCommand < Command - include VersionOption - - def initialize - super('rdoc', - 'Generates RDoc for pre-installed gems', - { - :version => Gem::Requirement.default, - :include_rdoc => true, - :include_ri => true, - }) - add_option('--all', - 'Generate RDoc/RI documentation for all', - 'installed gems') do |value, options| - options[:all] = value - end - add_option('--[no-]rdoc', - 'Include RDoc generated documents') do - |value, options| - options[:include_rdoc] = value - end - add_option('--[no-]ri', - 'Include RI generated documents' - ) do |value, options| - options[:include_ri] = value - end - add_version_option - end +class Gem::Commands::RdocCommand < Gem::Command + include Gem::VersionOption - def arguments # :nodoc: - "GEMNAME gem to generate documentation for (unless --all)" - end + def initialize + super 'rdoc', 'Generates RDoc for pre-installed gems', + :version => Gem::Requirement.default, + :include_rdoc => true, :include_ri => true - def defaults_str # :nodoc: - "--version '#{Gem::Requirement.default}' --rdoc --ri" - end + add_option('--all', + 'Generate RDoc/RI documentation for all', + 'installed gems') do |value, options| + options[:all] = value + end + + add_option('--[no-]rdoc', + 'Include RDoc generated documents') do |value, options| + options[:include_rdoc] = value + end + + add_option('--[no-]ri', + 'Include RI generated documents') do |value, options| + options[:include_ri] = value + end + + add_version_option + end + + def arguments # :nodoc: + "GEMNAME gem to generate documentation for (unless --all)" + end - def usage # :nodoc: - "#{program_name} [args]" + def defaults_str # :nodoc: + "--version '#{Gem::Requirement.default}' --rdoc --ri" + end + + def usage # :nodoc: + "#{program_name} [args]" + end + + def execute + if options[:all] then + specs = Gem::SourceIndex.from_installed_gems.collect { |name, spec| + spec + } + else + gem_name = get_one_gem_name + dep = Gem::Dependency.new gem_name, options[:version] + specs = Gem::SourceIndex.from_installed_gems.search dep + end + + if specs.empty? + fail "Failed to find gem #{gem_name} to generate RDoc for #{options[:version]}" + end + + if options[:include_ri] + specs.each do |spec| + Gem::DocManager.new(spec).generate_ri end - def execute - if options[:all] - specs = Gem::SourceIndex.from_installed_gems.collect { |name, spec| - spec - } - else - gem_name = get_one_gem_name - specs = Gem::SourceIndex.from_installed_gems.search( - gem_name, options[:version]) - end - - if specs.empty? - fail "Failed to find gem #{gem_name} to generate RDoc for #{options[:version]}" - end - - if options[:include_ri] - specs.each do |spec| - Gem::DocManager.new(spec).generate_ri - end - - Gem::DocManager.update_ri_cache - end - - if options[:include_rdoc] - specs.each do |spec| - Gem::DocManager.new(spec).generate_rdoc - end - end - - true + Gem::DocManager.update_ri_cache + end + + if options[:include_rdoc] + specs.each do |spec| + Gem::DocManager.new(spec).generate_rdoc end end + true end end + diff --git a/lib/rubygems/commands/search_command.rb b/lib/rubygems/commands/search_command.rb index 96f2e2c94d..52e96fd1ef 100644 --- a/lib/rubygems/commands/search_command.rb +++ b/lib/rubygems/commands/search_command.rb @@ -1,37 +1,31 @@ require 'rubygems/command' require 'rubygems/commands/query_command' -module Gem - module Commands - - class SearchCommand < QueryCommand - - def initialize - super( - 'search', - 'Display all gems whose name contains STRING' - ) - remove_option('--name-matches') - end - - def arguments # :nodoc: - "STRING fragment of gem name to search for" - end - - def defaults_str # :nodoc: - "--local --no-details" - end - - def usage # :nodoc: - "#{program_name} [STRING]" - end - - def execute - string = get_one_optional_argument - options[:name] = /#{string}/i - super - end - end +class Gem::Commands::SearchCommand < Gem::Commands::QueryCommand + def initialize + super 'search', 'Display all gems whose name contains STRING' + + remove_option '--name-matches' + end + + def arguments # :nodoc: + "STRING fragment of gem name to search for" end + + def defaults_str # :nodoc: + "--local --no-details" + end + + def usage # :nodoc: + "#{program_name} [STRING]" + end + + def execute + string = get_one_optional_argument + options[:name] = /#{string}/i + super + end + end + diff --git a/lib/rubygems/commands/server_command.rb b/lib/rubygems/commands/server_command.rb index 992ae1c8f8..f8b990d304 100644 --- a/lib/rubygems/commands/server_command.rb +++ b/lib/rubygems/commands/server_command.rb @@ -7,7 +7,23 @@ class Gem::Commands::ServerCommand < Gem::Command super 'server', 'Documentation and gem repository HTTP server', :port => 8808, :gemdir => Gem.dir, :daemon => false - add_option '-p', '--port=PORT', Integer, + OptionParser.accept :Port do |port| + if port =~ /\A\d+\z/ then + port = Integer port + raise OptionParser::InvalidArgument, "#{port}: not a port number" if + port > 65535 + + port + else + begin + Socket.getservbyname port + rescue SocketError => e + raise OptionParser::InvalidArgument, "#{port}: no such named service" + end + end + end + + add_option '-p', '--port=PORT', :Port, 'port to listen on' do |port, options| options[:port] = port end @@ -37,6 +53,12 @@ for gem installation. To install gems from a running server, use `gem install GEMNAME --source http://gem_server_host:8808` + +You can set up a shortcut to gem server documentation using the URL: + + http://localhost:8808/rdoc?q=%s - Firefox + http://localhost:8808/rdoc?q=* - LaunchBar + EOF end diff --git a/lib/rubygems/commands/setup_command.rb b/lib/rubygems/commands/setup_command.rb new file mode 100644 index 0000000000..3220a7497c --- /dev/null +++ b/lib/rubygems/commands/setup_command.rb @@ -0,0 +1,353 @@ +require 'rubygems/command' +require 'fileutils' +require 'rbconfig' +require 'tmpdir' +require 'pathname' + +## +# Installs RubyGems itself. This command is ordinarily only available from a +# RubyGems checkout or tarball. + +class Gem::Commands::SetupCommand < Gem::Command + + def initialize + super 'setup', 'Install RubyGems', + :format_executable => true, :rdoc => true, :ri => true, + :site_or_vendor => :sitelibdir, + :destdir => '', :prefix => '' + + add_option '--prefix=PREFIX', + 'Prefix path for installing RubyGems', + 'Will not affect gem repository location' do |prefix, options| + options[:prefix] = File.expand_path prefix + end + + add_option '--destdir=DESTDIR', + 'Root directory to install RubyGems into', + 'Mainly used for packaging RubyGems' do |destdir, options| + options[:destdir] = File.expand_path destdir + end + + add_option '--[no-]vendor', + 'Install into vendorlibdir not sitelibdir', + '(Requires Ruby 1.8.7)' do |vendor, options| + if vendor and Gem.ruby_version < Gem::Version.new('1.8.7') then + raise OptionParser::InvalidOption, + "requires ruby 1.8.7+ (you have #{Gem.ruby_version})" + end + + options[:site_or_vendor] = vendor ? :vendorlibdir : :sitelibdir + end + + add_option '--[no-]format-executable', + 'Makes `gem` match ruby', + 'If ruby is ruby18, gem will be gem18' do |value, options| + options[:format_executable] = value + end + + add_option '--[no-]rdoc', + 'Generate RDoc documentation for RubyGems' do |value, options| + options[:rdoc] = value + end + + add_option '--[no-]ri', + 'Generate RI documentation for RubyGems' do |value, options| + options[:ri] = value + end + end + + def check_ruby_version + required_version = Gem::Requirement.new '>= 1.8.6' + + unless required_version.satisfied_by? Gem.ruby_version then + alert_error "Expected Ruby version #{required_version}, is #{Gem.ruby_version}" + terminate_interaction 1 + end + end + + def defaults_str # :nodoc: + "--format-executable --rdoc --ri" + end + + def description # :nodoc: + <<-EOF +Installs RubyGems itself. + +RubyGems installs RDoc for itself in GEM_HOME. By default this is: + #{Gem.dir} + +If you prefer a different directory, set the GEM_HOME environment variable. + +RubyGems will install the gem command with a name matching ruby's +prefix and suffix. If ruby was installed as `ruby18`, gem will be +installed as `gem18`. + +By default, this RubyGems will install gem as: + #{Gem.default_exec_format % 'gem'} + EOF + end + + def execute + install_destdir = options[:destdir] + + unless install_destdir.empty? then + ENV['GEM_HOME'] ||= File.join(install_destdir, + Gem.default_dir.gsub(/^[a-zA-Z]:/, '')) + end + + check_ruby_version + + if Gem.configuration.really_verbose then + extend FileUtils::Verbose + else + extend FileUtils + end + + lib_dir, bin_dir = make_destination_dirs install_destdir + + install_lib lib_dir + + install_executables bin_dir + + remove_old_bin_files bin_dir + + remove_source_caches install_destdir + + install_rdoc + + say + say "-" * 78 + say + + release_notes = File.join Dir.pwd, 'doc', 'release_notes', + "rel_#{Gem::RubyGemsVersion.gsub '.', '_'}.rdoc" + + if File.exist? release_notes then + say File.read(release_notes) + else + say "Oh-no! Unable to find release notes!" + say "Looked in: #{release_notes}" if Gem.configuration.really_verbose + end + + say + say "-" * 78 + say + + say "RubyGems installed the following executables:" + say @bin_file_names.map { |name| "\t#{name}\n" } + say + + unless @bin_file_names.grep(/#{File::SEPARATOR}gem$/) then + say "If `gem` was installed by a previous RubyGems installation, you may need" + say "to remove it by hand." + say + end + end + + def install_executables(bin_dir) + say "Installing gem executable" + + @bin_file_names = [] + + Dir.chdir 'bin' do + bin_files = Dir['*'] + + bin_files.delete 'update_rubygems' + + bin_files.each do |bin_file| + bin_file_formatted = if options[:format_executable] then + Gem.default_exec_format % bin_file + else + bin_file + end + + dest_file = File.join bin_dir, bin_file_formatted + bin_tmp_file = File.join Dir.tmpdir, bin_file + + begin + bin = File.readlines bin_file + bin[0] = "#!#{Gem.ruby}\n" + + File.open bin_tmp_file, 'w' do |fp| + fp.puts bin.join + end + + install bin_tmp_file, dest_file, :mode => 0755 + @bin_file_names << dest_file + ensure + rm bin_tmp_file + end + + next unless Gem.win_platform? + + begin + bin_cmd_file = File.join Dir.tmpdir, "#{bin_file}.bat" + + File.open bin_cmd_file, 'w' do |file| + file.puts <<-TEXT +@ECHO OFF +IF NOT "%~f0" == "~f0" GOTO :WinNT +@"#{File.basename(Gem.ruby).chomp('"')}" "#{dest_file}" %1 %2 %3 %4 %5 %6 %7 %8 %9 +GOTO :EOF +:WinNT +@"#{File.basename(Gem.ruby).chomp('"')}" "%~dpn0" %* +TEXT + end + + install bin_cmd_file, "#{dest_file}.bat", :mode => 0755 + ensure + rm bin_cmd_file + end + end + end + end + + def install_lib(lib_dir) + say "Installing RubyGems" + + Dir.chdir 'lib' do + lib_files = Dir[File.join('**', '*rb')] + + lib_files.each do |lib_file| + dest_file = File.join lib_dir, lib_file + dest_dir = File.dirname dest_file + mkdir_p dest_dir unless File.directory? dest_dir + + install lib_file, dest_file, :mode => 0644 + end + end + end + + def install_rdoc + gem_doc_dir = File.join Gem.dir, 'doc' + rubygems_name = "rubygems-#{Gem::RubyGemsVersion}" + rubygems_doc_dir = File.join gem_doc_dir, rubygems_name + + if File.writable? gem_doc_dir and + (not File.exist? rubygems_doc_dir or + File.writable? rubygems_doc_dir) then + say "Removing old RubyGems RDoc and ri" + Dir[File.join(Gem.dir, 'doc', 'rubygems-[0-9]*')].each do |dir| + rm_rf dir + end + + if options[:ri] then + ri_dir = File.join rubygems_doc_dir, 'ri' + say "Installing #{rubygems_name} ri into #{ri_dir}" + run_rdoc '--ri', '--op', ri_dir + end + + if options[:rdoc] then + rdoc_dir = File.join rubygems_doc_dir, 'rdoc' + say "Installing #{rubygems_name} rdoc into #{rdoc_dir}" + run_rdoc '--op', rdoc_dir + end + else + say "Skipping RDoc generation, #{gem_doc_dir} not writable" + say "Set the GEM_HOME environment variable if you want RDoc generated" + end + end + + def make_destination_dirs(install_destdir) + lib_dir = nil + bin_dir = nil + + prefix = options[:prefix] + site_or_vendor = options[:site_or_vendor] + + if prefix.empty? then + lib_dir = Gem::ConfigMap[site_or_vendor] + bin_dir = Gem::ConfigMap[:bindir] + else + # Apple installed RubyGems into libdir, and RubyGems <= 1.1.0 gets + # confused about installation location, so switch back to + # sitelibdir/vendorlibdir. + if defined?(APPLE_GEM_HOME) and + # just in case Apple and RubyGems don't get this patched up proper. + (prefix == Gem::ConfigMap[:libdir] or + # this one is important + prefix == File.join(Gem::ConfigMap[:libdir], 'ruby')) then + lib_dir = Gem::ConfigMap[site_or_vendor] + bin_dir = Gem::ConfigMap[:bindir] + else + lib_dir = File.join prefix, 'lib' + bin_dir = File.join prefix, 'bin' + end + end + + unless install_destdir.empty? then + lib_dir = File.join install_destdir, lib_dir.gsub(/^[a-zA-Z]:/, '') + bin_dir = File.join install_destdir, bin_dir.gsub(/^[a-zA-Z]:/, '') + end + + mkdir_p lib_dir + mkdir_p bin_dir + + return lib_dir, bin_dir + end + + def remove_old_bin_files(bin_dir) + old_bin_files = { + 'gem_mirror' => 'gem mirror', + 'gem_server' => 'gem server', + 'gemlock' => 'gem lock', + 'gemri' => 'ri', + 'gemwhich' => 'gem which', + 'index_gem_repository.rb' => 'gem generate_index', + } + + old_bin_files.each do |old_bin_file, new_name| + old_bin_path = File.join bin_dir, old_bin_file + next unless File.exist? old_bin_path + + deprecation_message = "`#{old_bin_file}` has been deprecated. Use `#{new_name}` instead." + + File.open old_bin_path, 'w' do |fp| + fp.write <<-EOF +#!#{Gem.ruby} + +abort "#{deprecation_message}" + EOF + end + + next unless Gem.win_platform? + + File.open "#{old_bin_path}.bat", 'w' do |fp| + fp.puts %{@ECHO.#{deprecation_message}} + end + end + end + + def remove_source_caches(install_destdir) + if install_destdir.empty? + require 'rubygems/source_info_cache' + + user_cache_file = File.join(install_destdir, + Gem::SourceInfoCache.user_cache_file) + system_cache_file = File.join(install_destdir, + Gem::SourceInfoCache.system_cache_file) + + say "Removing old source_cache files" + rm_f user_cache_file if File.writable? File.dirname(user_cache_file) + rm_f system_cache_file if File.writable? File.dirname(system_cache_file) + end + end + + def run_rdoc(*args) + begin + gem 'rdoc' + rescue Gem::LoadError + end + + require 'rdoc/rdoc' + + args << '--quiet' + args << '--main' << 'README' + args << '.' << 'README' << 'LICENSE.txt' << 'GPL.txt' + + r = RDoc::RDoc.new + r.document args + end + +end + diff --git a/lib/rubygems/commands/sources_command.rb b/lib/rubygems/commands/sources_command.rb index 9aabb77cb1..245ab91c9f 100644 --- a/lib/rubygems/commands/sources_command.rb +++ b/lib/rubygems/commands/sources_command.rb @@ -3,9 +3,12 @@ require 'rubygems/command' require 'rubygems/remote_fetcher' require 'rubygems/source_info_cache' require 'rubygems/spec_fetcher' +require 'rubygems/local_remote_options' class Gem::Commands::SourcesCommand < Gem::Command + include Gem::LocalRemoteOptions + def initialize super 'sources', 'Manage the sources and cache file RubyGems uses to search for gems' @@ -30,6 +33,8 @@ class Gem::Commands::SourcesCommand < Gem::Command add_option '-u', '--update', 'Update source cache' do |value, options| options[:update] = value end + + add_proxy_option end def defaults_str diff --git a/lib/rubygems/commands/specification_command.rb b/lib/rubygems/commands/specification_command.rb index 5aaf6d1797..07d2c2cf0d 100644 --- a/lib/rubygems/commands/specification_command.rb +++ b/lib/rubygems/commands/specification_command.rb @@ -12,7 +12,8 @@ class Gem::Commands::SpecificationCommand < Gem::Command def initialize super 'specification', 'Display gem specification (in yaml)', - :domain => :local, :version => Gem::Requirement.default + :domain => :local, :version => Gem::Requirement.default, + :format => :yaml add_version_option('examine') add_platform_option @@ -22,26 +23,62 @@ class Gem::Commands::SpecificationCommand < Gem::Command options[:all] = true end + add_option('--ruby', 'Output ruby format') do |value, options| + options[:format] = :ruby + end + + add_option('--yaml', 'Output RUBY format') do |value, options| + options[:format] = :yaml + end + + add_option('--marshal', 'Output Marshal format') do |value, options| + options[:format] = :marshal + end + add_local_remote_options end def arguments # :nodoc: - "GEMFILE name of gem to show the gemspec for" + <<-ARGS +GEMFILE name of gem to show the gemspec for +FIELD name of gemspec field to show + ARGS end def defaults_str # :nodoc: - "--local --version '#{Gem::Requirement.default}'" + "--local --version '#{Gem::Requirement.default}' --yaml" end def usage # :nodoc: - "#{program_name} [GEMFILE]" + "#{program_name} [GEMFILE] [FIELD]" end def execute specs = [] - gem = get_one_gem_name + gem = options[:args].shift + + unless gem then + raise Gem::CommandLineError, + "Please specify a gem name or file on the command line" + end + dep = Gem::Dependency.new gem, options[:version] + field = get_one_optional_argument + + if field then + field = field.intern + + if options[:format] == :ruby then + raise Gem::CommandLineError, "--ruby and FIELD are mutually exclusive" + end + + unless Gem::Specification.attribute_names.include? field then + raise Gem::CommandLineError, + "no field %p on Gem::Specification" % field.to_s + end + end + if local? then if File.exist? gem then specs << Gem::Format.from_file_by_path(gem).spec rescue nil @@ -63,7 +100,17 @@ class Gem::Commands::SpecificationCommand < Gem::Command terminate_interaction 1 end - output = lambda { |s| say s.to_yaml; say "\n" } + output = lambda do |s| + s = s.send field if field + + say case options[:format] + when :ruby then s.to_ruby + when :marshal then Marshal.dump s + else s.to_yaml + end + + say "\n" + end if options[:all] then specs.each(&output) diff --git a/lib/rubygems/commands/uninstall_command.rb b/lib/rubygems/commands/uninstall_command.rb index 3d6e2383bc..db6aeed022 100644 --- a/lib/rubygems/commands/uninstall_command.rb +++ b/lib/rubygems/commands/uninstall_command.rb @@ -2,72 +2,82 @@ require 'rubygems/command' require 'rubygems/version_option' require 'rubygems/uninstaller' -module Gem - module Commands - class UninstallCommand < Command - - include VersionOption - - def initialize - super 'uninstall', 'Uninstall gems from the local repository', - :version => Gem::Requirement.default - - add_option('-a', '--[no-]all', - 'Uninstall all matching versions' - ) do |value, options| - options[:all] = value - end - - add_option('-I', '--[no-]ignore-dependencies', - 'Ignore dependency requirements while', - 'uninstalling') do |value, options| - options[:ignore] = value - end - - add_option('-x', '--[no-]executables', - 'Uninstall applicable executables without', - 'confirmation') do |value, options| - options[:executables] = value - end - - add_option('-i', '--install-dir DIR', - 'Directory to uninstall gem from') do |value, options| - options[:install_dir] = File.expand_path(value) - end - - add_option('-n', '--bindir DIR', - 'Directory to remove binaries from') do |value, options| - options[:bin_dir] = File.expand_path(value) - end - - add_version_option - add_platform_option - end +## +# Gem uninstaller command line tool +# +# See `gem help uninstall` - def arguments # :nodoc: - "GEMNAME name of gem to uninstall" - end +class Gem::Commands::UninstallCommand < Gem::Command - def defaults_str # :nodoc: - "--version '#{Gem::Requirement.default}' --no-force " \ - "--install-dir #{Gem.dir}" - end + include Gem::VersionOption - def usage # :nodoc: - "#{program_name} GEMNAME [GEMNAME ...]" - end + def initialize + super 'uninstall', 'Uninstall gems from the local repository', + :version => Gem::Requirement.default, :user_install => true + + add_option('-a', '--[no-]all', + 'Uninstall all matching versions' + ) do |value, options| + options[:all] = value + end + + add_option('-I', '--[no-]ignore-dependencies', + 'Ignore dependency requirements while', + 'uninstalling') do |value, options| + options[:ignore] = value + end + + add_option('-x', '--[no-]executables', + 'Uninstall applicable executables without', + 'confirmation') do |value, options| + options[:executables] = value + end + + add_option('-i', '--install-dir DIR', + 'Directory to uninstall gem from') do |value, options| + options[:install_dir] = File.expand_path(value) + end + + add_option('-n', '--bindir DIR', + 'Directory to remove binaries from') do |value, options| + options[:bin_dir] = File.expand_path(value) + end + + add_option('--[no-]user-install', + 'Uninstall from user\'s home directory', + 'in addition to GEM_HOME.') do |value, options| + options[:user_install] = value + end + + add_version_option + add_platform_option + end + + def arguments # :nodoc: + "GEMNAME name of gem to uninstall" + end - def execute - get_all_gem_names.each do |gem_name| - begin - Gem::Uninstaller.new(gem_name, options).uninstall - rescue Gem::GemNotInHomeException => e - spec = e.spec - alert("In order to remove #{spec.name}, please execute:\n" \ - "\tgem uninstall #{spec.name} --install-dir=#{spec.installation_path}") - end - end + def defaults_str # :nodoc: + "--version '#{Gem::Requirement.default}' --no-force " \ + "--install-dir #{Gem.dir}\n" \ + "--user-install" + end + + def usage # :nodoc: + "#{program_name} GEMNAME [GEMNAME ...]" + end + + def execute + get_all_gem_names.each do |gem_name| + begin + Gem::Uninstaller.new(gem_name, options).uninstall + rescue Gem::GemNotInHomeException => e + spec = e.spec + alert("In order to remove #{spec.name}, please execute:\n" \ + "\tgem uninstall #{spec.name} --install-dir=#{spec.installation_path}") end end end + end + diff --git a/lib/rubygems/commands/unpack_command.rb b/lib/rubygems/commands/unpack_command.rb index ab2494b0da..075dc04203 100644 --- a/lib/rubygems/commands/unpack_command.rb +++ b/lib/rubygems/commands/unpack_command.rb @@ -12,7 +12,7 @@ class Gem::Commands::UnpackCommand < Gem::Command :version => Gem::Requirement.default, :target => Dir.pwd - add_option('--target', 'target directory for unpacking') do |value, options| + add_option('--target=DIR', 'target directory for unpacking') do |value, options| options[:target] = value end @@ -35,18 +35,20 @@ class Gem::Commands::UnpackCommand < Gem::Command # TODO: allow, e.g., 'gem unpack rake-0.3.1'. Find a general solution for # this, so that it works for uninstall as well. (And check other commands # at the same time.) + def execute - gemname = get_one_gem_name - path = get_path(gemname, options[:version]) - - if path then - basename = File.basename(path).sub(/\.gem$/, '') - target_dir = File.expand_path File.join(options[:target], basename) - FileUtils.mkdir_p target_dir - Gem::Installer.new(path, :unpack => true).unpack target_dir - say "Unpacked gem: '#{target_dir}'" - else - alert_error "Gem '#{gemname}' not installed." + get_all_gem_names.each do |name| + path = get_path name, options[:version] + + if path then + basename = File.basename(path).sub(/\.gem$/, '') + target_dir = File.expand_path File.join(options[:target], basename) + FileUtils.mkdir_p target_dir + Gem::Installer.new(path, :unpack => true).unpack target_dir + say "Unpacked gem: '#{target_dir}'" + else + alert_error "Gem '#{name}' not installed." + end end end diff --git a/lib/rubygems/commands/update_command.rb b/lib/rubygems/commands/update_command.rb index 28d3a5d382..9974b2b54b 100644 --- a/lib/rubygems/commands/update_command.rb +++ b/lib/rubygems/commands/update_command.rb @@ -16,9 +16,9 @@ class Gem::Commands::UpdateCommand < Gem::Command super 'update', 'Update the named gems (or all installed gems) in the local repository', :generate_rdoc => true, - :generate_ri => true, - :force => false, - :test => false + :generate_ri => true, + :force => false, + :test => false add_install_update_options @@ -80,20 +80,27 @@ class Gem::Commands::UpdateCommand < Gem::Command gems_to_update.uniq.sort.each do |name| next if updated.any? { |spec| spec.name == name } + success = false say "Updating #{name}" - installer.install name + begin + installer.install name + success = true + rescue Gem::InstallError => e + alert_error "Error installing #{name}:\n\t#{e.message}" + success = false + end installer.installed_gems.each do |spec| updated << spec - say "Successfully installed #{spec.full_name}" + say "Successfully installed #{spec.full_name}" if success end end if gems_to_update.include? "rubygems-update" then Gem.source_index.refresh! - update_gems = Gem.source_index.search 'rubygems-update' + update_gems = Gem.source_index.find_name 'rubygems-update' latest_update_gem = update_gems.sort_by { |s| s.version }.last @@ -106,6 +113,20 @@ class Gem::Commands::UpdateCommand < Gem::Command say "Nothing to update" else say "Gems updated: #{updated.map { |spec| spec.name }.join ', '}" + + if options[:generate_ri] then + updated.each do |gem| + Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri + end + + Gem::DocManager.update_ri_cache + end + + if options[:generate_rdoc] then + updated.each do |gem| + Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc + end + end end end end diff --git a/lib/rubygems/commands/which_command.rb b/lib/rubygems/commands/which_command.rb index 2267e44b11..7c2d188324 100644 --- a/lib/rubygems/commands/which_command.rb +++ b/lib/rubygems/commands/which_command.rb @@ -46,7 +46,7 @@ class Gem::Commands::WhichCommand < Gem::Command end say "(checking gem #{spec.full_name} for #{arg})" if - Gem.configuration.verbose + Gem.configuration.verbose and $stdout.tty? end paths = find_paths arg, dirs diff --git a/lib/rubygems/config_file.rb b/lib/rubygems/config_file.rb index 545ef1a55a..3562805c62 100644 --- a/lib/rubygems/config_file.rb +++ b/lib/rubygems/config_file.rb @@ -5,7 +5,6 @@ #++ require 'yaml' -require 'rubygems' # Store the gem command options specified in the configuration file. The # config file object acts much like a hash. @@ -36,7 +35,8 @@ class Gem::ConfigFile CSIDL_COMMON_APPDATA = 0x0023 path = 0.chr * 260 - SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP', 'L', :stdcall + SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP', 'L', + :stdcall SHGetFolderPath.call nil, CSIDL_COMMON_APPDATA, nil, 1, path path.strip diff --git a/lib/rubygems/defaults.rb b/lib/rubygems/defaults.rb index 995b81e1b2..997f073835 100644 --- a/lib/rubygems/defaults.rb +++ b/lib/rubygems/defaults.rb @@ -20,8 +20,13 @@ module Gem if defined? RUBY_FRAMEWORK_VERSION then File.join File.dirname(ConfigMap[:sitedir]), 'Gems', ConfigMap[:ruby_version] + # 1.9.2dev reverted to 1.8 style path + elsif RUBY_VERSION > '1.9' and RUBY_VERSION < '1.9.2' then + File.join(ConfigMap[:libdir], ConfigMap[:ruby_install_name], 'gems', + ConfigMap[:ruby_version]) else - ConfigMap[:sitelibdir].sub(%r'/site_ruby/(?=[^/]+)', '/gems/') + File.join(ConfigMap[:libdir], ruby_engine, 'gems', + ConfigMap[:ruby_version]) end end @@ -37,15 +42,25 @@ module Gem # Default gem load path def self.default_path - [user_dir, default_dir] + if File.exist?(Gem.user_home) + [user_dir, default_dir] + else + [default_dir] + end end ## # Deduce Ruby's --program-prefix and --program-suffix from its install name def self.default_exec_format - baseruby = ConfigMap[:BASERUBY] || 'ruby' - ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s' + 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 ## diff --git a/lib/rubygems/dependency.rb b/lib/rubygems/dependency.rb index 7b9904df55..d142265c5d 100644 --- a/lib/rubygems/dependency.rb +++ b/lib/rubygems/dependency.rb @@ -4,8 +4,6 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems' - ## # The Dependency class holds a Gem name and a Gem::Requirement @@ -72,7 +70,7 @@ class Gem::Dependency alias requirements_list requirement_list def normalize - ver = @version_requirement.instance_eval { @version } + ver = @version_requirement.instance_variable_get :@version @version_requirements = Gem::Requirement.new([ver]) @version_requirement = nil end @@ -81,6 +79,21 @@ class Gem::Dependency "#{name} (#{version_requirements}, #{@type || :runtime})" end + def pretty_print(q) # :nodoc: + q.group 1, 'Gem::Dependency.new(', ')' do + q.pp @name + q.text ',' + q.breakable + + q.pp @version_requirements + + q.text ',' + q.breakable + + q.pp @type + end + end + def ==(other) # :nodoc: self.class === other && self.name == other.name && @@ -89,15 +102,22 @@ class Gem::Dependency end ## - # Uses this dependency as a pattern to compare to the dependency +other+. - # This dependency will match if the name matches the other's name, and other - # has only an equal version requirement that satisfies this dependency. + # Uses this dependency as a pattern to compare to +other+. This dependency + # will match if the name matches the other's name, and other has only an + # equal version requirement that satisfies this dependency. def =~(other) - return false unless self.class === other + other = if self.class === other then + other + else + return false unless other.respond_to? :name and + other.respond_to? :version + + Gem::Dependency.new other.name, other.version + end pattern = @name - pattern = /\A#{@name}\Z/ unless Regexp === pattern + pattern = /\A#{Regexp.escape @name}\Z/ unless Regexp === pattern return false unless pattern =~ other.name @@ -111,9 +131,18 @@ class Gem::Dependency version_requirements.satisfied_by? version end - def hash # :nodoc: + ## + # A dependency's hash is the sum of the hash of the #name, #type and + # #version_requirements + + def hash name.hash + type.hash + version_requirements.hash end + def inspect # :nodoc: + "<%s type=%p name=%p requirements=%p>" % [self.class, @type, @name, + version_requirements.to_s] + end + end diff --git a/lib/rubygems/dependency_installer.rb b/lib/rubygems/dependency_installer.rb index 9ae2659536..beea212818 100644 --- a/lib/rubygems/dependency_installer.rb +++ b/lib/rubygems/dependency_installer.rb @@ -20,8 +20,9 @@ class Gem::DependencyInstaller :force => false, :format_executable => false, # HACK dup :ignore_dependencies => false, + :prerelease => false, :security_policy => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low? - :wrappers => true + :wrappers => true, } ## @@ -37,6 +38,7 @@ class Gem::DependencyInstaller # :format_executable:: See Gem::Installer#initialize. # :ignore_dependencies:: Don't install any dependencies. # :install_dir:: See Gem::Installer#install. + # :prerelease:: Allow prerelease versions # :security_policy:: See Gem::Installer::new and Gem::Security. # :user_install:: See Gem::Installer.new # :wrappers:: See Gem::Installer::new @@ -58,6 +60,7 @@ class Gem::DependencyInstaller @force = options[:force] @format_executable = options[:format_executable] @ignore_dependencies = options[:ignore_dependencies] + @prerelease = options[:prerelease] @security_policy = options[:security_policy] @user_install = options[:user_install] @wrappers = options[:wrappers] @@ -90,10 +93,10 @@ class Gem::DependencyInstaller req end - all = requirements.length > 1 || - (requirements.first != ">=" and requirements.first != ">") + all = !@prerelease && (requirements.length > 1 || + (requirements.first != ">=" and requirements.first != ">")) - found = Gem::SpecFetcher.fetcher.fetch dep, all + found = Gem::SpecFetcher.fetcher.fetch dep, all, true, @prerelease gems_and_sources.push(*found) rescue Gem::RemoteFetcher::FetchError => e diff --git a/lib/rubygems/dependency_list.rb b/lib/rubygems/dependency_list.rb index a129743914..a73a32d545 100644 --- a/lib/rubygems/dependency_list.rb +++ b/lib/rubygems/dependency_list.rb @@ -8,6 +8,7 @@ require 'tsort' class Gem::DependencyList + include Enumerable include TSort def self.from_source_index(src_index) @@ -24,24 +25,27 @@ class Gem::DependencyList @specs = [] end + ## # Adds +gemspecs+ to the dependency list. + def add(*gemspecs) @specs.push(*gemspecs) end - # Return a list of the specifications in the dependency list, - # sorted in order so that no spec in the list depends on a gem - # earlier in the list. + ## + # Return a list of the specifications in the dependency list, sorted in + # order so that no spec in the list depends on a gem earlier in the list. # - # This is useful when removing gems from a set of installed gems. - # By removing them in the returned order, you don't get into as - # many dependency issues. + # This is useful when removing gems from a set of installed gems. By + # removing them in the returned order, you don't get into as many dependency + # issues. # - # If there are circular dependencies (yuck!), then gems will be - # returned in order until only the circular dependents and anything - # they reference are left. Then arbitrary gemspecs will be returned - # until the circular dependency is broken, after which gems will be - # returned in dependency order again. + # If there are circular dependencies (yuck!), then gems will be returned in + # order until only the circular dependents and anything they reference are + # left. Then arbitrary gemspecs will be returned until the circular + # dependency is broken, after which gems will be returned in dependency + # order again. + def dependency_order sorted = strongly_connected_components.flatten @@ -62,11 +66,20 @@ class Gem::DependencyList result.reverse end + ## + # Iterator over dependency_order + + def each(&block) + dependency_order.each(&block) + end + def find_name(full_name) @specs.find { |spec| spec.full_name == full_name } end + ## # Are all the dependencies in the list satisfied? + def ok? @specs.all? do |spec| spec.runtime_dependencies.all? do |dep| @@ -75,10 +88,12 @@ class Gem::DependencyList end end + ## # Is is ok to remove a gem from the dependency list? # - # If removing the gemspec creates breaks a currently ok dependency, - # then it is NOT ok to remove the gem. + # If removing the gemspec creates breaks a currently ok dependency, then it + # is NOT ok to remove the gem. + def ok_to_remove?(full_name) gem_to_remove = find_name full_name @@ -106,9 +121,10 @@ class Gem::DependencyList @specs.delete_if { |spec| spec.full_name == full_name } end - # Return a hash of predecessors. <tt>result[spec]</tt> is an - # Array of gemspecs that have a dependency satisfied by the named - # spec. + ## + # Return a hash of predecessors. <tt>result[spec]</tt> is an Array of + # gemspecs that have a dependency satisfied by the named spec. + def spec_predecessors result = Hash.new { |h,k| h[k] = [] } @@ -151,13 +167,17 @@ class Gem::DependencyList private + ## # Count the number of gemspecs in the list +specs+ that are not in # +ignored+. + def active_count(specs, ignored) result = 0 + specs.each do |spec| result += 1 unless ignored[spec.full_name] end + result end diff --git a/lib/rubygems/doc_manager.rb b/lib/rubygems/doc_manager.rb index 00ef4c51e3..e1c8e03b91 100644 --- a/lib/rubygems/doc_manager.rb +++ b/lib/rubygems/doc_manager.rb @@ -41,12 +41,23 @@ class Gem::DocManager begin require 'rdoc/rdoc' + + @rdoc_version = if defined? RDoc::VERSION then + Gem::Version.new RDoc::VERSION + else + Gem::Version.new '1.0.1' # HACK parsing is hard + end + rescue LoadError => e raise Gem::DocumentError, - "ERROR: RDoc documentation generator not installed!" + "ERROR: RDoc documentation generator not installed: #{e}" end end + def self.rdoc_version + @rdoc_version + end + ## # Updates the RI cache for RDoc 2 if it is installed @@ -94,10 +105,8 @@ class Gem::DocManager # RI docs generation to fail if run after RDoc). def generate_ri - if @spec.has_rdoc then - setup_rdoc - install_ri # RDoc bug, ri goes first - end + setup_rdoc + install_ri # RDoc bug, ri goes first FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir) end @@ -110,10 +119,8 @@ class Gem::DocManager # RI docs generation to fail if run after RDoc). def generate_rdoc - if @spec.has_rdoc then - setup_rdoc - install_rdoc - end + setup_rdoc + install_rdoc FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir) end @@ -151,8 +158,17 @@ class Gem::DocManager args << '--quiet' args << @spec.require_paths.clone args << @spec.extra_rdoc_files + args << '--title' << "#{@spec.full_name} Documentation" args = args.flatten.map do |arg| arg.to_s end + if self.class.rdoc_version >= Gem::Version.new('2.4.0') then + args.delete '--inline-source' + args.delete '--promiscuous' + args.delete '-p' + args.delete '--one-file' + # HACK more + end + r = RDoc::RDoc.new old_pwd = Dir.pwd @@ -194,20 +210,20 @@ class Gem::DocManager original_name = [ @spec.name, @spec.version, @spec.original_platform].join '-' - doc_dir = File.join @spec.installation_path, 'doc', @spec.full_name - unless File.directory? doc_dir then - doc_dir = File.join @spec.installation_path, 'doc', original_name - end + doc_dir = File.join @spec.installation_path, 'doc', @spec.full_name + unless File.directory? doc_dir then + doc_dir = File.join @spec.installation_path, 'doc', original_name + end - FileUtils.rm_rf doc_dir + FileUtils.rm_rf doc_dir - ri_dir = File.join @spec.installation_path, 'ri', @spec.full_name + ri_dir = File.join @spec.installation_path, 'ri', @spec.full_name - unless File.directory? ri_dir then - ri_dir = File.join @spec.installation_path, 'ri', original_name - end + unless File.directory? ri_dir then + ri_dir = File.join @spec.installation_path, 'ri', original_name + end - FileUtils.rm_rf ri_dir + FileUtils.rm_rf ri_dir end end diff --git a/lib/rubygems/exceptions.rb b/lib/rubygems/exceptions.rb index c37507c62a..d6c60c7a02 100644 --- a/lib/rubygems/exceptions.rb +++ b/lib/rubygems/exceptions.rb @@ -1,5 +1,3 @@ -require 'rubygems' - ## # Base exception class for RubyGems. All exception raised by RubyGems are a # subclass of this one. diff --git a/lib/rubygems/ext/builder.rb b/lib/rubygems/ext/builder.rb index a521c7b572..c029bbe1e9 100644 --- a/lib/rubygems/ext/builder.rb +++ b/lib/rubygems/ext/builder.rb @@ -4,8 +4,6 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems/ext' - class Gem::Ext::Builder def self.class_name @@ -15,7 +13,7 @@ class Gem::Ext::Builder def self.make(dest_path, results) unless File.exist? 'Makefile' then - raise Gem::InstallError, "Makefile not found:\n\n#{results.join "\n"}" + raise Gem::InstallError, "Makefile not found:\n\n#{results.join "\n"}" end mf = File.read('Makefile') diff --git a/lib/rubygems/ext/configure_builder.rb b/lib/rubygems/ext/configure_builder.rb index 1cde6915a7..c2087eb5ad 100644 --- a/lib/rubygems/ext/configure_builder.rb +++ b/lib/rubygems/ext/configure_builder.rb @@ -11,6 +11,7 @@ class Gem::Ext::ConfigureBuilder < Gem::Ext::Builder def self.build(extension, directory, dest_path, results) unless File.exist?('Makefile') then cmd = "sh ./configure --prefix=#{dest_path}" + cmd << " #{Gem::Command.build_args.join ' '}" unless Gem::Command.build_args.empty? run cmd, results end diff --git a/lib/rubygems/ext/ext_conf_builder.rb b/lib/rubygems/ext/ext_conf_builder.rb index cbe0e80821..b3d588dc9c 100644 --- a/lib/rubygems/ext/ext_conf_builder.rb +++ b/lib/rubygems/ext/ext_conf_builder.rb @@ -5,12 +5,13 @@ #++ require 'rubygems/ext/builder' +require 'rubygems/command' class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder def self.build(extension, directory, dest_path, results) cmd = "#{Gem.ruby} #{File.basename extension}" - cmd << " #{ARGV.join ' '}" unless ARGV.empty? + cmd << " #{Gem::Command.build_args.join ' '}" unless Gem::Command.build_args.empty? run cmd, results diff --git a/lib/rubygems/ext/rake_builder.rb b/lib/rubygems/ext/rake_builder.rb index 0c64e611a0..3b45ef4369 100644 --- a/lib/rubygems/ext/rake_builder.rb +++ b/lib/rubygems/ext/rake_builder.rb @@ -5,17 +5,21 @@ #++ require 'rubygems/ext/builder' +require 'rubygems/command' class Gem::Ext::RakeBuilder < Gem::Ext::Builder def self.build(extension, directory, dest_path, results) if File.basename(extension) =~ /mkrf_conf/i then cmd = "#{Gem.ruby} #{File.basename extension}" - cmd << " #{ARGV.join " "}" unless ARGV.empty? + cmd << " #{Gem::Command.build_args.join " "}" unless Gem::Command.build_args.empty? run cmd, results end - cmd = ENV['rake'] || 'rake' + # Deal with possible spaces in the path, e.g. C:/Program Files + dest_path = '"' + dest_path + '"' if dest_path.include?(' ') + + cmd = ENV['rake'] || "#{Gem.ruby} -rubygems #{Gem.bin_path('rake')}" rescue Gem.default_exec_format % 'rake' cmd += " RUBYARCHDIR=#{dest_path} RUBYLIBDIR=#{dest_path}" # ENV is frozen run cmd, results diff --git a/lib/rubygems/format.rb b/lib/rubygems/format.rb index 49a3951e26..b2e7897339 100644 --- a/lib/rubygems/format.rb +++ b/lib/rubygems/format.rb @@ -8,80 +8,80 @@ require 'fileutils' require 'rubygems/package' -module Gem +## +# Gem::Format knows the guts of the RubyGem .gem file format and provides the +# capability to read gem files + +class Gem::Format + + attr_accessor :spec, :file_entries, :gem_path + + extend Gem::UserInteraction ## - # The format class knows the guts of the RubyGem .gem file format - # and provides the capability to read gem files + # Constructs an instance of a Format object, representing the gem's + # data structure. # - class Format - attr_accessor :spec, :file_entries, :gem_path - extend Gem::UserInteraction - - ## - # Constructs an instance of a Format object, representing the gem's - # data structure. - # - # gem:: [String] The file name of the gem - # - def initialize(gem_path) - @gem_path = gem_path + # gem:: [String] The file name of the gem + # + def initialize(gem_path) + @gem_path = gem_path + end + + ## + # Reads the named gem file and returns a Format object, representing + # the data from the gem file + # + # file_path:: [String] Path to the gem file + + def self.from_file_by_path(file_path, security_policy = nil) + format = nil + + unless File.exist?(file_path) + raise Gem::Exception, "Cannot load gem at [#{file_path}] in #{Dir.pwd}" end - ## - # Reads the named gem file and returns a Format object, representing - # the data from the gem file - # - # file_path:: [String] Path to the gem file - # - def self.from_file_by_path(file_path, security_policy = nil) - format = nil - - unless File.exist?(file_path) - raise Gem::Exception, "Cannot load gem at [#{file_path}] in #{Dir.pwd}" + # check for old version gem + if File.read(file_path, 20).include?("MD5SUM =") + require 'rubygems/old_format' + + format = Gem::OldFormat.from_file_by_path(file_path) + else + open file_path, Gem.binary_mode do |io| + format = from_io io, file_path, security_policy end + end - # check for old version gem - if File.read(file_path, 20).include?("MD5SUM =") - require 'rubygems/old_format' + return format + end - format = OldFormat.from_file_by_path(file_path) - else - open file_path, Gem.binary_mode do |io| - format = from_io io, file_path, security_policy - end - end + ## + # Reads a gem from an io stream and returns a Format object, representing + # the data from the gem file + # + # io:: [IO] Stream from which to read the gem - return format - end + def self.from_io(io, gem_path="(io)", security_policy = nil) + format = new gem_path - ## - # Reads a gem from an io stream and returns a Format object, representing - # the data from the gem file - # - # io:: [IO] Stream from which to read the gem - # - def self.from_io(io, gem_path="(io)", security_policy = nil) - format = new gem_path - - Package.open io, 'r', security_policy do |pkg| - format.spec = pkg.metadata - format.file_entries = [] - - pkg.each do |entry| - size = entry.header.size - mode = entry.header.mode - - format.file_entries << [{ - "size" => size, "mode" => mode, "path" => entry.full_name, - }, - entry.read - ] - end - end + Gem::Package.open io, 'r', security_policy do |pkg| + format.spec = pkg.metadata + format.file_entries = [] + + pkg.each do |entry| + size = entry.header.size + mode = entry.header.mode - format + format.file_entries << [{ + "size" => size, "mode" => mode, "path" => entry.full_name, + }, + entry.read + ] + end end + format end + end + diff --git a/lib/rubygems/gem_openssl.rb b/lib/rubygems/gem_openssl.rb index 1456f2d7ce..bdaad8050a 100644 --- a/lib/rubygems/gem_openssl.rb +++ b/lib/rubygems/gem_openssl.rb @@ -4,23 +4,30 @@ # See LICENSE.txt for permissions. #++ +#-- # Some system might not have OpenSSL installed, therefore the core # library file openssl might not be available. We localize testing # for the presence of OpenSSL in this file. +#++ module Gem class << self + ## # Is SSL (used by the signing commands) available on this # platform? + def ssl_available? - require 'rubygems/gem_openssl' @ssl_available end - # Set the value of the ssl_available flag. + ## + # Is SSL available? + attr_writer :ssl_available + ## # Ensure that SSL is available. Throw an exception if it is not. + def ensure_ssl_available unless ssl_available? fail Gem::Exception, "SSL is not installed on this system" @@ -61,6 +68,8 @@ rescue LoadError, StandardError Gem.ssl_available = false end +# :stopdoc: + module Gem::SSL # We make our own versions of the constants here. This allows us @@ -70,7 +79,7 @@ module Gem::SSL # These constants are only used during load time. At runtime, any # method that makes a direct reference to SSL software must be # protected with a Gem.ensure_ssl_available call. - # + if Gem.ssl_available? then PKEY_RSA = OpenSSL::PKey::RSA DIGEST_SHA1 = OpenSSL::Digest::SHA1 @@ -81,3 +90,5 @@ module Gem::SSL end +# :startdoc: + diff --git a/lib/rubygems/gem_path_searcher.rb b/lib/rubygems/gem_path_searcher.rb index e2b8543bb0..2232a574e3 100644 --- a/lib/rubygems/gem_path_searcher.rb +++ b/lib/rubygems/gem_path_searcher.rb @@ -4,8 +4,6 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems' - ## # GemPathSearcher has the capability to find loadable files inside # gems. It generates data up front to speed up searches later. @@ -80,11 +78,15 @@ class Gem::GemPathSearcher ## # Return a list of all installed gemspecs, sorted by alphabetical order and - # in reverse version order. + # in reverse version order. (bar-2, bar-1, foo-2) def init_gemspecs - Gem.source_index.map { |_, spec| spec }.sort { |a,b| - (a.name <=> b.name).nonzero? || (b.version <=> a.version) + specs = Gem.source_index.map { |_, spec| spec } + + specs.sort { |a, b| + names = a.name <=> b.name + next names if names.nonzero? + b.version <=> a.version } end diff --git a/lib/rubygems/gem_runner.rb b/lib/rubygems/gem_runner.rb index 7edc93d68f..07a792dd9b 100644 --- a/lib/rubygems/gem_runner.rb +++ b/lib/rubygems/gem_runner.rb @@ -8,51 +8,71 @@ require 'rubygems/command_manager' require 'rubygems/config_file' require 'rubygems/doc_manager' -module Gem +## +# Run an instance of the gem program. +# +# Gem::GemRunner is only intended for internal use by RubyGems itself. It +# does not form any public API and may change at any time for any reason. +# +# If you would like to duplicate functionality of `gem` commands, use the +# classes they call directly. - #################################################################### - # Run an instance of the gem program. - # - class GemRunner +class Gem::GemRunner - def initialize(options={}) - @command_manager_class = options[:command_manager] || Gem::CommandManager - @config_file_class = options[:config_file] || Gem::ConfigFile - @doc_manager_class = options[:doc_manager] || Gem::DocManager + def initialize(options={}) + @command_manager_class = options[:command_manager] || Gem::CommandManager + @config_file_class = options[:config_file] || Gem::ConfigFile + @doc_manager_class = options[:doc_manager] || Gem::DocManager + end + + ## + # Run the gem command with the following arguments. + + def run(args) + start_time = Time.now + + if args.include?('--') + # We need to preserve the original ARGV to use for passing gem options + # to source gems. If there is a -- in the line, strip all options after + # it...its for the source building process. + build_args = args[args.index("--") + 1...args.length] + args = args[0...args.index("--")] end - # Run the gem command with the following arguments. - def run(args) - start_time = Time.now - do_configuration(args) - cmd = @command_manager_class.instance - cmd.command_names.each do |command_name| - config_args = Gem.configuration[command_name] - config_args = case config_args - when String - config_args.split ' ' - else - Array(config_args) - end - Command.add_specific_extra_args command_name, config_args - end - cmd.run(Gem.configuration.args) - end_time = Time.now - if Gem.configuration.benchmark - printf "\nExecution time: %0.2f seconds.\n", end_time-start_time - puts "Press Enter to finish" - STDIN.gets - end + Gem::Command.build_args = build_args if build_args + + do_configuration args + cmd = @command_manager_class.instance + + cmd.command_names.each do |command_name| + config_args = Gem.configuration[command_name] + config_args = case config_args + when String + config_args.split ' ' + else + Array(config_args) + end + Gem::Command.add_specific_extra_args command_name, config_args end - private + cmd.run Gem.configuration.args + end_time = Time.now - def do_configuration(args) - Gem.configuration = @config_file_class.new(args) - Gem.use_paths(Gem.configuration[:gemhome], Gem.configuration[:gempath]) - Gem::Command.extra_args = Gem.configuration[:gem] - @doc_manager_class.configured_args = Gem.configuration[:rdoc] + if Gem.configuration.benchmark then + printf "\nExecution time: %0.2f seconds.\n", end_time - start_time + puts "Press Enter to finish" + STDIN.gets end + end + + private + + def do_configuration(args) + Gem.configuration = @config_file_class.new(args) + Gem.use_paths(Gem.configuration[:gemhome], Gem.configuration[:gempath]) + Gem::Command.extra_args = Gem.configuration[:gem] + @doc_manager_class.configured_args = Gem.configuration[:rdoc] + end + +end - end # class -end # module diff --git a/lib/rubygems/indexer.rb b/lib/rubygems/indexer.rb index e2dd57d3fe..5ebde1b31c 100644 --- a/lib/rubygems/indexer.rb +++ b/lib/rubygems/indexer.rb @@ -6,6 +6,7 @@ require 'rubygems' require 'rubygems/format' begin + gem 'builder' require 'builder/xchar' rescue LoadError end @@ -18,11 +19,36 @@ class Gem::Indexer include Gem::UserInteraction ## + # Build indexes for RubyGems older than 1.2.0 when true + + attr_accessor :build_legacy + + ## + # Build indexes for RubyGems 1.2.0 and newer when true + + attr_accessor :build_modern + + ## # Index install location attr_reader :dest_directory ## + # Specs index install location + + attr_reader :dest_specs_index + + ## + # Latest specs index install location + + attr_reader :dest_latest_specs_index + + ## + # Prerelease specs index install location + + attr_reader :dest_prerelease_specs_index + + ## # Index build directory attr_reader :directory @@ -30,12 +56,21 @@ class Gem::Indexer ## # Create an indexer that will index the gems in +directory+. - def initialize(directory) + def initialize(directory, options = {}) unless ''.respond_to? :to_xs then fail "Gem::Indexer requires that the XML Builder library be installed:" \ "\n\tgem install builder" end + options = { :build_legacy => true, :build_modern => true }.merge options + + @build_legacy = options[:build_legacy] + @build_modern = options[:build_modern] + + @rss_title = options[:rss_title] + @rss_host = options[:rss_host] + @rss_gems_host = options[:rss_gems_host] + @dest_directory = directory @directory = File.join Dir.tmpdir, "gem_generate_index_#{$$}" @@ -54,22 +89,19 @@ class Gem::Indexer @specs_index = File.join @directory, "specs.#{Gem.marshal_version}" @latest_specs_index = File.join @directory, "latest_specs.#{Gem.marshal_version}" + @prerelease_specs_index = File.join(@directory, + "prerelease_specs.#{Gem.marshal_version}") - files = [ - @specs_index, - "#{@specs_index}.gz", - @latest_specs_index, - "#{@latest_specs_index}.gz", - @quick_dir, - @master_index, - "#{@master_index}.Z", - @marshal_index, - "#{@marshal_index}.Z", - ] - - @files = files.map do |path| - path.sub @directory, '' - end + @dest_specs_index = File.join @dest_directory, + "specs.#{Gem.marshal_version}" + @dest_latest_specs_index = File.join @dest_directory, + "latest_specs.#{Gem.marshal_version}" + @dest_prerelease_specs_index = File.join @dest_directory, + "prerelease_specs.#{Gem.marshal_version}" + + @rss_index = File.join @directory, 'index.rss' + + @files = [] end ## @@ -91,159 +123,367 @@ class Gem::Indexer # Build various indicies def build_indicies(index) + # Marshal gemspecs are used by both modern and legacy RubyGems + build_marshal_gemspecs index + build_legacy_indicies index if @build_legacy + build_modern_indicies index if @build_modern + build_rss index + + compress_indicies + end + + ## + # Builds indicies for RubyGems older than 1.2.x + + def build_legacy_indicies(index) progress = ui.progress_reporter index.size, - "Generating quick index gemspecs for #{index.size} gems", + "Generating YAML quick index gemspecs for #{index.size} gems", "Complete" - index.each do |original_name, spec| - spec_file_name = "#{original_name}.gemspec.rz" - yaml_name = File.join @quick_dir, spec_file_name - marshal_name = File.join @quick_marshal_dir, spec_file_name + Gem.time 'Generated YAML quick index gemspecs' do + index.each do |original_name, spec| + spec_file_name = "#{original_name}.gemspec.rz" + yaml_name = File.join @quick_dir, spec_file_name - yaml_zipped = Gem.deflate spec.to_yaml - open yaml_name, 'wb' do |io| io.write yaml_zipped end + yaml_zipped = Gem.deflate spec.to_yaml + open yaml_name, 'wb' do |io| io.write yaml_zipped end - marshal_zipped = Gem.deflate Marshal.dump(spec) - open marshal_name, 'wb' do |io| io.write marshal_zipped end + progress.updated original_name + end - progress.updated original_name + progress.done end - progress.done - - say "Generating specs index" + say "Generating quick index" - open @specs_index, 'wb' do |io| - specs = index.sort.map do |_, spec| - platform = spec.original_platform - platform = Gem::Platform::RUBY if platform.nil? or platform.empty? - [spec.name, spec.version, platform] + Gem.time 'Generated quick index' do + open @quick_index, 'wb' do |io| + io.puts index.sort.map { |_, spec| spec.original_name } end - - specs = compact_specs specs - - Marshal.dump specs, io end - say "Generating latest specs index" + say "Generating latest index" - open @latest_specs_index, 'wb' do |io| - specs = index.latest_specs.sort.map do |spec| - platform = spec.original_platform - platform = Gem::Platform::RUBY if platform.nil? or platform.empty? - [spec.name, spec.version, platform] + Gem.time 'Generated latest index' do + open @latest_index, 'wb' do |io| + io.puts index.latest_specs.sort.map { |spec| spec.original_name } end + end - specs = compact_specs specs + # Don't need prerelease legacy index + + say "Generating Marshal master index" - Marshal.dump specs, io + Gem.time 'Generated Marshal master index' do + open @marshal_index, 'wb' do |io| + io.write index.dump + end end - say "Generating quick index" + progress = ui.progress_reporter index.size, + "Generating YAML master index for #{index.size} gems (this may take a while)", + "Complete" - quick_index = File.join @quick_dir, 'index' - open quick_index, 'wb' do |io| - io.puts index.sort.map { |_, spec| spec.original_name } - end + Gem.time 'Generated YAML master index' do + open @master_index, 'wb' do |io| + io.puts "--- !ruby/object:#{index.class}" + io.puts "gems:" - say "Generating latest index" + gems = index.sort_by { |name, gemspec| gemspec.sort_obj } + gems.each do |original_name, gemspec| + yaml = gemspec.to_yaml.gsub(/^/, ' ') + yaml = yaml.sub(/\A ---/, '') # there's a needed extra ' ' here + io.print " #{original_name}:" + io.puts yaml + + progress.updated original_name + end + end - latest_index = File.join @quick_dir, 'latest_index' - open latest_index, 'wb' do |io| - io.puts index.latest_specs.sort.map { |spec| spec.original_name } + progress.done end - say "Generating Marshal master index" + @files << @quick_dir + @files << @master_index + @files << "#{@master_index}.Z" + @files << @marshal_index + @files << "#{@marshal_index}.Z" + end - open @marshal_index, 'wb' do |io| - io.write index.dump - end + ## + # Builds Marshal quick index gemspecs. + def build_marshal_gemspecs(index) progress = ui.progress_reporter index.size, - "Generating YAML master index for #{index.size} gems (this may take a while)", + "Generating Marshal quick index gemspecs for #{index.size} gems", "Complete" - open @master_index, 'wb' do |io| - io.puts "--- !ruby/object:#{index.class}" - io.puts "gems:" + files = [] - gems = index.sort_by { |name, gemspec| gemspec.sort_obj } - gems.each do |original_name, gemspec| - yaml = gemspec.to_yaml.gsub(/^/, ' ') - yaml = yaml.sub(/\A ---/, '') # there's a needed extra ' ' here - io.print " #{original_name}:" - io.puts yaml + Gem.time 'Generated Marshal quick index gemspecs' do + (index.gems.merge(index.prerelease_gems)).each do |original_name, spec| + spec_file_name = "#{original_name}.gemspec.rz" + marshal_name = File.join @quick_marshal_dir, spec_file_name + + marshal_zipped = Gem.deflate Marshal.dump(spec) + open marshal_name, 'wb' do |io| io.write marshal_zipped end + + files << marshal_name progress.updated original_name end + + progress.done end - progress.done + @files << @quick_marshal_dir - say "Compressing indicies" - # use gzip for future files. + files + end + + ## + # Build a single index for RubyGems 1.2 and newer + + def build_modern_index(index, file, name) + say "Generating #{name} index" + + Gem.time "Generated #{name} index" do + open(file, 'wb') do |io| + specs = index.map do |*spec| + # We have to splat here because latest_specs is an array, + # while the others are hashes. See the TODO in source_index.rb + spec = spec.flatten.last + platform = spec.original_platform + + # win32-api-1.0.4-x86-mswin32-60 + unless String === platform then + alert_warning "Skipping invalid platform in gem: #{spec.full_name}" + next + end + + platform = Gem::Platform::RUBY if platform.nil? or platform.empty? + [spec.name, spec.version, platform] + end + + specs = compact_specs(specs) + Marshal.dump(specs, io) + end + end + end + + ## + # Builds indicies for RubyGems 1.2 and newer. Handles full, latest, prerelease + + def build_modern_indicies(index) + build_modern_index(index.sort, @specs_index, 'specs') + build_modern_index(index.latest_specs.sort, + @latest_specs_index, + 'latest specs') + build_modern_index(index.prerelease_specs.sort, + @prerelease_specs_index, + 'prerelease specs') + + @files += [@specs_index, + "#{@specs_index}.gz", + @latest_specs_index, + "#{@latest_specs_index}.gz", + @prerelease_specs_index, + "#{@prerelease_specs_index}.gz"] + end - compress quick_index, 'rz' - paranoid quick_index, 'rz' + ## + # Builds an RSS feed for past two days gem releases according to the gem's + # date. - compress latest_index, 'rz' - paranoid latest_index, 'rz' + def build_rss(index) + if @rss_host.nil? or @rss_gems_host.nil? then + if Gem.configuration.really_verbose then + alert_warning "no --rss-host or --rss-gems-host, RSS generation disabled" + end + return + end - compress @marshal_index, 'Z' - paranoid @marshal_index, 'Z' + require 'cgi' + require 'rubygems/text' + + extend Gem::Text + + Gem.time 'Generated rss' do + open @rss_index, 'wb' do |io| + rss_host = CGI.escapeHTML @rss_host + rss_title = CGI.escapeHTML(@rss_title || 'gems') + + io.puts <<-HEADER +<?xml version="1.0"?> +<rss version="2.0"> + <channel> + <title>#{rss_title}</title> + <link>http://#{rss_host}</link> + <description>Recently released gems from http://#{rss_host}</description> + <generator>RubyGems v#{Gem::RubyGemsVersion}</generator> + <docs>http://cyber.law.harvard.edu/rss/rss.html</docs> + HEADER + + today = Gem::Specification::TODAY + yesterday = today - 86400 + + index = index.select do |_, spec| + spec_date = spec.date + + case spec_date + when Date + Time.parse(spec_date.to_s) >= yesterday + when Time + spec_date >= yesterday + end + end + + index = index.select do |_, spec| + spec_date = spec.date - compress @master_index, 'Z' - paranoid @master_index, 'Z' + case spec_date + when Date + Time.parse(spec_date.to_s) <= today + when Time + spec_date <= today + end + end - gzip @specs_index - gzip @latest_specs_index + index.sort_by { |_, spec| [-spec.date.to_i, spec] }.each do |_, spec| + gem_path = CGI.escapeHTML "http://#{@rss_gems_host}/gems/#{spec.full_name}.gem" + size = File.stat(spec.loaded_from).size rescue next + + description = spec.description || spec.summary || '' + authors = Array spec.authors + emails = Array spec.email + authors = emails.zip(authors).map do |email, author| + email += " (#{author})" if author and not author.empty? + end.join ', ' + + description = description.split(/\n\n+/).map do |chunk| + format_text chunk, 78 + end + + description = description.join "\n\n" + + item = '' + + item << <<-ITEM + <item> + <title>#{CGI.escapeHTML spec.full_name}</title> + <description> +<pre>#{CGI.escapeHTML description.chomp}</pre> + </description> + <author>#{CGI.escapeHTML authors}</author> + <guid>#{CGI.escapeHTML spec.full_name}</guid> + <enclosure url=\"#{gem_path}\" + length=\"#{size}\" type=\"application/octet-stream\" /> + <pubDate>#{spec.date.rfc2822}</pubDate> + ITEM + + item << <<-ITEM if spec.homepage + <link>#{CGI.escapeHTML spec.homepage}</link> + ITEM + + item << <<-ITEM + </item> + ITEM + + io.puts item + end + + io.puts <<-FOOTER + </channel> +</rss> + FOOTER + end + end + + @files << @rss_index end ## # Collect specifications from .gem files from the gem directory. - def collect_specs + def collect_specs(gems = gem_file_list) index = Gem::SourceIndex.new - progress = ui.progress_reporter gem_file_list.size, - "Loading #{gem_file_list.size} gems from #{@dest_directory}", + progress = ui.progress_reporter gems.size, + "Loading #{gems.size} gems from #{@dest_directory}", "Loaded all gems" - gem_file_list.each do |gemfile| - if File.size(gemfile.to_s) == 0 then - alert_warning "Skipping zero-length gem: #{gemfile}" - next - end - - begin - spec = Gem::Format.from_file_by_path(gemfile).spec - - unless gemfile =~ /\/#{Regexp.escape spec.original_name}.*\.gem\z/i then - alert_warning "Skipping misnamed gem: #{gemfile} => #{spec.full_name} (#{spec.original_name})" + Gem.time 'loaded' do + gems.each do |gemfile| + if File.size(gemfile.to_s) == 0 then + alert_warning "Skipping zero-length gem: #{gemfile}" next end - abbreviate spec - sanitize spec + begin + spec = Gem::Format.from_file_by_path(gemfile).spec + spec.loaded_from = gemfile + + unless gemfile =~ /\/#{Regexp.escape spec.original_name}.*\.gem\z/i then + expected_name = spec.full_name + expected_name << " (#{spec.original_name})" if + spec.original_name != spec.full_name + alert_warning "Skipping misnamed gem: #{gemfile} should be named #{expected_name}" + next + end - index.gems[spec.original_name] = spec + abbreviate spec + sanitize spec - progress.updated spec.original_name + index.add_spec spec, spec.original_name - rescue SignalException => e - alert_error "Received signal, exiting" - raise - rescue Exception => e - alert_error "Unable to process #{gemfile}\n#{e.message} (#{e.class})\n\t#{e.backtrace.join "\n\t"}" + progress.updated spec.original_name + + rescue SignalException => e + alert_error "Received signal, exiting" + raise + rescue Exception => e + alert_error "Unable to process #{gemfile}\n#{e.message} (#{e.class})\n\t#{e.backtrace.join "\n\t"}" + end end - end - progress.done + progress.done + end index end ## + # Compresses indicies on disk + #-- + # All future files should be compressed using gzip, not deflate + + def compress_indicies + say "Compressing indicies" + + Gem.time 'Compressed indicies' do + if @build_legacy then + compress @quick_index, 'rz' + paranoid @quick_index, 'rz' + + compress @latest_index, 'rz' + paranoid @latest_index, 'rz' + + compress @marshal_index, 'Z' + paranoid @marshal_index, 'Z' + + compress @master_index, 'Z' + paranoid @master_index, 'Z' + end + + if @build_modern then + gzip @specs_index + gzip @latest_specs_index + gzip @prerelease_specs_index + end + end + end + + ## # Compacts Marshal output for the specs index data source by using identical # objects as much as possible. @@ -282,7 +522,7 @@ class Gem::Indexer end ## - # Builds and installs indexicies. + # Builds and installs indicies. def generate_index make_temp_directories @@ -311,7 +551,27 @@ class Gem::Indexer say "Moving index into production dir #{@dest_directory}" if verbose - @files.each do |file| + files = @files.dup + files.delete @quick_marshal_dir if files.include? @quick_dir + + if files.include? @quick_marshal_dir and + not files.include? @quick_dir then + files.delete @quick_marshal_dir + quick_marshal_dir = @quick_marshal_dir.sub @directory, '' + + dst_name = File.join @dest_directory, quick_marshal_dir + + FileUtils.mkdir_p File.dirname(dst_name), :verbose => verbose + FileUtils.rm_rf dst_name, :verbose => verbose + FileUtils.mv @quick_marshal_dir, dst_name, :verbose => verbose, + :force => true + end + + files = files.map do |path| + path.sub @directory, '' + end + + files.each do |file| src_name = File.join @directory, file dst_name = File.join @dest_directory, file @@ -366,5 +626,87 @@ class Gem::Indexer string ? string.to_s.to_xs : string end + ## + # Perform an in-place update of the repository from newly added gems. Only + # works for modern indicies, and sets #build_legacy to false when run. + + def update_index + @build_legacy = false + + make_temp_directories + + specs_mtime = File.stat(@dest_specs_index).mtime + newest_mtime = Time.at 0 + + updated_gems = gem_file_list.select do |gem| + gem_mtime = File.stat(gem).mtime + newest_mtime = gem_mtime if gem_mtime > newest_mtime + gem_mtime >= specs_mtime + end + + if updated_gems.empty? then + say 'No new gems' + terminate_interaction 0 + end + + index = collect_specs updated_gems + + files = build_marshal_gemspecs index + + Gem.time 'Updated indexes' do + update_specs_index index, @dest_specs_index, @specs_index + update_specs_index index, @dest_latest_specs_index, @latest_specs_index + update_specs_index(index.prerelease_gems, @dest_prerelease_specs_index, + @prerelease_specs_index) + end + + compress_indicies + + verbose = Gem.configuration.really_verbose + + say "Updating production dir #{@dest_directory}" if verbose + + files << @specs_index + files << "#{@specs_index}.gz" + files << @latest_specs_index + files << "#{@latest_specs_index}.gz" + files << @prerelease_specs_index + files << "#{@prerelease_specs_index}.gz" + + files = files.map do |path| + path.sub @directory, '' + end + + files.each do |file| + src_name = File.join @directory, file + dst_name = File.join @dest_directory, File.dirname(file) + + FileUtils.mv src_name, dst_name, :verbose => verbose, + :force => true + + File.utime newest_mtime, newest_mtime, dst_name + end + end + + ## + # Combines specs in +index+ and +source+ then writes out a new copy to + # +dest+. For a latest index, does not ensure the new file is minimal. + + def update_specs_index(index, source, dest) + specs_index = Marshal.load Gem.read_binary(source) + + index.each do |_, spec| + platform = spec.original_platform + platform = Gem::Platform::RUBY if platform.nil? or platform.empty? + specs_index << [spec.name, spec.version, platform] + end + + specs_index = compact_specs specs_index.uniq.sort + + open dest, 'wb' do |io| + Marshal.dump specs_index, io + end + end + end diff --git a/lib/rubygems/install_update_options.rb b/lib/rubygems/install_update_options.rb index dd35acb176..a43a2a171c 100644 --- a/lib/rubygems/install_update_options.rb +++ b/lib/rubygems/install_update_options.rb @@ -9,9 +9,12 @@ require 'rubygems/security' ## # Mixin methods for install and update options for Gem::Commands + module Gem::InstallUpdateOptions + ## # Add the install/update options to the option parser. + def add_install_update_options OptionParser.accept Gem::Security::Policy do |value| value = Gem::Security::Policies[value] @@ -92,7 +95,7 @@ module Gem::InstallUpdateOptions add_option(:"Install/Update", '--[no-]user-install', 'Install in user\'s home directory instead', - 'of GEM_HOME. Defaults to using home directory', + 'of GEM_HOME. Defaults to using home', 'only if GEM_HOME is not writable.') do |value, options| options[:user_install] = value end @@ -102,9 +105,18 @@ module Gem::InstallUpdateOptions "dependencies") do |value, options| options[:development] = true end + + add_option(:"Install/Update", "--prerelease", + "Install prerelease versions of a gem if", + "available. Defaults to skipping", + "prereleases.") do |value, options| + options[:prerelease] = true + end end + ## # Default options for the gem install command. + def install_update_defaults_str '--rdoc --no-force --no-test --wrappers' end diff --git a/lib/rubygems/installer.rb b/lib/rubygems/installer.rb index 44bf2f8903..e9910876f3 100644 --- a/lib/rubygems/installer.rb +++ b/lib/rubygems/installer.rb @@ -13,17 +13,28 @@ require 'rubygems/ext' require 'rubygems/require_paths_builder' ## -# The installer class processes RubyGem .gem files and installs the -# files contained in the .gem into the Gem.path. +# The installer class processes RubyGem .gem files and installs the files +# contained in the .gem into the Gem.path. # # Gem::Installer does the work of putting files in all the right places on the # filesystem including unpacking the gem into its gem dir, installing the # gemspec in the specifications dir, storing the cached gem in the cache dir, # and installing either wrappers or symlinks for executables. +# +# The installer fires pre and post install hooks. Hooks can be added either +# through a rubygems_plugin.rb file in an installed gem or via a +# rubygems/defaults/#{RUBY_ENGINE}.rb or rubygems/defaults/operating_system.rb +# file. See Gem.pre_install and Gem.post_install for details. class Gem::Installer ## + # Paths where env(1) might live. Some systems are broken and have it in + # /bin + + ENV_PATHS = %w[/usr/bin/env /bin/env] + + ## # Raised when there is an error while building extensions. # class ExtensionBuildError < Gem::InstallError; end @@ -71,8 +82,6 @@ class Gem::Installer end - ENV_PATHS = %w[/usr/bin/env /bin/env] - ## # Constructs an Installer instance that will install the gem located at # +gem+. +options+ is a Hash with the following keys: @@ -100,17 +109,17 @@ class Gem::Installer :source_index => Gem.source_index, }.merge options - @env_shebang = options[:env_shebang] - @force = options[:force] - gem_home = options[:install_dir] - @gem_home = Pathname.new(gem_home).expand_path + @env_shebang = options[:env_shebang] + @force = options[:force] + gem_home = options[:install_dir] + @gem_home = Pathname.new(gem_home).expand_path @ignore_dependencies = options[:ignore_dependencies] - @format_executable = options[:format_executable] - @security_policy = options[:security_policy] - @wrappers = options[:wrappers] - @bin_dir = options[:bin_dir] - @development = options[:development] - @source_index = options[:source_index] + @format_executable = options[:format_executable] + @security_policy = options[:security_policy] + @wrappers = options[:wrappers] + @bin_dir = options[:bin_dir] + @development = options[:development] + @source_index = options[:source_index] begin @format = Gem::Format.from_file_by_path @gem, @security_policy @@ -121,7 +130,7 @@ class Gem::Installer begin FileUtils.mkdir_p @gem_home rescue Errno::EACCES, Errno::ENOTDIR - # We'll divert to ~/.gem below + # We'll divert to ~/.gems below end if not File.writable? @gem_home or @@ -131,7 +140,7 @@ class Gem::Installer if options[:user_install] == false then # You don't want to use ~ raise Gem::FilePermissionError, @gem_home elsif options[:user_install].nil? then - unless self.class.home_install_warning then + unless self.class.home_install_warning or options[:unpack] then alert_warning "Installing to ~/.gem since #{@gem_home} and\n\t #{Gem.bindir} aren't both writable." self.class.home_install_warning = true end @@ -392,19 +401,21 @@ class Gem::Installer ruby_name = Gem::ConfigMap[:ruby_install_name] if @env_shebang path = File.join @gem_dir, @spec.bindir, bin_file_name first_line = File.open(path, "rb") {|file| file.gets} + if /\A#!/ =~ first_line then # Preserve extra words on shebang line, like "-w". Thanks RPA. shebang = first_line.sub(/\A\#!.*?ruby\S*(?=(\s+\S+))/, "#!#{Gem.ruby}") opts = $1 shebang.strip! # Avoid nasty ^M issues. end - if !ruby_name + + if not ruby_name then "#!#{Gem.ruby}#{opts}" - elsif opts - %{#!/bin/sh\n'exec' #{ruby_name.dump} '-x' "$0" "$@"\n#{shebang}} + elsif opts then + "#!/bin/sh\n'exec' #{ruby_name.dump} '-x' \"$0\" \"$@\"\n#{shebang}" else # Create a plain shebang line. - @env_path ||= ENV_PATHS.find {|path| File.executable?(path)} + @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path } "#!#{@env_path} #{ruby_name}" end end @@ -432,7 +443,7 @@ if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then end gem '#{@spec.name}', version -load '#{bin_file_name}' +load Gem.bin_path('#{@spec.name}', '#{bin_file_name}', version) TEXT end @@ -443,10 +454,10 @@ TEXT <<-TEXT @ECHO OFF IF NOT "%~f0" == "~f0" GOTO :WinNT -@"#{File.basename(Gem.ruby)}" "#{File.join(bindir, bin_file_name)}" %1 %2 %3 %4 %5 %6 %7 %8 %9 +@"#{File.basename(Gem.ruby).chomp('"')}" "#{File.join(bindir, bin_file_name)}" %1 %2 %3 %4 %5 %6 %7 %8 %9 GOTO :EOF :WinNT -@"#{File.basename(Gem.ruby)}" "%~dpn0" %* +@"#{File.basename(Gem.ruby).chomp('"')}" "%~dpn0" %* TEXT end @@ -531,6 +542,7 @@ Results logged to #{File.join(Dir.pwd, 'gem_make.out')} raise Gem::InstallError, msg end + FileUtils.rm_rf(path) if File.exists?(path) FileUtils.mkdir_p File.dirname(path) File.open(path, "wb") do |out| diff --git a/lib/rubygems/local_remote_options.rb b/lib/rubygems/local_remote_options.rb index 730cb69b83..e238c7292c 100644 --- a/lib/rubygems/local_remote_options.rb +++ b/lib/rubygems/local_remote_options.rb @@ -23,7 +23,9 @@ module Gem::LocalRemoteOptions raise OptionParser::InvalidArgument, value end - raise OptionParser::InvalidArgument, value unless uri.scheme == 'http' + unless ['http', 'https', 'file'].include?(uri.scheme) + raise OptionParser::InvalidArgument, value + end value end @@ -90,7 +92,7 @@ module Gem::LocalRemoteOptions source << '/' if source !~ /\/\z/ if options[:added_source] then - Gem.sources << source + Gem.sources << source unless Gem.sources.include?(source) else options[:added_source] = true Gem.sources.replace [source] @@ -99,10 +101,9 @@ module Gem::LocalRemoteOptions end ## - # Add the --update-source option + # Add the --update-sources option def add_update_sources_option - add_option(:"Local/Remote", '-u', '--[no-]update-sources', 'Update local source cache') do |value, options| Gem.configuration.update_sources = value diff --git a/lib/rubygems/old_format.rb b/lib/rubygems/old_format.rb index 4b8db70bc6..43967db412 100644 --- a/lib/rubygems/old_format.rb +++ b/lib/rubygems/old_format.rb @@ -4,145 +4,149 @@ # See LICENSE.txt for permissions. #++ +require 'rubygems' require 'fileutils' require 'yaml' require 'zlib' -module Gem +## +# The format class knows the guts of the RubyGem .gem file format and provides +# the capability to read gem files + +class Gem::OldFormat + + attr_accessor :spec, :file_entries, :gem_path ## - # The format class knows the guts of the RubyGem .gem file format - # and provides the capability to read gem files + # Constructs an instance of a Format object, representing the gem's data + # structure. # - class OldFormat - attr_accessor :spec, :file_entries, :gem_path - - ## - # Constructs an instance of a Format object, representing the gem's - # data structure. - # - # gem:: [String] The file name of the gem - # - def initialize(gem_path) - @gem_path = gem_path - end + # gem:: [String] The file name of the gem - ## - # Reads the named gem file and returns a Format object, representing - # the data from the gem file - # - # file_path:: [String] Path to the gem file - # - def self.from_file_by_path(file_path) - unless File.exist?(file_path) - raise Gem::Exception, "Cannot load gem file [#{file_path}]" - end - File.open(file_path, 'rb') do |file| - from_io(file, file_path) - end + def initialize(gem_path) + @gem_path = gem_path + end + + ## + # Reads the named gem file and returns a Format object, representing the + # data from the gem file + # + # file_path:: [String] Path to the gem file + + def self.from_file_by_path(file_path) + unless File.exist?(file_path) + raise Gem::Exception, "Cannot load gem file [#{file_path}]" end - ## - # Reads a gem from an io stream and returns a Format object, representing - # the data from the gem file - # - # io:: [IO] Stream from which to read the gem - # - def self.from_io(io, gem_path="(io)") - format = self.new(gem_path) - skip_ruby(io) - format.spec = read_spec(io) - format.file_entries = [] - read_files_from_gem(io) do |entry, file_data| - format.file_entries << [entry, file_data] - end - format + File.open(file_path, 'rb') do |file| + from_io(file, file_path) end + end - private - ## - # Skips the Ruby self-install header. After calling this method, the - # IO index will be set after the Ruby code. - # - # file:: [IO] The IO to process (skip the Ruby code) - # - def self.skip_ruby(file) - end_seen = false - loop { - line = file.gets - if(line == nil || line.chomp == "__END__") then - end_seen = true - break - end - } - if(end_seen == false) then - raise Gem::Exception.new("Failed to find end of ruby script while reading gem") - end + ## + # Reads a gem from an io stream and returns a Format object, representing + # the data from the gem file + # + # io:: [IO] Stream from which to read the gem + + def self.from_io(io, gem_path="(io)") + format = self.new(gem_path) + skip_ruby(io) + format.spec = read_spec(io) + format.file_entries = [] + read_files_from_gem(io) do |entry, file_data| + format.file_entries << [entry, file_data] end + format + end - ## - # Reads the specification YAML from the supplied IO and constructs - # a Gem::Specification from it. After calling this method, the - # IO index will be set after the specification header. - # - # file:: [IO] The IO to process - # - def self.read_spec(file) - yaml = '' - begin - read_until_dashes(file) do |line| - yaml << line - end - Specification.from_yaml(yaml) - rescue YAML::Error => e - raise Gem::Exception.new("Failed to parse gem specification out of gem file") - rescue ArgumentError => e - raise Gem::Exception.new("Failed to parse gem specification out of gem file") + private + + ## + # Skips the Ruby self-install header. After calling this method, the + # IO index will be set after the Ruby code. + # + # file:: [IO] The IO to process (skip the Ruby code) + + def self.skip_ruby(file) + end_seen = false + loop { + line = file.gets + if(line == nil || line.chomp == "__END__") then + end_seen = true + break end + } + + if end_seen == false then + raise Gem::Exception.new("Failed to find end of ruby script while reading gem") end + end - ## - # Reads lines from the supplied IO until a end-of-yaml (---) is - # reached - # - # file:: [IO] The IO to process - # block:: [String] The read line - # - def self.read_until_dashes(file) - while((line = file.gets) && line.chomp.strip != "---") do - yield line - end + ## + # Reads the specification YAML from the supplied IO and constructs + # a Gem::Specification from it. After calling this method, the + # IO index will be set after the specification header. + # + # file:: [IO] The IO to process + + def self.read_spec(file) + yaml = '' + + read_until_dashes file do |line| + yaml << line + end + + Gem::Specification.from_yaml yaml + rescue YAML::Error => e + raise Gem::Exception, "Failed to parse gem specification out of gem file" + rescue ArgumentError => e + raise Gem::Exception, "Failed to parse gem specification out of gem file" + end + + ## + # Reads lines from the supplied IO until a end-of-yaml (---) is + # reached + # + # file:: [IO] The IO to process + # block:: [String] The read line + + def self.read_until_dashes(file) + while((line = file.gets) && line.chomp.strip != "---") do + yield line end + end + ## + # Reads the embedded file data from a gem file, yielding an entry + # containing metadata about the file and the file contents themselves + # for each file that's archived in the gem. + # NOTE: Many of these methods should be extracted into some kind of + # Gem file read/writer + # + # gem_file:: [IO] The IO to process - ## - # Reads the embedded file data from a gem file, yielding an entry - # containing metadata about the file and the file contents themselves - # for each file that's archived in the gem. - # NOTE: Many of these methods should be extracted into some kind of - # Gem file read/writer - # - # gem_file:: [IO] The IO to process - # - def self.read_files_from_gem(gem_file) - errstr = "Error reading files from gem" - header_yaml = '' - begin + def self.read_files_from_gem(gem_file) + errstr = "Error reading files from gem" + header_yaml = '' + begin + self.read_until_dashes(gem_file) do |line| + header_yaml << line + end + header = YAML.load(header_yaml) + raise Gem::Exception, errstr unless header + + header.each do |entry| + file_data = '' self.read_until_dashes(gem_file) do |line| - header_yaml << line - end - header = YAML.load(header_yaml) - raise Gem::Exception.new(errstr) unless header - header.each do |entry| - file_data = '' - self.read_until_dashes(gem_file) do |line| - file_data << line - end - yield [entry, Zlib::Inflate.inflate(file_data.strip.unpack("m")[0])] + file_data << line end - rescue Exception,Zlib::DataError => e - raise Gem::Exception.new(errstr) + yield [entry, Zlib::Inflate.inflate(file_data.strip.unpack("m")[0])] end + rescue Zlib::DataError => e + raise Gem::Exception, errstr end end + end + diff --git a/lib/rubygems/package/f_sync_dir.rb b/lib/rubygems/package/f_sync_dir.rb index 3e2e4a59a8..1915ab3ecb 100644 --- a/lib/rubygems/package/f_sync_dir.rb +++ b/lib/rubygems/package/f_sync_dir.rb @@ -3,8 +3,6 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' - module Gem::Package::FSyncDir private diff --git a/lib/rubygems/package/tar_header.rb b/lib/rubygems/package/tar_header.rb index fa78126a0d..44c6695cf9 100644 --- a/lib/rubygems/package/tar_header.rb +++ b/lib/rubygems/package/tar_header.rb @@ -3,8 +3,6 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' - ## #-- # struct tarfile_entry_posix { @@ -26,9 +24,13 @@ require 'rubygems/package' # char prefix[155]; # ASCII + (Z unless filled) # }; #++ +# A header for a tar file class Gem::Package::TarHeader + ## + # Fields in the tar header + FIELDS = [ :checksum, :devmajor, @@ -48,6 +50,9 @@ class Gem::Package::TarHeader :version, ] + ## + # Pack format for a tar header + PACK_FORMAT = 'a100' + # name 'a8' + # mode 'a8' + # uid @@ -65,6 +70,9 @@ class Gem::Package::TarHeader 'a8' + # devminor 'a155' # prefix + ## + # Unpack format for a tar header + UNPACK_FORMAT = 'A100' + # name 'A8' + # mode 'A8' + # uid @@ -84,6 +92,9 @@ class Gem::Package::TarHeader attr_reader(*FIELDS) + ## + # Creates a tar header from IO +stream+ + def self.from(stream) header = stream.read 512 empty = (header == "\0" * 512) @@ -147,6 +158,9 @@ class Gem::Package::TarHeader # :empty => empty end + ## + # Creates a new TarHeader using +vals+ + def initialize(vals) unless vals[:name] && vals[:size] && vals[:prefix] && vals[:mode] then raise ArgumentError, ":name, :size, :prefix and :mode required" @@ -171,11 +185,14 @@ class Gem::Package::TarHeader @empty = vals[:empty] end + ## + # Is the tar entry empty? + def empty? @empty end - def ==(other) + def ==(other) # :nodoc: self.class === other and @checksum == other.checksum and @devmajor == other.devmajor and @@ -195,11 +212,14 @@ class Gem::Package::TarHeader @version == other.version end - def to_s + def to_s # :nodoc: update_checksum header end + ## + # Updates the TarHeader's checksum + def update_checksum header = header " " * 8 @checksum = oct calculate_checksum(header), 6 diff --git a/lib/rubygems/package/tar_input.rb b/lib/rubygems/package/tar_input.rb index 2ed3d6b772..9f901023b8 100644 --- a/lib/rubygems/package/tar_input.rb +++ b/lib/rubygems/package/tar_input.rb @@ -3,8 +3,6 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' - class Gem::Package::TarInput include Gem::Package::FSyncDir @@ -72,9 +70,9 @@ class Gem::Package::TarInput # map trust policy from string to actual class (or a serialized YAML # file, if that exists) if String === security_policy then - if Gem::Security::Policy.key? security_policy then + if Gem::Security::Policies.key? security_policy then # load one of the pre-defined security policies - security_policy = Gem::Security::Policy[security_policy] + security_policy = Gem::Security::Policies[security_policy] elsif File.exist? security_policy then # FIXME: this doesn't work yet security_policy = YAML.load File.read(security_policy) @@ -136,10 +134,10 @@ class Gem::Package::TarInput def extract_entry(destdir, entry, expected_md5sum = nil) if entry.directory? then - dest = File.join(destdir, entry.full_name) + dest = File.join destdir, entry.full_name - if File.dir? dest then - @fileops.chmod entry.header.mode, dest, :verbose=>false + if File.directory? dest then + @fileops.chmod entry.header.mode, dest, :verbose => false else @fileops.mkdir_p dest, :mode => entry.header.mode, :verbose => false end diff --git a/lib/rubygems/package/tar_output.rb b/lib/rubygems/package/tar_output.rb index b22f7dd86b..dfb74af9fc 100644 --- a/lib/rubygems/package/tar_output.rb +++ b/lib/rubygems/package/tar_output.rb @@ -3,8 +3,6 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' - ## # TarOutput is a wrapper to TarWriter that builds gem-format tar file. # @@ -66,8 +64,10 @@ class Gem::Package::TarOutput Zlib::GzipWriter.wrap(sio || inner) do |os| Gem::Package::TarWriter.new os do |data_tar_writer| + # :stopdoc: def data_tar_writer.metadata() @metadata end def data_tar_writer.metadata=(metadata) @metadata = metadata end + # :startdoc: yield data_tar_writer diff --git a/lib/rubygems/package/tar_reader.rb b/lib/rubygems/package/tar_reader.rb index 4aa9c26cc9..1a2fbaf678 100644 --- a/lib/rubygems/package/tar_reader.rb +++ b/lib/rubygems/package/tar_reader.rb @@ -3,14 +3,21 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' +## +# TarReader reads tar files and allows iteration over their items class Gem::Package::TarReader include Gem::Package + ## + # Raised if the tar IO is not seekable + class UnexpectedEOF < StandardError; end + ## + # Creates a new TarReader on +io+ and yields it to the block, if given. + def self.new(io) reader = super @@ -25,14 +32,24 @@ class Gem::Package::TarReader nil end + ## + # Creates a new tar file reader on +io+ which needs to respond to #pos, + # #eof?, #read, #getc and #pos= + def initialize(io) @io = io @init_pos = io.pos end + ## + # Close the tar file + def close end + ## + # Iterates over files in the tarball yielding each entry + def each loop do return if @io.eof? @@ -84,3 +101,5 @@ class Gem::Package::TarReader end +require 'rubygems/package/tar_reader/entry' + diff --git a/lib/rubygems/package/tar_reader/entry.rb b/lib/rubygems/package/tar_reader/entry.rb index dcc66153d8..eeb70bf000 100644 --- a/lib/rubygems/package/tar_reader/entry.rb +++ b/lib/rubygems/package/tar_reader/entry.rb @@ -3,12 +3,19 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' +## +# Class for reading entries out of a tar file class Gem::Package::TarReader::Entry + ## + # Header for this tar entry + attr_reader :header + ## + # Creates a new tar entry for +header+ that will be read from +io+ + def initialize(header, io) @closed = false @header = header @@ -21,24 +28,39 @@ class Gem::Package::TarReader::Entry raise IOError, "closed #{self.class}" if closed? end + ## + # Number of bytes read out of the tar entry + def bytes_read @read end + ## + # Closes the tar entry + def close @closed = true end + ## + # Is the tar entry closed? + def closed? @closed end + ## + # Are we at the end of the tar entry? + def eof? check_closed @read >= @header.size end + ## + # Full name of the tar entry + def full_name if @header.prefix != "" then File.join @header.prefix, @header.name @@ -47,6 +69,9 @@ class Gem::Package::TarReader::Entry end end + ## + # Read one byte from the tar entry + def getc check_closed @@ -58,20 +83,33 @@ class Gem::Package::TarReader::Entry ret end + ## + # Is this tar entry a directory? + def directory? @header.typeflag == "5" end + ## + # Is this tar entry a file? + def file? @header.typeflag == "0" end + ## + # The position in the tar entry + def pos check_closed bytes_read end + ## + # Reads +len+ bytes from the tar file entry, or the rest of the entry if + # nil + def read(len = nil) check_closed @@ -86,6 +124,9 @@ class Gem::Package::TarReader::Entry ret end + ## + # Rewinds to the beginning of the tar file entry + def rewind check_closed diff --git a/lib/rubygems/package/tar_writer.rb b/lib/rubygems/package/tar_writer.rb index 04a15c7779..6f11529302 100644 --- a/lib/rubygems/package/tar_writer.rb +++ b/lib/rubygems/package/tar_writer.rb @@ -3,15 +3,30 @@ # See LICENSE.txt for additional licensing information. #-- -require 'rubygems/package' +## +# Allows writing of tar files class Gem::Package::TarWriter class FileOverflow < StandardError; end + ## + # IO wrapper that allows writing a limited amount of data + class BoundedStream - attr_reader :limit, :written + ## + # Maximum number of bytes that can be written + + attr_reader :limit + + ## + # Number of bytes written + + attr_reader :written + + ## + # Wraps +io+ and allows up to +limit+ bytes to be written def initialize(io, limit) @io = io @@ -19,6 +34,10 @@ class Gem::Package::TarWriter @written = 0 end + ## + # Writes +data+ onto the IO, raising a FileOverflow exception if the + # number of bytes will be more than #limit + def write(data) if data.size + @written > @limit raise FileOverflow, "You tried to feed more data than fits in the file." @@ -30,18 +49,30 @@ class Gem::Package::TarWriter end + ## + # IO wrapper that provides only #write + class RestrictedStream + ## + # Creates a new RestrictedStream wrapping +io+ + def initialize(io) @io = io end + ## + # Writes +data+ onto the IO + def write(data) @io.write data end end + ## + # Creates a new TarWriter, yielding it if a block is given + def self.new(io) writer = super @@ -56,12 +87,19 @@ class Gem::Package::TarWriter nil end + ## + # Creates a new TarWriter that will write to +io+ + def initialize(io) @io = io @closed = false end - def add_file(name, mode) + ## + # Adds file +name+ with permissions +mode+, and yields an IO for writing the + # file to + + def add_file(name, mode) # :yields: io check_closed raise Gem::Package::NonSeekableIO unless @io.respond_to? :pos= @@ -90,7 +128,11 @@ class Gem::Package::TarWriter self end - def add_file_simple(name, mode, size) + ## + # Add file +name+ with permissions +mode+ +size+ bytes long. Yields an IO + # to write the file to. + + def add_file_simple(name, mode, size) # :yields: io check_closed name, prefix = split_name name @@ -112,10 +154,16 @@ class Gem::Package::TarWriter self end + ## + # Raises IOError if the TarWriter is closed + def check_closed raise IOError, "closed #{self.class}" if closed? end + ## + # Closes the TarWriter + def close check_closed @@ -125,16 +173,25 @@ class Gem::Package::TarWriter @closed = true end + ## + # Is the TarWriter closed? + def closed? @closed end + ## + # Flushes the TarWriter's IO + def flush check_closed @io.flush if @io.respond_to? :flush end + ## + # Creates a new directory in the tar file +name+ with +mode+ + def mkdir(name, mode) check_closed @@ -149,6 +206,9 @@ class Gem::Package::TarWriter self end + ## + # Splits +name+ into a name and prefix that can fit in the TarHeader + def split_name(name) # :nodoc: raise Gem::Package::TooLongFileName if name.size > 256 @@ -169,7 +229,7 @@ class Gem::Package::TarWriter name = newname if name.size > 100 or prefix.size > 155 then - raise Gem::Package::TooLongFileName + raise Gem::Package::TooLongFileName end end diff --git a/lib/rubygems/package_task.rb b/lib/rubygems/package_task.rb new file mode 100644 index 0000000000..d7f83276f8 --- /dev/null +++ b/lib/rubygems/package_task.rb @@ -0,0 +1,118 @@ +# Copyright (c) 2003, 2004 Jim Weirich, 2009 Eric Hodel +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +require 'rubygems' +begin + gem 'rake' +rescue Gem::LoadError +end + +require 'rake/packagetask' + +## +# Create a package based upon a Gem::Specification. Gem packages, as well as +# zip files and tar/gzipped packages can be produced by this task. +# +# In addition to the Rake targets generated by Rake::PackageTask, a +# Gem::PackageTask will also generate the following tasks: +# +# [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.gem"</b>] +# Create a RubyGems package with the given name and version. +# +# Example using a Gem::Specification: +# +# require 'rubygems' +# require 'rubygems/package_task' +# +# spec = Gem::Specification.new do |s| +# s.platform = Gem::Platform::RUBY +# s.summary = "Ruby based make-like utility." +# s.name = 'rake' +# s.version = PKG_VERSION +# s.requirements << 'none' +# s.require_path = 'lib' +# s.autorequire = 'rake' +# s.files = PKG_FILES +# s.description = <<-EOF +# Rake is a Make-like program implemented in Ruby. Tasks +# and dependencies are specified in standard Ruby syntax. +# EOF +# end +# +# Gem::PackageTask.new(spec) do |pkg| +# pkg.need_zip = true +# pkg.need_tar = true +# end + +class Gem::PackageTask < Rake::PackageTask + + ## + # Ruby Gem::Specification containing the metadata for this package. The + # name, version and package_files are automatically determined from the + # gemspec and don't need to be explicitly provided. + + attr_accessor :gem_spec + + ## + # Create a Gem Package task library. Automatically define the gem if a + # block is given. If no block is supplied, then #define needs to be called + # to define the task. + + def initialize(gem_spec) + init gem_spec + yield self if block_given? + define if block_given? + end + + ## + # Initialization tasks without the "yield self" or define operations. + + def init(gem) + super gem.name, gem.version + @gem_spec = gem + @package_files += gem_spec.files if gem_spec.files + end + + ## + # Create the Rake tasks and actions specified by this Gem::PackageTask. + # (+define+ is automatically called if a block is given to +new+). + + def define + super + task :package => [:gem] + desc "Build the gem file #{gem_file}" + task :gem => ["#{package_dir}/#{gem_file}"] + file "#{package_dir}/#{gem_file}" => [package_dir] + @gem_spec.files do + when_writing("Creating #{gem_spec.full_name}.gem") { + Gem::Builder.new(gem_spec).build + verbose(true) { + mv gem_file, "#{package_dir}/#{gem_file}" + } + } + end + end + + def gem_file + "#{@gem_spec.full_name}.gem" + end + +end + diff --git a/lib/rubygems/platform.rb b/lib/rubygems/platform.rb index 3e5b5cde66..bfa8fca0ff 100644 --- a/lib/rubygems/platform.rb +++ b/lib/rubygems/platform.rb @@ -1,5 +1,3 @@ -require 'rubygems' - ## # Available list of platforms for targeting Gem installations. @@ -105,6 +103,10 @@ class Gem::Platform def to_s to_a.compact.join '-' end + + def empty? + to_s.empty? + end ## # Is +other+ equal to this platform? Two platforms are equal if they have @@ -143,14 +145,14 @@ class Gem::Platform when String then # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007 other = case other - when /^i686-darwin(\d)/ then ['x86', 'darwin', $1] - when /^i\d86-linux/ then ['x86', 'linux', nil] - when 'java', 'jruby' then [nil, 'java', nil] - when /mswin32(\_(\d+))?/ then ['x86', 'mswin32', $2] - when 'powerpc-darwin' then ['powerpc', 'darwin', nil] - when /powerpc-darwin(\d)/ then ['powerpc', 'darwin', $1] - when /sparc-solaris2.8/ then ['sparc', 'solaris', '2.8'] - when /universal-darwin(\d)/ then ['universal', 'darwin', $1] + when /^i686-darwin(\d)/ then ['x86', 'darwin', $1 ] + when /^i\d86-linux/ then ['x86', 'linux', nil ] + when 'java', 'jruby' then [nil, 'java', nil ] + when /mswin32(\_(\d+))?/ then ['x86', 'mswin32', $2 ] + when 'powerpc-darwin' then ['powerpc', 'darwin', nil ] + when /powerpc-darwin(\d)/ then ['powerpc', 'darwin', $1 ] + when /sparc-solaris2.8/ then ['sparc', 'solaris', '2.8' ] + when /universal-darwin(\d)/ then ['universal', 'darwin', $1 ] else other end diff --git a/lib/rubygems/remote_fetcher.rb b/lib/rubygems/remote_fetcher.rb index 1570740163..945523e5b0 100644 --- a/lib/rubygems/remote_fetcher.rb +++ b/lib/rubygems/remote_fetcher.rb @@ -55,7 +55,7 @@ class Gem::RemoteFetcher # HTTP_PROXY_PASS) # * <tt>:no_proxy</tt>: ignore environment variables and _don't_ use a proxy - def initialize(proxy) + def initialize(proxy = nil) Socket.do_not_reverse_lookup = true @connections = {} @@ -86,7 +86,11 @@ class Gem::RemoteFetcher FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir - source_uri = URI.parse source_uri unless URI::Generic === source_uri + # Always escape URI's to deal with potential spaces and such + unless URI::Generic === source_uri + source_uri = URI.parse(URI.escape(source_uri)) + end + scheme = source_uri.scheme # URI.parse gets confused by MS Windows paths with forward slashes. @@ -101,7 +105,7 @@ class Gem::RemoteFetcher remote_gem_path = source_uri + "gems/#{gem_file_name}" - gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path + gem = self.fetch_path remote_gem_path rescue Gem::RemoteFetcher::FetchError raise if spec.original_platform == spec.platform @@ -112,16 +116,34 @@ class Gem::RemoteFetcher remote_gem_path = source_uri + "gems/#{alternate_name}" - gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path + gem = self.fetch_path remote_gem_path end File.open local_gem_path, 'wb' do |fp| fp.write gem end end - when nil, 'file' then # TODO test for local overriding cache + when 'file' then + begin + path = source_uri.path + path = File.dirname(path) if File.extname(path) == '.gem' + + remote_gem_path = File.join(path, 'gems', gem_file_name) + + FileUtils.cp(remote_gem_path, local_gem_path) + rescue Errno::EACCES + local_gem_path = source_uri.to_s + end + + say "Using local gem #{local_gem_path}" if + Gem.configuration.really_verbose + when nil then # TODO test for local overriding cache begin - FileUtils.cp source_uri.to_s, local_gem_path + if Gem.win_platform? && source_uri.scheme && !source_uri.path.include?(':') + FileUtils.cp URI.unescape(source_uri.scheme + ':' + source_uri.path), local_gem_path + else + FileUtils.cp URI.unescape(source_uri.path), local_gem_path + end rescue Errno::EACCES local_gem_path = source_uri.to_s end @@ -177,7 +199,7 @@ class Gem::RemoteFetcher return nil if env_proxy.nil? or env_proxy.empty? - uri = URI.parse env_proxy + uri = URI.parse(normalize_uri(env_proxy)) if uri and uri.user.nil? and uri.password.nil? then # Probably we have http_proxy_* variables? @@ -233,10 +255,25 @@ class Gem::RemoteFetcher def open_uri_or_path(uri, last_modified = nil, head = false, depth = 0) raise "block is dead" if block_given? - return open(get_file_uri_path(uri)) if file_uri? uri - uri = URI.parse uri unless URI::Generic === uri - raise ArgumentError, 'uri is not an HTTP URI' unless URI::HTTP === uri + + # This check is redundant unless Gem::RemoteFetcher is likely + # to be used directly, since the scheme is checked elsewhere. + # - Daniel Berger + unless ['http', 'https', 'file'].include?(uri.scheme) + raise ArgumentError, 'uri scheme is invalid' + end + + if uri.scheme == 'file' + path = uri.path + + # Deal with leading slash on Windows paths + if path[0].chr == '/' && path[1].chr =~ /[a-zA-Z]/ && path[2].chr == ':' + path = path[1..-1] + end + + return Gem.read_binary(path) + end fetch_type = head ? Net::HTTP::Head : Net::HTTP::Get response = request uri, fetch_type, last_modified @@ -326,19 +363,5 @@ class Gem::RemoteFetcher connection.start end - ## - # Checks if the provided string is a file:// URI. - - def file_uri?(uri) - uri =~ %r{\Afile://} - end - - ## - # Given a file:// URI, returns its local path. - - def get_file_uri_path(uri) - uri.sub(%r{\Afile://}, '') - end - end diff --git a/lib/rubygems/require_paths_builder.rb b/lib/rubygems/require_paths_builder.rb index fe4f593bf4..a77818603b 100644 --- a/lib/rubygems/require_paths_builder.rb +++ b/lib/rubygems/require_paths_builder.rb @@ -1,15 +1,17 @@ -module Gem - module RequirePathsBuilder - def write_require_paths_file_if_needed(spec = @spec, gem_home = @gem_home) - return if spec.require_paths == ["lib"] && (spec.bindir.nil? || spec.bindir == "bin") - file_name = File.join(gem_home, 'gems', "#{@spec.full_name}", ".require_paths") - file_name.untaint - File.open(file_name, "w") do |file| - spec.require_paths.each do |path| - file.puts path - end - file.puts spec.bindir if spec.bindir +require 'rubygems' + +module Gem::RequirePathsBuilder + def write_require_paths_file_if_needed(spec = @spec, gem_home = @gem_home) + return if spec.require_paths == ["lib"] && + (spec.bindir.nil? || spec.bindir == "bin") + file_name = File.join(gem_home, 'gems', "#{@spec.full_name}", ".require_paths") + file_name.untaint + File.open(file_name, "w") do |file| + spec.require_paths.each do |path| + file.puts path end + file.puts spec.bindir if spec.bindir end end -end
\ No newline at end of file +end + diff --git a/lib/rubygems/requirement.rb b/lib/rubygems/requirement.rb index c9128b5ebc..471d84eb61 100644 --- a/lib/rubygems/requirement.rb +++ b/lib/rubygems/requirement.rb @@ -4,8 +4,6 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems/version' - ## # Requirement version includes a prefaced comparator in addition # to a version number. @@ -26,10 +24,10 @@ class Gem::Requirement "<" => lambda { |v, r| v < r }, ">=" => lambda { |v, r| v >= r }, "<=" => lambda { |v, r| v <= r }, - "~>" => lambda { |v, r| v >= r && v < r.bump } + "~>" => lambda { |v, r| v = v.release; v >= r && v < r.bump } } - OP_RE = /#{OPS.keys.map{ |k| Regexp.quote k }.join '|'}/o + OP_RE = OPS.keys.map{ |k| Regexp.quote k }.join '|' ## # Factory method to create a Gem::Requirement object. Input may be a @@ -65,7 +63,7 @@ class Gem::Requirement ## # Constructs a Requirement from +requirements+ which can be a String, a - # Gem::Version, or an Array of those. See parse for details on the + # Gem::Version, or an Array of those. See #parse for details on the # formatting of requirement strings. def initialize(requirements) @@ -99,11 +97,15 @@ class Gem::Requirement as_list.join(", ") end + def pretty_print(q) # :nodoc: + q.group 1, 'Gem::Requirement.new(', ')' do + q.pp as_list + end + end + def as_list normalize - @requirements.collect { |req| - "#{req[0]} #{req[1]}" - } + @requirements.map do |op, version| "#{op} #{version}" end end def normalize @@ -129,18 +131,23 @@ class Gem::Requirement OPS[op].call(version, required_version) end + def prerelease? + # TODO: why is @requirements a nested array? + @requirements.any?{ |r| r[1].prerelease? } + end + ## # Parse the version requirement obj returning the operator and version. # # The requirement can be a String or a Gem::Version. A String can be an - # operator (<, <=, =, =>, >, !=, ~>), a version number, or both, operator + # operator (<, <=, =, >=, >, !=, ~>), a version number, or both, operator # first. def parse(obj) case obj - when /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/o then + when /^\s*(#{OP_RE})\s*(#{Gem::Version::VERSION_PATTERN})\s*$/o then [$1, Gem::Version.new($2)] - when /^\s*([0-9.]+)\s*$/ then + when /^\s*(#{Gem::Version::VERSION_PATTERN})\s*$/o then ['=', Gem::Version.new($1)] when /^\s*(#{OP_RE})\s*$/o then [$1, Gem::Version.new('0')] diff --git a/lib/rubygems/rubygems_version.rb b/lib/rubygems/rubygems_version.rb index d7b5622d97..eda0a0e906 100644 --- a/lib/rubygems/rubygems_version.rb +++ b/lib/rubygems/rubygems_version.rb @@ -1,6 +1,19 @@ +#-- # DO NOT EDIT # This file is auto-generated by build scripts. # See: rake update_version +#++ + module Gem - RubyGemsVersion = '1.3.1' + + ## + # The version of RubyGems you are using + + RubyGemsVersion = '1.3.4' + + ## + # The version of RubyGems you are using (duplicated for familiarity) + + VERSION = RubyGemsVersion + end diff --git a/lib/rubygems/security.rb b/lib/rubygems/security.rb index 5cd3fb756f..abf3cf4a6a 100644 --- a/lib/rubygems/security.rb +++ b/lib/rubygems/security.rb @@ -218,7 +218,7 @@ require 'rubygems/gem_openssl' # # # signing key (still kept in an undisclosed location!) # s.signing_key = '/mnt/floppy/alf-private_key.pem' -# +# # # certificate chain (includes the issuer certificate now too) # s.cert_chain = ['/home/alf/doc/seattlerb-public_cert.pem', # '/home/alf/doc/alf_at_seattle-public_cert.pem'] @@ -274,7 +274,7 @@ require 'rubygems/gem_openssl' # # convert a PEM format X509 certificate into DER format: # # (note: Windows .cer files are X509 certificates in DER format) # $ openssl x509 -in input.pem -outform der -out output.der -# +# # # print out the certificate in a human-readable format: # $ openssl x509 -in input.pem -noout -text # @@ -282,7 +282,7 @@ require 'rubygems/gem_openssl' # # # convert a PEM format RSA key into DER format: # $ openssl rsa -in input_key.pem -outform der -out output_key.der -# +# # # print out the key in a human readable format: # $ openssl rsa -in input_key.pem -noout -text # diff --git a/lib/rubygems/server.rb b/lib/rubygems/server.rb index 2c617ff144..44bee74abf 100644 --- a/lib/rubygems/server.rb +++ b/lib/rubygems/server.rb @@ -17,6 +17,7 @@ require 'rubygems/doc_manager' # name/version/platform index # * "/quick/" - Individual gemspecs # * "/gems" - Direct access to download the installable gems +# * "/rdoc?q=" - Search for installed rdoc documentation # * legacy indexes: # * "/Marshal.#{Gem.marshal_version}" - Full SourceIndex dump of metadata # for installed gems @@ -32,9 +33,20 @@ require 'rubygems/doc_manager' class Gem::Server + include ERB::Util include Gem::UserInteraction - DOC_TEMPLATE = <<-'WEBPAGE' + SEARCH = <<-SEARCH + <form class="headerSearch" name="headerSearchForm" method="get" action="/rdoc"> + <div id="search" style="float:right"> + <span>Filter/Search</span> + <input id="q" type="text" style="width:10em" name="q"/> + <button type="submit" style="display:none" /> + </div> + </form> + SEARCH + + DOC_TEMPLATE = <<-'DOC_TEMPLATE' <?xml version="1.0" encoding="iso-8859-1"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" @@ -47,6 +59,7 @@ class Gem::Server </head> <body> <div id="fileHeader"> +<%= SEARCH %> <h1>RubyGems Documentation Index</h1> </div> <!-- banner header --> @@ -114,10 +127,10 @@ class Gem::Server </div> </body> </html> - WEBPAGE + DOC_TEMPLATE # CSS is copy & paste from rdoc-style.css, RDoc V1.0.1 - 20041108 - RDOC_CSS = <<-RDOCCSS + RDOC_CSS = <<-RDOC_CSS body { font-family: Verdana,Arial,Helvetica,sans-serif; font-size: 90%; @@ -325,7 +338,92 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; } .ruby-comment { color: #b22222; font-weight: bold; background: transparent; } .ruby-regexp { color: #ffa07a; background: transparent; } .ruby-value { color: #7fffd4; background: transparent; } - RDOCCSS + RDOC_CSS + + RDOC_NO_DOCUMENTATION = <<-'NO_DOC' +<?xml version="1.0" encoding="iso-8859-1"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> + <head> + <title>Found documentation</title> + <link rel="stylesheet" href="gem-server-rdoc-style.css" type="text/css" media="screen" /> + </head> + <body> + <div id="fileHeader"> +<%= SEARCH %> + <h1>No documentation found</h1> + </div> + + <div id="bodyContent"> + <div id="contextContent"> + <div id="description"> + <p>No gems matched <%= h query.inspect %></p> + + <p> + Back to <a href="/">complete gem index</a> + </p> + + </div> + </div> + </div> + <div id="validator-badges"> + <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p> + </div> + </body> +</html> + NO_DOC + + RDOC_SEARCH_TEMPLATE = <<-'RDOC_SEARCH' +<?xml version="1.0" encoding="iso-8859-1"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> + <head> + <title>Found documentation</title> + <link rel="stylesheet" href="gem-server-rdoc-style.css" type="text/css" media="screen" /> + </head> + <body> + <div id="fileHeader"> +<%= SEARCH %> + <h1>Found documentation</h1> + </div> + <!-- banner header --> + + <div id="bodyContent"> + <div id="contextContent"> + <div id="description"> + <h1>Summary</h1> + <p><%=doc_items.length%> documentation topics found.</p> + <h1>Topics</h1> + + <dl> + <% doc_items.each do |doc_item| %> + <dt> + <b><%=doc_item[:name]%></b> + <a href="<%=doc_item[:url]%>">[rdoc]</a> + </dt> + <dd> + <%=doc_item[:summary]%> + <br/> + <br/> + </dd> + <% end %> + </dl> + + <p> + Back to <a href="/">complete gem index</a> + </p> + + </div> + </div> + </div> + <div id="validator-badges"> + <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p> + </div> + </body> +</html> + RDOC_SEARCH def self.run(options) new(options[:gemdir], options[:port], options[:daemon]).run @@ -533,6 +631,90 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; } res.body = result end + ## + # Can be used for quick navigation to the rdoc documentation. You can then + # define a search shortcut for your browser. E.g. in Firefox connect + # 'shortcut:rdoc' to http://localhost:8808/rdoc?q=%s template. Then you can + # directly open the ActionPack documentation by typing 'rdoc actionp'. If + # there are multiple hits for the search term, they are presented as a list + # with links. + # + # Search algorithm aims for an intuitive search: + # 1. first try to find the gems and documentation folders which name + # starts with the search term + # 2. search for entries, that *contain* the search term + # 3. show all the gems + # + # If there is only one search hit, user is immediately redirected to the + # documentation for the particular gem, otherwise a list with results is + # shown. + # + # === Additional trick - install documentation for ruby core + # + # Note: please adjust paths accordingly use for example 'locate yaml.rb' and + # 'gem environment' to identify directories, that are specific for your + # local installation + # + # 1. install ruby sources + # cd /usr/src + # sudo apt-get source ruby + # + # 2. generate documentation + # rdoc -o /usr/lib/ruby/gems/1.8/doc/core/rdoc \ + # /usr/lib/ruby/1.8 ruby1.8-1.8.7.72 + # + # By typing 'rdoc core' you can now access the core documentation + + def rdoc(req, res) + query = req.query['q'] + show_rdoc_for_pattern("#{query}*", res) && return + show_rdoc_for_pattern("*#{query}*", res) && return + + template = ERB.new RDOC_NO_DOCUMENTATION + + res['content-type'] = 'text/html' + res.body = template.result binding + end + + ## + # Returns true and prepares http response, if rdoc for the requested gem + # name pattern was found. + # + # The search is based on the file system content, not on the gems metadata. + # This allows additional documentation folders like 'core' for the ruby core + # documentation - just put it underneath the main doc folder. + + def show_rdoc_for_pattern(pattern, res) + found_gems = Dir.glob("#{@gem_dir}/doc/#{pattern}").select {|path| + File.exist? File.join(path, 'rdoc/index.html') + } + case found_gems.length + when 0 + return false + when 1 + new_path = File.basename(found_gems[0]) + res.status = 302 + res['Location'] = "/doc_root/#{new_path}/rdoc/index.html" + return true + else + doc_items = [] + found_gems.each do |file_name| + base_name = File.basename(file_name) + doc_items << { + :name => base_name, + :url => "/doc_root/#{base_name}/rdoc/index.html", + :summary => '' + } + end + + template = ERB.new(RDOC_SEARCH_TEMPLATE) + res['content-type'] = 'text/html' + result = template.result binding + res.body = result + return true + end + end + def run @server.listen nil, @port @@ -564,6 +746,8 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; } @server.mount_proc "/", method(:root) + @server.mount_proc "/rdoc", method(:rdoc) + paths = { "/gems" => "/cache/", "/doc_root" => "/doc/" } paths.each do |mount_point, mount_dir| @server.mount(mount_point, WEBrick::HTTPServlet::FileHandler, diff --git a/lib/rubygems/source_index.rb b/lib/rubygems/source_index.rb index 57f6c30ae6..c616aefcc0 100644 --- a/lib/rubygems/source_index.rb +++ b/lib/rubygems/source_index.rb @@ -4,12 +4,14 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems' require 'rubygems/user_interaction' require 'rubygems/specification' + +# :stopdoc: module Gem - autoload(:SpecFetcher, 'rubygems/spec_fetcher') + autoload :SpecFetcher, 'rubygems/spec_fetcher' end +# :startdoc: ## # The SourceIndex object indexes all the gems available from a @@ -28,7 +30,7 @@ class Gem::SourceIndex include Gem::UserInteraction - attr_reader :gems # :nodoc: + attr_reader :gems, :prerelease_gems # :nodoc: ## # Directories to use to refresh this SourceIndex when calling refresh! @@ -81,13 +83,15 @@ class Gem::SourceIndex # loaded spec. def load_specification(file_name) - begin - spec_code = if RUBY_VERSION < '1.9' then - File.read file_name - else - File.read file_name, :encoding => 'UTF-8' - end.untaint + return nil unless file_name and File.exist? file_name + spec_code = if RUBY_VERSION < '1.9' then + File.read file_name + else + File.read file_name, :encoding => 'UTF-8' + end.untaint + + begin gemspec = eval spec_code, binding, file_name if gemspec.is_a?(Gem::Specification) @@ -104,24 +108,33 @@ class Gem::SourceIndex alert_warning "#{e.inspect}\n#{spec_code}" alert_warning "Invalid .gemspec format in '#{file_name}'" end + return nil end end ## - # Constructs a source index instance from the provided - # specifications - # - # specifications:: - # [Hash] hash of [Gem name, Gem::Specification] pairs + # Constructs a source index instance from the provided specifications, which + # is a Hash of gem full names and Gem::Specifications. + #-- + # TODO merge @gems and @prerelease_gems and provide a separate method + # #prerelease_gems def initialize(specifications={}) - @gems = specifications + @gems, @prerelease_gems = [{}, {}] + specifications.each{ |full_name, spec| add_spec spec } @spec_dirs = nil end ## + # Both regular and prerelease gems + + def all_gems + @gems.merge @prerelease_gems + end + + ## # Reconstruct the source index from the specifications in +spec_dirs+. def load_gems_in(*spec_dirs) @@ -170,14 +183,29 @@ class Gem::SourceIndex result[name] << spec end + # TODO: why is this a hash while @gems is an array? Seems like + # structural similarity would be good. result.values.flatten end ## + # An array including only the prerelease gemspecs + + def prerelease_specs + @prerelease_gems.values + end + + ## # Add a gem specification to the source index. - def add_spec(gem_spec) - @gems[gem_spec.full_name] = gem_spec + def add_spec(gem_spec, name = gem_spec.full_name) + # No idea why, but the Indexer wants to insert them using original_name + # instead of full_name. So we make it an optional arg. + if gem_spec.version.prerelease? + @prerelease_gems[name] = gem_spec + else + @gems[name] = gem_spec + end end ## @@ -193,7 +221,11 @@ class Gem::SourceIndex # Remove a gem specification named +full_name+. def remove_spec(full_name) - @gems.delete(full_name) + if @gems.key? full_name then + @gems.delete full_name + else + @prerelease_gems.delete full_name + end end ## @@ -215,18 +247,18 @@ class Gem::SourceIndex # change in the index. def index_signature - require 'rubygems/digest/sha2' + require 'digest' - Gem::SHA256.new.hexdigest(@gems.keys.sort.join(',')).to_s + Digest::SHA256.new.hexdigest(@gems.keys.sort.join(',')).to_s end ## # The signature for the given gem specification. def gem_signature(gem_full_name) - require 'rubygems/digest/sha2' + require 'digest' - Gem::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s + Digest::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s end def size @@ -238,7 +270,7 @@ class Gem::SourceIndex # Find a gem by an exact match on the short name. def find_name(gem_name, version_requirement = Gem::Requirement.default) - dep = Gem::Dependency.new(/^#{gem_name}$/, version_requirement) + dep = Gem::Dependency.new gem_name, version_requirement search dep end @@ -257,7 +289,7 @@ class Gem::SourceIndex # TODO - Remove support and warning for legacy arguments after 2008/11 unless Gem::Dependency === gem_pattern - warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated" + warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated, use #find_name" end case gem_pattern @@ -282,7 +314,7 @@ class Gem::SourceIndex version_requirement = Gem::Requirement.create version_requirement end - specs = @gems.values.select do |spec| + specs = all_gems.values.select do |spec| spec.name =~ gem_pattern and version_requirement.satisfied_by? spec.version end @@ -376,7 +408,7 @@ class Gem::SourceIndex end def ==(other) # :nodoc: - self.class === other and @gems == other.gems + self.class === other and @gems == other.gems end def dump @@ -545,15 +577,15 @@ class Gem::SourceIndex end +# :stopdoc: module Gem - # :stopdoc: - + ## # Cache is an alias for SourceIndex to allow older YAMLized source index # objects to load properly. - Cache = SourceIndex - # :startdoc: + Cache = SourceIndex end +# :startdoc: diff --git a/lib/rubygems/source_info_cache.rb b/lib/rubygems/source_info_cache.rb index 4289cdb52a..fdb30ad8d3 100644 --- a/lib/rubygems/source_info_cache.rb +++ b/lib/rubygems/source_info_cache.rb @@ -286,7 +286,7 @@ class Gem::SourceInfoCache next unless Gem.sources.include? source_uri # TODO - Remove this gunk after 2008/11 unless pattern.kind_of?(Gem::Dependency) - pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) + pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) end sic_entry.source_index.search pattern, platform_only end.flatten.compact @@ -306,7 +306,7 @@ class Gem::SourceInfoCache # TODO - Remove this gunk after 2008/11 unless pattern.kind_of?(Gem::Dependency) - pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) + pattern = Gem::Dependency.new(pattern, Gem::Requirement.default) end sic_entry.source_index.search(pattern, only_platform).each do |spec| diff --git a/lib/rubygems/source_info_cache_entry.rb b/lib/rubygems/source_info_cache_entry.rb index c3f75e5b99..d8106b2806 100644 --- a/lib/rubygems/source_info_cache_entry.rb +++ b/lib/rubygems/source_info_cache_entry.rb @@ -13,8 +13,8 @@ class Gem::SourceInfoCacheEntry attr_reader :source_index ## - # The size of the of the source entry. Used to determine if the - # source index has changed. + # The size of the source entry. Used to determine if the source index has + # changed. attr_reader :size diff --git a/lib/rubygems/spec_fetcher.rb b/lib/rubygems/spec_fetcher.rb index a1fc82ed4f..f46c355413 100644 --- a/lib/rubygems/spec_fetcher.rb +++ b/lib/rubygems/spec_fetcher.rb @@ -1,6 +1,6 @@ require 'zlib' +require 'fileutils' -require 'rubygems' require 'rubygems/remote_fetcher' require 'rubygems/user_interaction' @@ -26,6 +26,11 @@ class Gem::SpecFetcher attr_reader :specs # :nodoc: + ## + # Cache of prerelease specs + + attr_reader :prerelease_specs # :nodoc: + @fetcher = nil def self.fetcher @@ -42,6 +47,7 @@ class Gem::SpecFetcher @specs = {} @latest_specs = {} + @prerelease_specs = {} @fetcher = Gem::RemoteFetcher.fetcher end @@ -56,10 +62,10 @@ class Gem::SpecFetcher ## # Fetch specs matching +dependency+. If +all+ is true, all matching # versions are returned. If +matching_platform+ is false, all platforms are - # returned. + # returned. If +prerelease+ is true, prerelease versions are included. - def fetch(dependency, all = false, matching_platform = true) - specs_and_sources = find_matching dependency, all, matching_platform + def fetch(dependency, all = false, matching_platform = true, prerelease = false) + specs_and_sources = find_matching dependency, all, matching_platform, prerelease specs_and_sources.map do |spec_tuple, source_uri| [fetch_spec(spec_tuple, URI.parse(source_uri)), source_uri] @@ -110,10 +116,10 @@ class Gem::SpecFetcher # versions are returned. If +matching_platform+ is false, gems for all # platforms are returned. - def find_matching(dependency, all = false, matching_platform = true) + def find_matching(dependency, all = false, matching_platform = true, prerelease = false) found = {} - list(all).each do |source_uri, specs| + list(all, prerelease).each do |source_uri, specs| found[source_uri] = specs.select do |spec_name, version, spec_platform| dependency =~ Gem::Dependency.new(spec_name, version) and (not matching_platform or Gem::Platform.match(spec_platform)) @@ -155,28 +161,37 @@ class Gem::SpecFetcher ## # Returns a list of gems available for each source in Gem::sources. If - # +all+ is true, all versions are returned instead of only latest versions. + # +all+ is true, all versions are returned instead of only latest + # versions. If +prerelease+ is true, include prerelease versions. + + def list(all = false, prerelease = false) + # TODO: make type the only argument + type = if all + :all + elsif prerelease + :prerelease + else + :latest + end - def list(all = false) list = {} - file = all ? 'specs' : 'latest_specs' + file = { :latest => 'latest_specs', + :prerelease => 'prerelease_specs', + :all => 'specs' }[type] + cache = { :latest => @latest_specs, + :prerelease => @prerelease_specs, + :all => @specs }[type] + Gem.sources.each do |source_uri| source_uri = URI.parse source_uri - if all and @specs.include? source_uri then - list[source_uri] = @specs[source_uri] - elsif not all and @latest_specs.include? source_uri then - list[source_uri] = @latest_specs[source_uri] - else - specs = load_specs source_uri, file - - cache = all ? @specs : @latest_specs - - cache[source_uri] = specs - list[source_uri] = specs + unless cache.include? source_uri + cache[source_uri] = load_specs source_uri, file end + + list[source_uri] = cache[source_uri] end list @@ -206,7 +221,14 @@ class Gem::SpecFetcher loaded = true end - specs = Marshal.load spec_dump + specs = begin + Marshal.load spec_dump + rescue ArgumentError + spec_dump = @fetcher.fetch_path spec_path + loaded = true + + Marshal.load spec_dump + end if loaded and @update_cache then begin diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb index 634b88f1f0..3630b4adf5 100644 --- a/lib/rubygems/specification.rb +++ b/lib/rubygems/specification.rb @@ -4,1260 +4,1440 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems' require 'rubygems/version' require 'rubygems/requirement' require 'rubygems/platform' # :stopdoc: -# Time::today has been deprecated in 0.9.5 and will be removed. -if RUBY_VERSION < '1.9' then - def Time.today - t = Time.now - t - ((t.to_f + t.gmt_offset) % 86400) - end unless defined? Time.today -end - class Date; end # for ruby_code if date.rb wasn't required - # :startdoc: -module Gem +## +# The Specification class contains the metadata for a Gem. Typically +# defined in a .gemspec file or a Rakefile, and looks like this: +# +# spec = Gem::Specification.new do |s| +# s.name = 'rfoo' +# s.version = '1.0' +# s.summary = 'Example gem specification' +# ... +# end +# +# For a great way to package gems, use Hoe. + +class Gem::Specification ## - # == Gem::Specification - # - # The Specification class contains the metadata for a Gem. Typically - # defined in a .gemspec file or a Rakefile, and looks like this: + # Allows deinstallation of gems with legacy platforms. + + attr_accessor :original_platform # :nodoc: + + ## + # The the version number of a specification that does not specify one + # (i.e. RubyGems 0.7 or earlier). + + NONEXISTENT_SPECIFICATION_VERSION = -1 + + ## + # The specification version applied to any new Specification instances + # created. This should be bumped whenever something in the spec format + # changes. + #-- + # When updating this number, be sure to also update #to_ruby. # - # spec = Gem::Specification.new do |s| - # s.name = 'rfoo' - # s.version = '1.0' - # s.summary = 'Example gem specification' - # ... - # end + # NOTE RubyGems < 1.2 cannot load specification versions > 2. + + CURRENT_SPECIFICATION_VERSION = 3 + + ## + # An informal list of changes to the specification. The highest-valued + # key should be equal to the CURRENT_SPECIFICATION_VERSION. + + SPECIFICATION_VERSION_HISTORY = { + -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'], + 1 => [ + 'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"', + '"test_file=x" is a shortcut for "test_files=[x]"' + ], + 2 => [ + 'Added "required_rubygems_version"', + 'Now forward-compatible with future versions', + ], + 3 => [ + 'Added Fixnum validation to the specification_version' + ] + } + + # :stopdoc: + MARSHAL_FIELDS = { -1 => 16, 1 => 16, 2 => 16, 3 => 17 } + + now = Time.at(Time.now.to_i) + TODAY = now - ((now.to_i + now.gmt_offset) % 86400) + # :startdoc: + + ## + # Optional block used to gather newly defined instances. + + @@gather = nil + + ## + # List of attribute names: [:name, :version, ...] + + @@required_attributes = [] + + ## + # List of _all_ attributes and default values: # - # There are many <em>gemspec attributes</em>, and the best place to learn - # about them in the "Gemspec Reference" linked from the RubyGems wiki. - - class Specification - - ## - # Allows deinstallation of gems with legacy platforms. - - attr_accessor :original_platform # :nodoc: - - ## - # The the version number of a specification that does not specify one - # (i.e. RubyGems 0.7 or earlier). - - NONEXISTENT_SPECIFICATION_VERSION = -1 - - ## - # The specification version applied to any new Specification instances - # created. This should be bumped whenever something in the spec format - # changes. - #-- - # When updating this number, be sure to also update #to_ruby. - # - # NOTE RubyGems < 1.2 cannot load specification versions > 2. - - CURRENT_SPECIFICATION_VERSION = 2 - - ## - # An informal list of changes to the specification. The highest-valued - # key should be equal to the CURRENT_SPECIFICATION_VERSION. - - SPECIFICATION_VERSION_HISTORY = { - -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'], - 1 => [ - 'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"', - '"test_file=x" is a shortcut for "test_files=[x]"' - ], - 2 => [ - 'Added "required_rubygems_version"', - 'Now forward-compatible with future versions', - ], - } + # [[:name, nil], + # [:bindir, 'bin'], + # ...] - # :stopdoc: - MARSHAL_FIELDS = { -1 => 16, 1 => 16, 2 => 16 } + @@attributes = [] - now = Time.at(Time.now.to_i) - TODAY = now - ((now.to_i + now.gmt_offset) % 86400) - # :startdoc: + @@nil_attributes = [] + @@non_nil_attributes = [:@original_platform] - ## - # List of Specification instances. + ## + # List of array attributes - @@list = [] + @@array_attributes = [] - ## - # Optional block used to gather newly defined instances. + ## + # Map of attribute names to default values. - @@gather = nil + @@default_value = {} - ## - # List of attribute names: [:name, :version, ...] - @@required_attributes = [] + ## + # Names of all specification attributes - ## - # List of _all_ attributes and default values: - # - # [[:name, nil], - # [:bindir, 'bin'], - # ...] + def self.attribute_names + @@attributes.map { |name, default| name } + end - @@attributes = [] + ## + # Default values for specification attributes - @@nil_attributes = [] - @@non_nil_attributes = [:@original_platform] + def self.attribute_defaults + @@attributes.dup + end - ## - # List of array attributes + ## + # The default value for specification attribute +name+ - @@array_attributes = [] + def self.default_value(name) + @@default_value[name] + end - ## - # Map of attribute names to default values. + ## + # Required specification attributes - @@default_value = {} + def self.required_attributes + @@required_attributes.dup + end - ## - # Names of all specification attributes + ## + # Is +name+ a required attribute? - def self.attribute_names - @@attributes.map { |name, default| name } - end + def self.required_attribute?(name) + @@required_attributes.include? name.to_sym + end - ## - # Default values for specification attributes + ## + # Specification attributes that are arrays (appendable and so-forth) - def self.attribute_defaults - @@attributes.dup - end + def self.array_attributes + @@array_attributes.dup + end - ## - # The default value for specification attribute +name+ + ## + # Specifies the +name+ and +default+ for a specification attribute, and + # creates a reader and writer method like Module#attr_accessor. + # + # The reader method returns the default if the value hasn't been set. - def self.default_value(name) - @@default_value[name] + def self.attribute(name, default=nil) + ivar_name = "@#{name}".intern + if default.nil? then + @@nil_attributes << ivar_name + else + @@non_nil_attributes << [ivar_name, default] end - ## - # Required specification attributes + @@attributes << [name, default] + @@default_value[name] = default + attr_accessor(name) + end + + ## + # Same as :attribute, but ensures that values assigned to the attribute + # are array values by applying :to_a to the value. + + def self.array_attribute(name) + @@non_nil_attributes << ["@#{name}".intern, []] + + @@array_attributes << name + @@attributes << [name, []] + @@default_value[name] = [] + code = %{ + def #{name} + @#{name} ||= [] + end + def #{name}=(value) + @#{name} = Array(value) + end + } - def self.required_attributes - @@required_attributes.dup - end + module_eval code, __FILE__, __LINE__ - 9 + end - ## - # Is +name+ a required attribute? + ## + # Same as attribute above, but also records this attribute as mandatory. - def self.required_attribute?(name) - @@required_attributes.include? name.to_sym - end + def self.required_attribute(*args) + @@required_attributes << args.first + attribute(*args) + end - ## - # Specification attributes that are arrays (appendable and so-forth) + ## + # Sometimes we don't want the world to use a setter method for a + # particular attribute. + # + # +read_only+ makes it private so we can still use it internally. - def self.array_attributes - @@array_attributes.dup + def self.read_only(*names) + names.each do |name| + private "#{name}=" end + end - ## - # A list of Specification instances that have been defined in this Ruby - # instance. + # Shortcut for creating several attributes at once (each with a default + # value of +nil+). - def self.list - @@list + def self.attributes(*args) + args.each do |arg| + attribute(arg, nil) end + end - ## - # Specifies the +name+ and +default+ for a specification attribute, and - # creates a reader and writer method like Module#attr_accessor. - # - # The reader method returns the default if the value hasn't been set. + ## + # Some attributes require special behaviour when they are accessed. This + # allows for that. - def self.attribute(name, default=nil) - ivar_name = "@#{name}".intern - if default.nil? then - @@nil_attributes << ivar_name - else - @@non_nil_attributes << [ivar_name, default] - end + def self.overwrite_accessor(name, &block) + remove_method name + define_method(name, &block) + end - @@attributes << [name, default] - @@default_value[name] = default - attr_accessor(name) - end + ## + # Defines a _singular_ version of an existing _plural_ attribute (i.e. one + # whose value is expected to be an array). This means just creating a + # helper method that takes a single value and appends it to the array. + # These are created for convenience, so that in a spec, one can write + # + # s.require_path = 'mylib' + # + # instead of: + # + # s.require_paths = ['mylib'] + # + # That above convenience is available courtesy of: + # + # attribute_alias_singular :require_path, :require_paths + + def self.attribute_alias_singular(singular, plural) + define_method("#{singular}=") { |val| + send("#{plural}=", [val]) + } + define_method("#{singular}") { + val = send("#{plural}") + val.nil? ? nil : val.first + } + end + + ## + # Dump only crucial instance variables. + #-- + # MAINTAIN ORDER! + + def _dump(limit) + Marshal.dump [ + @rubygems_version, + @specification_version, + @name, + @version, + (Time === @date ? @date : (require 'time'; Time.parse(@date.to_s))), + @summary, + @required_ruby_version, + @required_rubygems_version, + @original_platform, + @dependencies, + @rubyforge_project, + @email, + @authors, + @description, + @homepage, + @has_rdoc, + @new_platform, + @licenses + ] + end - ## - # Same as :attribute, but ensures that values assigned to the attribute - # are array values by applying :to_a to the value. + ## + # Load custom marshal format, re-initializing defaults as needed + + def self._load(str) + array = Marshal.load str + + spec = Gem::Specification.new + spec.instance_variable_set :@specification_version, array[1] + + current_version = CURRENT_SPECIFICATION_VERSION + + field_count = if spec.specification_version > current_version then + spec.instance_variable_set :@specification_version, + current_version + MARSHAL_FIELDS[current_version] + else + MARSHAL_FIELDS[spec.specification_version] + end + + if array.size < field_count then + raise TypeError, "invalid Gem::Specification format #{array.inspect}" + end + + spec.instance_variable_set :@rubygems_version, array[0] + # spec version + spec.instance_variable_set :@name, array[2] + spec.instance_variable_set :@version, array[3] + spec.instance_variable_set :@date, array[4] + spec.instance_variable_set :@summary, array[5] + spec.instance_variable_set :@required_ruby_version, array[6] + spec.instance_variable_set :@required_rubygems_version, array[7] + spec.instance_variable_set :@original_platform, array[8] + spec.instance_variable_set :@dependencies, array[9] + spec.instance_variable_set :@rubyforge_project, array[10] + spec.instance_variable_set :@email, array[11] + spec.instance_variable_set :@authors, array[12] + spec.instance_variable_set :@description, array[13] + spec.instance_variable_set :@homepage, array[14] + spec.instance_variable_set :@has_rdoc, array[15] + spec.instance_variable_set :@new_platform, array[16] + spec.instance_variable_set :@platform, array[16].to_s + spec.instance_variable_set :@license, array[17] + spec.instance_variable_set :@loaded, false + + spec + end - def self.array_attribute(name) - @@non_nil_attributes << ["@#{name}".intern, []] + ## + # List of depedencies that will automatically be activated at runtime. - @@array_attributes << name - @@attributes << [name, []] - @@default_value[name] = [] - code = %{ - def #{name} - @#{name} ||= [] - end - def #{name}=(value) - @#{name} = Array(value) - end - } + def runtime_dependencies + dependencies.select { |d| d.type == :runtime || d.type == nil } + end - module_eval code, __FILE__, __LINE__ - 9 - end + ## + # List of dependencies that are used for development - ## - # Same as attribute above, but also records this attribute as mandatory. + def development_dependencies + dependencies.select { |d| d.type == :development } + end - def self.required_attribute(*args) - @@required_attributes << args.first - attribute(*args) - end + def test_suite_file # :nodoc: + warn 'test_suite_file deprecated, use test_files' + test_files.first + end - ## - # Sometimes we don't want the world to use a setter method for a - # particular attribute. - # - # +read_only+ makes it private so we can still use it internally. + def test_suite_file=(val) # :nodoc: + warn 'test_suite_file= deprecated, use test_files=' + @test_files = [] unless defined? @test_files + @test_files << val + end - def self.read_only(*names) - names.each do |name| - private "#{name}=" - end + ## + # true when this gemspec has been loaded from a specifications directory. + # This attribute is not persisted. + + attr_accessor :loaded + + ## + # Path this gemspec was loaded from. This attribute is not persisted. + + attr_accessor :loaded_from + + ## + # Returns an array with bindir attached to each executable in the + # executables list + + def add_bindir(executables) + return nil if executables.nil? + + if @bindir then + Array(executables).map { |e| File.join(@bindir, e) } + else + executables end + rescue + return nil + end - # Shortcut for creating several attributes at once (each with a default - # value of +nil+). + ## + # Files in the Gem under one of the require_paths - def self.attributes(*args) - args.each do |arg| - attribute(arg, nil) + def lib_files + @files.select do |file| + require_paths.any? do |path| + file.index(path) == 0 end end + end - ## - # Some attributes require special behaviour when they are accessed. This - # allows for that. + ## + # True if this gem was loaded from disk - def self.overwrite_accessor(name, &block) - remove_method name - define_method(name, &block) - end + alias :loaded? :loaded - ## - # Defines a _singular_ version of an existing _plural_ attribute (i.e. one - # whose value is expected to be an array). This means just creating a - # helper method that takes a single value and appends it to the array. - # These are created for convenience, so that in a spec, one can write - # - # s.require_path = 'mylib' - # - # instead of: - # - # s.require_paths = ['mylib'] - # - # That above convenience is available courtesy of: - # - # attribute_alias_singular :require_path, :require_paths - - def self.attribute_alias_singular(singular, plural) - define_method("#{singular}=") { |val| - send("#{plural}=", [val]) - } - define_method("#{singular}") { - val = send("#{plural}") - val.nil? ? nil : val.first - } - end + ## + # True if this gem has files in test_files - ## - # Dump only crucial instance variables. - #-- - # MAINTAIN ORDER! - - def _dump(limit) - Marshal.dump [ - @rubygems_version, - @specification_version, - @name, - @version, - (Time === @date ? @date : (require 'time'; Time.parse(@date.to_s))), - @summary, - @required_ruby_version, - @required_rubygems_version, - @original_platform, - @dependencies, - @rubyforge_project, - @email, - @authors, - @description, - @homepage, - @has_rdoc, - @new_platform, - ] - end + def has_unit_tests? + not test_files.empty? + end - ## - # Load custom marshal format, re-initializing defaults as needed + # :stopdoc: + alias has_test_suite? has_unit_tests? + # :startdoc: - def self._load(str) - array = Marshal.load str + ## + # Specification constructor. Assigns the default values to the attributes + # and yields itself for further initialization. - spec = Gem::Specification.new - spec.instance_variable_set :@specification_version, array[1] + def initialize + @new_platform = nil + assign_defaults + @loaded = false + @loaded_from = nil - current_version = CURRENT_SPECIFICATION_VERSION + yield self if block_given? - field_count = if spec.specification_version > current_version then - spec.instance_variable_set :@specification_version, - current_version - MARSHAL_FIELDS[current_version] - else - MARSHAL_FIELDS[spec.specification_version] - end + @@gather.call(self) if @@gather + end - if array.size < field_count then - raise TypeError, "invalid Gem::Specification format #{array.inspect}" - end + ## + # Duplicates array_attributes from +other_spec+ so state isn't shared. + + def initialize_copy(other_spec) + other_ivars = other_spec.instance_variables + other_ivars = other_ivars.map { |ivar| ivar.intern } if # for 1.9 + other_ivars.any? { |ivar| String === ivar } - spec.instance_variable_set :@rubygems_version, array[0] - # spec version - spec.instance_variable_set :@name, array[2] - spec.instance_variable_set :@version, array[3] - spec.instance_variable_set :@date, array[4] - spec.instance_variable_set :@summary, array[5] - spec.instance_variable_set :@required_ruby_version, array[6] - spec.instance_variable_set :@required_rubygems_version, array[7] - spec.instance_variable_set :@original_platform, array[8] - spec.instance_variable_set :@dependencies, array[9] - spec.instance_variable_set :@rubyforge_project, array[10] - spec.instance_variable_set :@email, array[11] - spec.instance_variable_set :@authors, array[12] - spec.instance_variable_set :@description, array[13] - spec.instance_variable_set :@homepage, array[14] - spec.instance_variable_set :@has_rdoc, array[15] - spec.instance_variable_set :@new_platform, array[16] - spec.instance_variable_set :@platform, array[16].to_s - spec.instance_variable_set :@loaded, false - - spec + self.class.array_attributes.each do |name| + name = :"@#{name}" + next unless other_ivars.include? name + instance_variable_set name, other_spec.instance_variable_get(name).dup end + end - ## - # List of depedencies that will automatically be activated at runtime. + ## + # Each attribute has a default value (possibly nil). Here, we initialize + # all attributes to their default value. This is done through the + # accessor methods, so special behaviours will be honored. Furthermore, + # we take a _copy_ of the default so each specification instance has its + # own empty arrays, etc. - def runtime_dependencies - dependencies.select { |d| d.type == :runtime || d.type == nil } + def assign_defaults + @@nil_attributes.each do |name| + instance_variable_set name, nil end - ## - # List of dependencies that are used for development + @@non_nil_attributes.each do |name, default| + value = case default + when Time, Numeric, Symbol, true, false, nil then default + else default.dup + end - def development_dependencies - dependencies.select { |d| d.type == :development } + instance_variable_set name, value end - def test_suite_file # :nodoc: - warn 'test_suite_file deprecated, use test_files' - test_files.first + # HACK + instance_variable_set :@new_platform, Gem::Platform::RUBY + end + + ## + # Special loader for YAML files. When a Specification object is loaded + # from a YAML file, it bypasses the normal Ruby object initialization + # routine (#initialize). This method makes up for that and deals with + # gems of different ages. + # + # 'input' can be anything that YAML.load() accepts: String or IO. + + def self.from_yaml(input) + input = normalize_yaml_input input + spec = YAML.load input + + if spec && spec.class == FalseClass then + raise Gem::EndOfYAMLException end - def test_suite_file=(val) # :nodoc: - warn 'test_suite_file= deprecated, use test_files=' - @test_files = [] unless defined? @test_files - @test_files << val + unless Gem::Specification === spec then + raise Gem::Exception, "YAML data doesn't evaluate to gem specification" end - ## - # true when this gemspec has been loaded from a specifications directory. - # This attribute is not persisted. + unless (spec.instance_variables.include? '@specification_version' or + spec.instance_variables.include? :@specification_version) and + spec.instance_variable_get :@specification_version + spec.instance_variable_set :@specification_version, + NONEXISTENT_SPECIFICATION_VERSION + end - attr_accessor :loaded + spec + end - ## - # Path this gemspec was loaded from. This attribute is not persisted. + ## + # Loads ruby format gemspec from +filename+ + + def self.load(filename) + gemspec = nil + fail "NESTED Specification.load calls not allowed!" if @@gather + @@gather = proc { |gs| gemspec = gs } + data = File.read(filename) + eval(data) + gemspec + ensure + @@gather = nil + end - attr_accessor :loaded_from + ## + # Make sure the YAML specification is properly formatted with dashes - ## - # Returns an array with bindir attached to each executable in the - # executables list + def self.normalize_yaml_input(input) + result = input.respond_to?(:read) ? input.read : input + result = "--- " + result unless result =~ /^--- / + result + end - def add_bindir(executables) - return nil if executables.nil? + ## + # Sets the rubygems_version to the current RubyGems version - if @bindir then - Array(executables).map { |e| File.join(@bindir, e) } - else - executables - end - rescue - return nil - end + def mark_version + @rubygems_version = Gem::RubyGemsVersion + end - ## - # Files in the Gem under one of the require_paths + ## + # Ignore unknown attributes while loading - def lib_files - @files.select do |file| - require_paths.any? do |path| - file.index(path) == 0 - end - end + def method_missing(sym, *a, &b) # :nodoc: + if @specification_version > CURRENT_SPECIFICATION_VERSION and + sym.to_s =~ /=$/ then + warn "ignoring #{sym} loading #{full_name}" if $DEBUG + else + super end + end - ## - # True if this gem was loaded from disk + ## + # Adds a development dependency named +gem+ with +requirements+ to this + # Gem. For example: + # + # spec.add_development_dependency 'jabber4r', '> 0.1', '<= 0.5' + # + # Development dependencies aren't installed by default and aren't + # activated when a gem is required. - alias :loaded? :loaded + def add_development_dependency(gem, *requirements) + add_dependency_with_type(gem, :development, *requirements) + end - ## - # True if this gem has files in test_files + ## + # Adds a runtime dependency named +gem+ with +requirements+ to this Gem. + # For example: + # + # spec.add_runtime_dependency 'jabber4r', '> 0.1', '<= 0.5' - def has_unit_tests? - not test_files.empty? - end + def add_runtime_dependency(gem, *requirements) + add_dependency_with_type(gem, :runtime, *requirements) + end - alias has_test_suite? has_unit_tests? # :nodoc: deprecated + ## + # Adds a runtime dependency - ## - # Specification constructor. Assigns the default values to the - # attributes, adds this spec to the list of loaded specs (see - # Specification.list), and yields itself for further initialization. + alias add_dependency add_runtime_dependency - def initialize - @new_platform = nil - assign_defaults - @loaded = false - @loaded_from = nil - @@list << self + ## + # Returns the full name (name-version) of this Gem. Platform information + # is included (name-version-platform) if it is specified and not the + # default Ruby platform. + + def full_name + if platform == Gem::Platform::RUBY or platform.nil? then + "#{@name}-#{@version}" + else + "#{@name}-#{@version}-#{platform}" + end + end - yield self if block_given? + ## + # Returns the full name (name-version) of this gemspec using the original + # platform. For use with legacy gems. - @@gather.call(self) if @@gather + def original_name # :nodoc: + if platform == Gem::Platform::RUBY or platform.nil? then + "#{@name}-#{@version}" + else + "#{@name}-#{@version}-#{@original_platform}" end + end - ## - # Each attribute has a default value (possibly nil). Here, we initialize - # all attributes to their default value. This is done through the - # accessor methods, so special behaviours will be honored. Furthermore, - # we take a _copy_ of the default so each specification instance has its - # own empty arrays, etc. + ## + # The full path to the gem (install path + full name). - def assign_defaults - @@nil_attributes.each do |name| - instance_variable_set name, nil - end + def full_gem_path + path = File.join installation_path, 'gems', full_name + return path if File.directory? path + File.join installation_path, 'gems', original_name + end - @@non_nil_attributes.each do |name, default| - value = case default - when Time, Numeric, Symbol, true, false, nil then default - else default.dup - end + ## + # The default (generated) file name of the gem. - instance_variable_set name, value - end + def file_name + full_name + ".gem" + end - # HACK - instance_variable_set :@new_platform, Gem::Platform::RUBY + ## + # The directory that this gem was installed into. + + def installation_path + unless @loaded_from then + raise Gem::Exception, "spec #{full_name} is not from an installed gem" end - ## - # Special loader for YAML files. When a Specification object is loaded - # from a YAML file, it bypasses the normal Ruby object initialization - # routine (#initialize). This method makes up for that and deals with - # gems of different ages. - # - # 'input' can be anything that YAML.load() accepts: String or IO. + File.expand_path File.dirname(File.dirname(@loaded_from)) + end - def self.from_yaml(input) - input = normalize_yaml_input input - spec = YAML.load input + ## + # Checks if this specification meets the requirement of +dependency+. - if spec && spec.class == FalseClass then - raise Gem::EndOfYAMLException - end + def satisfies_requirement?(dependency) + return @name == dependency.name && + dependency.version_requirements.satisfied_by?(@version) + end - unless Gem::Specification === spec then - raise Gem::Exception, "YAML data doesn't evaluate to gem specification" - end + ## + # Returns an object you can use to sort specifications in #sort_by. - unless (spec.instance_variables.include? '@specification_version' or - spec.instance_variables.include? :@specification_version) and - spec.instance_variable_get :@specification_version - spec.instance_variable_set :@specification_version, - NONEXISTENT_SPECIFICATION_VERSION - end + def sort_obj + [@name, @version, @new_platform == Gem::Platform::RUBY ? -1 : 1] + end - spec - end + def <=>(other) # :nodoc: + sort_obj <=> other.sort_obj + end - ## - # Loads ruby format gemspec from +filename+ - - def self.load(filename) - gemspec = nil - fail "NESTED Specification.load calls not allowed!" if @@gather - @@gather = proc { |gs| gemspec = gs } - data = File.read(filename) - eval(data) - gemspec - ensure - @@gather = nil - end + ## + # Tests specs for equality (across all attributes). - ## - # Make sure the YAML specification is properly formatted with dashes + def ==(other) # :nodoc: + self.class === other && same_attributes?(other) + end - def self.normalize_yaml_input(input) - result = input.respond_to?(:read) ? input.read : input - result = "--- " + result unless result =~ /^--- / - result - end + alias eql? == # :nodoc: - ## - # Sets the rubygems_version to the current RubyGems version + ## + # True if this gem has the same attributes as +other+. - def mark_version - @rubygems_version = RubyGemsVersion + def same_attributes?(other) + @@attributes.each do |name, default| + return false unless self.send(name) == other.send(name) end + true + end - ## - # Ignore unknown attributes while loading + private :same_attributes? - def method_missing(sym, *a, &b) # :nodoc: - if @specification_version > CURRENT_SPECIFICATION_VERSION and - sym.to_s =~ /=$/ then - warn "ignoring #{sym} loading #{full_name}" if $DEBUG - else - super + def hash # :nodoc: + @@attributes.inject(0) { |hash_code, (name, default_value)| + n = self.send(name).hash + hash_code + n + } + end + + def to_yaml(opts = {}) # :nodoc: + mark_version + + attributes = @@attributes.map { |name,| name.to_s }.sort + attributes = attributes - %w[name version platform] + + yaml = YAML.quick_emit object_id, opts do |out| + out.map taguri, to_yaml_style do |map| + map.add 'name', @name + map.add 'version', @version + platform = case @original_platform + when nil, '' then + 'ruby' + when String then + @original_platform + else + @original_platform.to_s + end + map.add 'platform', platform + + attributes.each do |name| + map.add name, instance_variable_get("@#{name}") + end end end + end - ## - # Adds a development dependency named +gem+ with +requirements+ to this - # Gem. For example: - # - # spec.add_development_dependency 'jabber4r', '> 0.1', '<= 0.5' - # - # Development dependencies aren't installed by default and aren't - # activated when a gem is required. - - def add_development_dependency(gem, *requirements) - add_dependency_with_type(gem, :development, *requirements) + def yaml_initialize(tag, vals) # :nodoc: + vals.each do |ivar, val| + instance_variable_set "@#{ivar}", val end - ## - # Adds a runtime dependency named +gem+ with +requirements+ to this Gem. - # For example: - # - # spec.add_runtime_dependency 'jabber4r', '> 0.1', '<= 0.5' + @original_platform = @platform # for backwards compatibility + self.platform = Gem::Platform.new @platform + end - def add_runtime_dependency(gem, *requirements) - add_dependency_with_type(gem, :runtime, *requirements) + ## + # Returns a Ruby code representation of this specification, such that it + # can be eval'ed and reconstruct the same specification later. Attributes + # that still have their default values are omitted. + + def to_ruby + mark_version + result = [] + result << "# -*- encoding: utf-8 -*-" + result << nil + result << "Gem::Specification.new do |s|" + + result << " s.name = #{ruby_code name}" + result << " s.version = #{ruby_code version}" + unless platform.nil? or platform == Gem::Platform::RUBY then + result << " s.platform = #{ruby_code original_platform}" + end + result << "" + result << " s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version=" + + handled = [ + :dependencies, + :name, + :platform, + :required_rubygems_version, + :specification_version, + :version, + ] + + attributes = @@attributes.sort_by { |attr_name,| attr_name.to_s } + + attributes.each do |attr_name, default| + next if handled.include? attr_name + current_value = self.send(attr_name) + if current_value != default or + self.class.required_attribute? attr_name then + result << " s.#{attr_name} = #{ruby_code current_value}" + end end - ## - # Adds a runtime dependency - - alias add_dependency add_runtime_dependency + result << nil + result << " if s.respond_to? :specification_version then" + result << " current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION" + result << " s.specification_version = #{specification_version}" + result << nil - ## - # Returns the full name (name-version) of this Gem. Platform information - # is included (name-version-platform) if it is specified and not the - # default Ruby platform. + result << " if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then" - def full_name - if platform == Gem::Platform::RUBY or platform.nil? then - "#{@name}-#{@version}" - else - "#{@name}-#{@version}-#{platform}" + unless dependencies.empty? then + dependencies.each do |dep| + version_reqs_param = dep.requirements_list.inspect + dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK + result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>, #{version_reqs_param})" end end - ## - # Returns the full name (name-version) of this gemspec using the original - # platform. For use with legacy gems. + result << " else" - def original_name # :nodoc: - if platform == Gem::Platform::RUBY or platform.nil? then - "#{@name}-#{@version}" - else - "#{@name}-#{@version}-#{@original_platform}" + unless dependencies.empty? then + dependencies.each do |dep| + version_reqs_param = dep.requirements_list.inspect + result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})" end end - ## - # The full path to the gem (install path + full name). + result << ' end' - def full_gem_path - path = File.join installation_path, 'gems', full_name - return path if File.directory? path - File.join installation_path, 'gems', original_name - end + result << " else" + dependencies.each do |dep| + version_reqs_param = dep.requirements_list.inspect + result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})" + end + result << " end" - ## - # The default (generated) file name of the gem. + result << "end" + result << nil - def file_name - full_name + ".gem" - end + result.join "\n" + end - ## - # The directory that this gem was installed into. + ## + # Checks that the specification contains all required fields, and does a + # very basic sanity check. + # + # Raises InvalidSpecificationException if the spec does not pass the + # checks.. + + def validate + extend Gem::UserInteraction + normalize - def installation_path - path = File.dirname(@loaded_from).split(File::SEPARATOR)[0..-2] - path = path.join File::SEPARATOR - File.expand_path path + if rubygems_version != Gem::RubyGemsVersion then + raise Gem::InvalidSpecificationException, + "expected RubyGems version #{Gem::RubyGemsVersion}, was #{rubygems_version}" end - ## - # Checks if this specification meets the requirement of +dependency+. + @@required_attributes.each do |symbol| + unless self.send symbol then + raise Gem::InvalidSpecificationException, + "missing value for attribute #{symbol}" + end + end - def satisfies_requirement?(dependency) - return @name == dependency.name && - dependency.version_requirements.satisfied_by?(@version) + unless String === name then + raise Gem::InvalidSpecificationException, + "invalid value for attribute name: \"#{name.inspect}\"" end - ## - # Returns an object you can use to sort specifications in #sort_by. + if require_paths.empty? then + raise Gem::InvalidSpecificationException, + 'specification must have at least one require_path' + end - def sort_obj - [@name, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1] + @files.delete_if do |file| File.directory? file end + @test_files.delete_if do |file| File.directory? file end + @executables.delete_if do |file| + File.directory? File.join(bindir, file) end + @extra_rdoc_files.delete_if do |file| File.directory? file end + @extensions.delete_if do |file| File.directory? file end - def <=>(other) # :nodoc: - sort_obj <=> other.sort_obj + non_files = files.select do |file| + !File.file? file end - ## - # Tests specs for equality (across all attributes). + unless non_files.empty? then + non_files = non_files.map { |file| file.inspect } + raise Gem::InvalidSpecificationException, + "[#{non_files.join ", "}] are not files" + end - def ==(other) # :nodoc: - self.class === other && same_attributes?(other) + unless specification_version.is_a?(Fixnum) + raise Gem::InvalidSpecificationException, + 'specification_version must be a Fixnum (did you mean version?)' end - alias eql? == # :nodoc: + case platform + when Gem::Platform, Gem::Platform::RUBY then # ok + else + raise Gem::InvalidSpecificationException, + "invalid platform #{platform.inspect}, see Gem::Platform" + end - ## - # True if this gem has the same attributes as +other+. + unless Array === authors and + authors.all? { |author| String === author } then + raise Gem::InvalidSpecificationException, + 'authors must be Array of Strings' + end - def same_attributes?(other) - @@attributes.each do |name, default| - return false unless self.send(name) == other.send(name) + licenses.each { |license| + if license.length > 64 + raise Gem::InvalidSpecificationException, + "each license must be 64 characters or less" end - true - end + } - private :same_attributes? + # reject FIXME and TODO - def hash # :nodoc: - @@attributes.inject(0) { |hash_code, (name, default_value)| - n = self.send(name).hash - hash_code + n - } + unless authors.grep(/FIXME|TODO/).empty? then + raise Gem::InvalidSpecificationException, + '"FIXME" or "TODO" is not an author' end - def to_yaml(opts = {}) # :nodoc: - mark_version - - attributes = @@attributes.map { |name,| name.to_s }.sort - attributes = attributes - %w[name version platform] - - yaml = YAML.quick_emit object_id, opts do |out| - out.map taguri, to_yaml_style do |map| - map.add 'name', @name - map.add 'version', @version - platform = case @original_platform - when nil, '' then - 'ruby' - when String then - @original_platform - else - @original_platform.to_s - end - map.add 'platform', platform - - attributes.each do |name| - map.add name, instance_variable_get("@#{name}") - end - end - end + unless Array(email).grep(/FIXME|TODO/).empty? then + raise Gem::InvalidSpecificationException, + '"FIXME" or "TODO" is not an email address' end - def yaml_initialize(tag, vals) # :nodoc: - vals.each do |ivar, val| - instance_variable_set "@#{ivar}", val - end + if description =~ /FIXME|TODO/ then + raise Gem::InvalidSpecificationException, + '"FIXME" or "TODO" is not a description' + end - @original_platform = @platform # for backwards compatibility - self.platform = Gem::Platform.new @platform + if summary =~ /FIXME|TODO/ then + raise Gem::InvalidSpecificationException, + '"FIXME" or "TODO" is not a summary' end - ## - # Returns a Ruby code representation of this specification, such that it - # can be eval'ed and reconstruct the same specification later. Attributes - # that still have their default values are omitted. - - def to_ruby - mark_version - result = [] - result << "# -*- encoding: utf-8 -*-" - result << nil - result << "Gem::Specification.new do |s|" - - result << " s.name = #{ruby_code name}" - result << " s.version = #{ruby_code version}" - unless platform.nil? or platform == Gem::Platform::RUBY then - result << " s.platform = #{ruby_code original_platform}" - end - result << "" - result << " s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version=" - - handled = [ - :dependencies, - :name, - :platform, - :required_rubygems_version, - :specification_version, - :version, - ] + if homepage and not homepage.empty? and + homepage !~ /\A[a-z][a-z\d+.-]*:/i then + raise Gem::InvalidSpecificationException, + "\"#{homepage}\" is not a URI" + end - attributes = @@attributes.sort_by { |attr_name,| attr_name.to_s } + # Warnings - attributes.each do |attr_name, default| - next if handled.include? attr_name - current_value = self.send(attr_name) - if current_value != default or - self.class.required_attribute? attr_name then - result << " s.#{attr_name} = #{ruby_code current_value}" - end - end + %w[author description email homepage rubyforge_project summary].each do |attribute| + value = self.send attribute + alert_warning "no #{attribute} specified" if value.nil? or value.empty? + end - result << nil - result << " if s.respond_to? :specification_version then" - result << " current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION" - result << " s.specification_version = #{specification_version}" - result << nil + if summary and not summary.empty? and description == summary then + alert_warning 'description and summary are identical' + end - result << " if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then" + alert_warning "deprecated autorequire specified" if autorequire - unless dependencies.empty? then - dependencies.each do |dep| - version_reqs_param = dep.requirements_list.inspect - dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK - result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>, #{version_reqs_param})" - end - end + executables.each do |executable| + executable_path = File.join bindir, executable + shebang = File.read(executable_path, 2) == '#!' - result << " else" + alert_warning "#{executable_path} is missing #! line" unless shebang + end - unless dependencies.empty? then - dependencies.each do |dep| - version_reqs_param = dep.requirements_list.inspect - result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})" - end - end + true + end - result << ' end' + ## + # Normalize the list of files so that: + # * All file lists have redundancies removed. + # * Files referenced in the extra_rdoc_files are included in the package + # file list. + + def normalize + if defined?(@extra_rdoc_files) and @extra_rdoc_files then + @extra_rdoc_files.uniq! + @files ||= [] + @files.concat(@extra_rdoc_files) + end + @files.uniq! if @files + end - result << " else" - dependencies.each do |dep| - version_reqs_param = dep.requirements_list.inspect - result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})" + ## + # Return a list of all gems that have a dependency on this gemspec. The + # list is structured with entries that conform to: + # + # [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]] + + def dependent_gems + out = [] + Gem.source_index.each do |name,gem| + gem.dependencies.each do |dep| + if self.satisfies_requirement?(dep) then + sats = [] + find_all_satisfiers(dep) do |sat| + sats << sat + end + out << [gem, dep, sats] end - result << " end" + end + end + out + end - result << "end" - result << nil + def to_s # :nodoc: + "#<Gem::Specification name=#{@name} version=#{@version}>" + end - result.join "\n" - end + def pretty_print(q) # :nodoc: + q.group 2, 'Gem::Specification.new do |s|', 'end' do + q.breakable - ## - # Checks that the specification contains all required fields, and does a - # very basic sanity check. - # - # Raises InvalidSpecificationException if the spec does not pass the - # checks.. + attributes = @@attributes.sort_by { |attr_name,| attr_name.to_s } - def validate - extend Gem::UserInteraction - normalize + attributes.each do |attr_name, default| + current_value = self.send attr_name + if current_value != default or + self.class.required_attribute? attr_name then - if rubygems_version != RubyGemsVersion then - raise Gem::InvalidSpecificationException, - "expected RubyGems version #{RubyGemsVersion}, was #{rubygems_version}" - end + q.text "s.#{attr_name} = " - @@required_attributes.each do |symbol| - unless self.send symbol then - raise Gem::InvalidSpecificationException, - "missing value for attribute #{symbol}" - end - end + if attr_name == :date then + current_value = current_value.utc - if require_paths.empty? then - raise Gem::InvalidSpecificationException, - "specification must have at least one require_path" - end + q.text "Time.utc(#{current_value.year}, #{current_value.month}, #{current_value.day})" + else + q.pp current_value + end - case platform - when Gem::Platform, Platform::RUBY then # ok - else - raise Gem::InvalidSpecificationException, - "invalid platform #{platform.inspect}, see Gem::Platform" + q.breakable + end end + end + end - unless Array === authors and - authors.all? { |author| String === author } then - raise Gem::InvalidSpecificationException, - 'authors must be Array of Strings' - end + ## + # Adds a dependency on gem +dependency+ with type +type+ that requires + # +requirements+. Valid types are currently <tt>:runtime</tt> and + # <tt>:development</tt>. - # Warnings + def add_dependency_with_type(dependency, type, *requirements) + requirements = if requirements.empty? then + Gem::Requirement.default + else + requirements.flatten + end - %w[author email homepage rubyforge_project summary].each do |attribute| - value = self.send attribute - alert_warning "no #{attribute} specified" if value.nil? or value.empty? - end + unless dependency.respond_to?(:name) && + dependency.respond_to?(:version_requirements) - alert_warning "RDoc will not be generated (has_rdoc == false)" unless - has_rdoc + dependency = Gem::Dependency.new(dependency, requirements, type) + end - alert_warning "deprecated autorequire specified" if autorequire + dependencies << dependency + end - executables.each do |executable| - executable_path = File.join bindir, executable - shebang = File.read(executable_path, 2) == '#!' + private :add_dependency_with_type - alert_warning "#{executable_path} is missing #! line" unless shebang - end + ## + # Finds all gems that satisfy +dep+ - true + def find_all_satisfiers(dep) + Gem.source_index.each do |_, gem| + yield gem if gem.satisfies_requirement? dep end + end - ## - # Normalize the list of files so that: - # * All file lists have redundancies removed. - # * Files referenced in the extra_rdoc_files are included in the package - # file list. - # - # Also, the summary and description are converted to a normal format. - - def normalize - if defined?(@extra_rdoc_files) and @extra_rdoc_files then - @extra_rdoc_files.uniq! - @files ||= [] - @files.concat(@extra_rdoc_files) - end - @files.uniq! if @files - end + private :find_all_satisfiers - ## - # Return a list of all gems that have a dependency on this gemspec. The - # list is structured with entries that conform to: - # - # [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]] - - def dependent_gems - out = [] - Gem.source_index.each do |name,gem| - gem.dependencies.each do |dep| - if self.satisfies_requirement?(dep) then - sats = [] - find_all_satisfiers(dep) do |sat| - sats << sat - end - out << [gem, dep, sats] - end - end - end - out + ## + # Return a string containing a Ruby code representation of the given + # object. + + def ruby_code(obj) + case obj + when String then '%q{' + obj + '}' + when Array then obj.inspect + when Gem::Version then obj.to_s.inspect + when Date then '%q{' + obj.strftime('%Y-%m-%d') + '}' + when Time then '%q{' + obj.strftime('%Y-%m-%d') + '}' + when Numeric then obj.inspect + when true, false, nil then obj.inspect + when Gem::Platform then "Gem::Platform.new(#{obj.to_a.inspect})" + when Gem::Requirement then "Gem::Requirement.new(#{obj.to_s.inspect})" + else raise Gem::Exception, "ruby_code case not handled: #{obj.class}" end + end - def to_s - "#<Gem::Specification name=#{@name} version=#{@version}>" - end + private :ruby_code - def add_dependency_with_type(dependency, type, *requirements) - requirements = if requirements.empty? then - Gem::Requirement.default - else - requirements.flatten - end + # :section: Required gemspec attributes - unless dependency.respond_to?(:name) && - dependency.respond_to?(:version_requirements) + ## + # :attr_accessor: rubygems_version + # + # The version of RubyGems used to create this gem - dependency = Dependency.new(dependency, requirements, type) - end + required_attribute :rubygems_version, Gem::RubyGemsVersion - dependencies << dependency - end + ## + # :attr_accessor: specification_version + # + # The Gem::Specification version of this gemspec - private :add_dependency_with_type + required_attribute :specification_version, CURRENT_SPECIFICATION_VERSION - def find_all_satisfiers(dep) - Gem.source_index.each do |name,gem| - if(gem.satisfies_requirement?(dep)) then - yield gem - end - end - end + ## + # :attr_accessor: name + # + # This gem's name - private :find_all_satisfiers - - ## - # Return a string containing a Ruby code representation of the given - # object. - - def ruby_code(obj) - case obj - when String then '%q{' + obj + '}' - when Array then obj.inspect - when Gem::Version then obj.to_s.inspect - when Date then '%q{' + obj.strftime('%Y-%m-%d') + '}' - when Time then '%q{' + obj.strftime('%Y-%m-%d') + '}' - when Numeric then obj.inspect - when true, false, nil then obj.inspect - when Gem::Platform then "Gem::Platform.new(#{obj.to_a.inspect})" - when Gem::Requirement then "Gem::Requirement.new(#{obj.to_s.inspect})" - else raise Exception, "ruby_code case not handled: #{obj.class}" - end - end + required_attribute :name - private :ruby_code + ## + # :attr_accessor: version + # + # This gem's version - # :section: Required gemspec attributes + required_attribute :version - ## - # The version of RubyGems used to create this gem + ## + # :attr_accessor: date + # + # The date this gem was created - required_attribute :rubygems_version, Gem::RubyGemsVersion + required_attribute :date, TODAY - ## - # The Gem::Specification version of this gemspec + ## + # :attr_accessor: summary + # + # A short summary of this gem's description. Displayed in `gem list -d`. - required_attribute :specification_version, CURRENT_SPECIFICATION_VERSION + required_attribute :summary - ## - # This gem's name + ## + # :attr_accessor: require_paths + # + # Paths in the gem to add to $LOAD_PATH when this gem is activated - required_attribute :name + required_attribute :require_paths, ['lib'] - ## - # This gem's version + # :section: Optional gemspec attributes - required_attribute :version + ## + # :attr_accessor: email + # + # A contact email for this gem - ## - # The date this gem was created + attribute :email - required_attribute :date, TODAY + ## + # :attr_accessor: homepage + # + # The URL of this gem's home page - ## - # A short summary of this gem's description. Displayed in `gem list -d`. + attribute :homepage - required_attribute :summary + ## + # :attr_accessor: rubyforge_project + # + # The rubyforge project this gem lives under. i.e. RubyGems' + # rubyforge_project is "rubygems". - ## - # Paths in the gem to add to $LOAD_PATH when this gem is activated + attribute :rubyforge_project - required_attribute :require_paths, ['lib'] + ## + # :attr_accessor: description + # + # A long description of this gem - # :section: Optional gemspec attributes + attribute :description - ## - # A contact email for this gem + ## + # :attr_accessor: autorequire + # + # Autorequire was used by old RubyGems to automatically require a file. + # It no longer is supported. - attribute :email + attribute :autorequire - ## - # The URL of this gem's home page + ## + # :attr_accessor: default_executable + # + # The default executable for this gem. - attribute :homepage + attribute :default_executable - ## - # The rubyforge project this gem lives under. i.e. RubyGems' - # rubyforge_project is "rubygems". + ## + # :attr_accessor: bindir + # + # The path in the gem for executable scripts - attribute :rubyforge_project + attribute :bindir, 'bin' - ## - # A long description of this gem + ## + # :attr_accessor: has_rdoc + # + # Deprecated and ignored, defaults to true. + # + # Formerly used to indicate this gem was RDoc-capable. - attribute :description + attribute :has_rdoc, true - ## - # Autorequire was used by old RubyGems to automatically require a file. - # It no longer is supported. + ## + # True if this gem supports RDoc - attribute :autorequire + alias :has_rdoc? :has_rdoc - ## - # The default executable for this gem. + ## + # :attr_accessor: required_ruby_version + # + # The ruby of version required by this gem - attribute :default_executable + attribute :required_ruby_version, Gem::Requirement.default - ## - # The path in the gem for executable scripts + ## + # :attr_accessor: required_rubygems_version + # + # The RubyGems version required by this gem - attribute :bindir, 'bin' + attribute :required_rubygems_version, Gem::Requirement.default - ## - # True if this gem is RDoc-compliant + ## + # :attr_accessor: platform + # + # The platform this gem runs on. See Gem::Platform for details. - attribute :has_rdoc, false + attribute :platform, Gem::Platform::RUBY - ## - # True if this gem supports RDoc + ## + # :attr_accessor: signing_key + # + # The key used to sign this gem. See Gem::Security for details. - alias :has_rdoc? :has_rdoc + attribute :signing_key, nil - ## - # The ruby of version required by this gem + ## + # :attr_accessor: cert_chain + # + # The certificate chain used to sign this gem. See Gem::Security for + # details. - attribute :required_ruby_version, Gem::Requirement.default + attribute :cert_chain, [] - ## - # The RubyGems version required by this gem + ## + # :attr_accessor: post_install_message + # + # A message that gets displayed after the gem is installed - attribute :required_rubygems_version, Gem::Requirement.default + attribute :post_install_message, nil - ## - # The platform this gem runs on. See Gem::Platform for details. + ## + # :attr_accessor: authors + # + # The list of authors who wrote this gem - attribute :platform, Gem::Platform::RUBY + array_attribute :authors - ## - # The key used to sign this gem. See Gem::Security for details. + ## + # :attr_accessor: licenses + # + # The license(s) for the library. Each license must be a short name, no + # more than 64 characters. - attribute :signing_key, nil + array_attribute :licenses - ## - # The certificate chain used to sign this gem. See Gem::Security for - # details. + ## + # :attr_accessor: files + # + # Files included in this gem. You cannot append to this accessor, you must + # assign to it. + # + # Only add files you can require to this list, not directories, etc. + # + # Directories are automatically stripped from this list when building a gem, + # other non-files cause an error. - attribute :cert_chain, [] + array_attribute :files - ## - # A message that gets displayed after the gem is installed + ## + # :attr_accessor: test_files + # + # Test files included in this gem. You cannot append to this accessor, you + # must assign to it. - attribute :post_install_message, nil + array_attribute :test_files - ## - # The list of authors who wrote this gem + ## + # :attr_accessor: rdoc_options + # + # An ARGV-style array of options to RDoc - array_attribute :authors + array_attribute :rdoc_options - ## - # Files included in this gem + ## + # :attr_accessor: extra_rdoc_files + # + # Extra files to add to RDoc - array_attribute :files + array_attribute :extra_rdoc_files - ## - # Test files included in this gem + ## + # :attr_accessor: executables + # + # Executables included in the gem - array_attribute :test_files + array_attribute :executables - ## - # An ARGV-style array of options to RDoc + ## + # :attr_accessor: extensions + # + # Extensions to build when installing the gem. See + # Gem::Installer#build_extensions for valid values. + + array_attribute :extensions - array_attribute :rdoc_options + ## + # :attr_accessor: requirements + # + # An array or things required by this gem. Not used by anything + # presently. - ## - # Extra files to add to RDoc + array_attribute :requirements - array_attribute :extra_rdoc_files + ## + # :attr_reader: dependencies + # + # A list of Gem::Dependency objects this gem depends on. - ## - # Executables included in the gem + array_attribute :dependencies - array_attribute :executables + read_only :dependencies - ## - # Extensions to build when installing the gem. See - # Gem::Installer#build_extensions for valid values. + # :section: Aliased gemspec attributes - array_attribute :extensions + ## + # Singular accessor for #executables - ## - # An array or things required by this gem. Not used by anything - # presently. + attribute_alias_singular :executable, :executables - array_attribute :requirements + ## + # Singular accessor for #authors - ## - # A list of Gem::Dependency objects this gem depends on. Only appendable. + attribute_alias_singular :author, :authors - array_attribute :dependencies + ## + # Singular accessor for #licenses - read_only :dependencies + attribute_alias_singular :license, :licenses - # :section: Aliased gemspec attributes + ## + # Singular accessor for #require_paths - ## - # Singular accessor for executables + attribute_alias_singular :require_path, :require_paths - attribute_alias_singular :executable, :executables + ## + # Singular accessor for #test_files - ## - # Singular accessor for authors + attribute_alias_singular :test_file, :test_files - attribute_alias_singular :author, :authors + ## + # has_rdoc is now ignored - ## - # Singular accessor for require_paths + overwrite_accessor :has_rdoc do + true + end - attribute_alias_singular :require_path, :require_paths + ## + # has_rdoc is now ignored - ## - # Singular accessor for test_files + overwrite_accessor :has_rdoc= do |value| + @has_rdoc = true + end - attribute_alias_singular :test_file, :test_files + overwrite_accessor :version= do |version| + @version = Gem::Version.create(version) + self.required_rubygems_version = '> 1.3.1' if @version.prerelease? + return @version + end - overwrite_accessor :version= do |version| - @version = Version.create(version) - end + overwrite_accessor :platform do + @new_platform + end - overwrite_accessor :platform do - @new_platform + overwrite_accessor :platform= do |platform| + if @original_platform.nil? or + @original_platform == Gem::Platform::RUBY then + @original_platform = platform end - overwrite_accessor :platform= do |platform| - if @original_platform.nil? or - @original_platform == Gem::Platform::RUBY then - @original_platform = platform - end - - case platform - when Gem::Platform::CURRENT then - @new_platform = Gem::Platform.local - @original_platform = @new_platform.to_s - - when Gem::Platform then - @new_platform = platform - - # legacy constants - when nil, Gem::Platform::RUBY then - @new_platform = Gem::Platform::RUBY - when 'mswin32' then # was Gem::Platform::WIN32 - @new_platform = Gem::Platform.new 'x86-mswin32' - when 'mswin64' then - @new_platform = Gem::Platform.new 'x86-mswin64' - when 'i586-linux' then # was Gem::Platform::LINUX_586 - @new_platform = Gem::Platform.new 'x86-linux' - when 'powerpc-darwin' then # was Gem::Platform::DARWIN - @new_platform = Gem::Platform.new 'ppc-darwin' - else - @new_platform = Gem::Platform.new platform - end + case platform + when Gem::Platform::CURRENT then + @new_platform = Gem::Platform.local + @original_platform = @new_platform.to_s - @platform = @new_platform.to_s + when Gem::Platform then + @new_platform = platform - @new_platform + # legacy constants + when nil, Gem::Platform::RUBY then + @new_platform = Gem::Platform::RUBY + when 'mswin32' then # was Gem::Platform::WIN32 + @new_platform = Gem::Platform.new 'x86-mswin32' + when 'i586-linux' then # was Gem::Platform::LINUX_586 + @new_platform = Gem::Platform.new 'x86-linux' + when 'powerpc-darwin' then # was Gem::Platform::DARWIN + @new_platform = Gem::Platform.new 'ppc-darwin' + else + @new_platform = Gem::Platform.new platform end - overwrite_accessor :required_ruby_version= do |value| - @required_ruby_version = Gem::Requirement.create(value) - end + @platform = @new_platform.to_s - overwrite_accessor :required_rubygems_version= do |value| - @required_rubygems_version = Gem::Requirement.create(value) - end + @new_platform + end - overwrite_accessor :date= do |date| - # We want to end up with a Time object with one-day resolution. - # This is the cleanest, most-readable, faster-than-using-Date - # way to do it. - case date - when String then - @date = if /\A(\d{4})-(\d{2})-(\d{2})\Z/ =~ date then - Time.local($1.to_i, $2.to_i, $3.to_i) - else - require 'time' - Time.parse date - end - when Time then - @date = Time.local(date.year, date.month, date.day) - when Date then - @date = Time.local(date.year, date.month, date.day) - else - @date = TODAY - end - end + overwrite_accessor :required_ruby_version= do |value| + @required_ruby_version = Gem::Requirement.create(value) + end - overwrite_accessor :date do - self.date = nil if @date.nil? # HACK Sets the default value for date - @date - end + overwrite_accessor :required_rubygems_version= do |value| + @required_rubygems_version = Gem::Requirement.create(value) + end - overwrite_accessor :summary= do |str| - @summary = if str then - str.strip. - gsub(/(\w-)\n[ \t]*(\w)/, '\1\2'). - gsub(/\n[ \t]*/, " ") - end + overwrite_accessor :date= do |date| + # We want to end up with a Time object with one-day resolution. + # This is the cleanest, most-readable, faster-than-using-Date + # way to do it. + case date + when String then + @date = if /\A(\d{4})-(\d{2})-(\d{2})\Z/ =~ date then + Time.local($1.to_i, $2.to_i, $3.to_i) + else + require 'time' + Time.parse date + end + when Time then + @date = Time.local(date.year, date.month, date.day) + when Date then + @date = Time.local(date.year, date.month, date.day) + else + @date = TODAY end + end - overwrite_accessor :description= do |str| - @description = if str then - str.strip. - gsub(/(\w-)\n[ \t]*(\w)/, '\1\2'). - gsub(/\n[ \t]*/, " ") - end - end + overwrite_accessor :date do + self.date = nil if @date.nil? # HACK Sets the default value for date + @date + end - overwrite_accessor :default_executable do - begin - if defined?(@default_executable) and @default_executable - result = @default_executable - elsif @executables and @executables.size == 1 - result = Array(@executables).first - else - result = nil - end - result - rescue - nil - end - end + overwrite_accessor :summary= do |str| + @summary = if str then + str.strip. + gsub(/(\w-)\n[ \t]*(\w)/, '\1\2'). + gsub(/\n[ \t]*/, " ") + end + end - overwrite_accessor :test_files do - # Handle the possibility that we have @test_suite_file but not - # @test_files. This will happen when an old gem is loaded via - # YAML. - if defined? @test_suite_file then - @test_files = [@test_suite_file].flatten - @test_suite_file = nil - end - if defined?(@test_files) and @test_files then - @test_files + overwrite_accessor :description= do |str| + @description = str.to_s + end + + overwrite_accessor :default_executable do + begin + if defined?(@default_executable) and @default_executable + result = @default_executable + elsif @executables and @executables.size == 1 + result = Array(@executables).first else - @test_files = [] + result = nil end + result + rescue + nil end + end - overwrite_accessor :files do - result = [] - result.push(*@files) if defined?(@files) - result.push(*@test_files) if defined?(@test_files) - result.push(*(add_bindir(@executables))) - result.push(*@extra_rdoc_files) if defined?(@extra_rdoc_files) - result.push(*@extensions) if defined?(@extensions) - result.uniq.compact + overwrite_accessor :test_files do + # Handle the possibility that we have @test_suite_file but not + # @test_files. This will happen when an old gem is loaded via + # YAML. + if defined? @test_suite_file then + @test_files = [@test_suite_file].flatten + @test_suite_file = nil end + if defined?(@test_files) and @test_files then + @test_files + else + @test_files = [] + end + end + overwrite_accessor :files do + result = [] + result.push(*@files) if defined?(@files) + result.push(*@test_files) if defined?(@test_files) + result.push(*(add_bindir(@executables))) + result.push(*@extra_rdoc_files) if defined?(@extra_rdoc_files) + result.push(*@extensions) if defined?(@extensions) + result.uniq.compact end end diff --git a/lib/rubygems/test_utilities.rb b/lib/rubygems/test_utilities.rb index 85541c9fc3..8b23d3236e 100644 --- a/lib/rubygems/test_utilities.rb +++ b/lib/rubygems/test_utilities.rb @@ -11,9 +11,9 @@ require 'rubygems/remote_fetcher' # @fetcher = Gem::FakeFetcher.new # @fetcher.data['http://gems.example.com/yaml'] = source_index.to_yaml # Gem::RemoteFetcher.fetcher = @fetcher -# +# # # invoke RubyGems code -# +# # paths = @fetcher.paths # assert_equal 'http://gems.example.com/yaml', paths.shift # assert paths.empty?, paths.join(', ') diff --git a/lib/rubygems/text.rb b/lib/rubygems/text.rb new file mode 100644 index 0000000000..c694e8a9c0 --- /dev/null +++ b/lib/rubygems/text.rb @@ -0,0 +1,30 @@ +require 'rubygems' + +## +# A collection of text-wrangling methods + +module Gem::Text + + ## + # Wraps +text+ to +wrap+ characters and optionally indents by +indent+ + # characters + + def format_text(text, wrap, indent=0) + result = [] + work = text.dup + + while work.length > wrap do + if work =~ /^(.{0,#{wrap}})[ \n]/ then + result << $1 + work.slice!(0, $&.length) + else + result << work.slice!(0, wrap) + end + end + + result << work if work.length.nonzero? + result.join("\n").gsub(/^/, " " * indent) + end + +end + diff --git a/lib/rubygems/timer.rb b/lib/rubygems/timer.rb index 06250f26b5..028e640230 100644 --- a/lib/rubygems/timer.rb +++ b/lib/rubygems/timer.rb @@ -1,6 +1,6 @@ # -# This file defines a $log variable for logging, and a time() method for recording timing -# information. +# This file defines a $log variable for logging, and a time() method for +# recording timing information. # #-- # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. @@ -8,18 +8,21 @@ # See LICENSE.txt for permissions. #++ +require 'rubygems' + +file, lineno = Gem.location_of_caller + +warn "#{file}:#{lineno}:Warning: RubyGems' lib/rubygems/timer.rb deprecated and will be removed on or after June 2009." $log = Object.new -def $log.debug(str) - STDERR.puts str + +# :stopdoc: +def $log.debug(message) + Gem.debug message end -def time(msg, width=25) - t = Time.now - return_value = yield - elapsed = Time.now.to_f - t.to_f - elapsed = sprintf("%3.3f", elapsed) - $log.debug "#{msg.ljust(width)}: #{elapsed}s" - return_value +def time(msg, width=25, &block) + Gem.time(msg, width, &block) end +# :startdoc: diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb index 5f19da5e82..4bb777a2a2 100644 --- a/lib/rubygems/uninstaller.rb +++ b/lib/rubygems/uninstaller.rb @@ -12,6 +12,11 @@ require 'rubygems/user_interaction' ## # An Uninstaller. +# +# The uninstaller fires pre and post uninstall hooks. Hooks can be added +# either through a rubygems_plugin.rb file in an installed gem or via a +# rubygems/defaults/#{RUBY_ENGINE}.rb or rubygems/defaults/operating_system.rb +# file. See Gem.pre_uninstall and Gem.post_uninstall for details. class Gem::Uninstaller @@ -46,8 +51,17 @@ class Gem::Uninstaller @force_ignore = options[:ignore] @bin_dir = options[:bin_dir] + # only add user directory if install_dir is not set + @user_install = false + @user_install = options[:user_install] unless options[:install_dir] + spec_dir = File.join @gem_home, 'specifications' @source_index = Gem::SourceIndex.from_gems_in spec_dir + + if @user_install then + user_dir = File.join Gem.user_dir, 'specifications' + @user_index = Gem::SourceIndex.from_gems_in user_dir + end end ## @@ -56,9 +70,10 @@ class Gem::Uninstaller def uninstall list = @source_index.find_name @gem, @version + list += @user_index.find_name @gem, @version if @user_install if list.empty? then - raise Gem::InstallError, "Unknown gem #{@gem} #{@version}" + raise Gem::InstallError, "cannot uninstall, check `gem list -d #{@gem}`" elsif list.size > 1 and @force_all then remove_all list.dup @@ -91,8 +106,8 @@ class Gem::Uninstaller hook.call self end - specs.each { |s| remove_executables s } - remove spec, specs + remove_executables @spec + remove @spec, specs Gem.post_uninstall_hooks.each do |hook| hook.call self @@ -105,29 +120,29 @@ class Gem::Uninstaller # Removes installed executables and batch files (windows only) for # +gemspec+. - def remove_executables(gemspec) - return if gemspec.nil? + def remove_executables(spec) + return if spec.nil? - if gemspec.executables.size > 0 then - bindir = @bin_dir ? @bin_dir : (Gem.bindir @gem_home) + unless spec.executables.empty? then + bindir = @bin_dir ? @bin_dir : Gem.bindir(spec.installation_path) - list = @source_index.find_name(gemspec.name).delete_if { |spec| - spec.version == gemspec.version + list = @source_index.find_name(spec.name).delete_if { |s| + s.version == spec.version } - executables = gemspec.executables.clone + executables = spec.executables.clone - list.each do |spec| - spec.executables.each do |exe_name| - executables.delete(exe_name) + list.each do |s| + s.executables.each do |exe_name| + executables.delete exe_name end end - return if executables.size == 0 + return if executables.empty? answer = if @force_executables.nil? then ask_yes_no("Remove executables:\n" \ - "\t#{gemspec.executables.join(", ")}\n\nin addition to the gem?", + "\t#{spec.executables.join(", ")}\n\nin addition to the gem?", true) # " # appease ruby-mode - don't ask else @force_executables @@ -138,7 +153,7 @@ class Gem::Uninstaller else raise Gem::FilePermissionError, bindir unless File.writable? bindir - gemspec.executables.each do |exe_name| + spec.executables.each do |exe_name| say "Removing #{exe_name}" FileUtils.rm_f File.join(bindir, exe_name) FileUtils.rm_f File.join(bindir, "#{exe_name}.bat") @@ -169,7 +184,8 @@ class Gem::Uninstaller "Uninstallation aborted due to dependent gem(s)" end - unless path_ok? spec then + unless path_ok?(@gem_home, spec) or + (@user_install and path_ok?(Gem.user_dir, spec)) then e = Gem::GemNotInHomeException.new \ "Gem is not installed in directory #{@gem_home}" e.spec = spec @@ -210,9 +226,12 @@ class Gem::Uninstaller list.delete spec end - def path_ok?(spec) - full_path = File.join @gem_home, 'gems', spec.full_name - original_path = File.join @gem_home, 'gems', spec.original_name + ## + # Is +spec+ in +gem_dir+? + + def path_ok?(gem_dir, spec) + full_path = File.join gem_dir, 'gems', spec.full_name + original_path = File.join gem_dir, 'gems', spec.original_name full_path == spec.full_gem_path || original_path == spec.full_gem_path end @@ -221,6 +240,7 @@ class Gem::Uninstaller return true if @force_ignore deplist = Gem::DependencyList.from_source_index @source_index + deplist.add(*@user_index.gems.values) if @user_install deplist.ok_to_remove?(spec.full_name) || ask_if_ok(spec) end diff --git a/lib/rubygems/user_interaction.rb b/lib/rubygems/user_interaction.rb index 30a728c597..6a80c7c0bc 100644 --- a/lib/rubygems/user_interaction.rb +++ b/lib/rubygems/user_interaction.rb @@ -4,357 +4,387 @@ # See LICENSE.txt for permissions. #++ -module Gem +## +# Module that defines the default UserInteraction. Any class including this +# module will have access to the +ui+ method that returns the default UI. - ## - # Module that defines the default UserInteraction. Any class including this - # module will have access to the +ui+ method that returns the default UI. +module Gem::DefaultUserInteraction - module DefaultUserInteraction + ## + # The default UI is a class variable of the singleton class for this + # module. - ## - # The default UI is a class variable of the singleton class for this - # module. + @ui = nil - @ui = nil + ## + # Return the default UI. - ## - # Return the default UI. + def self.ui + @ui ||= Gem::ConsoleUI.new + end - def self.ui - @ui ||= Gem::ConsoleUI.new - end + ## + # Set the default UI. If the default UI is never explicitly set, a simple + # console based UserInteraction will be used automatically. - ## - # Set the default UI. If the default UI is never explicitly set, a simple - # console based UserInteraction will be used automatically. + def self.ui=(new_ui) + @ui = new_ui + end - def self.ui=(new_ui) - @ui = new_ui - end + ## + # Use +new_ui+ for the duration of +block+. + + def self.use_ui(new_ui) + old_ui = @ui + @ui = new_ui + yield + ensure + @ui = old_ui + end - ## - # Use +new_ui+ for the duration of +block+. - - def self.use_ui(new_ui) - old_ui = @ui - @ui = new_ui - yield - ensure - @ui = old_ui - end + ## + # See DefaultUserInteraction::ui - ## - # See DefaultUserInteraction::ui + def ui + Gem::DefaultUserInteraction.ui + end - def ui - DefaultUserInteraction.ui - end + ## + # See DefaultUserInteraction::ui= - ## - # See DefaultUserInteraction::ui= + def ui=(new_ui) + Gem::DefaultUserInteraction.ui = new_ui + end - def ui=(new_ui) - DefaultUserInteraction.ui = new_ui - end + ## + # See DefaultUserInteraction::use_ui - ## - # See DefaultUserInteraction::use_ui + def use_ui(new_ui, &block) + Gem::DefaultUserInteraction.use_ui(new_ui, &block) + end - def use_ui(new_ui, &block) - DefaultUserInteraction.use_ui(new_ui, &block) - end +end - end +## +# Make the default UI accessable without the "ui." prefix. Classes +# including this module may use the interaction methods on the default UI +# directly. Classes may also reference the ui and ui= methods. +# +# Example: +# +# class X +# include Gem::UserInteraction +# +# def get_answer +# n = ask("What is the meaning of life?") +# end +# end + +module Gem::UserInteraction + + include Gem::DefaultUserInteraction ## - # Make the default UI accessable without the "ui." prefix. Classes - # including this module may use the interaction methods on the default UI - # directly. Classes may also reference the ui and ui= methods. - # - # Example: - # - # class X - # include Gem::UserInteraction - # - # def get_answer - # n = ask("What is the meaning of life?") - # end - # end - - module UserInteraction - - include DefaultUserInteraction - - [:alert, - :alert_error, - :alert_warning, - :ask, - :ask_yes_no, - :choose_from_list, - :say, - :terminate_interaction ].each do |methname| - class_eval %{ - def #{methname}(*args) - ui.#{methname}(*args) - end - }, __FILE__, __LINE__ - end - end + # :method: alert ## - # StreamUI implements a simple stream based user interface. + # :method: alert_error - class StreamUI + ## + # :method: alert_warning - attr_reader :ins, :outs, :errs + ## + # :method: ask - def initialize(in_stream, out_stream, err_stream=STDERR) - @ins = in_stream - @outs = out_stream - @errs = err_stream - end + ## + # :method: ask_yes_no - ## - # Choose from a list of options. +question+ is a prompt displayed above - # the list. +list+ is a list of option strings. Returns the pair - # [option_name, option_index]. + ## + # :method: choose_from_list - def choose_from_list(question, list) - @outs.puts question + ## + # :method: say - list.each_with_index do |item, index| - @outs.puts " #{index+1}. #{item}" + ## + # :method: terminate_interaction + + [:alert, + :alert_error, + :alert_warning, + :ask, + :ask_yes_no, + :choose_from_list, + :say, + :terminate_interaction ].each do |methname| + class_eval %{ + def #{methname}(*args) + ui.#{methname}(*args) end + }, __FILE__, __LINE__ + end +end + +## +# Gem::StreamUI implements a simple stream based user interface. + +class Gem::StreamUI + + attr_reader :ins, :outs, :errs - @outs.print "> " - @outs.flush + def initialize(in_stream, out_stream, err_stream=STDERR) + @ins = in_stream + @outs = out_stream + @errs = err_stream + end - result = @ins.gets + ## + # Choose from a list of options. +question+ is a prompt displayed above + # the list. +list+ is a list of option strings. Returns the pair + # [option_name, option_index]. - return nil, nil unless result + def choose_from_list(question, list) + @outs.puts question - result = result.strip.to_i - 1 - return list[result], result + list.each_with_index do |item, index| + @outs.puts " #{index+1}. #{item}" end - ## - # Ask a question. Returns a true for yes, false for no. If not connected - # to a tty, raises an exception if default is nil, otherwise returns - # default. - - def ask_yes_no(question, default=nil) - unless @ins.tty? then - if default.nil? then - raise Gem::OperationNotSupportedError, - "Not connected to a tty and no default specified" - else - return default - end - end + @outs.print "> " + @outs.flush - qstr = case default - when nil - 'yn' - when true - 'Yn' - else - 'yN' - end - - result = nil - - while result.nil? - result = ask("#{question} [#{qstr}]") - result = case result - when /^[Yy].*/ - true - when /^[Nn].*/ - false - when /^$/ - default - else - nil - end + result = @ins.gets + + return nil, nil unless result + + result = result.strip.to_i - 1 + return list[result], result + end + + ## + # Ask a question. Returns a true for yes, false for no. If not connected + # to a tty, raises an exception if default is nil, otherwise returns + # default. + + def ask_yes_no(question, default=nil) + unless @ins.tty? then + if default.nil? then + raise Gem::OperationNotSupportedError, + "Not connected to a tty and no default specified" + else + return default end + end - return result + qstr = case default + when nil + 'yn' + when true + 'Yn' + else + 'yN' + end + + result = nil + + while result.nil? + result = ask("#{question} [#{qstr}]") + result = case result + when /^[Yy].*/ + true + when /^[Nn].*/ + false + when /^$/ + default + else + nil + end end - ## - # Ask a question. Returns an answer if connected to a tty, nil otherwise. + return result + end - def ask(question) - return nil if not @ins.tty? + ## + # Ask a question. Returns an answer if connected to a tty, nil otherwise. - @outs.print(question + " ") - @outs.flush + def ask(question) + return nil if not @ins.tty? - result = @ins.gets - result.chomp! if result - result - end + @outs.print(question + " ") + @outs.flush - ## - # Display a statement. + result = @ins.gets + result.chomp! if result + result + end - def say(statement="") - @outs.puts statement - end + ## + # Display a statement. - ## - # Display an informational alert. Will ask +question+ if it is not nil. + def say(statement="") + @outs.puts statement + end - def alert(statement, question=nil) - @outs.puts "INFO: #{statement}" - ask(question) if question - end + ## + # Display an informational alert. Will ask +question+ if it is not nil. - ## - # Display a warning in a location expected to get error messages. Will - # ask +question+ if it is not nil. + def alert(statement, question=nil) + @outs.puts "INFO: #{statement}" + ask(question) if question + end - def alert_warning(statement, question=nil) - @errs.puts "WARNING: #{statement}" - ask(question) if question - end + ## + # Display a warning in a location expected to get error messages. Will + # ask +question+ if it is not nil. - ## - # Display an error message in a location expected to get error messages. - # Will ask +question+ if it is not nil. + def alert_warning(statement, question=nil) + @errs.puts "WARNING: #{statement}" + ask(question) if question + end - def alert_error(statement, question=nil) - @errs.puts "ERROR: #{statement}" - ask(question) if question - end + ## + # Display an error message in a location expected to get error messages. + # Will ask +question+ if it is not nil. - ## - # Terminate the application with exit code +status+, running any exit - # handlers that might have been defined. + def alert_error(statement, question=nil) + @errs.puts "ERROR: #{statement}" + ask(question) if question + end - def terminate_interaction(status = 0) - raise Gem::SystemExitException, status - end + ## + # Display a debug message on the same location as error messages. - ## - # Return a progress reporter object chosen from the current verbosity. - - def progress_reporter(*args) - case Gem.configuration.verbose - when nil, false - SilentProgressReporter.new(@outs, *args) - when true - SimpleProgressReporter.new(@outs, *args) - else - VerboseProgressReporter.new(@outs, *args) - end - end + def debug(statement) + @errs.puts statement + end - ## - # An absolutely silent progress reporter. + ## + # Terminate the application with exit code +status+, running any exit + # handlers that might have been defined. - class SilentProgressReporter - attr_reader :count + def terminate_interaction(status = 0) + raise Gem::SystemExitException, status + end - def initialize(out_stream, size, initial_message, terminal_message = nil) - end + ## + # Return a progress reporter object chosen from the current verbosity. + + def progress_reporter(*args) + case Gem.configuration.verbose + when nil, false + SilentProgressReporter.new(@outs, *args) + when true + SimpleProgressReporter.new(@outs, *args) + else + VerboseProgressReporter.new(@outs, *args) + end + end - def updated(message) - end + ## + # An absolutely silent progress reporter. - def done - end + class SilentProgressReporter + attr_reader :count + + def initialize(out_stream, size, initial_message, terminal_message = nil) end - ## - # A basic dotted progress reporter. + def updated(message) + end - class SimpleProgressReporter - include DefaultUserInteraction + def done + end + end - attr_reader :count + ## + # A basic dotted progress reporter. - def initialize(out_stream, size, initial_message, - terminal_message = "complete") - @out = out_stream - @total = size - @count = 0 - @terminal_message = terminal_message + class SimpleProgressReporter - @out.puts initial_message - end + include Gem::DefaultUserInteraction - ## - # Prints out a dot and ignores +message+. + attr_reader :count - def updated(message) - @count += 1 - @out.print "." - @out.flush - end + def initialize(out_stream, size, initial_message, + terminal_message = "complete") + @out = out_stream + @total = size + @count = 0 + @terminal_message = terminal_message - ## - # Prints out the terminal message. + @out.puts initial_message + end - def done - @out.puts "\n#{@terminal_message}" - end + ## + # Prints out a dot and ignores +message+. + def updated(message) + @count += 1 + @out.print "." + @out.flush end ## - # A progress reporter that prints out messages about the current progress. + # Prints out the terminal message. - class VerboseProgressReporter - include DefaultUserInteraction + def done + @out.puts "\n#{@terminal_message}" + end - attr_reader :count + end - def initialize(out_stream, size, initial_message, - terminal_message = 'complete') - @out = out_stream - @total = size - @count = 0 - @terminal_message = terminal_message + ## + # A progress reporter that prints out messages about the current progress. - @out.puts initial_message - end + class VerboseProgressReporter - ## - # Prints out the position relative to the total and the +message+. + include Gem::DefaultUserInteraction - def updated(message) - @count += 1 - @out.puts "#{@count}/#{@total}: #{message}" - end + attr_reader :count - ## - # Prints out the terminal message. + def initialize(out_stream, size, initial_message, + terminal_message = 'complete') + @out = out_stream + @total = size + @count = 0 + @terminal_message = terminal_message - def done - @out.puts @terminal_message - end + @out.puts initial_message end - end - ## - # Subclass of StreamUI that instantiates the user interaction using STDIN, - # STDOUT, and STDERR. + ## + # Prints out the position relative to the total and the +message+. - class ConsoleUI < StreamUI - def initialize - super(STDIN, STDOUT, STDERR) + def updated(message) + @count += 1 + @out.puts "#{@count}/#{@total}: #{message}" end - end - ## - # SilentUI is a UI choice that is absolutely silent. + ## + # Prints out the terminal message. - class SilentUI - def method_missing(sym, *args, &block) - self + def done + @out.puts @terminal_message end end end +## +# Subclass of StreamUI that instantiates the user interaction using STDIN, +# STDOUT, and STDERR. + +class Gem::ConsoleUI < Gem::StreamUI + def initialize + super STDIN, STDOUT, STDERR + end +end + +## +# SilentUI is a UI choice that is absolutely silent. + +class Gem::SilentUI + def method_missing(sym, *args, &block) + self + end +end + diff --git a/lib/rubygems/validator.rb b/lib/rubygems/validator.rb index 4dd12ad4df..9bccc605b5 100644 --- a/lib/rubygems/validator.rb +++ b/lib/rubygems/validator.rb @@ -6,10 +6,17 @@ require 'find' -require 'rubygems/digest/md5' +require 'digest' require 'rubygems/format' require 'rubygems/installer' +# Load test-unit 2.x if it's a gem +begin + Gem.activate('test-unit') +rescue Gem::LoadError + # Ignore - use the test-unit library that's part of the standard library +end + ## # Validator performs various gem file and gem database validation @@ -33,7 +40,7 @@ class Gem::Validator sum_data = gem_data.gsub(/MD5SUM = "([a-z0-9]+)"/, "MD5SUM = \"#{"F" * 32}\"") - unless Gem::MD5.hexdigest(sum_data) == $1.to_s then + unless Digest::MD5.hexdigest(sum_data) == $1.to_s then raise Gem::VerificationError, 'invalid checksum for gem file' end end @@ -48,7 +55,7 @@ class Gem::Validator gem_data = file.read verify_gem gem_data end - rescue Errno::ENOENT + rescue Errno::ENOENT, Errno::EINVAL raise Gem::VerificationError, "missing gem file #{gem_path}" end @@ -56,13 +63,11 @@ class Gem::Validator def find_files_for_gem(gem_directory) installed_files = [] - Find.find(gem_directory) {|file_name| - fn = file_name.slice((gem_directory.size)..(file_name.size-1)).sub(/^\//, "") - if(!(fn =~ /CVS/ || File.directory?(fn) || fn == "")) then - installed_files << fn - end - - } + Find.find gem_directory do |file_name| + fn = file_name[gem_directory.size..file_name.size-1].sub(/^\//, "") + installed_files << fn unless + fn =~ /CVS/ || fn.empty? || File.directory?(file_name) + end installed_files end @@ -81,53 +86,82 @@ class Gem::Validator # # returns a hash of ErrorData objects, keyed on the problem gem's name. - def alien - errors = {} + def alien(gems=[]) + errors = Hash.new { |h,k| h[k] = {} } Gem::SourceIndex.from_installed_gems.each do |gem_name, gem_spec| - errors[gem_name] ||= [] - - gem_path = File.join(Gem.dir, "cache", gem_spec.full_name) + ".gem" - spec_path = File.join(Gem.dir, "specifications", gem_spec.full_name) + ".gemspec" - gem_directory = File.join(Gem.dir, "gems", gem_spec.full_name) - - installed_files = find_files_for_gem(gem_directory) + next unless gems.include? gem_spec.name unless gems.empty? + + install_dir = gem_spec.installation_path + gem_path = File.join(install_dir, "cache", gem_spec.full_name) + ".gem" + spec_path = File.join(install_dir, "specifications", + gem_spec.full_name) + ".gemspec" + gem_directory = gem_spec.full_gem_path + + unless File.directory? gem_directory then + errors[gem_name][gem_spec.full_name] = + "Gem registered but doesn't exist at #{gem_directory}" + next + end unless File.exist? spec_path then - errors[gem_name] << ErrorData.new(spec_path, "Spec file doesn't exist for installed gem") + errors[gem_name][spec_path] = "Spec file missing for installed gem" end begin verify_gem_file(gem_path) + good, gone, unreadable = nil, nil, nil, nil + open gem_path, Gem.binary_mode do |file| format = Gem::Format.from_file_by_path(gem_path) - format.file_entries.each do |entry, data| - # Found this file. Delete it from list - installed_files.delete remove_leading_dot_dir(entry['path']) - next unless data # HACK `gem check -a mkrf` + good, gone = format.file_entries.partition { |entry, _| + File.exist? File.join(gem_directory, entry['path']) + } + + gone.map! { |entry, _| entry['path'] } + gone.sort.each do |path| + errors[gem_name][path] = "Missing file" + end + + good, unreadable = good.partition { |entry, _| + File.readable? File.join(gem_directory, entry['path']) + } + + unreadable.map! { |entry, _| entry['path'] } + unreadable.sort.each do |path| + errors[gem_name][path] = "Unreadable file" + end - open File.join(gem_directory, entry['path']), Gem.binary_mode do |f| - unless Gem::MD5.hexdigest(f.read).to_s == - Gem::MD5.hexdigest(data).to_s then - errors[gem_name] << ErrorData.new(entry['path'], "installed file doesn't match original from gem") + good.each do |entry, data| + begin + next unless data # HACK `gem check -a mkrf` + + open File.join(gem_directory, entry['path']), Gem.binary_mode do |f| + unless Digest::MD5.hexdigest(f.read).to_s == + Digest::MD5.hexdigest(data).to_s then + errors[gem_name][entry['path']] = "Modified from original" + end end end end end + + installed_files = find_files_for_gem(gem_directory) + good.map! { |entry, _| entry['path'] } + extras = installed_files - good - unreadable + + extras.each do |extra| + errors[gem_name][extra] = "Extra file" + end rescue Gem::VerificationError => e - errors[gem_name] << ErrorData.new(gem_path, e.message) + errors[gem_name][gem_path] = e.message end + end - # Clean out directories that weren't explicitly included in the gemspec - # FIXME: This still allows arbitrary incorrect directories. - installed_files.delete_if {|potential_directory| - File.directory?(File.join(gem_directory, potential_directory)) - } - if(installed_files.size > 0) then - errors[gem_name] << ErrorData.new(gem_path, "Unmanaged files in gem: #{installed_files.inspect}") - end + errors.each do |name, subhash| + errors[name] = subhash.map { |path, msg| ErrorData.new(path, msg) } end errors @@ -167,7 +201,7 @@ class Gem::Validator def unit_test(gem_spec) start_dir = Dir.pwd Dir.chdir(gem_spec.full_gem_path) - $: << File.join(Gem.dir, "gems", gem_spec.full_name) + $: << gem_spec.full_gem_path # XXX: why do we need this gem_spec when we've already got 'spec'? test_files = gem_spec.test_files @@ -200,7 +234,6 @@ class Gem::Validator Dir.chdir(start_dir) end - private def remove_leading_dot_dir(path) path.sub(/^\.\//, "") end diff --git a/lib/rubygems/version.rb b/lib/rubygems/version.rb index 21ea9565b4..7c49a34a73 100644 --- a/lib/rubygems/version.rb +++ b/lib/rubygems/version.rb @@ -4,27 +4,81 @@ # See LICENSE.txt for permissions. #++ -require 'rubygems' - ## -# The Version class processes string versions into comparable values +# The Version class processes string versions into comparable +# values. A version string should normally be a series of numbers +# separated by periods. Each part (digits separated by periods) is +# considered its own number, and these are used for sorting. So for +# instance, 3.10 sorts higher than 3.2 because ten is greater than +# two. +# +# If any part contains letters (currently only a-z are supported) then +# that version is considered prerelease. Versions with a prerelease +# part in the Nth part sort less than versions with N-1 parts. Prerelease +# parts are sorted alphabetically using the normal Ruby string sorting +# rules. +# +# Prereleases sort between real releases (newest to oldest): +# +# 1. 1.0 +# 2. 1.0.b +# 3. 1.0.a +# 4. 0.9 class Gem::Version + class Part + include Comparable + + attr_reader :value + + def initialize(value) + @value = (value =~ /\A\d+\z/) ? value.to_i : value + end + + def to_s + self.value.to_s + end + + def inspect + @value + end + + def alpha? + String === value + end + + def numeric? + Fixnum === value + end + + def <=>(other) + if self.numeric? && other.alpha? then + 1 + elsif self.alpha? && other.numeric? then + -1 + else + self.value <=> other.value + end + end + + def succ + self.class.new(self.value.succ) + end + end + include Comparable - attr_reader :ints + VERSION_PATTERN = '[0-9]+(\.[0-9a-z]+)*' attr_reader :version - ## - # Returns true if +version+ is a valid version string. - def self.correct?(version) - case version - when Integer, /\A\s*(\d+(\.-?\d+)*)*\s*\z/ then true - else false - end + pattern = /\A\s*(#{VERSION_PATTERN})*\s*\z/ + + version.is_a? Integer or + version =~ pattern or + version.to_s =~ pattern end ## @@ -47,7 +101,7 @@ class Gem::Version ## # Constructs a Version from the +version+ string. A version string is a - # series of digits separated by dots. + # series of digits or ASCII letters separated by dots. def initialize(version) raise ArgumentError, "Malformed version number string #{version}" unless @@ -60,46 +114,43 @@ class Gem::Version "#<#{self.class} #{@version.inspect}>" end + ## # Dump only the raw version string, not the complete object + def marshal_dump [@version] end + ## # Load custom marshal format + def marshal_load(array) self.version = array[0] end + def parts + @parts ||= normalize + end + ## # Strip ignored trailing zeros. def normalize - @ints = build_array_from_version_string - - return if @ints.length == 1 - - @ints.pop while @ints.last == 0 - - @ints = [0] if @ints.empty? + parts_arr = parse_parts_from_version_string + if parts_arr.length != 1 + parts_arr.pop while parts_arr.last && parts_arr.last.value == 0 + parts_arr = [Part.new(0)] if parts_arr.empty? + end + parts_arr end ## # Returns the text representation of the version - # - # return:: [String] version as string - # + def to_s @version end - ## - # Returns an integer array representation of this Version. - - def to_ints - normalize unless @ints - @ints - end - def to_yaml_properties ['@version'] end @@ -109,6 +160,23 @@ class Gem::Version normalize end + ## + # A version is considered a prerelease if any part contains a letter. + + def prerelease? + parts.any? { |part| part.alpha? } + end + + ## + # The release for this version (e.g. 1.2.0.a -> 1.2.0) + # Non-prerelease versions return themselves + def release + return self unless prerelease? + rel_parts = parts.dup + rel_parts.pop while rel_parts.any? { |part| part.alpha? } + self.class.new(rel_parts.join('.')) + end + def yaml_initialize(tag, values) self.version = values['version'] end @@ -120,7 +188,14 @@ class Gem::Version def <=>(other) return nil unless self.class === other return 1 unless other - @ints <=> other.ints + mine, theirs = balance(self.parts.dup, other.parts.dup) + mine <=> theirs + end + + def balance(a, b) + a << Part.new(0) while a.size < b.size + b << Part.new(0) while b.size < a.size + [a, b] end ## @@ -135,24 +210,33 @@ class Gem::Version @version.hash end - # Return a new version object where the next to the last revision - # number is one greater. (e.g. 5.3.1 => 5.4) + ## + # Return a new version object where the next to the last revision number is + # one greater. (e.g. 5.3.1 => 5.4) + # + # Pre-release (alpha) parts are ignored. (e.g 5.3.1.b2 => 5.4) + def bump - ints = build_array_from_version_string - ints.pop if ints.size > 1 - ints[-1] += 1 - self.class.new(ints.join(".")) + parts = parse_parts_from_version_string + parts.pop while parts.any? { |part| part.alpha? } + parts.pop if parts.size > 1 + parts[-1] = parts[-1].succ + self.class.new(parts.join(".")) end - def build_array_from_version_string - @version.to_s.scan(/\d+/).map { |s| s.to_i } + def parse_parts_from_version_string # :nodoc: + @version.to_s.scan(/[0-9a-z]+/i).map { |s| Part.new(s) } + end + + def pretty_print(q) # :nodoc: + q.text "Gem::Version.new(#{@version.inspect})" end - private :build_array_from_version_string #:stopdoc: require 'rubygems/requirement' + ## # Gem::Requirement's original definition is nested in Version. # Although an inappropriate place, current gems specs reference the nested # class name explicitly. To remain compatible with old software loading diff --git a/lib/rubygems/version_option.rb b/lib/rubygems/version_option.rb index 1374018913..a69b732f78 100644 --- a/lib/rubygems/version_option.rb +++ b/lib/rubygems/version_option.rb @@ -41,6 +41,7 @@ module Gem::VersionOption "Specify version of gem to #{task}", *wrap) do |value, options| options[:version] = value + options[:prerelease] = true if value.prerelease? end end |