rubygems-update 0.9.2 → 0.9.3

data/lib/rubygems/commands/list_command.rb

@@ -0,0 +1,33 @@
+module Gem
+  module Commands
+    class ListCommand < QueryCommand
+      include CommandAids
+
+      def initialize
+        super(
+          'list',
+          'Display all gems whose name starts with STRING'
+        )
+        remove_option('--name-matches')
+      end
+
+      def defaults_str
+        "--local --no-details"
+      end
+
+      def usage
+        "#{program_name} [STRING]"
+      end
+
+      def arguments
+        "STRING   start of gem name to look for"
+      end
+
+      def execute
+        string = get_one_optional_argument || ''
+        options[:name] = /^#{string}/i
+        super
+      end
+    end
+  end
+end

data/lib/rubygems/commands/outdated_command.rb

@@ -0,0 +1,21 @@
+module Gem
+  module Commands
+
+    class OutdatedCommand < Command
+
+      def initialize
+        super 'outdated', 'Display all gems that need updates'
+      end
+
+      def execute
+        locals = Gem::SourceIndex.from_installed_gems
+        locals.outdated.each do |name|
+          local = locals.search(/^#{name}$/).last
+          remote = Gem::SourceInfoCache.search(/^#{name}$/).last
+          say "#{local.name} (#{local.version} < #{remote.version})"
+        end
+      end
+
+    end
+  end
+end

data/lib/rubygems/commands/pristine_command.rb

@@ -0,0 +1,103 @@
+module Gem
+  module Commands
+    class PristineCommand < Command
+      include VersionOption
+      include CommandAids
+      def initialize
+        super('pristine',
+          'Restores gem directories to pristine condition from files located in the gem cache',
+          {
+            :version => "> 0.0.0"
+          })
+        add_option('--all',
+          'Restore all installed gems to pristine', 'condition'
+          ) do |value, options|
+          options[:all] = value
+        end
+        add_version_option('restore to', 'pristine condition')
+      end
+
+      def defaults_str
+        "--all"
+      end
+
+      def usage
+        "#{program_name} [args]"
+      end
+
+      def arguments
+        "GEMNAME          The gem to restore to pristine condition (unless --all)"
+      end
+
+      def execute
+        say "Restoring gem(s) to pristine condition..."
+        if options[:all]
+          all_gems = true
+          specs = Gem::SourceIndex.from_installed_gems.collect do |name, spec|
+            spec
+          end
+        else
+          all_gems = false
+          gem_name = get_one_gem_name
+          specs = Gem::SourceIndex.from_installed_gems.search(gem_name, options[:version])
+        end
+
+        if specs.empty?
+          fail "Failed to find gem #{gem_name} #{options[:version]} to restore to pristine condition"
+        end
+        install_dir = Gem.dir # TODO use installer option
+        raise Gem::FilePermissionError.new(install_dir) unless File.writable?(install_dir)
+
+        gems_were_pristine = true
+
+        specs.each do |spec|
+          installer = Gem::Installer.new nil, :wrappers => true # HACK ugly TODO use installer option
+
+          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).untaint
+          pristine_files = format.file_entries.collect {|data| data[0]["path"]}
+          file_map = {}
+          format.file_entries.each {|entry, file_data| file_map[entry["path"]] = file_data}
+          require 'fileutils'
+
+          Dir.chdir target_directory do
+            deployed_files = Dir.glob(File.join("**", "*")) +
+                             Dir.glob(File.join("**", ".*"))
+            to_redeploy = (pristine_files - deployed_files).collect {|path| path.untaint}
+            if to_redeploy.length > 0
+              gems_were_pristine = false
+              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
+            end
+          end
+
+          installer.generate_bin spec, install_dir
+        end
+
+        say "Rebuilt all bin stubs"
+
+        if gems_were_pristine
+          if all_gems
+            say "All installed gem files are already in pristine condition"
+          else
+            say "#{specs[0].full_name} is already in pristine condition"
+          end
+        else
+          if all_gems
+            say "All installed gem files restored to pristine condition"
+          else
+            say "#{specs[0].full_name} restored to pristine condition"
+          end
+        end
+      end
+    end    
+  end
+end

data/lib/rubygems/commands/query_command.rb

@@ -0,0 +1,86 @@
+module Gem
+  module Commands
+    class QueryCommand < Command
+      include LocalRemoteOptions
+      
+      def initialize(name='query', summary='Query gem information in local or remote repositories')
+        super(name,
+          summary,
+          {:name=>/.*/, :domain=>:local, :details=>false}
+          )
+        add_option('-n', '--name-matches REGEXP', 'Name of gem(s) to query on matches the provided REGEXP') do |value, options|
+          options[:name] = /#{value}/i
+        end
+        add_option('-d', '--[no-]details', 'Display detailed information of gem(s)') do |value, options|
+          options[:details] = value
+        end
+        add_local_remote_options
+      end
+
+      def defaults_str
+        "--local --name-matches '.*' --no-details"
+      end
+    
+      def execute
+        if local?
+          say
+          say "*** LOCAL GEMS ***"
+          output_query_results(Gem::cache.search(options[:name]))
+        end
+        if remote?
+          say
+          say "*** REMOTE GEMS ***"
+          output_query_results(Gem::SourceInfoCache.search(options[:name]))
+        end
+      end
+
+      private
+
+      def output_query_results(gemspecs)
+        gem_list_with_version = {}
+        gemspecs.flatten.each do |gemspec|
+          gem_list_with_version[gemspec.name] ||= []
+          gem_list_with_version[gemspec.name] << gemspec
+        end
+      
+        gem_list_with_version = gem_list_with_version.sort do |first, second|
+          first[0].downcase <=> second[0].downcase
+        end
+        gem_list_with_version.each do |gem_name, list_of_matching| 
+          say
+          list_of_matching = list_of_matching.sort_by { |x| x.version }.reverse
+          seen_versions = []
+          list_of_matching.delete_if do |item|
+            if(seen_versions.member?(item.version))           
+              true
+            else 
+              seen_versions << item.version
+              false
+            end
+          end
+          say "#{gem_name} (#{list_of_matching.map{|gem| gem.version.to_s}.join(", ")})"
+          say format_text(list_of_matching[0].summary, 68, 4)
+        end
+      end
+    
+      ##
+      # Used for wrapping and indenting text
+      #
+      def format_text(text, wrap, indent=0)
+        result = []
+        pattern = Regexp.new("^(.{0,#{wrap}})[ \n]")
+        work = text.dup
+        while work.length > wrap
+          if work =~ pattern
+            result << $1
+            work.slice!(0, $&.length)
+          else
+            result << work.slice!(0, wrap)
+          end
+        end
+        result << work if work.length.nonzero?
+        result.join("\n").gsub(/^/, " " * indent)
+      end
+    end
+  end
+end

data/lib/rubygems/commands/rdoc_command.rb

@@ -0,0 +1,75 @@
+module Gem
+  module Commands
+    class RdocCommand < Command
+      include VersionOption
+      include CommandAids
+
+      def initialize
+        super('rdoc',
+          'Generates RDoc for pre-installed gems',
+          {
+            :version => "> 0.0.0",
+            :include_rdoc => true,
+            :include_ri => true,
+          })
+        add_option('--all',
+                   'Generate RDoc/RI documentation for all',
+                   'installed gems') do |value, options|
+          options[:all] = value
+        end
+        add_option('--[no-]rdoc', 
+          'Include RDoc generated documents') do
+          |value, options|
+          options[:include_rdoc] = value
+        end
+        add_option('--[no-]ri', 
+          'Include RI generated documents'
+          ) do |value, options|
+          options[:include_ri] = value
+        end
+        add_version_option('rdoc')
+      end
+
+      def defaults_str
+        "--version '> 0.0.0' --rdoc --ri"
+      end
+
+      def usage
+        "#{program_name} [args]"
+      end
+
+      def arguments
+        "GEMNAME          The gem to generate RDoc for (unless --all)"
+      end
+
+      def execute
+        if options[:all]
+          specs = Gem::SourceIndex.from_installed_gems.collect { |name, spec|
+            spec
+          }
+        else
+          gem_name = get_one_gem_name
+          specs = Gem::SourceIndex.from_installed_gems.search(
+            gem_name, options[:version])
+        end
+
+        if specs.empty?
+          fail "Failed to find gem #{gem_name} to generate RDoc for #{options[:version]}"
+        end
+        if options[:include_ri]
+          specs.each do |spec|
+            Gem::DocManager.new(spec).generate_ri
+          end
+        end
+        if options[:include_rdoc]
+          specs.each do |spec|
+            Gem::DocManager.new(spec).generate_rdoc
+          end
+        end
+
+        true
+      end
+    end
+    
+  end
+end

data/lib/rubygems/commands/search_command.rb

@@ -0,0 +1,35 @@
+module Gem
+  module Commands
+
+    class SearchCommand < QueryCommand
+      include CommandAids
+
+      def initialize
+        super(
+          'search',
+          'Display all gems whose name contains STRING'
+        )
+        remove_option('--name-matches')
+      end
+
+      def defaults_str
+        "--local --no-details"
+      end
+
+      def usage
+        "#{program_name} [STRING]"
+      end
+
+      def arguments
+        "STRING   fragment of gem name to look for"
+      end
+
+      def execute
+        string = get_one_optional_argument
+        options[:name] = /#{string}/i
+        super
+      end
+    end
+    
+  end
+end

data/lib/rubygems/commands/sources_command.rb

@@ -0,0 +1,73 @@
+module Gem
+  module Commands
+  
+    class SourcesCommand < Command
+
+      def initialize
+        super 'sources', 'Manage the sources RubyGems will search forgems'
+
+        add_option '-a', '--add SOURCE_URI', 'Add source' do |value, options|
+          options[:add] = value
+        end
+
+        add_option '-l', '--list', 'List sources' do |value, options|
+          options[:list] = value
+        end
+
+        add_option '-r', '--remove SOURCE_URI', 'Remove source' do |value, options|
+          options[:remove] = value
+        end
+      end
+
+      def defaults_str
+        '--list'
+      end
+
+      def execute
+        if options[:add] then
+          source_uri = options[:add]
+
+          sice = Gem::SourceInfoCacheEntry.new nil, nil
+          begin
+            sice.refresh source_uri
+          rescue ArgumentError
+            say "#{source_uri} is not a URI"
+          rescue Gem::RemoteFetcher::FetchError => e
+            say "Error fetching #{source_uri}:\n\t#{e.message}"
+          else
+            Gem::SourceInfoCache.cache_data[source_uri] = sice
+            Gem::SourceInfoCache.cache.update
+            Gem::SourceInfoCache.cache.flush
+
+            say "#{source_uri} added to sources"
+          end
+        end
+
+        if options[:remove] then
+          source_uri = options[:remove]
+
+          unless Gem::SourceInfoCache.cache_data.include? source_uri then
+            say "source #{source_uri} not present in cache"
+          else
+            Gem::SourceInfoCache.cache_data.delete source_uri
+            Gem::SourceInfoCache.cache.update
+            Gem::SourceInfoCache.cache.flush
+            say "#{source_uri} removed from sources"
+          end
+        end
+
+        if options[:list] or not (options[:add] or options[:remove]) then
+          say "*** CURRENT SOURCES ***"
+          say
+
+          Gem::SourceInfoCache.cache_data.keys.each do |source_uri|
+            say source_uri
+          end
+        end
+      end
+
+    end
+
+    
+  end
+end

data/lib/rubygems/commands/specification_command.rb

@@ -0,0 +1,58 @@
+module Gem
+  module Commands
+    class SpecificationCommand < Command
+      include VersionOption
+      include LocalRemoteOptions
+      include CommandAids
+    
+      def initialize
+        super('specification', 'Display gem specification (in yaml)',
+              {:domain=>:local, :version=>"> 0.0.0"})
+        add_version_option('examine')
+        add_local_remote_options
+        add_option('--all', 'Output specifications for all versions of',
+                   'the gem') do |value, options|
+          options[:all] = true
+        end
+      end
+
+      def defaults_str
+        "--local --version '(latest)'"
+      end
+
+      def usage
+        "#{program_name} GEMFILE"
+      end
+
+      def arguments
+        "GEMFILE       Name of a .gem file to examine"
+      end
+
+      def execute
+        if local?
+          gem = get_one_gem_name
+          gem_specs = Gem::SourceIndex.from_installed_gems.search(gem, options[:version])
+          unless gem_specs.empty?
+            require 'yaml'
+            output = lambda { |spec| say spec.to_yaml; say "\n" }
+            if options[:all]
+              gem_specs.each(&output)
+            else
+              spec = gem_specs.sort_by { |spec| spec.version }.last
+              output[spec]
+            end
+          else
+            alert_error "Unknown gem #{gem}"
+          end
+        end
+      
+        if remote?
+          say "(Remote 'info' operation is not yet implemented.)"
+          # NOTE: when we do implement remote info, make sure we don't
+          # duplicate huge swabs of local data.  If it's the same, just
+          # say it's the same.
+        end
+      end
+    end
+  end
+end