Class: Gem::Commands::QueryCommand

# File 'lib/rubygems/commands/query_command.rb', line 118

def gem_name?
  !options[:name].source.empty?
end

# File 'lib/rubygems/commands/query_command.rb', line 126

def show_prereleases?
  prerelease.nil? || prerelease
end

# File 'lib/rubygems/commands/query_command.rb', line 94

def check_installed_gems(gem_names)
  exit_code = 0

  if args.empty? && !gem_name?
    alert_error "You must specify a gem name"
    exit_code = 4
  elsif gem_names.count > 1
    alert_error "You must specify only ONE gem!"
    exit_code = 4
  else
    installed = installed?(gem_names.first, options[:version])
    installed = !installed unless options[:installed]

    say(installed)
    exit_code = 1 if !installed
  end

  exit_code
end

# File 'lib/rubygems/commands/query_command.rb', line 67

def defaults_str # :nodoc:
  "--local --name-matches // --no-details --versions --no-installed"
end

# File 'lib/rubygems/commands/query_command.rb', line 71

def description # :nodoc:
  <<-EOF
The query command is the basis for the list and search commands.

You should really use the list and search commands instead.  This command
is too hard to use.
  EOF
end

# File 'lib/rubygems/commands/query_command.rb', line 134

def display_header(type)
  if (ui.outs.tty? and Gem.configuration.verbose) or both?
    say
    say "*** #{type} GEMS ***"
    say
  end
end

# File 'lib/rubygems/commands/query_command.rb', line 246

def entry_details(entry, detail_tuple, specs, platforms)
  return unless options[:details]

  name_tuple, spec = detail_tuple

  spec = spec.fetch_spec(name_tuple)if spec.respond_to?(:fetch_spec)

  entry << "\n"

  spec_platforms   entry, platforms
  spec_authors     entry, spec
  spec_homepage    entry, spec
  spec_license     entry, spec
  spec_loaded_from entry, spec, specs
  spec_summary     entry, spec
end

# File 'lib/rubygems/commands/query_command.rb', line 263

def entry_versions(entry, name_tuples, platforms, specs)
  return unless options[:versions]

  list =
    if platforms.empty? or options[:details]
      name_tuples.map { |n| n.version }.uniq
    else
      platforms.sort.reverse.map do |version, pls|
        out = version.to_s

        if options[:domain] == :local
          default = specs.any? do |s|
            !s.is_a?(Gem::Source) && s.version == version && s.default_gem?
          end
          out = "default: #{out}" if default
        end

        if pls != [Gem::Platform::RUBY]
          platform_list = [pls.delete(Gem::Platform::RUBY), *pls.sort].compact
          out = platform_list.unshift(out).join(' ')
        end

        out
      end
    end

  entry << " (#{list.join ', '})"
end

# File 'lib/rubygems/commands/query_command.rb', line 80

def execute
  gem_names = Array(options[:name])

  if !args.empty?
    gem_names = options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i }
  end

  terminate_interaction(check_installed_gems(gem_names)) if check_installed_gems?

  gem_names.each { |n| show_gems(n) }
end

# File 'lib/rubygems/commands/query_command.rb', line 200

def installed?(name, req = Gem::Requirement.default)
  Gem::Specification.any? { |s| s.name =~ name and req =~ s.version }
end

# File 'lib/rubygems/commands/query_command.rb', line 292

def make_entry(entry_tuples, platforms)
  detail_tuple = entry_tuples.first

  name_tuples, specs = entry_tuples.flatten.partition do |item|
    Gem::NameTuple === item
  end

  entry = [name_tuples.first.name]

  entry_versions(entry, name_tuples, platforms, specs)
  entry_details(entry, detail_tuple, specs, platforms)

  entry.join
end

# File 'lib/rubygems/commands/query_command.rb', line 204

def output_query_results(spec_tuples)
  output = []
  versions = Hash.new { |h,name| h[name] = [] }

  spec_tuples.each do |spec_tuple, source|
    versions[spec_tuple.name] << [spec_tuple, source]
  end

  versions = versions.sort_by do |(n,_),_|
    n.downcase
  end

  output_versions output, versions

  say output.join(options[:details] ? "\n\n" : "\n")
end

# File 'lib/rubygems/commands/query_command.rb', line 221

def output_versions(output, versions)
  versions.each do |gem_name, matching_tuples|
    matching_tuples = matching_tuples.sort_by { |n,_| n.version }.reverse

    platforms = Hash.new { |h,version| h[version] = [] }

    matching_tuples.each do |n, _|
      platforms[n.version] << n.platform if n.platform
    end

    seen = {}

    matching_tuples.delete_if do |n,_|
      if seen[n.version]
        true
      else
        seen[n.version] = true
        false
      end
    end

    output << clean_text(make_entry(matching_tuples, platforms))
  end
end

# File 'lib/rubygems/commands/query_command.rb', line 122

def prerelease
  options[:prerelease]
end

# File 'lib/rubygems/commands/query_command.rb', line 143

def show_gems(name)
  show_local_gems(name)  if local?
  show_remote_gems(name) if remote?
end

# File 'lib/rubygems/commands/query_command.rb', line 148

def show_local_gems(name, req = Gem::Requirement.default)
  display_header("LOCAL")

  specs = Gem::Specification.find_all do |s|
    s.name =~ name and req =~ s.version
  end

  dep = Gem::Deprecate.skip_during { Gem::Dependency.new name, req }
  specs.select! do |s|
    dep.match?(s.name, s.version, show_prereleases?)
  end

  spec_tuples = specs.map do |spec|
    [spec.name_tuple, spec]
  end

  output_query_results(spec_tuples)
end

# File 'lib/rubygems/commands/query_command.rb', line 167

def show_remote_gems(name)
  display_header("REMOTE")

  fetcher = Gem::SpecFetcher.fetcher

  spec_tuples = if name.respond_to?(:source) && name.source.empty?
                  fetcher.detect(specs_type) { true }
                else
                  fetcher.detect(specs_type) do |name_tuple|
                    name === name_tuple.name
                  end
                end

  output_query_results(spec_tuples)
end

# File 'lib/rubygems/commands/query_command.rb', line 307

def spec_authors(entry, spec)
  authors = "Author#{spec.authors.length > 1 ? 's' : ''}: ".dup
  authors << spec.authors.join(', ')
  entry << format_text(authors, 68, 4)
end

# File 'lib/rubygems/commands/query_command.rb', line 313

def spec_homepage(entry, spec)
  return if spec.homepage.nil? or spec.homepage.empty?

  entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4)
end

# File 'lib/rubygems/commands/query_command.rb', line 319

def spec_license(entry, spec)
  return if spec.license.nil? or spec.license.empty?

  licenses = "License#{spec.licenses.length > 1 ? 's' : ''}: ".dup
  licenses << spec.licenses.join(', ')
  entry << "\n" << format_text(licenses, 68, 4)
end

# File 'lib/rubygems/commands/query_command.rb', line 327

def spec_loaded_from(entry, spec, specs)
  return unless spec.loaded_from

  if specs.length == 1
    default = spec.default_gem? ? ' (default)' : nil
    entry << "\n" << "    Installed at#{default}: #{spec.base_dir}"
  else
    label = 'Installed at'
    specs.each do |s|
      version = s.version.to_s
      version << ', default' if s.default_gem?
      entry << "\n" << "    #{label} (#{version}): #{s.base_dir}"
      label = ' ' * label.length
    end
  end
end

# File 'lib/rubygems/commands/query_command.rb', line 344

def spec_platforms(entry, platforms)
  non_ruby = platforms.any? do |_, pls|
    pls.any? { |pl| pl != Gem::Platform::RUBY }
  end

  return unless non_ruby

  if platforms.length == 1
    title = platforms.values.length == 1 ? 'Platform' : 'Platforms'
    entry << "    #{title}: #{platforms.values.sort.join(', ')}\n"
  else
    entry << "    Platforms:\n"

    sorted_platforms = platforms.sort_by { |version,| version }

    sorted_platforms.each do |version, pls|
      label = "        #{version}: "
      data = format_text pls.sort.join(', '), 68, label.length
      data[0, label.length] = label
      entry << data << "\n"
    end
  end
end

# File 'lib/rubygems/commands/query_command.rb', line 368

def spec_summary(entry, spec)
  summary = truncate_text(spec.summary, "the summary for #{spec.full_name}")
  entry << "\n\n" << format_text(summary, 68, 4)
end

# File 'lib/rubygems/commands/query_command.rb', line 183

def specs_type
  if options[:all]
    if options[:prerelease]
      :complete
    else
      :released
    end
  elsif options[:prerelease]
    :prerelease
  else
    :latest
  end
end