rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/commands/contents_command.rb

@@ -1,66 +1,74 @@
-module Gem
-  module Commands
-    class ContentsCommand < Command
-      include CommandAids
-      include VersionOption
-      def initialize
-        super(
-          'contents',
-          'Display the contents of the installed gems',
-          { :list => true, :specdirs => [] })
-
-        add_version_option('contents')
-
-        add_option("-l","--list",'List the files inside a Gem') do |v,o|
-          o[:list] = true
-        end
-      
-        add_option('-s','--spec-dir a,b,c', Array, "Search for gems under specific paths") do |v,o|
-          o[:specdirs] = v
-        end
-      
-        add_option('-V','--verbose','Be verbose when showing status') do |v,o|
-          o[:verbose] = v
-        end
-      end
+require 'rubygems/command'
+require 'rubygems/version_option'
+
+class Gem::Commands::ContentsCommand < Gem::Command
+
+  include Gem::VersionOption
+
+  def initialize
+    super 'contents', 'Display the contents of the installed gems',
+          :specdirs => [], :lib_only => false
+
+    add_version_option
+
+    add_option('-s', '--spec-dir a,b,c', Array,
+               "Search for gems under specific paths") do |spec_dirs, options|
+      options[:specdirs] = spec_dirs
+    end
+
+    add_option('-l', '--[no-]lib-only',
+               "Only return files in the Gem's lib_dirs") do |lib_only, options|
+      options[:lib_only] = lib_only
+    end
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to list contents for"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-lib-only"
+  end
 
-      def execute(io=STDOUT)
-        if options[:list]
-          version = options[:version] || "> 0.0.0"
-          gem = get_one_gem_name
-        
-          s = options[:specdirs].map do |i|
-            [i, File.join(i,"specifications")]
-          end.flatten
-        
-          if s.empty?
-            s = Gem::SourceIndex.installed_spec_directories
-            path_kind = "default gem paths"
-            system = true
-          else
-            path_kind = "specified path"
-            system = false
-          end
-
-          si = Gem::SourceIndex.from_gems_in(*s)
-
-          gem_spec = si.search(gem, version).last
-          unless gem_spec
-            io.puts "Unable to find gem '#{gem}' in #{path_kind}"
-            if options[:verbose]
-              io.puts "\nDirectories searched:"
-              s.each do |p|
-                io.puts p
-              end
-            end
-            return
-          end
-          # show the list of files.
-          gem_spec.files.each do |f|
-            io.puts File.join(gem_spec.full_gem_path, f)
-          end
-        end
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  def execute
+    version = options[:version] || Gem::Requirement.default
+    gem = get_one_gem_name
+
+    s = options[:specdirs].map do |i|
+      [i, File.join(i, "specifications")]
+    end.flatten
+
+    path_kind = if s.empty? then
+                  s = Gem::SourceIndex.installed_spec_directories
+                  "default gem paths"
+                else
+                  "specified path"
+                end
+
+    si = Gem::SourceIndex.from_gems_in(*s)
+
+    gem_spec = si.search(/\A#{gem}\z/, version).last
+
+    unless gem_spec then
+      say "Unable to find gem '#{gem}' in #{path_kind}"
+
+      if Gem.configuration.verbose then
+        say "\nDirectories searched:"
+        s.each { |dir| say dir }
       end
+
+      terminate_interaction
+    end
+
+    files = options[:lib_only] ? gem_spec.lib_files : gem_spec.files
+    files.each do |f|
+      say File.join(gem_spec.full_gem_path, f)
     end
   end
-end
+
+end
+

data/lib/rubygems/commands/dependency_command.rb

@@ -1,105 +1,150 @@
-module Gem
-  module Commands
-    class DependencyCommand < Command
-      include VersionOption
-      include CommandAids
-
-      def initialize
-        super('dependency',
+require 'rubygems/command'
+require 'rubygems/local_remote_options'
+require 'rubygems/version_option'
+require 'rubygems/source_info_cache'
+
+class Gem::Commands::DependencyCommand < Gem::Command
+
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
+
+  def initialize
+    super 'dependency',
           'Show the dependencies of an installed gem',
-          {:version=>"> 0"})
-        add_version_option('dependency')
-        add_option('-r', '--[no-]reverse-dependencies',
-          'Include reverse dependencies in the output'
-          ) do |value, options|
-          options[:reverse_dependencies] = value
-        end
-        add_option('-p', '--pipe', "Pipe Format (name --version ver)") do |value, options|
-          options[:pipe_format] = value
-        end
-      end
+          :version => Gem::Requirement.default, :domain => :local
 
-      def defaults_str
-        "--version '> 0' --no-reverse"
-      end
-    
-      def usage
-        "#{program_name} GEMNAME"
+    add_version_option
+    add_platform_option
+
+    add_option('-R', '--[no-]reverse-dependencies',
+               'Include reverse dependencies in the output') do
+      |value, options|
+      options[:reverse_dependencies] = value
+    end
+
+    add_option('-p', '--pipe',
+               "Pipe Format (name --version ver)") do |value, options|
+      options[:pipe_format] = value
+    end
+
+    add_local_remote_options
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to show dependencies for"
+  end
+
+  def defaults_str # :nodoc:
+    "--local --version '#{Gem::Requirement.default}' --no-reverse-dependencies"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  def execute
+    options[:args] << '.' if options[:args].empty?
+    specs = {}
+
+    source_indexes = []
+
+    if local? then
+      source_indexes << Gem::SourceIndex.from_installed_gems
+    end
+
+    if remote? then
+      Gem::SourceInfoCache.cache_data.map do |_, sice|
+        source_indexes << sice.source_index
       end
+    end
 
-      def arguments
-        "GEMNAME   name of gems to show"
+    options[:args].each do |name|
+      new_specs = nil
+      source_indexes.each do |source_index|
+        new_specs =  find_gems(name, source_index)
       end
 
-      def execute
-        specs = {}
-        srcindex = SourceIndex.from_installed_gems
-        options[:args] << '.' if options[:args].empty?
-        options[:args].each do |name|
-          speclist = srcindex.search(name, options[:version])
-          if speclist.empty?
-            say "No match found for #{name} (#{options[:version]})"
-          else
-            speclist.each do |spec|
-              specs[spec.full_name] = spec
-            end
-          end
-        end
-        reverse = Hash.new { |h, k| h[k] = [] }
-        if options[:reverse_dependencies]
-          specs.values.each do |spec|
-            reverse[spec.full_name] = find_reverse_dependencies(spec, srcindex)
-          end
-        end
-        if options[:pipe_format]
-          specs.values.sort.each do |spec|
-            unless spec.dependencies.empty?
-              spec.dependencies.each do |dep|
-                puts "#{dep.name} --version '#{dep.version_requirements}'"
-              end
-            end
-          end     
-        else
-          response = ''
-          specs.values.sort.each do |spec|
-            response << print_dependencies(spec)
-            unless reverse[spec.full_name].empty?
-              response << "  Used by\n"
-              reverse[spec.full_name].each do |sp, dep|
-                response << "    #{sp} (#{dep})\n"
-              end
-            end
-            response << "\n"
-          end
-          say response
-        end
+      say "No match found for #{name} (#{options[:version]})" if
+        new_specs.empty?
+
+      specs = specs.merge new_specs
+    end
+
+    terminate_interaction 1 if specs.empty?
+
+    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
       end
+    end
 
-      def print_dependencies(spec, level = 0)
-        response = ''
-        response << '  ' * level + "Gem #{spec.full_name}\n"
+    if options[:pipe_format] then
+      specs.values.sort_by { |_, spec| spec }.each do |_, spec|
         unless spec.dependencies.empty?
-  #        response << '  ' * level + "  Requires\n"
           spec.dependencies.each do |dep|
-            response << '  ' * level + "  #{dep}\n"
+            say "#{dep.name} --version '#{dep.version_requirements}'"
           end
         end
-        response
       end
+    else
+      response = ''
 
-      # Retuns list of [specification, dep] that are satisfied by spec.
-      def find_reverse_dependencies(spec, srcindex)
-        result = []
-        srcindex.each do |name, sp|
-          sp.dependencies.each do |dep|
-            if spec.name == dep.name &&
-                dep.version_requirements.satisfied_by?(spec.version)
-              result << [sp.full_name, dep]
-            end
+      specs.values.sort_by { |_, spec| spec }.each do |_, spec|
+        response << print_dependencies(spec)
+        unless reverse[spec.full_name].empty? then
+          response << "  Used by\n"
+          reverse[spec.full_name].each do |sp, dep|
+            response << "    #{sp} (#{dep})\n"
           end
         end
-        result
+        response << "\n"
+      end
+
+      say response
+    end
+  end
+
+  def print_dependencies(spec, level = 0)
+    response = ''
+    response << '  ' * level + "Gem #{spec.full_name}\n"
+    unless spec.dependencies.empty? then
+      spec.dependencies.each do |dep|
+        response << '  ' * level + "  #{dep}\n"
+      end
+    end
+    response
+  end
+
+  # Retuns list of [specification, dep] that are satisfied by spec.
+  def find_reverse_dependencies(spec, source_index)
+    result = []
+
+    source_index.each do |name, sp|
+      sp.dependencies.each do |dep|
+        dep = Gem::Dependency.new(*dep) unless Gem::Dependency === dep
+
+        if spec.name == dep.name and
+           dep.version_requirements.satisfied_by?(spec.version) then
+          result << [sp.full_name, dep]
+        end
       end
-    end      
+    end
+
+    result
+  end
+
+  def find_gems(name, source_index)
+    specs = {}
+
+    spec_list = source_index.search name, options[:version]
+
+    spec_list.each do |spec|
+      specs[spec.full_name] = [source_index, spec]
+    end
+
+    specs
   end
 end
+

data/lib/rubygems/commands/environment_command.rb

@@ -1,59 +1,80 @@
-module Gem
-  module Commands
-    class EnvironmentCommand < Command
-      include CommandAids
+require 'rubygems/command'
 
-      def initialize
-        super('environment', 'Display information about the RubyGems environment')
-      end
+class Gem::Commands::EnvironmentCommand < Gem::Command
 
-      def usage
-        "#{program_name} [args]"
-      end
+  def initialize
+    super 'environment', 'Display information about the RubyGems environment'
+  end
 
-      def arguments
-        args = <<-EOF
+  def arguments # :nodoc:
+    args = <<-EOF
           packageversion  display the package version
           gemdir          display the path where gems are installed
           gempath         display path used to search for gems
           version         display the gem format version
           remotesources   display the remote gem servers
           <omitted>       display everything
-        EOF
-        return args.gsub(/^\s+/, '')
+    EOF
+    return args.gsub(/^\s+/, '')
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [arg]"
+  end
+
+  def execute
+    out = ''
+    arg = options[:args][0]
+    if begins?("packageversion", arg) then
+      out << Gem::RubyGemsPackageVersion
+    elsif begins?("version", arg) then
+      out << Gem::RubyGemsVersion
+    elsif begins?("gemdir", arg) then
+      out << Gem.dir
+    elsif begins?("gempath", arg) then
+      out << Gem.path.join("\n")
+    elsif begins?("remotesources", arg) then
+      out << Gem.sources.join("\n")
+    elsif arg then
+      fail Gem::CommandLineError, "Unknown enviroment option [#{arg}]"
+    else
+      out = "RubyGems Environment:\n"
+
+      out << "  - RUBYGEMS VERSION: #{Gem::RubyGemsVersion} (#{Gem::RubyGemsPackageVersion})\n"
+
+      out << "  - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
+      out << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+      out << ") [#{RUBY_PLATFORM}]\n"
+
+      out << "  - INSTALLATION DIRECTORY: #{Gem.dir}\n"
+
+      out << "  - RUBYGEMS PREFIX: #{Gem.prefix}\n" unless Gem.prefix.nil?
+
+      out << "  - RUBY EXECUTABLE: #{Gem.ruby}\n"
+
+      out << "  - RUBYGEMS PLATFORMS:\n"
+      Gem.platforms.each do |platform|
+        out << "    - #{platform}\n"
+      end
+
+      out << "  - GEM PATHS:\n"
+      Gem.path.each do |p|
+        out << "     - #{p}\n"
       end
 
-      def execute
-        out = ''
-        arg = options[:args][0]
-        if begins?("packageversion", arg)
-          out = Gem::RubyGemsPackageVersion.to_s
-        elsif begins?("version", arg)
-          out = Gem::RubyGemsVersion.to_s
-        elsif begins?("gemdir", arg)
-          out = Gem.dir
-        elsif begins?("gempath", arg)
-          Gem.path.collect { |p| out << "#{p}\n" }
-        elsif begins?("remotesources", arg)
-          require 'sources'
-          out << Gem.sources.join("\n") << "\n"
-        elsif arg
-          fail Gem::CommandLineError, "Unknown enviroment option [#{arg}]"
-        else
-          out = "RubyGems Environment:\n"
-          out << "  - VERSION: #{Gem::RubyGemsVersion} (#{Gem::RubyGemsPackageVersion})\n"
-          out << "  - INSTALLATION DIRECTORY: #{Gem.dir}\n"
-          out << "  - GEM PATH:\n"
-          Gem.path.collect { |p| out << "     - #{p}\n" }
-          out << "  - REMOTE SOURCES:\n"
-          require 'sources'
-          Gem.sources.collect do |s|
-            out << "     - #{s}\n"
-          end
-        end
-        say out
-        true
+      out << "  - GEM CONFIGURATION:\n"
+      Gem.configuration.each do |name, value|
+        out << "     - #{name.inspect} => #{value.inspect}\n"
       end
-    end    
+
+      out << "  - REMOTE SOURCES:\n"
+      Gem.sources.each do |s|
+        out << "     - #{s}\n"
+      end
+    end
+    say out
+    true
   end
-end
+
+end
+