- Gem::Validator.new.alien.each do |key, val|

- if(val.size > 0)

- say "\t#{error_entry.path}:"

- say "\t#{error_entry.problem}"

- say

- say "#{key} is error-free"

- specs = Gem.cache.search(/^#{gem_name}$/i)

- uninstall_command = Gem::CommandManager.instance['uninstall']

- options[:version] = "= #{spec.version}"

- options[:executables] = false

- uninstaller = Gem::Uninstaller.new spec.name, options

- rescue Gem::DependencyRemovalException,

- "--no-lib-only"

- "#{program_name} GEMNAME"

- gem = get_one_gem_name

- s = options[:specdirs].map do |i|

- path_kind = if s.empty? then

- s = Gem::SourceIndex.installed_spec_directories

- si = Gem::SourceIndex.from_gems_in(*s)

- gem_spec = si.find_name(gem, 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 }

- 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)

- :directory => '.'

- "--directory ."

-the --directory option. When done, it will generate a set of files like this:

- gems/ # .gem files you want to index

- quick/<gemname>.gemspec.rz # legacy YAML quick index file

- quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file

- Marshal.<version>.Z # Marshal full index

- yaml.Z # legacy YAML full index

-The .Z and .rz extension files are compressed with the inflate algorithm. The

-Marshal version number comes from ruby's Marshal::MAJOR_VERSION and

-Marshal::MINOR_VERSION constants. It is used to ensure compatibility. The

-yaml indexes exist for legacy RubyGems clients and fallback in case of Marshal

-version changes.

- indexer = Gem::Indexer.new options[:directory]

- indexer.generate_index

- :generate_rdoc => true,

- :generate_ri => true,

- :test => false,

- :version => Gem::Requirement.default,

-directory by deault. This can be overridden with the --no-wrappers option.

- install_options = {

- :env_shebang => options[:env_shebang],

- :domain => options[:domain],

- :force => options[:force],

- :format_executable => options[:format_executable],

- :ignore_dependencies => options[:ignore_dependencies],

- :install_dir => options[:install_dir],

- :security_policy => options[:security_policy],

- :wrappers => options[:wrappers],

- :bin_dir => options[:bin_dir],

- :development => options[:development],

- }

-

- inst = Gem::DependencyInstaller.new install_options

-# 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}: #{e.message}"

-# return

- 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] then

- installed_gems.each do |gem|

- Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri

- end

- Gem::DocManager.update_ri_cache

- end

- if options[:generate_rdoc] then

- installed_gems.each do |gem|

- Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc

- end

- if options[:test] then

- 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)

- if result and not result.passed?

- unless ask_yes_no("...keep Gem?", true) then

- Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall

- spec_tuples = fetcher.find_matching dep, all, false

- ##

- # Used for wrapping and indenting text

-

- def format_text(text, wrap, indent=0)

- result = []

- work = text.dup

-

- while work.length > wrap

- if work =~ /^(.{0,#{wrap}})[ \n]/o then

- 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

-

-module Gem

- module Commands

- class RdocCommand < Command

- include VersionOption

-

- def initialize

- super('rdoc',

- 'Generates RDoc for pre-installed gems',

- {

- :version => Gem::Requirement.default,

- :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

- end

- def arguments # :nodoc:

- "GEMNAME gem to generate documentation for (unless --all)"

- end

- def defaults_str # :nodoc:

- "--version '#{Gem::Requirement.default}' --rdoc --ri"

- end

- def usage # :nodoc:

- "#{program_name} [args]"

- 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

-

- Gem::DocManager.update_ri_cache

- end

-

- if options[:include_rdoc]

- specs.each do |spec|

- Gem::DocManager.new(spec).generate_rdoc

- end

- end

-

- true

-module Gem

- module Commands

-

- class SearchCommand < QueryCommand

-

- def initialize

- super(

- 'search',

- 'Display all gems whose name contains STRING'

- )

- remove_option('--name-matches')

- end

-

- def arguments # :nodoc:

- "STRING fragment of gem name to search 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

- add_option '-p', '--port=PORT', Integer,

- :domain => :local, :version => Gem::Requirement.default

- "GEMFILE name of gem to show the gemspec for"

- "--local --version '#{Gem::Requirement.default}'"

- "#{program_name} [GEMFILE]"

- gem = get_one_gem_name

- output = lambda { |s| say s.to_yaml; say "\n" }

-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

- add_option('--target', 'target directory for unpacking') do |value, options|

- 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."

- :generate_ri => true,

- :force => false,

- :test => false

- installer.install name

- say "Successfully installed #{spec.full_name}"

- update_gems = Gem.source_index.search 'rubygems-update'

- Gem.configuration.verbose