class Gem::Resolver::APISet

def find_all(req)
  res = []
  return res unless @remote
  if @to_fetch.include?(req.name)
    prefetch_now
  end
  versions(req.name).each do |ver|
    if req.dependency.match? req.name, ver[:number], @prerelease
      res << Gem::Resolver::APISpecification.new(self, ver)
    end
  end
  res
end

def initialize(dep_uri = "https://index.rubygems.org/info/")
  super()
  dep_uri = Gem::URI dep_uri unless Gem::URI === dep_uri
  @dep_uri = dep_uri
  @uri     = dep_uri + ".."
  @data   = Hash.new {|h,k| h[k] = [] }
  @source = Gem::Source.new @uri
  @to_fetch = []
end

def lines(str)
  lines = str.split("\n")
  header = lines.index("---")
  header ? lines[header + 1..-1] : lines
end

def parse_gem(string)
  @gem_parser ||= GemParser.new
  @gem_parser.parse(string)
end

def prefetch(reqs)
  return unless @remote
  names = reqs.map {|r| r.dependency.name }
  needed = names - @data.keys - @to_fetch
  @to_fetch += needed
end

def prefetch_now # :nodoc:
  needed = @to_fetch
  @to_fetch = []
  needed.sort.each do |name|
    versions(name)
  end
end

def pretty_print(q) # :nodoc:
  q.group 2, "[APISet", "]" do
    q.breakable
    q.text "URI: #{@dep_uri}"
    q.breakable
    q.text "gem names:"
    q.pp @data.keys
  end
end

def versions(name) # :nodoc:
  if @data.key?(name)
    return @data[name]
  end
  uri = @dep_uri + name
  begin
    str = Gem::RemoteFetcher.fetcher.fetch_path uri
  rescue Gem::RemoteFetcher::FetchError
    @data[name] = []
  else
    lines(str).each do |ver|
      number, platform, dependencies, requirements = parse_gem(ver)
      platform ||= "ruby"
      dependencies = dependencies.map {|dep_name, reqs| [dep_name, reqs.join(", ")] }
      requirements = requirements.map {|req_name, reqs| [req_name.to_sym, reqs] }.to_h
      @data[name] << { name: name, number: number, platform: platform, dependencies: dependencies, requirements: requirements }
    end
  end
  @data[name]
end