Class: Gem::SpecFetcher

# File 'lib/rubygems/spec_fetcher.rb', line 46

def self.fetcher=(fetcher) # :nodoc:
  @fetcher = fetcher
end

# File 'lib/rubygems/spec_fetcher.rb', line 34

attr_reader :prerelease_specs # :nodoc:

# File 'lib/rubygems/spec_fetcher.rb', line 24

attr_reader :sources # :nodoc:

# File 'lib/rubygems/spec_fetcher.rb', line 29

attr_reader :specs # :nodoc:

# File 'lib/rubygems/spec_fetcher.rb', line 133

def detect(type=:complete)
  tuples = []

  list, _ = available_specs(type)
  list.each do |source, specs|
    specs.each do |tup|
      if yield(tup)
        tuples << [tup, source]
      end
    end
  end

  tuples
end

# File 'lib/rubygems/spec_fetcher.rb', line 86

def search_for_dependency(dependency, matching_platform=true)
  found = {}

  rejected_specs = {}

  list, errors = available_specs(dependency.identity)

  list.each do |source, specs|
    if dependency.name.is_a?(String) && specs.respond_to?(:bsearch)
      start_index = (0...specs.length).bsearch {|i| specs[i].name >= dependency.name }
      end_index   = (0...specs.length).bsearch {|i| specs[i].name > dependency.name }
      specs = specs[start_index...end_index] if start_index && end_index
    end

    found[source] = specs.select do |tup|
      if dependency.match?(tup)
        if matching_platform && !Gem::Platform.match_gem?(tup.platform, tup.name)
          pm = (
            rejected_specs[dependency] ||= \
              Gem::PlatformMismatch.new(tup.name, tup.version))
          pm.add_platform tup.platform
          false
        else
          true
        end
      end
    end
  end

  errors += rejected_specs.values

  tuples = []

  found.each do |source, specs|
    specs.each do |s|
      tuples << [s, source]
    end
  end

  tuples = tuples.sort_by {|x| x[0].version }

  [tuples, errors]
end

# File 'lib/rubygems/spec_fetcher.rb', line 153

def spec_for_dependency(dependency, matching_platform=true)
  tuples, errors = search_for_dependency(dependency, matching_platform)

  specs = []
  tuples.each do |tup, source|
    spec = source.fetch_spec(tup)
  rescue Gem::RemoteFetcher::FetchError => e
    errors << Gem::SourceFetchProblem.new(source, e)
  else
    specs << [spec, source]
  end

  [specs, errors]
end

# File 'lib/rubygems/spec_fetcher.rb', line 172

def suggest_gems_from_name(gem_name, type = :latest, num_results = 5)
  gem_name = gem_name.downcase.tr("_-", "")

  # All results for 3-character-or-shorter (minus hyphens/underscores) gem
  # names get rejected, so we just return an empty array immediately instead.
  return [] if gem_name.length <= 3

  max   = gem_name.size / 2
  names = available_specs(type).first.values.flatten(1)

  min_length = gem_name.length - max
  max_length = gem_name.length + max

  matches = names.filter_map do |n|
    len = n.name.length
    # If the length is min_length or shorter, we've done `max` deletions.
    # If the length is max_length or longer, we've done `max` insertions.
    # These would both be rejected later, so we skip early for performance.
    next if len <= min_length || len >= max_length

    # If the gem doesn't support the current platform, bail early.
    next unless n.match_platform?

    # The candidate name, normalized the same as gem_name.
    normalized_name = n.name.downcase
    normalized_name.tr!("_-", "")

    # If we found an exact match (after stripping underscores and hyphens),
    # that's our most likely candidate.
    # Return it immediately, and skip the rest of the loop.
    return [n.name] if normalized_name == gem_name

    distance = levenshtein_distance gem_name, normalized_name

    # Skip current candidate, if the edit distance is greater than allowed.
    next if distance >= max

    # If all else fails, return the name and the calculated distance.
    [n.name, distance]
  end

  matches = if matches.empty? && type != :prerelease
    suggest_gems_from_name gem_name, :prerelease
  else
    matches.uniq.sort_by {|_name, dist| dist }
  end

  matches.map {|name, _dist| name }.uniq.first(num_results)
end

# File 'lib/rubygems/spec_fetcher.rb', line 272

def tuples_for(source, type, gracefully_ignore=false) # :nodoc:
  @caches[type][source.uri] ||=
    source.load_specs(type).sort_by(&:name)
rescue Gem::RemoteFetcher::FetchError
  raise unless gracefully_ignore
  []
end