rubygems-update 1.1.1 → 1.2.0

data/lib/rubygems/command.rb

@@ -342,7 +342,7 @@ module Gem
 
     add_common_option('-V', '--[no-]verbose',
                       'Set the verbose level of output') do |value, options|
-      # Set us to "really verbose" so the progess meter works
+      # Set us to "really verbose" so the progress meter works
       if Gem.configuration.verbose and value then
         Gem.configuration.verbose = 1
       else

data/lib/rubygems/command_manager.rb

@@ -16,7 +16,7 @@ module Gem
   class CommandManager
     include UserInteraction
     
-    # Return the authoratative instance of the command manager.
+    # Return the authoritative instance of the command manager.
     def self.instance
       @command_manager ||= CommandManager.new
     end
@@ -46,6 +46,7 @@ module Gem
       register_command :server
       register_command :sources
       register_command :specification
+      register_command :stale
       register_command :uninstall
       register_command :unpack
       register_command :update
@@ -69,7 +70,7 @@ module Gem
       @commands.keys.collect {|key| key.to_s}.sort
     end
     
-    # Run the config specificed by +args+.
+    # Run the config specified by +args+.
     def run(args)
       process_args(args)
     rescue StandardError, Timeout::Error => ex

data/lib/rubygems/commands/cert_command.rb

@@ -19,7 +19,7 @@ class Gem::Commands::CertCommand < Gem::Command
       Dir::glob(glob_str) do |path|
         begin
           cert = OpenSSL::X509::Certificate.new(File.read(path))
-          # this could proably be formatted more gracefully
+          # this could probably be formatted more gracefully
           say cert.subject.to_s
         rescue OpenSSL::X509::CertificateError
           next

data/lib/rubygems/commands/dependency_command.rb

@@ -43,40 +43,77 @@ class Gem::Commands::DependencyCommand < Gem::Command
   end
 
   def execute
-    options[:args] << '.' if options[:args].empty?
+    options[:args] << '' if options[:args].empty?
     specs = {}
 
-    source_indexes = []
+    source_indexes = Hash.new do |h, source_uri|
+      h[source_uri] = Gem::SourceIndex.new
+    end
 
-    if local? then
-      source_indexes << Gem::SourceIndex.from_installed_gems
+    pattern = if options[:args].length == 1 and
+                 options[:args].first =~ /\A\/(.*)\/(i)?\z/m then
+                flags = $2 ? Regexp::IGNORECASE : nil
+                Regexp.new $1, flags
+              else
+                /\A#{Regexp.union(*options[:args])}/
+              end
+
+    dependency = Gem::Dependency.new pattern, options[:version]
+
+    if options[:reverse_dependencies] and remote? and not local? then
+      alert_error 'Only reverse dependencies for local gems are supported.'
+      terminate_interaction 1
     end
 
-    if remote? then
-      Gem::SourceInfoCache.cache_data.map do |_, sice|
-        source_indexes << sice.source_index
+    if local? then
+      Gem.source_index.search(dependency).each do |spec|
+        source_indexes[:local].add_spec spec
       end
     end
 
-    options[:args].each do |name|
-      new_specs = nil
-      source_indexes.each do |source_index|
-        new_specs =  find_gems(name, source_index)
+    if remote? and not options[:reverse_dependencies] then
+      fetcher = Gem::SpecFetcher.fetcher
+
+      begin
+        fetcher.find_matching(dependency).each do |spec_tuple, source_uri|
+          spec = fetcher.fetch_spec spec_tuple, URI.parse(source_uri)
+
+          source_indexes[source_uri].add_spec spec
+        end
+      rescue Gem::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'rubygems/source_info_cache'
+
+          specs = Gem::SourceInfoCache.search_with_source dependency, false
+
+          specs.each do |spec, source_uri|
+            source_indexes[source_uri].add_spec spec
+          end
+        end
       end
+    end
 
-      say "No match found for #{name} (#{options[:version]})" if
-        new_specs.empty?
+    if source_indexes.empty? then
+      patterns = options[:args].join ','
+      say "No gems found matching #{patterns} (#{options[:version]})" if
+        Gem.configuration.verbose
 
-      specs = specs.merge new_specs
+      terminate_interaction 1
     end
 
-    terminate_interaction 1 if specs.empty?
+    specs = {}
+
+    source_indexes.values.each do |source_index|
+      source_index.gems.each do |name, spec|
+        specs[spec.full_name] = [source_index, spec]
+      end
+    end
 
     reverse = Hash.new { |h, k| h[k] = [] }
 
     if options[:reverse_dependencies] then
-      specs.values.each do |source_index, spec|
-        reverse[spec.full_name] = find_reverse_dependencies spec, source_index
+      specs.values.each do |_, spec|
+        reverse[spec.full_name] = find_reverse_dependencies spec
       end
     end
 
@@ -118,10 +155,10 @@ class Gem::Commands::DependencyCommand < Gem::Command
   end
 
   # Retuns list of [specification, dep] that are satisfied by spec.
-  def find_reverse_dependencies(spec, source_index)
+  def find_reverse_dependencies(spec)
     result = []
 
-    source_index.each do |name, sp|
+    Gem.source_index.each do |name, sp|
       sp.dependencies.each do |dep|
         dep = Gem::Dependency.new(*dep) unless Gem::Dependency === dep
 
@@ -146,5 +183,6 @@ class Gem::Commands::DependencyCommand < Gem::Command
 
     specs
   end
+
 end
 

data/lib/rubygems/commands/environment_command.rb

@@ -51,6 +51,8 @@ class Gem::Commands::EnvironmentCommand < Gem::Command
 
       out << "  - RUBY EXECUTABLE: #{Gem.ruby}\n"
 
+      out << "  - EXECUTABLE DIRECTORY: #{Gem.bindir}\n"
+
       out << "  - RUBYGEMS PLATFORMS:\n"
       Gem.platforms.each do |platform|
         out << "    - #{platform}\n"

data/lib/rubygems/commands/fetch_command.rb

@@ -33,12 +33,14 @@ class Gem::Commands::FetchCommand < Gem::Command
 
   def execute
     version = options[:version] || Gem::Requirement.default
+    all = Gem::Requirement.default
 
     gem_names = get_all_gem_names
 
     gem_names.each do |gem_name|
       dep = Gem::Dependency.new gem_name, version
-      specs_and_sources = Gem::SourceInfoCache.search_with_source dep, true
+
+      specs_and_sources = Gem::SpecFetcher.fetcher.fetch dep, all
 
       specs_and_sources.sort_by { |spec,| spec.version }
 

data/lib/rubygems/commands/install_command.rb

@@ -16,7 +16,6 @@ class Gem::Commands::InstallCommand < Gem::Command
     defaults = Gem::DependencyInstaller::DEFAULT_OPTIONS.merge({
       :generate_rdoc => true,
       :generate_ri   => true,
-      :install_dir => Gem.dir,
       :format_executable => false,
       :test => false,
       :version => Gem::Requirement.default,
@@ -51,7 +50,7 @@ class Gem::Commands::InstallCommand < Gem::Command
 
     installed_gems = []
 
-    ENV['GEM_PATH'] = options[:install_dir] # HACK what does this do?
+    ENV.delete 'GEM_PATH' if options[:install_dir].nil? and RUBY_VERSION > '1.9'
 
     install_options = {
       :env_shebang => options[:env_shebang],
@@ -62,7 +61,8 @@ class Gem::Commands::InstallCommand < Gem::Command
       :install_dir => options[:install_dir],
       :security_policy => options[:security_policy],
       :wrappers => options[:wrappers],
-      :bin_dir => options[:bin_dir]
+      :bin_dir => options[:bin_dir],
+      :development => options[:development],
     }
 
     exit_code = 0

data/lib/rubygems/commands/list_command.rb

@@ -1,33 +1,35 @@
 require 'rubygems/command'
 require 'rubygems/commands/query_command'
 
-module Gem
-  module Commands
-    class ListCommand < QueryCommand
-
-      def initialize
-        super 'list', 'Display gems whose name starts with STRING'
-
-        remove_option('--name-matches')
-      end
-
-      def arguments # :nodoc:
-        "STRING        start of gem name to look 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
+##
+# An alternate to Gem::Commands::QueryCommand that searches for gems starting
+# with the the supplied argument.
+
+class Gem::Commands::ListCommand < Gem::Commands::QueryCommand
+
+  def initialize
+    super 'list', 'Display gems whose name starts with STRING'
+
+    remove_option('--name-matches')
+  end
+
+  def arguments # :nodoc:
+    "STRING        start of gem name to look 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
+

data/lib/rubygems/commands/lock_command.rb

@@ -80,7 +80,7 @@ lock it down to the exact version.
       say "gem '#{spec.name}', '= #{spec.version}'" unless locked[spec.name]
       locked[spec.name] = true
 
-      spec.dependencies.each do |dep|
+      spec.runtime_dependencies.each do |dep|
         next if locked[dep.name]
         candidates = Gem.source_index.search dep.name, dep.requirement_list
 

data/lib/rubygems/commands/outdated_command.rb

@@ -1,6 +1,6 @@
 require 'rubygems/command'
 require 'rubygems/local_remote_options'
-require 'rubygems/source_info_cache'
+require 'rubygems/spec_fetcher'
 require 'rubygems/version_option'
 
 class Gem::Commands::OutdatedCommand < Gem::Command
@@ -20,8 +20,11 @@ class Gem::Commands::OutdatedCommand < Gem::Command
 
     locals.outdated.sort.each do |name|
       local = locals.search(/^#{name}$/).last
-      remotes = Gem::SourceInfoCache.search_with_source(/^#{name}$/, true)
+
+      dep = Gem::Dependency.new local.name, ">= #{local.version}"
+      remotes = Gem::SpecFetcher.fetcher.fetch dep
       remote = remotes.last.first
+
       say "#{local.name} (#{local.version} < #{remote.version})"
     end
   end

data/lib/rubygems/commands/pristine_command.rb

@@ -82,51 +82,10 @@ revert the gem.
       end
 
       # TODO use installer options
-      installer = Gem::Installer.new gem, :wrappers => true
+      installer = Gem::Installer.new gem, :wrappers => true, :force => true
+      installer.install
 
-      gem_file = File.join install_dir, "cache", "#{spec.full_name}.gem"
-
-      security_policy = nil # TODO use installer option
-
-      format = Gem::Format.from_file_by_path gem_file, security_policy
-
-      target_directory = File.join(install_dir, "gems", format.spec.full_name)
-      target_directory.untaint
-
-      pristine_files = format.file_entries.collect { |data| data[0]["path"] }
-      file_map = {}
-
-      format.file_entries.each do |entry, file_data|
-        file_map[entry["path"]] = file_data
-      end
-
-      Dir.chdir target_directory do
-        deployed_files = Dir.glob(File.join("**", "*")) +
-                         Dir.glob(File.join("**", ".*"))
-
-        pristine_files = pristine_files.map { |f| File.expand_path f }
-        deployed_files = deployed_files.map { |f| File.expand_path f }
-
-        to_redeploy = (pristine_files - deployed_files)
-        to_redeploy = to_redeploy.map { |path| path.untaint}
-
-        if to_redeploy.length > 0 then
-          say "Restoring #{to_redeploy.length} file#{to_redeploy.length == 1 ? "" : "s"} to #{spec.full_name}..."
-
-          to_redeploy.each do |path|
-            say "  #{path}"
-            FileUtils.mkdir_p File.dirname(path)
-            File.open(path, "wb") do |out|
-              out.write file_map[path]
-            end
-          end
-        else
-          say "#{spec.full_name} is in pristine condition"
-        end
-      end
-
-      installer.generate_bin
-      installer.build_extensions
+      say "Restored #{spec.full_name}"
     end
   end
 

data/lib/rubygems/commands/query_command.rb

@@ -1,6 +1,6 @@
 require 'rubygems/command'
 require 'rubygems/local_remote_options'
-require 'rubygems/source_info_cache'
+require 'rubygems/spec_fetcher'
 require 'rubygems/version_option'
 
 class Gem::Commands::QueryCommand < Gem::Command
@@ -74,7 +74,13 @@ class Gem::Commands::QueryCommand < Gem::Command
       say "*** LOCAL GEMS ***"
       say
 
-      output_query_results Gem.source_index.search(name)
+      specs = Gem.source_index.search name
+
+      spec_tuples = specs.map do |spec|
+        [[spec.name, spec.version, spec.original_platform, spec], :local]
+      end
+
+      output_query_results spec_tuples
     end
 
     if remote? then
@@ -84,13 +90,26 @@ class Gem::Commands::QueryCommand < Gem::Command
 
       all = options[:all]
 
+      dep = Gem::Dependency.new name, Gem::Requirement.default
       begin
-        Gem::SourceInfoCache.cache all
-      rescue Gem::RemoteFetcher::FetchError
-        # no network
+        fetcher = Gem::SpecFetcher.fetcher
+        spec_tuples = fetcher.find_matching dep, all, false
+      rescue Gem::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'rubygems/source_info_cache'
+
+          dep.name = '' if dep.name == //
+
+          specs = Gem::SourceInfoCache.search_with_source dep, false, all
+
+          spec_tuples = specs.map do |spec, source_uri|
+            [[spec.name, spec.version, spec.original_platform, spec],
+             source_uri]
+          end
+        end
       end
 
-      output_query_results Gem::SourceInfoCache.search(name, false, all)
+      output_query_results spec_tuples
     end
   end
 
@@ -104,28 +123,30 @@ class Gem::Commands::QueryCommand < Gem::Command
     !Gem.source_index.search(dep).empty?
   end
 
-  def output_query_results(gemspecs)
+  def output_query_results(spec_tuples)
     output = []
-    gem_list_with_version = {}
+    versions = Hash.new { |h,name| h[name] = [] }
 
-    gemspecs.flatten.each do |gemspec|
-      gem_list_with_version[gemspec.name] ||= []
-      gem_list_with_version[gemspec.name] << gemspec
+    spec_tuples.each do |spec_tuple, source_uri|
+      versions[spec_tuple.first] << [spec_tuple, source_uri]
     end
 
-    gem_list_with_version = gem_list_with_version.sort_by do |name, spec|
+    versions = versions.sort_by do |(name,_),_|
       name.downcase
     end
 
-    gem_list_with_version.each do |gem_name, list_of_matching|
-      list_of_matching = list_of_matching.sort_by { |x| x.version.to_ints }.reverse
-      seen_versions = {}
+    versions.each do |gem_name, matching_tuples|
+      matching_tuples = matching_tuples.sort_by do |(name, version,_),_|
+        version
+      end.reverse
 
-      list_of_matching.delete_if do |item|
-        if seen_versions[item.version] then
+      seen = {}
+
+      matching_tuples.delete_if do |(name, version,_),_|
+        if seen[version] then
           true
         else
-          seen_versions[item.version] = true
+          seen[version] = true
           false
         end
       end
@@ -133,12 +154,50 @@ class Gem::Commands::QueryCommand < Gem::Command
       entry = gem_name.dup
 
       if options[:versions] then
-        versions = list_of_matching.map { |s| s.version }.uniq
+        versions = matching_tuples.map { |(name, version,_),_| version }.uniq
         entry << " (#{versions.join ', '})"
       end
 
-      entry << "\n" << format_text(list_of_matching[0].summary, 68, 4) if
-        options[:details]
+      if options[:details] then
+        detail_tuple = matching_tuples.first
+
+        spec = if detail_tuple.first.length == 4 then
+                 detail_tuple.first.last
+               else
+                 uri = URI.parse detail_tuple.last
+                 Gem::SpecFetcher.fetcher.fetch_spec detail_tuple.first, uri
+               end
+
+        entry << "\n"
+        authors = "Author#{spec.authors.length > 1 ? 's' : ''}: "
+        authors << spec.authors.join(', ')
+        entry << format_text(authors, 68, 4)
+
+        if spec.rubyforge_project and not spec.rubyforge_project.empty? then
+          rubyforge = "Rubyforge: http://rubyforge.org/projects/#{spec.rubyforge_project}"
+          entry << "\n" << format_text(rubyforge, 68, 4)
+        end
+
+        if spec.homepage and not spec.homepage.empty? then
+          entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4)
+        end
+
+        if spec.loaded_from then
+          if matching_tuples.length == 1 then
+            loaded_from = File.dirname File.dirname(spec.loaded_from)
+            entry << "\n" << "    Installed at: #{loaded_from}"
+          else
+            label = 'Installed at'
+            matching_tuples.each do |(_,version,_,s),|
+              loaded_from = File.dirname File.dirname(s.loaded_from)
+              entry << "\n" << "    #{label} (#{version}): #{loaded_from}"
+              label = ' ' * label.length
+            end
+          end
+        end
+
+        entry << "\n\n" << format_text(spec.summary, 68, 4)
+      end
       output << entry
     end