bundler

type Definition ¶

type Definition struct {
	// Dependencies are the top-level Gemfile dependencies (DEPENDENCIES section).
	Dependencies []*Dependency
	// Platforms is the PLATFORMS section.
	Platforms []string
	// RubyVersion, when set, becomes the "RUBY VERSION" section.
	RubyVersion string
	// BundledWith is the Bundler version to record ("BUNDLED WITH").
	BundledWith string
	// Source is the source the resolved specs are attached to (a GEM remote in
	// the common case).
	Source *Source
}

Definition is the pure part of Bundler::Definition: the glue between the Gemfile's dependencies (supplied by the host after evaluating the Gemfile), the resolution source, the resolved SpecSet, and the lockfile production. The Gemfile evaluation, index fetch and install are all host-side seams.

func (d *Definition) Lockfile(res *Resolution) *Lockfile

func (d *Definition) Resolve(index Index) (*Resolution, error)

type Dependency ¶

type Dependency struct {
	Name        string
	Requirement *rubygems.Requirement

	// Groups is the set of bundler groups (default [:default]); empty means the
	// default group.
	Groups []string
	// Platforms is the set of Gemfile platforms the dep applies to (e.g. "ruby",
	// "mri", "jruby"); empty means all.
	Platforms []string
	// Source, when non-nil, pins the dependency to a PATH or GIT source and
	// makes it print with a "!" suffix in DEPENDENCIES.
	Source *Source
}

Dependency is a Bundler::Dependency: a gem name plus a requirement, the bundler groups it belongs to, the platforms it applies to, and the source it is pinned to (if any). The groups/platforms drive `bundle install --without` and platform filtering; resolution itself uses name + requirement + source.

func MustDependency(name string, constraints ...string) *Dependency

func NewDependency(name string, constraints ...string) (*Dependency, error)

type Gemfile ¶

type Gemfile struct {
	// Sources is the list of `source "url"` URLs in declaration order. The first
	// is Bundler's primary remote.
	Sources []string
	// RubyVersion is the `ruby "x.y.z"` constraint ("" when absent).
	RubyVersion string
	// Gems is the declared dependencies in declaration order, each carrying its
	// requirement, groups, platforms and (git/path) source options.
	Gems []*Dependency
	// Gemspecs holds each `gemspec` directive (development gemspec inclusion).
	Gemspecs []GemspecDirective
	// GitSources maps a custom `git_source(:name){ |repo| url }` name to its URL
	// template (with "%s" where the repo slug is interpolated).
	GitSources map[string]string
}

Gemfile is the parsed model of a Bundler Gemfile (the DSL the host evaluates to drive resolution). It is the structured result of reading the canonical, deterministic DSL forms — the ones a `bundle lock` cares about — without a Ruby interpreter.

A Gemfile is, in full generality, arbitrary Ruby; ParseGemfile reads the common static forms (string literals, symbols, arrays, hash options) and reports anything it cannot statically understand. For Gemfiles that compute gem names or requirements at runtime, the host evaluates the Ruby (e.g. rbgo) and builds the []*Dependency directly.

func ParseGemfile(content string) (*Gemfile, error)

func (gf *Gemfile) Dependencies() []*Dependency

type GemfileError ¶

type GemfileError struct {
	Line int
	// contains filtered or unexported fields
}

GemfileError reports a Gemfile DSL line that could not be statically parsed.

func (e *GemfileError) Error() string

type GemspecDirective ¶

type GemspecDirective struct {
	Path             string // :path option (default ".")
	Name             string // :name option (default: the single gemspec found)
	DevelopmentGroup string // :development_group option (default "development")
}

GemspecDirective is a `gemspec` line: it pulls a local .gemspec's runtime dependencies into the Gemfile. The options (path/name/development_group) are captured; resolving the actual gemspec is a host-side seam.

type Index ¶

type Index interface {
	// Versions returns every available spec for name. The resolver sorts them
	// itself, so any order is fine. An unknown gem returns an empty slice.
	Versions(name string) []IndexSpec
}

Index is the resolution seam: it answers "what versions of NAME exist, and what does each depend on?" with NO network and NO filesystem. A test fixture, an in-memory mirror of the compact index, or an HTTP-backed implementation can all satisfy it.

type IndexSpec ¶

type IndexSpec struct {
	Name         string
	Version      *rubygems.Version
	Platform     string
	Dependencies []SpecDependency
}

IndexSpec is one candidate gem version in the resolution index: its name, version, and its own runtime dependencies. It is the unit the resolver activates. Where the candidate comes from (network, mirror, fixture) is a host-side seam.

type LockSource ¶

type LockSource struct {
	Source *Source
	Specs  []*Spec
}

LockSource pairs a Source header with the specs locked under it.

type Lockfile ¶

type Lockfile struct {
	// Sources holds the GEM/PATH/GIT sections in lock order, each carrying the
	// specs that resolved against it.
	Sources []*LockSource
	// Platforms is the PLATFORMS section (sorted on emit).
	Platforms []string
	// Dependencies is the DEPENDENCIES section (the top-level Gemfile deps).
	Dependencies []*Dependency
	// RubyVersion is the "RUBY VERSION" section value ("" when absent).
	RubyVersion string
	// BundledWith is the "BUNDLED WITH" version ("" when absent).
	BundledWith string
}

Lockfile is the parsed/parseable model of a Gemfile.lock: the source sections with their specs, the platforms, the top-level dependencies, an optional locked ruby version, and the bundler version. Serializing it reproduces the original bytes.

func ParseLockfile(content string) (*Lockfile, error)

func (l *Lockfile) Bytes() []byte

func (l *Lockfile) String() string

type MapIndex ¶

type MapIndex map[string][]IndexSpec

MapIndex is a trivial in-memory Index built from a name -> specs map. It is the fixture index used by the tests and a convenient host-side adapter.

func (m MapIndex) AddGem(name, version string, deps ...SpecDependency) error

func (m MapIndex) Versions(name string) []IndexSpec

type ParseError ¶

type ParseError struct {
	// contains filtered or unexported fields
}

ParseError is returned when a Gemfile.lock cannot be parsed.

func (e *ParseError) Error() string

type Resolution ¶

type Resolution struct {
	// contains filtered or unexported fields
}

Resolution is the successful result of Resolve: the activated specs keyed by name, in a deterministic order.

func Resolve(deps []*Dependency, index Index, source *Source) (*Resolution, error)

func (r *Resolution) Get(name string) *Spec

func (r *Resolution) Specs() []*Spec

type Source ¶

type Source struct {
	Type SourceType

	// Remotes holds the source's remote URLs. For a GEM source there may be
	// several; for PATH/GIT there is exactly one.
	Remotes []string

	// Revision is the locked git commit (GIT only).
	Revision string
	// Ref, Branch, Tag and Submodules are the optional git locators (GIT only),
	// serialized in this fixed order after revision.
	Ref        string
	Branch     string
	Tag        string
	Submodules string
	// Glob is the gemspec glob (PATH and GIT). The empty string means "the
	// default", which is omitted from the lockfile.
	Glob string
}

Source describes one resolution source — a rubygems remote, a local path or a git checkout — exactly as it appears in a Gemfile.lock section header. It is the pure-data model; fetching from it is a host-side seam.

func (s *Source) GemRemote() string

type SourceType ¶

type SourceType string

SourceType is the kind of a lockfile source section.

const (
	// GemSource is a rubygems remote ("GEM") section.
	GemSource SourceType = "GEM"
	// PathSource is a local path ("PATH") section.
	PathSource SourceType = "PATH"
	// GitSource is a git ("GIT") section.
	GitSource SourceType = "GIT"
)

type Spec ¶

type Spec struct {
	Name         string
	Version      *rubygems.Version
	Platform     string // "" means the "ruby" platform (Gem::Platform::RUBY)
	Source       *Source
	Dependencies []SpecDependency
}

Spec is a resolved specification in the lockfile: a name, a version, an optional platform, the source it came from, and its runtime dependencies. It is the pure-data analogue of Bundler::LazySpecification.

type SpecDependency ¶

type SpecDependency struct {
	Name        string
	Requirement *rubygems.Requirement
}

SpecDependency is one runtime dependency edge of a resolved spec: a gem name and its requirement. It mirrors a Gem::Dependency line nested under a spec in the lockfile's specs: tree.

func Dep(name string, constraints ...string) SpecDependency

type VersionConflict ¶

type VersionConflict struct {
	// Name is the gem whose requirements conflict.
	Name string
	// Requesters maps each requirement string to the gem(s) that imposed it
	// ("Gemfile" for a root dependency).
	Requesters map[string][]string
	// contains filtered or unexported fields
}

VersionConflict is returned when no consistent set satisfies the requirements. Its message names the gem that could not be resolved and the conflicting requirements, in the shape Bundler reports.

func (e *VersionConflict) Error() string