123456789_123456789_123456789_123456789_123456789_

Module: Gem::QueryUtils

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
Defined in: lib/rubygems/query_utils.rb

Instance Attribute Summary

LocalRemoteOptions - Included

#both?

Is fetching of local and remote information enabled?

#local?

Is local fetching enabled?

#remote?

Is remote fetching enabled?

Instance Method Summary

VersionOption - Included

#add_platform_option

Add the –platform option to the option parser.

#add_prerelease_option

Add the –prerelease option to the option parser.

#add_version_option

Add the –version option to the option parser.

#get_platform_from_requirements

Extract platform given on the command line.

LocalRemoteOptions - Included

#accept_uri_http

Allows OptionParser to handle HTTP URIs.

#add_bulk_threshold_option

Add the –bulk-threshold option.

#add_clear_sources_option

Add the –clear-sources option.

#add_local_remote_options

Add local/remote options to the command line parser.

#add_proxy_option

Add the –http-proxy option.

#add_source_option

Add the –source option.

#add_update_sources_option

Add the –update-sources option.

Text - Included

#clean_text

Remove any non-printable characters and make the text suitable for printing.

#format_text

Wraps text to wrap characters and optionally indents by indent characters.

#levenshtein_distance

Returns a value representing the “cost” of transforming str1 into str2 Vendored version of DidYouMean::Levenshtein.distance from the ruby/did_you_mean gem @ 1.4.0 github.com/ruby/did_you_mean/blob/2ddf39b874808685965dbc47d344cf6c7651807c/lib/did_you_mean/levenshtein.rb#L7-L37.

#truncate_text, #min3

Instance Attribute Details

#check_installed_gems?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 94

def check_installed_gems?
  !options[:installed].nil?
end

#gem_name?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 98

def gem_name?
  !options[:name].nil?
end

#show_prereleases?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 106

def show_prereleases?
  prerelease.nil? || prerelease
end

Instance Method Details

#add_query_options

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 14

def add_query_options
  add_option("-i", "--[no-]installed",
             "Check for installed gem") do |value, options|
    options[:installed] = value
  end

  add_option("-I", "Equivalent to --no-installed") do |value, options|
    options[:installed] = false
  end

  add_version_option command, "for use with --installed"

  add_option("-d", "--[no-]details",
             "Display detailed information of gem(s)") do |value, options|
    options[:details] = value
  end

  add_option("--[no-]versions",
             "Display only gem names") do |value, options|
    options[:versions] = value
    options[:details] = false unless value
  end

  add_option("-a", "--all",
             "Display all gem versions") do |value, options|
    options[:all] = value
  end

  add_option("-e", "--exact",
             "Name of gem(s) to query on matches the",
             "provided STRING") do |value, options|
    options[:exact] = value
  end

  add_option("--[no-]prerelease",
             "Display prerelease versions") do |value, options|
    options[:prerelease] = value
  end

  add_local_remote_options
end

#args (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 110

def args
  options[:args].to_a
end

#check_installed_gems(gem_names) (readonly, private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 74

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

#defaults_str

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 56

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

#display_header(type) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 114

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

#entry_details(entry, detail_tuple, specs, platforms) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 224

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

#entry_versions(entry, name_tuples, platforms, specs) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 241

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

  list =
    if platforms.empty? || 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

#execute

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 60

def execute
  gem_names = if args.empty?
    [options[:name]]
  else
    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

#installed?(name, req = Gem::Requirement.default) ⇒ Boolean (private)

Check if gem name version version is installed.

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 178

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

#make_entry(entry_tuples, platforms) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 270

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

#output_query_results(spec_tuples) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 182

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

#output_versions(output, versions) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 199

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

#prerelease (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 102

def prerelease
  options[:prerelease]
end

#show_gems(name) (private)

Guts of original execute

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 123

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

#show_local_gems(name, req = Gem::Requirement.default) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 128

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

  specs = Gem::Specification.find_all do |s|
    name_matches = name ? s.name =~ name : true
    version_matches = show_prereleases? || !s.version.prerelease?

    name_matches && version_matches
  end

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

  output_query_results(spec_tuples)
end

#show_remote_gems(name) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 145

def show_remote_gems(name)
  display_header("REMOTE")

  fetcher = Gem::SpecFetcher.fetcher

  spec_tuples = if name.nil?
    fetcher.detect(specs_type) { true }
  else
    fetcher.detect(specs_type) do |name_tuple|
      name === name_tuple.name && options[:version].satisfied_by?(name_tuple.version)
    end
  end

  output_query_results(spec_tuples)
end

#spec_authors(entry, spec) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 285

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

#spec_homepage(entry, spec) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 291

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

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

#spec_license(entry, spec) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 297

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

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

#spec_loaded_from(entry, spec, specs) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 305

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

#spec_platforms(entry, platforms) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 322

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

#spec_summary(entry, spec) (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 346

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

#specs_type (private)

[ GitHub ]

  
# File 'lib/rubygems/query_utils.rb', line 161

def specs_type
  if options[:all] || options[:version].specific?
    if options[:prerelease]
      :complete
    else
      :released
    end
  elsif options[:prerelease]
    :prerelease
  else
    :latest
  end
end