shoesgem 0.1424.0

data/shoes/ruby/lib/rubygems/commands/uninstall_command.rb

@@ -0,0 +1,73 @@
+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
+
+      def arguments # :nodoc:
+        "GEMNAME       name of gem to uninstall"
+      end
+
+      def defaults_str # :nodoc:
+        "--version '#{Gem::Requirement.default}' --no-force " \
+        "--install-dir #{Gem.dir}"
+      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
+  end
+end

data/shoes/ruby/lib/rubygems/commands/unpack_command.rb

@@ -0,0 +1,95 @@
+require 'fileutils'
+require 'rubygems/command'
+require 'rubygems/installer'
+require 'rubygems/version_option'
+
+class Gem::Commands::UnpackCommand < Gem::Command
+
+  include Gem::VersionOption
+
+  def initialize
+    super 'unpack', 'Unpack an installed gem to the current directory',
+          :version => Gem::Requirement.default,
+          :target  => Dir.pwd
+
+    add_option('--target', 'target directory for unpacking') do |value, options|
+      options[:target] = value
+    end
+
+    add_version_option
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to unpack"
+  end
+
+  def defaults_str # :nodoc:
+    "--version '#{Gem::Requirement.default}'"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  #--
+  # 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."
+    end
+  end
+
+  # Return the full path to the cached gem file matching the given
+  # name and version requirement.  Returns 'nil' if no match.
+  #
+  # Example:
+  #
+  #   get_path('rake', '> 0.4')   # -> '/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem'
+  #   get_path('rake', '< 0.1')   # -> nil
+  #   get_path('rak')             # -> nil (exact name required)
+  #--
+  # TODO: This should be refactored so that it's a general service. I don't
+  # think any of our existing classes are the right place though.  Just maybe
+  # 'Cache'?
+  #
+  # TODO: It just uses Gem.dir for now.  What's an easy way to get the list of
+  # source directories?
+  def get_path(gemname, version_req)
+    return gemname if gemname =~ /\.gem$/i
+
+    specs = Gem::source_index.find_name gemname, version_req
+
+    selected = specs.sort_by { |s| s.version }.last
+
+    return nil if selected.nil?
+
+    # We expect to find (basename).gem in the 'cache' directory.
+    # Furthermore, the name match must be exact (ignoring case).
+    if gemname =~ /^#{selected.name}$/i
+      filename = selected.full_name + '.gem'
+      path = nil
+
+      Gem.path.find do |gem_dir|
+        path = File.join gem_dir, 'cache', filename
+        File.exist? path
+      end
+
+      path
+    else
+      nil
+    end
+  end
+
+end
+

data/shoes/ruby/lib/rubygems/commands/update_command.rb

@@ -0,0 +1,181 @@
+require 'rubygems/command'
+require 'rubygems/command_manager'
+require 'rubygems/install_update_options'
+require 'rubygems/local_remote_options'
+require 'rubygems/spec_fetcher'
+require 'rubygems/version_option'
+require 'rubygems/commands/install_command'
+
+class Gem::Commands::UpdateCommand < Gem::Command
+
+  include Gem::InstallUpdateOptions
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
+
+  def initialize
+    super 'update',
+          'Update the named gems (or all installed gems) in the local repository',
+      :generate_rdoc => true,
+      :generate_ri => true,
+      :force => false,
+      :test => false
+
+    add_install_update_options
+
+    add_option('--system',
+               'Update the RubyGems system software') do |value, options|
+      options[:system] = value
+    end
+
+    add_local_remote_options
+
+    add_platform_option
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to update"
+  end
+
+  def defaults_str # :nodoc:
+    "--rdoc --ri --no-force --no-test --install-dir #{Gem.dir}"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...]"
+  end
+
+  def execute
+    hig = {}
+
+    if options[:system] then
+      say "Updating RubyGems"
+
+      unless options[:args].empty? then
+        fail "No gem names are allowed with the --system option"
+      end
+
+      rubygems_update = Gem::Specification.new
+      rubygems_update.name = 'rubygems-update'
+      rubygems_update.version = Gem::Version.new Gem::RubyGemsVersion
+      hig['rubygems-update'] = rubygems_update
+
+      options[:user_install] = false
+    else
+      say "Updating installed gems"
+
+      hig = {} # highest installed gems
+
+      Gem.source_index.each do |name, spec|
+        if hig[spec.name].nil? or hig[spec.name].version < spec.version then
+          hig[spec.name] = spec
+        end
+      end
+    end
+
+    gems_to_update = which_to_update hig, options[:args]
+
+    updated = []
+
+    installer = Gem::DependencyInstaller.new options
+
+    gems_to_update.uniq.sort.each do |name|
+      next if updated.any? { |spec| spec.name == name }
+
+      say "Updating #{name}"
+      installer.install name
+
+      installer.installed_gems.each do |spec|
+        updated << spec
+        say "Successfully installed #{spec.full_name}"
+      end
+    end
+
+    if gems_to_update.include? "rubygems-update" then
+      Gem.source_index.refresh!
+
+      update_gems = Gem.source_index.search 'rubygems-update'
+
+      latest_update_gem = update_gems.sort_by { |s| s.version }.last
+
+      say "Updating RubyGems to #{latest_update_gem.version}"
+      installed = do_rubygems_update latest_update_gem.version
+
+      say "RubyGems system software updated" if installed
+    else
+      if updated.empty? then
+        say "Nothing to update"
+      else
+        say "Gems updated: #{updated.map { |spec| spec.name }.join ', '}"
+      end
+    end
+  end
+
+  ##
+  # Update the RubyGems software to +version+.
+
+  def do_rubygems_update(version)
+    args = []
+    args.push '--prefix', Gem.prefix unless Gem.prefix.nil?
+    args << '--no-rdoc' unless options[:generate_rdoc]
+    args << '--no-ri' unless options[:generate_ri]
+    args << '--no-format-executable' if options[:no_format_executable]
+
+    update_dir = File.join Gem.dir, 'gems', "rubygems-update-#{version}"
+
+    Dir.chdir update_dir do
+      say "Installing RubyGems #{version}"
+      setup_cmd = "#{Gem.ruby} setup.rb #{args.join ' '}"
+
+      # Make sure old rubygems isn't loaded
+      old = ENV["RUBYOPT"]
+      ENV.delete("RUBYOPT")
+      system setup_cmd
+      ENV["RUBYOPT"] = old if old
+    end
+  end
+
+  def which_to_update(highest_installed_gems, gem_names)
+    result = []
+
+    highest_installed_gems.each do |l_name, l_spec|
+      next if not gem_names.empty? and
+              gem_names.all? { |name| /#{name}/ !~ l_spec.name }
+
+      dependency = Gem::Dependency.new l_spec.name, "> #{l_spec.version}"
+
+      begin
+        fetcher = Gem::SpecFetcher.fetcher
+        spec_tuples = fetcher.find_matching dependency
+      rescue Gem::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'rubygems/source_info_cache'
+
+          dependency.name = '' if dependency.name == //
+
+          specs = Gem::SourceInfoCache.search_with_source dependency
+
+          spec_tuples = specs.map do |spec, source_uri|
+            [[spec.name, spec.version, spec.original_platform], source_uri]
+          end
+        end
+      end
+
+      matching_gems = spec_tuples.select do |(name, version, platform),|
+        name == l_name and Gem::Platform.match platform
+      end
+
+      highest_remote_gem = matching_gems.sort_by do |(name, version),|
+        version
+      end.last
+
+      if highest_remote_gem and
+         l_spec.version < highest_remote_gem.first[1] then
+        result << l_name
+      end
+    end
+
+    result
+  end
+
+end
+

data/shoes/ruby/lib/rubygems/commands/which_command.rb

@@ -0,0 +1,87 @@
+require 'rubygems/command'
+require 'rubygems/gem_path_searcher'
+
+class Gem::Commands::WhichCommand < Gem::Command
+
+  EXT = %w[.rb .rbw .so .dll .bundle] # HACK
+
+  def initialize
+    super 'which', 'Find the location of a library file you can require',
+          :search_gems_first => false, :show_all => false
+
+    add_option '-a', '--[no-]all', 'show all matching files' do |show_all, options|
+      options[:show_all] = show_all
+    end
+
+    add_option '-g', '--[no-]gems-first',
+               'search gems before non-gems' do |gems_first, options|
+      options[:search_gems_first] = gems_first
+    end
+  end
+
+  def arguments # :nodoc:
+    "FILE          name of file to find"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-gems-first --no-all"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} FILE [FILE ...]"
+  end
+
+  def execute
+    searcher = Gem::GemPathSearcher.new
+
+    options[:args].each do |arg|
+      dirs = $LOAD_PATH
+      spec = searcher.find arg
+
+      if spec then
+        if options[:search_gems_first] then
+          dirs = gem_paths(spec) + $LOAD_PATH
+        else
+          dirs = $LOAD_PATH + gem_paths(spec)
+        end
+
+        say "(checking gem #{spec.full_name} for #{arg})" if
+          Gem.configuration.verbose
+      end
+
+      paths = find_paths arg, dirs
+
+      if paths.empty? then
+        say "Can't find ruby library file or shared library #{arg}"
+      else
+        say paths
+      end
+    end
+  end
+
+  def find_paths(package_name, dirs)
+    result = []
+
+    dirs.each do |dir|
+      EXT.each do |ext|
+        full_path = File.join dir, "#{package_name}#{ext}"
+        if File.exist? full_path then
+          result << full_path
+          return result unless options[:show_all]
+        end
+      end
+    end
+
+    result
+  end
+
+  def gem_paths(spec)
+    spec.require_paths.collect { |d| File.join spec.full_gem_path, d }
+  end
+
+  def usage # :nodoc:
+    "#{program_name} FILE [...]"
+  end
+
+end
+

data/shoes/ruby/lib/rubygems/config_file.rb

@@ -0,0 +1,266 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'yaml'
+require 'rubygems'
+
+# Store the gem command options specified in the configuration file.  The
+# config file object acts much like a hash.
+
+class Gem::ConfigFile
+
+  DEFAULT_BACKTRACE = false
+  DEFAULT_BENCHMARK = false
+  DEFAULT_BULK_THRESHOLD = 1000
+  DEFAULT_VERBOSITY = true
+  DEFAULT_UPDATE_SOURCES = true
+
+  ##
+  # For Ruby packagers to set configuration defaults.  Set in
+  # rubygems/defaults/operating_system.rb
+
+  OPERATING_SYSTEM_DEFAULTS = {}
+
+  ##
+  # For Ruby implementers to set configuration defaults.  Set in
+  # rubygems/defaults/#{RUBY_ENGINE}.rb
+
+  PLATFORM_DEFAULTS = {}
+
+  system_config_path = 
+    begin
+      require 'Win32API'
+
+      CSIDL_COMMON_APPDATA = 0x0023
+      path = 0.chr * 260
+      SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'LLLLP', 'L'
+      SHGetFolderPath.call 0, CSIDL_COMMON_APPDATA, 0, 1, path
+
+      path.strip
+    rescue LoadError
+      '/etc'
+    end
+
+  SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'gemrc'
+  
+  # List of arguments supplied to the config file object.
+  attr_reader :args
+
+  # Where to look for gems
+  attr_accessor :path
+
+  attr_accessor :home
+
+  # True if we print backtraces on errors.
+  attr_writer :backtrace
+
+  # True if we are benchmarking this run.
+  attr_accessor :benchmark
+
+  # Bulk threshold value.  If the number of missing gems are above
+  # this threshold value, then a bulk download technique is used.
+  attr_accessor :bulk_threshold
+
+  # Verbose level of output:
+  # * false -- No output
+  # * true -- Normal output
+  # * :loud -- Extra output
+  attr_accessor :verbose
+
+  # True if we want to update the SourceInfoCache every time, false otherwise
+  attr_accessor :update_sources
+
+  # Create the config file object.  +args+ is the list of arguments
+  # from the command line.
+  #
+  # The following command line options are handled early here rather
+  # than later at the time most command options are processed.
+  #
+  # * --config-file and --config-file==NAME -- Obviously these need
+  #   to be handled by the ConfigFile object to ensure we get the
+  #   right config file.
+  #
+  # * --backtrace -- Backtrace needs to be turned on early so that
+  #   errors before normal option parsing can be properly handled.
+  #
+  # * --debug -- Enable Ruby level debug messages.  Handled early
+  #   for the same reason as --backtrace.
+  #
+  def initialize(arg_list)
+    @config_file_name = nil
+    need_config_file_name = false
+
+    arg_list = arg_list.map do |arg|
+      if need_config_file_name then
+        @config_file_name = arg
+        need_config_file_name = false
+        nil
+      elsif arg =~ /^--config-file=(.*)/ then
+        @config_file_name = $1
+        nil
+      elsif arg =~ /^--config-file$/ then
+        need_config_file_name = true
+        nil
+      else
+        arg
+      end
+    end.compact
+
+    @backtrace = DEFAULT_BACKTRACE
+    @benchmark = DEFAULT_BENCHMARK
+    @bulk_threshold = DEFAULT_BULK_THRESHOLD
+    @verbose = DEFAULT_VERBOSITY
+    @update_sources = DEFAULT_UPDATE_SOURCES
+
+    operating_system_config = Marshal.load Marshal.dump(OPERATING_SYSTEM_DEFAULTS)
+    platform_config = Marshal.load Marshal.dump(PLATFORM_DEFAULTS)
+    system_config = load_file SYSTEM_WIDE_CONFIG_FILE
+    user_config = load_file config_file_name.dup.untaint
+
+    @hash = operating_system_config.merge platform_config
+    @hash = @hash.merge system_config
+    @hash = @hash.merge user_config
+
+    # HACK these override command-line args, which is bad
+    @backtrace = @hash[:backtrace] if @hash.key? :backtrace
+    @benchmark = @hash[:benchmark] if @hash.key? :benchmark
+    @bulk_threshold = @hash[:bulk_threshold] if @hash.key? :bulk_threshold
+    Gem.sources = @hash[:sources] if @hash.key? :sources
+    @verbose = @hash[:verbose] if @hash.key? :verbose
+    @update_sources = @hash[:update_sources] if @hash.key? :update_sources
+    @path = @hash[:gempath] if @hash.key? :gempath
+    @home = @hash[:gemhome] if @hash.key? :gemhome
+
+    handle_arguments arg_list
+  end
+
+  def load_file(filename)
+    begin
+      YAML.load(File.read(filename)) if filename and File.exist?(filename)
+    rescue ArgumentError
+      warn "Failed to load #{config_file_name}"
+    rescue Errno::EACCES
+      warn "Failed to load #{config_file_name} due to permissions problem."
+    end or {}
+  end
+
+  # True if the backtrace option has been specified, or debug is on.
+  def backtrace
+    @backtrace or $DEBUG
+  end
+
+  # The name of the configuration file.
+  def config_file_name
+    @config_file_name || Gem.config_file
+  end
+
+  # Delegates to @hash
+  def each(&block)
+    hash = @hash.dup
+    hash.delete :update_sources
+    hash.delete :verbose
+    hash.delete :benchmark
+    hash.delete :backtrace
+    hash.delete :bulk_threshold
+
+    yield :update_sources, @update_sources
+    yield :verbose, @verbose
+    yield :benchmark, @benchmark
+    yield :backtrace, @backtrace
+    yield :bulk_threshold, @bulk_threshold
+
+    yield 'config_file_name', @config_file_name if @config_file_name
+
+    hash.each(&block)
+  end
+
+  # Handle the command arguments.
+  def handle_arguments(arg_list)
+    @args = []
+
+    arg_list.each do |arg|
+      case arg
+      when /^--(backtrace|traceback)$/ then
+        @backtrace = true
+      when /^--bench(mark)?$/ then
+        @benchmark = true
+      when /^--debug$/ then
+        $DEBUG = true
+      else
+        @args << arg
+      end
+    end
+  end
+
+  # Really verbose mode gives you extra output.
+  def really_verbose
+    case verbose
+    when true, false, nil then false
+    else true
+    end
+  end
+
+  # to_yaml only overwrites things you can't override on the command line.
+  def to_yaml # :nodoc:
+    yaml_hash = {}
+    yaml_hash[:backtrace] = @hash.key?(:backtrace) ? @hash[:backtrace] :
+      DEFAULT_BACKTRACE
+    yaml_hash[:benchmark] = @hash.key?(:benchmark) ? @hash[:benchmark] :
+      DEFAULT_BENCHMARK
+    yaml_hash[:bulk_threshold] = @hash.key?(:bulk_threshold) ?
+      @hash[:bulk_threshold] : DEFAULT_BULK_THRESHOLD
+    yaml_hash[:sources] = Gem.sources
+    yaml_hash[:update_sources] = @hash.key?(:update_sources) ?
+      @hash[:update_sources] : DEFAULT_UPDATE_SOURCES
+    yaml_hash[:verbose] = @hash.key?(:verbose) ? @hash[:verbose] :
+      DEFAULT_VERBOSITY
+
+    keys = yaml_hash.keys.map { |key| key.to_s }
+    keys << 'debug'
+    re = Regexp.union(*keys)
+
+    @hash.each do |key, value|
+      key = key.to_s
+      next if key =~ re
+      yaml_hash[key.to_s] = value
+    end
+
+    yaml_hash.to_yaml
+  end
+
+  # Writes out this config file, replacing its source.
+  def write
+    File.open config_file_name, 'w' do |fp|
+      fp.write self.to_yaml
+    end
+  end
+
+  # Return the configuration information for +key+.
+  def [](key)
+    @hash[key.to_s]
+  end
+
+  # Set configuration option +key+ to +value+.
+  def []=(key, value)
+    @hash[key.to_s] = value
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and
+    @backtrace == other.backtrace and
+    @benchmark == other.benchmark and
+    @bulk_threshold == other.bulk_threshold and
+    @verbose == other.verbose and
+    @update_sources == other.update_sources and
+    @hash == other.hash
+  end
+
+  protected
+
+  attr_reader :hash
+
+end
+