manifest

Documentation

Index

• Constants
• func Overwrite(rw ManifestIO, filename string, p ManifestPatch) error
• func SplitNPMAlias(v string) (name, version string)
• type DependencyPatch
• type DependencyWithOrigin
• type Manifest
  • func (m Manifest) Clone() Manifest
  • func (m Manifest) System() resolve.System
• type ManifestIO
  • func GetManifestIO(pathToManifest string) (ManifestIO, error)
• type ManifestPatch
• type MavenManifestIO
  • func NewMavenManifestIO() MavenManifestIO
  • func (m MavenManifestIO) Read(df lockfile.DepFile) (Manifest, error)
  • func (MavenManifestIO) Write(df lockfile.DepFile, w io.Writer, patch ManifestPatch) error
• type MavenManifestSpecific
• type MavenPropertyPatches
• type NpmManifestIO
  • func (rw NpmManifestIO) Read(f lockfile.DepFile) (Manifest, error)
  • func (NpmManifestIO) Write(r lockfile.DepFile, w io.Writer, patch ManifestPatch) error
• type PackageJSON
• type PropertyWithOrigin
• type RequirementKey
  • func MakeRequirementKey(requirement resolve.RequirementVersion) RequirementKey

Constants

const (
	OriginManagement = "management"
	OriginParent     = "parent"
	OriginPlugin     = "plugin"
	OriginProfile    = "profile"
)

const MaxParent = 100

To avoid indefinite loop when fetching parents, set a limit on the number of parents.

Functions

func Overwrite

func Overwrite(rw ManifestIO, filename string, p ManifestPatch) error

Overwrite applies the ManifestPatch to the manifest at filename. Used so as to not have the same file open for reading and writing at the same time.

func SplitNPMAlias

func SplitNPMAlias(v string) (name, version string)

extract the real package name & version from an alias-specified version e.g. "npm:pkg@^1.2.3" -> name: "pkg", version: "^1.2.3" name is empty and version is unchanged if not an alias specifier

Types

type DependencyPatch

type DependencyPatch struct {
	Pkg          resolve.PackageKey // The package this applies to
	Type         dep.Type           // The dependency type
	OrigRequire  string             // The original requirement string e.g. "1.*.*"
	NewRequire   string             // The new requirement string e.g. "2.*.*"
	OrigResolved string             // The version the original resolves to e.g. "1.2.3" (for display only)
	NewResolved  string             // The version the new resolves to e.g. "2.4.6" (for display only)
}

type DependencyWithOrigin

type DependencyWithOrigin struct {
	maven.Dependency
	Origin string // Origin indicates where the dependency comes from
}

type Manifest

type Manifest struct {
	FilePath          string                       // Path to the manifest file on disk
	Root              resolve.Version              // Version representing this package
	Requirements      []resolve.RequirementVersion // All direct requirements, including dev
	Groups            map[RequirementKey][]string  // Dependency groups that the imports belong to
	LocalManifests    []Manifest                   // manifests of local packages
	EcosystemSpecific any                          // Any ecosystem-specific information needed
}

func (Manifest) Clone

func (m Manifest) Clone() Manifest

func (Manifest) System

func (m Manifest) System() resolve.System

type ManifestIO

type ManifestIO interface {
	// Read parses a manifest file into a Manifest, possibly recursively following references to other local manifest files
	Read(file lockfile.DepFile) (Manifest, error)
	// Write applies the ManifestPatch to the manifest, with minimal changes to the file.
	// `original` is the original manifest file to read from. The updated manifest is written to `output`.
	Write(original lockfile.DepFile, output io.Writer, patches ManifestPatch) error
}

func GetManifestIO

func GetManifestIO(pathToManifest string) (ManifestIO, error)

type ManifestPatch

type ManifestPatch struct {
	Manifest          *Manifest         // The original manifest
	Deps              []DependencyPatch // Changed direct dependencies
	EcosystemSpecific any               // Any ecosystem-specific information
}

type MavenManifestIO

type MavenManifestIO struct {
	datasource.MavenRegistryAPIClient
}

func NewMavenManifestIO

func NewMavenManifestIO() MavenManifestIO

func (MavenManifestIO) Read

func (m MavenManifestIO) Read(df lockfile.DepFile) (Manifest, error)

TODO: handle profiles (activation and interpolation)

func (MavenManifestIO) Write

func (MavenManifestIO) Write(df lockfile.DepFile, w io.Writer, patch ManifestPatch) error

type MavenManifestSpecific

type MavenManifestSpecific struct {
	Properties             []PropertyWithOrigin         // Properties from the base project only
	OriginalRequirements   []DependencyWithOrigin       // Dependencies from the base project only
	RequirementsForUpdates []resolve.RequirementVersion // Requirements that we only need for updates
}

type MavenPropertyPatches

type MavenPropertyPatches map[string]map[string]string // origin -> tag -> value

MavenPropertyPatches represent the properties to be updated, which is a map of properties of each origin.

type NpmManifestIO

type NpmManifestIO struct{}

func (NpmManifestIO) Read

func (rw NpmManifestIO) Read(f lockfile.DepFile) (Manifest, error)

func (NpmManifestIO) Write

func (NpmManifestIO) Write(r lockfile.DepFile, w io.Writer, patch ManifestPatch) error

type PackageJSON

type PackageJSON struct {
	Name    string `json:"name"`
	Version string `json:"version"`
	// TODO: yarn allows workspaces to be a object OR a list:
	// https://classic.yarnpkg.com/blog/2018/02/15/nohoist/
	Workspaces           []string          `json:"workspaces"`
	Dependencies         map[string]string `json:"dependencies"`
	DevDependencies      map[string]string `json:"devDependencies"`
	OptionalDependencies map[string]string `json:"optionalDependencies"`

	// These fields are currently only used when parsing package-lock.json
	PeerDependencies map[string]string `json:"peerDependencies"`
}

type PropertyWithOrigin

type PropertyWithOrigin struct {
	maven.Property
	Origin string // Origin indicates where the property comes from
}

type RequirementKey

type RequirementKey struct {
	resolve.PackageKey
	EcosystemSpecific any
}

A RequirementKey is a comparable type that uniquely identifies a package dependency in a manifest. It does not include the version specification.

func MakeRequirementKey

func MakeRequirementKey(requirement resolve.RequirementVersion) RequirementKey