rb2exe 0.1.11 → 0.1.12

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/ext/cmake_builder.rb

@@ -0,0 +1,16 @@
+require 'rubygems/command'
+
+class Gem::Ext::CmakeBuilder < Gem::Ext::Builder
+  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
+    unless File.exist?('Makefile') then
+      cmd = "cmake . -DCMAKE_INSTALL_PREFIX=#{dest_path}"
+      cmd << " #{Gem::Command.build_args.join ' '}" unless Gem::Command.build_args.empty?
+
+      run cmd, results
+    end
+
+    make dest_path, results
+
+    results
+  end
+end

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/ext/configure_builder.rb

@@ -0,0 +1,23 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+class Gem::Ext::ConfigureBuilder < Gem::Ext::Builder
+
+  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
+    unless File.exist?('Makefile') then
+      cmd = "sh ./configure --prefix=#{dest_path}"
+      cmd << " #{args.join ' '}" unless args.empty?
+
+      run cmd, results
+    end
+
+    make dest_path, results
+
+    results
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/ext/ext_conf_builder.rb

@@ -0,0 +1,78 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'fileutils'
+require 'tempfile'
+
+class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder
+  FileEntry = FileUtils::Entry_ # :nodoc:
+
+  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
+    # relative path required as some versions of mktmpdir return an absolute
+    # path which breaks make if it includes a space in the name
+    tmp_dest = get_relative_path(Dir.mktmpdir(".gem.", "."))
+
+    t = nil
+    Tempfile.open %w"siteconf .rb", "." do |siteconf|
+      t = siteconf
+      siteconf.puts "require 'rbconfig'"
+      siteconf.puts "dest_path = #{tmp_dest.dump}"
+      %w[sitearchdir sitelibdir].each do |dir|
+        siteconf.puts "RbConfig::MAKEFILE_CONFIG['#{dir}'] = dest_path"
+        siteconf.puts "RbConfig::CONFIG['#{dir}'] = dest_path"
+      end
+
+      siteconf.flush
+
+      destdir = ENV["DESTDIR"]
+
+      begin
+        cmd = [Gem.ruby, "-r", get_relative_path(siteconf.path), File.basename(extension), *args].join ' '
+
+        begin
+          run cmd, results
+        ensure
+          FileUtils.mv 'mkmf.log', dest_path if File.exist? 'mkmf.log'
+          siteconf.unlink
+        end
+
+        ENV["DESTDIR"] = nil
+
+        make dest_path, results
+
+        if tmp_dest
+          # TODO remove in RubyGems 3
+          if Gem.install_extension_in_lib and lib_dir then
+            FileUtils.mkdir_p lib_dir
+            entries = Dir.entries(tmp_dest) - %w[. ..]
+            entries = entries.map { |entry| File.join tmp_dest, entry }
+            FileUtils.cp_r entries, lib_dir, :remove_destination => true
+          end
+
+          FileEntry.new(tmp_dest).traverse do |ent|
+            destent = ent.class.new(dest_path, ent.rel)
+            destent.exist? or FileUtils.mv(ent.path, destent.path)
+          end
+        end
+      ensure
+        ENV["DESTDIR"] = destdir
+      end
+    end
+    t.unlink if t and t.path
+
+    results
+  ensure
+    FileUtils.rm_rf tmp_dest if tmp_dest
+  end
+
+  private
+  def self.get_relative_path(path)
+    path[0..Dir.pwd.length-1] = '.' if path.start_with?(Dir.pwd)
+    path
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/ext/rake_builder.rb

@@ -0,0 +1,36 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+class Gem::Ext::RakeBuilder < Gem::Ext::Builder
+
+  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
+    if File.basename(extension) =~ /mkrf_conf/i then
+      cmd = "#{Gem.ruby} #{File.basename extension}"
+      cmd << " #{args.join " "}" unless args.empty?
+      run cmd, results
+    end
+
+    # Deal with possible spaces in the path, e.g. C:/Program Files
+    dest_path = '"' + dest_path.to_s + '"' if dest_path.to_s.include?(' ')
+
+    rake = ENV['rake']
+
+    rake ||= begin
+               "#{Gem.ruby} -rubygems #{Gem.bin_path('rake', 'rake')}"
+             rescue Gem::Exception
+             end
+
+    rake ||= Gem.default_exec_format % 'rake'
+
+    cmd = "#{rake} RUBYARCHDIR=#{dest_path} RUBYLIBDIR=#{dest_path}" # ENV is frozen
+
+    run cmd, results
+
+    results
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/gem_runner.rb

@@ -0,0 +1,81 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'rubygems'
+require 'rubygems/command_manager'
+require 'rubygems/config_file'
+
+##
+# Load additional plugins from $LOAD_PATH
+
+Gem.load_env_plugins rescue nil
+
+##
+# 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.
+
+class Gem::GemRunner
+
+  def initialize(options={})
+    # TODO: nuke these options
+    @command_manager_class = options[:command_manager] || Gem::CommandManager
+    @config_file_class = options[:config_file] || Gem::ConfigFile
+  end
+
+  ##
+  # Run the gem command with the following arguments.
+
+  def run args
+    build_args = extract_build_args 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
+
+    cmd.run Gem.configuration.args, build_args
+  end
+
+  ##
+  # Separates the build arguments (those following <code>--</code>) from the
+  # other arguments in the list.
+
+  def extract_build_args args # :nodoc:
+    return [] unless offset = args.index('--')
+
+    build_args = args.slice!(offset...args.length)
+
+    build_args.shift
+
+    build_args
+  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]
+  end
+
+end
+
+Gem.load_plugins

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/gemcutter_utilities.rb

@@ -0,0 +1,154 @@
+require 'rubygems/remote_fetcher'
+
+##
+# Utility methods for using the RubyGems API.
+
+module Gem::GemcutterUtilities
+
+  # TODO: move to Gem::Command
+  OptionParser.accept Symbol do |value|
+    value.to_sym
+  end
+
+  attr_writer :host
+
+  ##
+  # Add the --key option
+
+  def add_key_option
+    add_option('-k', '--key KEYNAME', Symbol,
+               'Use the given API key',
+               'from ~/.gem/credentials') do |value,options|
+      options[:key] = value
+    end
+  end
+
+  ##
+  # The API key from the command options or from the user's configuration.
+
+  def api_key
+    if options[:key] then
+      verify_api_key options[:key]
+    elsif Gem.configuration.api_keys.key?(host)
+      Gem.configuration.api_keys[host]
+    else
+      Gem.configuration.rubygems_api_key
+    end
+  end
+
+  ##
+  # The host to connect to either from the RUBYGEMS_HOST environment variable
+  # or from the user's configuration
+
+  def host
+    configured_host = Gem.host unless
+      Gem.configuration.disable_default_gem_server
+
+    @host ||=
+      begin
+        env_rubygems_host = ENV['RUBYGEMS_HOST']
+        env_rubygems_host = nil if
+          env_rubygems_host and env_rubygems_host.empty?
+
+        env_rubygems_host|| configured_host
+      end
+  end
+
+  ##
+  # Creates an RubyGems API to +host+ and +path+ with the given HTTP +method+.
+  #
+  # If +allowed_push_host+ metadata is present, then it will only allow that host.
+
+  def rubygems_api_request(method, path, host = nil, allowed_push_host = nil, &block)
+    require 'net/http'
+
+    self.host = host if host
+    unless self.host
+      alert_error "You must specify a gem server"
+      terminate_interaction 1 # TODO: question this
+    end
+
+    if allowed_push_host and self.host != allowed_push_host
+      alert_error "#{self.host.inspect} is not allowed by the gemspec, which only allows #{allowed_push_host.inspect}"
+      terminate_interaction 1
+    end
+
+    uri = URI.parse "#{self.host}/#{path}"
+
+    request_method = Net::HTTP.const_get method.to_s.capitalize
+
+    Gem::RemoteFetcher.fetcher.request(uri, request_method, &block)
+  end
+
+  ##
+  # Signs in with the RubyGems API at +sign_in_host+ and sets the rubygems API
+  # key.
+
+  def sign_in sign_in_host = nil
+    sign_in_host ||= self.host
+    return if api_key
+
+    pretty_host = if Gem::DEFAULT_HOST == sign_in_host then
+                    'RubyGems.org'
+                  else
+                    sign_in_host
+                  end
+
+    say "Enter your #{pretty_host} credentials."
+    say "Don't have an account yet? " +
+        "Create one at #{sign_in_host}/sign_up"
+
+    email    =              ask "   Email: "
+    password = ask_for_password "Password: "
+    say "\n"
+
+    response = rubygems_api_request(:get, "api/v1/api_key",
+                                    sign_in_host) do |request|
+      request.basic_auth email, password
+    end
+
+    with_response response do |resp|
+      say "Signed in."
+      Gem.configuration.rubygems_api_key = resp.body
+    end
+  end
+
+  ##
+  # Retrieves the pre-configured API key +key+ or terminates interaction with
+  # an error.
+
+  def verify_api_key(key)
+    if Gem.configuration.api_keys.key? key then
+      Gem.configuration.api_keys[key]
+    else
+      alert_error "No such API key. Please add it to your configuration (done automatically on initial `gem push`)."
+      terminate_interaction 1 # TODO: question this
+    end
+  end
+
+  ##
+  # If +response+ is an HTTP Success (2XX) response, yields the response if a
+  # block was given or shows the response body to the user.
+  #
+  # If the response was not successful, shows an error to the user including
+  # the +error_prefix+ and the response body.
+
+  def with_response response, error_prefix = nil
+    case response
+    when Net::HTTPSuccess then
+      if block_given? then
+        yield response
+      else
+        say response.body
+      end
+    else
+      message = response.body
+      message = "#{error_prefix}: #{message}" if error_prefix
+
+      say message
+      terminate_interaction 1 # TODO: question this
+    end
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/indexer.rb

@@ -0,0 +1,498 @@
+require 'rubygems'
+require 'rubygems/package'
+require 'time'
+
+begin
+  gem 'builder'
+  require 'builder/xchar'
+rescue LoadError
+end
+
+##
+# Top level class for building the gem repository index.
+
+class Gem::Indexer
+
+  include Gem::UserInteraction
+
+  ##
+  # 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
+
+  ##
+  # Create an indexer that will index the gems in +directory+.
+
+  def initialize(directory, options = {})
+    require 'fileutils'
+    require 'tmpdir'
+    require 'zlib'
+
+    unless defined?(Builder::XChar) then
+      raise "Gem::Indexer requires that the XML Builder library be installed:" +
+            "\n\tgem install builder"
+    end
+
+    options = { :build_modern => true }.merge options
+
+    @build_modern = options[:build_modern]
+
+    @dest_directory = directory
+    @directory = File.join(Dir.tmpdir, "gem_generate_index_#{$$}")
+
+    marshal_name = "Marshal.#{Gem.marshal_version}"
+
+    @master_index = File.join @directory, 'yaml'
+    @marshal_index = File.join @directory, marshal_name
+
+    @quick_dir = File.join @directory, 'quick'
+    @quick_marshal_dir = File.join @quick_dir, marshal_name
+    @quick_marshal_dir_base = File.join "quick", marshal_name # FIX: UGH
+
+    @quick_index = File.join @quick_dir, 'index'
+    @latest_index = File.join @quick_dir, 'latest_index'
+
+    @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}")
+    @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}")
+
+    @files = []
+  end
+
+  ##
+  # Abbreviate the spec for downloading.  Abbreviated specs are only used for
+  # searching, downloading and related activities and do not need deployment
+  # specific information (e.g. list of files).  So we abbreviate the spec,
+  # making it much smaller for quicker downloads.
+  #--
+  # TODO move to Gem::Specification
+
+  def abbreviate(spec)
+    spec.files = []
+    spec.test_files = []
+    spec.rdoc_options = []
+    spec.extra_rdoc_files = []
+    spec.cert_chain = []
+    spec
+  end
+
+  ##
+  # Build various indicies
+
+  def build_indicies
+    Gem::Specification.dirs = []
+    Gem::Specification.add_specs(*map_gems_to_specs(gem_file_list))
+
+    build_marshal_gemspecs
+    build_modern_indicies if @build_modern
+
+    compress_indicies
+  end
+
+  ##
+  # Builds Marshal quick index gemspecs.
+
+  def build_marshal_gemspecs
+    count = Gem::Specification.count { |s| not s.default_gem? }
+    progress = ui.progress_reporter count,
+                                    "Generating Marshal quick index gemspecs for #{count} gems",
+                                    "Complete"
+
+    files = []
+
+    Gem.time 'Generated Marshal quick index gemspecs' do
+      Gem::Specification.each do |spec|
+        next if spec.default_gem?
+        spec_file_name = "#{spec.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 spec.original_name
+      end
+
+      progress.done
+    end
+
+    @files << @quick_marshal_dir
+
+    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.
+          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
+    specs = Gem::Specification.reject { |s| s.default_gem? }
+
+    prerelease, released = specs.partition { |s|
+      s.version.prerelease?
+    }
+    latest_specs =
+      Gem::Specification.latest_specs.reject { |s| s.default_gem? }
+
+    build_modern_index(released.sort, @specs_index, 'specs')
+    build_modern_index(latest_specs.sort, @latest_specs_index, 'latest specs')
+    build_modern_index(prerelease.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
+
+  def map_gems_to_specs gems
+    gems.map { |gemfile|
+      if File.size(gemfile) == 0 then
+        alert_warning "Skipping zero-length gem: #{gemfile}"
+        next
+      end
+
+      begin
+        spec = Gem::Package.new(gemfile).spec
+        spec.loaded_from = gemfile
+
+        # HACK: fuck this shit - borks all tests that use pl1
+        # if File.basename(gemfile, ".gem") != spec.original_name then
+        #   exp = spec.full_name
+        #   exp << " (#{spec.original_name})" if
+        #     spec.original_name != spec.full_name
+        #   msg = "Skipping misnamed gem: #{gemfile} should be named #{exp}"
+        #   alert_warning msg
+        #   next
+        # end
+
+        abbreviate spec
+        sanitize spec
+
+        spec
+      rescue SignalException
+        alert_error "Received signal, exiting"
+        raise
+      rescue Exception => e
+        msg = ["Unable to process #{gemfile}",
+               "#{e.message} (#{e.class})",
+               "\t#{e.backtrace.join "\n\t"}"].join("\n")
+        alert_error msg
+      end
+    }.compact
+  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_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.
+
+  def compact_specs(specs)
+    names = {}
+    versions = {}
+    platforms = {}
+
+    specs.map do |(name, version, platform)|
+      names[name] = name unless names.include? name
+      versions[version] = version unless versions.include? version
+      platforms[platform] = platform unless platforms.include? platform
+
+      [names[name], versions[version], platforms[platform]]
+    end
+  end
+
+  ##
+  # Compress +filename+ with +extension+.
+
+  def compress(filename, extension)
+    data = Gem.read_binary filename
+
+    zipped = Gem.deflate data
+
+    open "#{filename}.#{extension}", 'wb' do |io|
+      io.write zipped
+    end
+  end
+
+  ##
+  # List of gem file names to index.
+
+  def gem_file_list
+    Dir[File.join(@dest_directory, "gems", '*.gem')]
+  end
+
+  ##
+  # Builds and installs indicies.
+
+  def generate_index
+    make_temp_directories
+    build_indicies
+    install_indicies
+  rescue SignalException
+  ensure
+    FileUtils.rm_rf @directory
+  end
+
+  ##
+  # Zlib::GzipWriter wrapper that gzips +filename+ on disk.
+
+  def gzip(filename)
+    Zlib::GzipWriter.open "#{filename}.gz" do |io|
+      io.write Gem.read_binary(filename)
+    end
+  end
+
+  ##
+  # Install generated indicies into the destination directory.
+
+  def install_indicies
+    verbose = Gem.configuration.really_verbose
+
+    say "Moving index into production dir #{@dest_directory}" if verbose
+
+    files = @files
+    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
+
+      dst_name = File.join(@dest_directory, @quick_marshal_dir_base)
+
+      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(/^#{Regexp.escape @directory}\/?/, '') # HACK?
+    end
+
+    files.each do |file|
+      src_name = File.join @directory, file
+      dst_name = File.join @dest_directory, file
+
+      FileUtils.rm_rf dst_name, :verbose => verbose
+      FileUtils.mv(src_name, @dest_directory,
+                   :verbose => verbose, :force => true)
+    end
+  end
+
+  ##
+  # Make directories for index generation
+
+  def make_temp_directories
+    FileUtils.rm_rf @directory
+    FileUtils.mkdir_p @directory, :mode => 0700
+    FileUtils.mkdir_p @quick_marshal_dir
+  end
+
+  ##
+  # Ensure +path+ and path with +extension+ are identical.
+
+  def paranoid(path, extension)
+    data = Gem.read_binary path
+    compressed_data = Gem.read_binary "#{path}.#{extension}"
+
+    unless data == Gem.inflate(compressed_data) then
+      raise "Compressed file #{compressed_path} does not match uncompressed file #{path}"
+    end
+  end
+
+  ##
+  # Sanitize the descriptive fields in the spec.  Sometimes non-ASCII
+  # characters will garble the site index.  Non-ASCII characters will
+  # be replaced by their XML entity equivalent.
+
+  def sanitize(spec)
+    spec.summary              = sanitize_string(spec.summary)
+    spec.description          = sanitize_string(spec.description)
+    spec.post_install_message = sanitize_string(spec.post_install_message)
+    spec.authors              = spec.authors.collect { |a| sanitize_string(a) }
+
+    spec
+  end
+
+  ##
+  # Sanitize a single string.
+
+  def sanitize_string(string)
+    return string unless string
+
+    # HACK the #to_s is in here because RSpec has an Array of Arrays of
+    # Strings for authors.  Need a way to disallow bad values on gemspec
+    # generation.  (Probably won't happen.)
+    string = string.to_s
+
+    begin
+      Builder::XChar.encode string
+    rescue NameError, NoMethodError
+      string.to_xs
+    end
+  end
+
+  ##
+  # Perform an in-place update of the repository from newly added gems.
+
+  def update_index
+    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
+
+    specs = map_gems_to_specs updated_gems
+    prerelease, released = specs.partition { |s| s.version.prerelease? }
+
+    Gem::Specification.dirs = []
+    Gem::Specification.add_specs(*specs)
+
+    files = build_marshal_gemspecs
+
+    Gem.time 'Updated indexes' do
+      update_specs_index released, @dest_specs_index, @specs_index
+      update_specs_index released, @dest_latest_specs_index, @latest_specs_index
+      update_specs_index(prerelease,
+                         @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(/^#{Regexp.escape @directory}\/?/, '') # HACK?
+    end
+
+    files.each do |file|
+      src_name = File.join @directory, file
+      dst_name = File.join @dest_directory, file # REFACTOR: duped above
+
+      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