rubygems-update 0.9.2 → 0.9.3

data/lib/rubygems/commands/cleanup_command.rb

@@ -0,0 +1,75 @@
+module Gem
+  module Commands
+    class CleanupCommand < Command
+      def initialize
+        super(
+          'cleanup',
+          'Clean up old versions of installed gems in the local repository',
+          {
+            :force => false, 
+            :test => false, 
+            :install_dir => Gem.dir
+          })
+        add_option('-d', '--dryrun', "") do |value, options|
+          options[:dryrun] = true
+        end
+      end
+    
+      def defaults_str
+        "--no-dryrun"
+      end
+
+      def arguments
+        "GEMNAME(s)   name of gem(s) to cleanup"
+      end
+
+      def execute
+        say "Cleaning up installed gems..."
+        srcindex = Gem::SourceIndex.from_installed_gems
+        primary_gems = {}
+        srcindex.each do |name, spec|
+          if primary_gems[spec.name].nil? or primary_gems[spec.name].version < spec.version
+            primary_gems[spec.name] = spec
+          end
+        end
+        gems_to_cleanup = []
+        if ! options[:args].empty?
+          options[:args].each do |gem_name|
+            specs = Gem.cache.search(/^#{gem_name}$/i)
+            specs.each do |spec|
+              gems_to_cleanup << spec
+            end
+          end
+        else
+          srcindex.each do |name, spec|
+              gems_to_cleanup << spec
+          end
+        end
+        gems_to_cleanup = gems_to_cleanup.select { |spec|
+          primary_gems[spec.name].version != spec.version
+        }
+        uninstall_command = command_manager['uninstall']
+        deplist = DependencyList.new
+        gems_to_cleanup.uniq.each do |spec| deplist.add(spec) end
+        deplist.dependency_order.each do |spec|
+          if options[:dryrun]
+            say "Dry Run Mode: Would uninstall #{spec.full_name}"
+          else
+            say "Attempting uninstall on #{spec.full_name}"
+            options[:args] = [spec.name]
+            options[:version] = "= #{spec.version}"
+            options[:executables] = true
+            uninstall_command.merge_options(options)
+            begin
+              uninstall_command.execute
+            rescue Gem::DependencyRemovalException => ex
+              say "Unable to uninstall #{spec.full_name} ... continuing with remaining gems"
+            end
+          end
+        end
+        say "Clean Up Complete"
+      end
+    end
+      
+  end
+end

data/lib/rubygems/commands/contents_command.rb

@@ -0,0 +1,66 @@
+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
+
+      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
+      end
+    end
+  end
+end

data/lib/rubygems/commands/dependency_command.rb

@@ -0,0 +1,105 @@
+module Gem
+  module Commands
+    class DependencyCommand < Command
+      include VersionOption
+      include CommandAids
+
+      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
+
+      def defaults_str
+        "--version '> 0' --no-reverse"
+      end
+    
+      def usage
+        "#{program_name} GEMNAME"
+      end
+
+      def arguments
+        "GEMNAME   name of gems to show"
+      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
+      end
+
+      def print_dependencies(spec, level = 0)
+        response = ''
+        response << '  ' * level + "Gem #{spec.full_name}\n"
+        unless spec.dependencies.empty?
+  #        response << '  ' * level + "  Requires\n"
+          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, 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
+          end
+        end
+        result
+      end
+    end      
+  end
+end

data/lib/rubygems/commands/environment_command.rb

@@ -0,0 +1,59 @@
+module Gem
+  module Commands
+    class EnvironmentCommand < Command
+      include CommandAids
+
+      def initialize
+        super('environment', 'Display information about the RubyGems environment')
+      end
+
+      def usage
+        "#{program_name} [args]"
+      end
+
+      def arguments
+        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+/, '')
+      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
+      end
+    end    
+  end
+end

data/lib/rubygems/commands/help_command.rb

@@ -0,0 +1,82 @@
+module Gem
+  module Commands
+    class HelpCommand < Command
+      include CommandAids
+
+      def initialize
+        super('help', "Provide help on the 'gem' command")
+      end
+
+      def usage
+        "#{program_name} ARGUMENT"
+      end
+
+      def arguments
+        args = <<-EOF
+          commands      List all 'gem' commands
+          examples      Show examples of 'gem' usage
+          <command>     Show specific help for <command>
+        EOF
+        return args.gsub(/^\s+/, '')
+      end
+
+      def execute
+        arg = options[:args][0]
+        if begins?("commands", arg)
+          out = []
+          out << "GEM commands are:"
+          out << nil
+
+          margin_width = 4
+          desc_width = command_manager.command_names.collect {|n| n.size}.max + 4
+          summary_width = 80 - margin_width - desc_width
+          wrap_indent = ' ' * (margin_width + desc_width)
+          format = "#{' ' * margin_width}%-#{desc_width}s%s"
+
+          command_manager.command_names.each do |cmd_name|
+            summary = command_manager[cmd_name].summary
+            summary = wrap(summary, summary_width).split "\n"
+            out << sprintf(format, cmd_name, summary.shift)
+            until summary.empty? do
+              out << "#{wrap_indent}#{summary.shift}"
+            end
+          end
+
+          out << nil
+          out << "For help on a particular command, use 'gem help COMMAND'."
+          out << nil
+          out << "Commands may be abbreviated, so long as they are unambiguous."
+          out << "e.g. 'gem i rake' is short for 'gem install rake'."
+
+          say out.join("\n")
+
+        elsif begins?("options", arg)
+          say Gem::HELP
+        elsif begins?("examples", arg)
+          say Gem::EXAMPLES
+        elsif options[:help]
+          command = command_manager[options[:help]]
+          if command
+            # help with provided command
+            command.invoke("--help")
+          else
+            alert_error "Unknown command #{options[:help]}.  Try 'gem help commands'"
+          end
+        elsif arg
+          possibilities = command_manager.find_command_possibilities(arg.downcase)
+          if possibilities.size == 1
+            command = command_manager[possibilities.first]
+            command.invoke("--help")
+          elsif possibilities.size > 1
+            alert_warning "Ambiguous command #{arg} (#{possibilities.join(', ')})"
+          else
+            alert_warning "Unknown command #{arg}. Try gem help commands"
+          end
+        else
+          say Gem::HELP
+        end
+      end
+    end
+    
+  end
+end

data/lib/rubygems/commands/install_command.rb

@@ -0,0 +1,139 @@
+module Gem
+  module Commands
+    class InstallCommand < Command
+      include CommandAids
+      include VersionOption
+      include LocalRemoteOptions
+      include InstallUpdateOptions
+
+      def initialize
+        super(
+          'install',
+          'Install a gem into the local repository',
+          {
+            :domain => :both, 
+            :generate_rdoc => true,
+            :generate_ri   => true,
+            :force => false, 
+            :test => false, 
+            :wrappers => true,
+            :version => "> 0",
+            :install_dir => Gem.dir,
+            :security_policy => nil,
+          })
+        add_version_option('install')
+        add_local_remote_options
+        add_install_update_options
+      end
+    
+      def usage
+        "#{program_name} GEMNAME [options]
+     or: #{program_name} GEMNAME [options] -- --build-flags"
+      end
+
+      def arguments
+        "GEMNAME   name of gem to install"
+      end
+
+      def defaults_str
+        "--both --version '> 0' --rdoc --ri --no-force --no-test\n" +
+        "--install-dir #{Gem.dir}"
+      end
+
+      def execute
+        ENV['GEM_PATH'] = options[:install_dir]
+        if(options[:args].empty?)
+          fail Gem::CommandLineError,
+            "Please specify a gem name on the command line (e.g. gem build GEMNAME)"
+        end
+        options[:args].each do |gem_name|
+          if local?
+            begin
+              entries = []
+                if(File.exist?(gem_name) && !File.directory?(gem_name))
+                  entries << gem_name
+                else
+                  filepattern = gem_name + "*.gem"
+                  entries = Dir[filepattern] 
+                end
+                unless entries.size > 0
+                  if options[:domain] == :local
+                    alert_error "Local gem file not found: #{filepattern}"
+                  end
+                else
+                  result = Gem::Installer.new(entries.last, options).install(options[:force],     options[:install_dir])
+                  installed_gems = [result].flatten
+                  say "Successfully installed #{installed_gems[0].name}, " +
+                  "version #{installed_gems[0].version}" if installed_gems
+              end
+            rescue LocalInstallationError => e
+              say " -> Local installation can't proceed: #{e.message}"
+            rescue Gem::LoadError => e
+              say " -> Local installation can't proceed due to LoadError: #{e.message}"
+            rescue Gem::InstallError => e
+              raise "Error instaling #{gem_name}:\n\t#{e.message}"
+            rescue => e
+              # TODO: Fix this handle to allow the error to propagate to
+              # the top level handler.  Examine the other errors as
+              # well.  This implementation here looks suspicious to me --
+              # JimWeirich (4/Jan/05) 
+              alert_error "Error installing gem #{gem_name}[.gem]: #{e.message}"
+              return
+            end
+          end
+        
+          if remote? && installed_gems.nil?
+            installer = Gem::RemoteInstaller.new(options)
+            installed_gems = installer.install(
+              gem_name,
+              options[:version],
+              options[:force],
+              options[:install_dir])
+            if installed_gems
+              installed_gems.compact!
+              installed_gems.each do |spec|
+                say "Successfully installed #{spec.full_name}"
+              end
+            end
+          end
+        
+          unless installed_gems
+            alert_error "Could not install a local " +
+              "or remote copy of the gem: #{gem_name}"
+            terminate_interaction(1)
+          end
+        
+          # NOTE: *All* of the RI documents must be generated first.
+          # For some reason, RI docs cannot be generated after any RDoc
+          # documents are generated.
+
+          if options[:generate_ri]
+            installed_gems.each do |gem|
+              Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri
+            end
+          end
+
+          if options[:generate_rdoc]
+            installed_gems.each do |gem|
+              Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc
+            end
+          end
+
+          if options[:test]
+            installed_gems.each do |spec|
+              gem_spec = Gem::SourceIndex.from_installed_gems.search(spec.name, spec.version.version).first
+              result = Gem::Validator.new.unit_test(gem_spec)
+              unless result.passed?
+                unless ask_yes_no("...keep Gem?", true) then
+                  Gem::Uninstaller.new(spec.name, spec.version.version).uninstall
+                end
+              end
+            end
+          end
+        end
+      end
+    
+    end
+    
+  end
+end