RubyGems - rubygems-update - Versions diffs - 1.4.2 → 1.5.0 - Mend

rubygems-update 1.4.2 → 1.5.0

Potentially problematic release.

This version of rubygems-update might be problematic. Click here for more details.

Files changed (150) hide show

metadata.gz.sig CHANGED

Binary file

data/lib/rubygems/commands/mirror_command.rb DELETED

@@ -1,111 +0,0 @@
-require 'rubygems/command'
-class Gem::Commands::MirrorCommand < Gem::Command
-  def initialize
-    require 'yaml'
-    require 'zlib'
-    require 'open-uri'
-    super 'mirror', 'Mirror a gem repository'
-  end
-  def description # :nodoc:
-    <<-EOF
-The mirror command uses the ~/.gemmirrorrc config file to mirror remote gem
-repositories to a local path. The config file is a YAML document that looks
-like this:
-  ---
-  - from: http://gems.example.com # source repository URI
-    to: /path/to/mirror           # destination directory
-Multiple sources and destinations may be specified.
-    EOF
-  end
-  def execute
-    config_file = File.join Gem.user_home, '.gemmirrorrc'
-    raise "Config file #{config_file} not found" unless File.exist? config_file
-    mirrors = YAML.load_file config_file
-    raise "Invalid config file #{config_file}" unless mirrors.respond_to? :each
-    mirrors.each do |mir|
-      raise "mirror missing 'from' field" unless mir.has_key? 'from'
-      raise "mirror missing 'to' field" unless mir.has_key? 'to'
-      get_from = mir['from']
-      save_to = File.expand_path mir['to']
-      raise "Directory not found: #{save_to}" unless File.exist? save_to
-      raise "Not a directory: #{save_to}" unless File.directory? save_to
-      gems_dir = File.join save_to, "gems"
-      if File.exist? gems_dir then
-        raise "Not a directory: #{gems_dir}" unless File.directory? gems_dir
-      else
-        Dir.mkdir gems_dir
-      end
-      source_index_data = ''
-      say "fetching: #{get_from}/Marshal.#{Gem.marshal_version}.Z"
-      get_from = URI.parse get_from
-      if get_from.scheme.nil? then
-        get_from = get_from.to_s
-      elsif get_from.scheme == 'file' then
-        # check if specified URI contains a drive letter (file:/D:/Temp)
-        get_from = get_from.to_s
-        get_from = if get_from =~ /^file:.*[a-z]:/i then
-                     get_from[6..-1]
-                   else
-                     get_from[5..-1]
-                   end
-      end
-      open File.join(get_from.to_s, "Marshal.#{Gem.marshal_version}.Z"), "rb" do |y|
-        source_index_data = Zlib::Inflate.inflate y.read
-        open File.join(save_to, "Marshal.#{Gem.marshal_version}"), "wb" do |out|
-          out.write source_index_data
-        end
-      end
-      source_index = Marshal.load source_index_data
-      progress = ui.progress_reporter source_index.size,
-                                      "Fetching #{source_index.size} gems"
-      source_index.each do |fullname, gem|
-        gem_file = gem.file_name
-        gem_dest = File.join gems_dir, gem_file
-        unless File.exist? gem_dest then
-          begin
-            open "#{get_from}/gems/#{gem_file}", "rb" do |g|
-              contents = g.read
-              open gem_dest, "wb" do |out|
-                out.write contents
-              end
-            end
-          rescue
-            old_gf = gem_file
-            gem_file = gem_file.downcase
-            retry if old_gf != gem_file
-            alert_error $!
-          end
-        end
-        progress.updated gem_file
-      end
-      progress.done
-    end
-  end
-end

data/lib/rubygems/source_info_cache.rb DELETED

@@ -1,394 +0,0 @@
-require 'rubygems'
-require 'rubygems/source_info_cache_entry'
-require 'rubygems/user_interaction'
-##
-# SourceInfoCache stores a copy of the gem index for each gem source.
-#
-# There are two possible cache locations, the system cache and the user cache:
-# * The system cache is preferred if it is writable or can be created.
-# * The user cache is used otherwise
-#
-# Once a cache is selected, it will be used for all operations.
-# SourceInfoCache will not switch between cache files dynamically.
-#
-# Cache data is a Hash mapping a source URI to a SourceInfoCacheEntry.
-#
-#--
-# To keep things straight, this is how the cache objects all fit together:
-#
-#   Gem::SourceInfoCache
-#     @cache_data = {
-#       source_uri => Gem::SourceInfoCacheEntry
-#         @size = source index size
-#         @source_index = Gem::SourceIndex
-#       ...
-#     }
-class Gem::SourceInfoCache
-  include Gem::UserInteraction
-  ##
-  # The singleton Gem::SourceInfoCache.  If +all+ is true, a full refresh will
-  # be performed if the singleton instance is being initialized.
-  def self.cache(all = false)
-    return @cache if @cache
-    @cache = new
-    @cache.refresh all if Gem.configuration.update_sources
-    @cache
-  end
-  def self.cache_data
-    cache.cache_data
-  end
-  ##
-  # The name of the system cache file.
-  def self.latest_system_cache_file
-    File.join File.dirname(system_cache_file),
-              "latest_#{File.basename system_cache_file}"
-  end
-  ##
-  # The name of the latest user cache file.
-  def self.latest_user_cache_file
-    File.join File.dirname(user_cache_file),
-              "latest_#{File.basename user_cache_file}"
-  end
-  ##
-  # Reset all singletons, discarding any changes.
-  def self.reset
-    @cache = nil
-    @system_cache_file = nil
-    @user_cache_file = nil
-  end
-  ##
-  # Search all source indexes.  See Gem::SourceInfoCache#search.
-  def self.search(*args)
-    cache.search(*args)
-  end
-  ##
-  # Search all source indexes returning the source_uri.  See
-  # Gem::SourceInfoCache#search_with_source.
-  def self.search_with_source(*args)
-    cache.search_with_source(*args)
-  end
-  ##
-  # The name of the system cache file. (class method)
-  def self.system_cache_file
-    @system_cache_file ||= Gem.default_system_source_cache_dir
-  end
-  ##
-  # The name of the user cache file.
-  def self.user_cache_file
-    @user_cache_file ||=
-      ENV['GEMCACHE'] || Gem.default_user_source_cache_dir
-  end
-  def initialize # :nodoc:
-    require 'fileutils'
-    @cache_data = nil
-    @cache_file = nil
-    @dirty = false
-    @only_latest = true
-  end
-  ##
-  # The most recent cache data.
-  def cache_data
-    return @cache_data if @cache_data
-    cache_file # HACK writable check
-    @only_latest = true
-    @cache_data = read_cache_data latest_cache_file
-    @cache_data
-  end
-  ##
-  # The name of the cache file.
-  def cache_file
-    return @cache_file if @cache_file
-    @cache_file = (try_file(system_cache_file) or
-      try_file(user_cache_file) or
-      raise "unable to locate a writable cache file")
-  end
-  ##
-  # Write the cache to a local file (if it is dirty).
-  def flush
-    write_cache if @dirty
-    @dirty = false
-  end
-  def latest_cache_data
-    latest_cache_data = {}
-    cache_data.each do |repo, sice|
-      latest = sice.source_index.latest_specs
-      new_si = Gem::SourceIndex.new
-      new_si.add_specs(*latest)
-      latest_sice = Gem::SourceInfoCacheEntry.new new_si, sice.size
-      latest_cache_data[repo] = latest_sice
-    end
-    latest_cache_data
-  end
-  ##
-  # The name of the latest cache file.
-  def latest_cache_file
-    File.join File.dirname(cache_file), "latest_#{File.basename cache_file}"
-  end
-  ##
-  # The name of the latest system cache file.
-  def latest_system_cache_file
-    self.class.latest_system_cache_file
-  end
-  ##
-  # The name of the latest user cache file.
-  def latest_user_cache_file
-    self.class.latest_user_cache_file
-  end
-  ##
-  # Merges the complete cache file into this Gem::SourceInfoCache.
-  def read_all_cache_data
-    if @only_latest then
-      @only_latest = false
-      all_data = read_cache_data cache_file
-      cache_data.update all_data do |source_uri, latest_sice, all_sice|
-        all_sice.source_index.gems.update latest_sice.source_index.gems
-        Gem::SourceInfoCacheEntry.new all_sice.source_index, latest_sice.size
-      end
-      begin
-        refresh true
-      rescue Gem::RemoteFetcher::FetchError
-      end
-    end
-  end
-  ##
-  # Reads cached data from +file+.
-  def read_cache_data(file)
-    # Marshal loads 30-40% faster from a String, and 2MB on 20061116 is small
-    data = open file, 'rb' do |fp| fp.read end
-    cache_data = Marshal.load data
-    cache_data.each do |url, sice|
-      next unless sice.is_a?(Hash)
-      update
-      cache = sice['cache']
-      size  = sice['size']
-      if cache.is_a?(Gem::SourceIndex) and size.is_a?(Numeric) then
-        new_sice = Gem::SourceInfoCacheEntry.new cache, size
-        cache_data[url] = new_sice
-      else # irreperable, force refetch.
-        reset_cache_for url, cache_data
-      end
-    end
-    cache_data
-  rescue Errno::ENOENT
-    {}
-  rescue => e
-    if Gem.configuration.really_verbose then
-      say "Exception during cache_data handling: #{e.class} - #{e}"
-      say "Cache file was: #{file}"
-      say "\t#{e.backtrace.join "\n\t"}"
-    end
-    {}
-  end
-  ##
-  # Refreshes each source in the cache from its repository.  If +all+ is
-  # false, only latest gems are updated.
-  def refresh(all)
-    Gem.sources.each do |source_uri|
-      cache_entry = cache_data[source_uri]
-      if cache_entry.nil? then
-        cache_entry = Gem::SourceInfoCacheEntry.new nil, 0
-        cache_data[source_uri] = cache_entry
-      end
-      update if cache_entry.refresh source_uri, all
-    end
-    flush
-  end
-  def reset_cache_for(url, cache_data)
-    say "Reseting cache for #{url}" if Gem.configuration.really_verbose
-    sice = Gem::SourceInfoCacheEntry.new Gem::SourceIndex.new, 0
-    sice.refresh url, false # HACK may be unnecessary, see ::cache and #refresh
-    cache_data[url] = sice
-    cache_data
-  end
-  def reset_cache_data
-    @cache_data = nil
-    @only_latest = true
-  end
-  ##
-  # Force cache file to be reset, useful for integration testing of rubygems
-  def reset_cache_file
-    @cache_file = nil
-  end
-  ##
-  # Searches all source indexes.  See Gem::SourceIndex#search for details on
-  # +pattern+ and +platform_only+.  If +all+ is set to true, the full index
-  # will be loaded before searching.
-  def search(pattern, platform_only = false, all = false)
-    read_all_cache_data if all
-    cache_data.map do |source_uri, sic_entry|
-      next unless Gem.sources.include? source_uri
-      # TODO - Remove this gunk after 2008/11
-      unless pattern.kind_of? Gem::Dependency then
-        pattern = Gem::Dependency.new pattern, Gem::Requirement.default
-      end
-      sic_entry.source_index.search pattern, platform_only
-    end.flatten.compact
-  end
-  ##
-  # Searches all source indexes for +pattern+.  If +only_platform+ is true,
-  # only gems matching Gem.platforms will be selected.  Returns an Array of
-  # pairs containing the Gem::Specification found and the source_uri it was
-  # found at.
-  def search_with_source(pattern, only_platform = false, all = false)
-    read_all_cache_data if all
-    results = []
-    cache_data.map do |source_uri, sic_entry|
-      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)
-      end
-      sic_entry.source_index.search(pattern, only_platform).each do |spec|
-        results << [spec, source_uri]
-      end
-    end
-    results
-  end
-  ##
-  # Set the source info cache data directly.  This is mainly used for unit
-  # testing when we don't want to read a file system to grab the cached source
-  # index information.  The +hash+ should map a source URL into a
-  # SourceInfoCacheEntry.
-  def set_cache_data(hash)
-    @cache_data = hash
-    update
-  end
-  ##
-  # The name of the system cache file.
-  def system_cache_file
-    self.class.system_cache_file
-  end
-  ##
-  # Determine if +path+ is a candidate for a cache file.  Returns +path+ if
-  # it is, nil if not.
-  def try_file(path)
-    return path if File.writable? path
-    return nil if File.exist? path
-    dir = File.dirname path
-    unless File.exist? dir then
-      begin
-        FileUtils.mkdir_p dir
-      rescue RuntimeError, SystemCallError
-        return nil
-      end
-    end
-    return path if File.writable? dir
-    nil
-  end
-  ##
-  # Mark the cache as updated (i.e. dirty).
-  def update
-    @dirty = true
-  end
-  ##
-  # The name of the user cache file.
-  def user_cache_file
-    self.class.user_cache_file
-  end
-  ##
-  # Write data to the proper cache files.
-  def write_cache
-    if not File.exist?(cache_file) or not @only_latest then
-      open cache_file, 'wb' do |io|
-        io.write Marshal.dump(cache_data)
-      end
-    end
-    open latest_cache_file, 'wb' do |io|
-      io.write Marshal.dump(latest_cache_data)
-    end
-  end
-  reset
-end