class Gem::RequestSet::GemDependencyAPI

# File lib/rubygems/request_set/gem_dependency_api.rb, line 197
def initialize(set, path)
  @set = set
  @path = path

  @current_groups     = nil
  @current_platforms  = nil
  @current_repository = nil
  @dependencies       = {}
  @default_sources    = true
  @git_set            = @set.git_set
  @git_sources        = {}
  @installing         = false
  @requires           = Hash.new {|h, name| h[name] = [] }
  @vendor_set         = @set.vendor_set
  @source_set         = @set.source_set
  @gem_sources        = {}
  @without_groups     = []

  git_source :github do |repo_name|
    repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include? "/"

    "https://github.com/#{repo_name}.git"
  end

  git_source :bitbucket do |repo_name|
    repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include? "/"

    user, = repo_name.split "/", 2

    "https://#{user}@bitbucket.org/#{repo_name}.git"
  end
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 605
def git_source(name, &callback)
  @git_sources[name] = callback
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 282
def load
  instance_eval File.read(@path), @path, 1

  self
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 695
def pin_gem_source(name, type = :default, source = nil)
  source_description =
    case type
    when :default then "(default)"
    when :path    then "path: #{source}"
    when :git     then "git: #{source}"
    when :source  then "source: #{source}"
    else               "(unknown)"
    end

  raise ArgumentError,
    "duplicate source #{source_description} for gem #{name}" if
      @gem_sources.fetch(name, source) != source

  @gem_sources[name] = source
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 359
  def gem(name, *requirements)
    options = requirements.pop if requirements.last.is_a?(Hash)
    options ||= {}

    options[:git] = @current_repository if @current_repository

    source_set = false

    source_set ||= gem_path       name, options
    source_set ||= gem_git        name, options
    source_set ||= gem_git_source name, options
    source_set ||= gem_source     name, options

    duplicate = @dependencies.include? name

    @dependencies[name] =
      if requirements.empty? && !source_set
        Gem::Requirement.default
      elsif source_set
        Gem::Requirement.source_set
      else
        Gem::Requirement.create requirements
      end

    return unless gem_platforms name, options

    groups = gem_group name, options

    return unless (groups & @without_groups).empty?

    pin_gem_source name, :default unless source_set

    gem_requires name, options

    if duplicate
      warn <<-WARNING
Gem dependencies file #{@path} requires #{name} more than once.
      WARNING
    end

    @set.gem name, *requirements
  end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 638
def gemspec(options = {})
  name              = options.delete(:name) || "{,*}"
  path              = options.delete(:path) || "."
  development_group = options.delete(:development_group) || :development

  spec = find_gemspec name, path

  groups = gem_group spec.name, {}

  self_dep = Gem::Dependency.new spec.name, spec.version

  add_dependencies groups, [self_dep]
  add_dependencies groups, spec.runtime_dependencies

  @dependencies[spec.name] = Gem::Requirement.source_set

  spec.dependencies.each do |dep|
    @dependencies[dep.name] = dep.requirement
  end

  groups << development_group

  add_dependencies groups, spec.development_dependencies

  @vendor_set.add_vendor_gem spec.name, path
  gem_requires spec.name, options
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 592
def git(repository)
  @current_repository = repository

  yield
ensure
  @current_repository = nil
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 683
def group(*groups)
  @current_groups = groups

  yield
ensure
  @current_groups = nil
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 757
def platform(*platforms)
  @current_platforms = platforms

  yield
ensure
  @current_platforms = nil
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 783
def ruby(version, options = {})
  engine         = options[:engine]
  engine_version = options[:engine_version]

  raise ArgumentError,
        "You must specify engine_version along with the Ruby engine" if
          engine && !engine_version

  return true if @installing

  unless version == RUBY_VERSION
    message = "Your Ruby version is #{RUBY_VERSION}, " \
              "but your #{gem_deps_file} requires #{version}"

    raise Gem::RubyVersionMismatch, message
  end

  if engine && engine != Gem.ruby_engine
    message = "Your Ruby engine is #{Gem.ruby_engine}, " \
              "but your #{gem_deps_file} requires #{engine}"

    raise Gem::RubyVersionMismatch, message
  end

  if engine_version
    if engine_version != RUBY_ENGINE_VERSION
      message =
        "Your Ruby engine version is #{Gem.ruby_engine} #{RUBY_ENGINE_VERSION}, " \
        "but your #{gem_deps_file} requires #{engine} #{engine_version}"

      raise Gem::RubyVersionMismatch, message
    end
  end

  true
end

# File lib/rubygems/request_set/gem_dependency_api.rb, line 834
def source(url)
  Gem.sources.clear if @default_sources

  @default_sources = false

  Gem.sources << url
end