beku

package module
v0.7.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 30, 2022 License: BSD-3-Clause Imports: 15 Imported by: 0

README

Beku

Beku is a library and program to manage packages in user's environment (GOPATH or vendor directory).

For beku as library see the following GoDoc.

For beku as program see the below documentation or at GoDoc.

Beku program

Beku is command line program to manage packages in user's environment (GOPATH or vendor directory). Beku provide syntax like pacman.

Beku read and write the package database into a file named "beku.db".

At first execution, beku will try to open the package database in current directory. If no file found, it will try to open "{prefix}/var/beku/beku.db". When both locations does not provide package database, beku will scan entire "{prefix}/src" and write the package database into "{prefix}/var/beku/beku.db".

Global Options

--noconfirm

No confirmation will be asked on any operation. Useful when running beku inside a script.

-d, --nodeps

Do not install any missing dependencies. This options can be used on freeze or sync operations.

-V, --vendor

Operate in vendor mode. This option used only when first scanning (beku -V -S). Any operation after that, will use the "vendor" directory in current working directory as installation prefix.

Freeze Operation

-B, --freeze

Operate on the package database and user's environment. This operation will ensure that all packages listed on database file is installed with their specific version. Also, all packages that are not registered will be removed from "src" and "pkg" directories.

Database Operation

-D, --database

Modify the package database. This operation required one of the options below.

Options
-e, --exclude <pkg ...>

Remove list of package by import path from database and add mark it as excluded package. Excluded package will be ignored on future operations.

Examples
$ beku -De github.com/shuLhan/beku

Exclude package "github.com/shuLhan/beku" from future scanning, installation, or removal operations.

Query Operation

-Q, --query [pkg ...]

Query the package database.

Remove Operation

-R, --remove [pkg]

Remove package from environment, including source and installed binaries and archives.

Options
[-s,--recursive]

Also remove all target dependencies, as long as is not required by other packages.

Examples
$ beku -R github.com/shuLhan/beku

Remove package "github.com/shuLhan/beku" source in "{prefix}/src", their installed binaries in "{prefix}/bin", and their installed archives on "{prefix}/pkg/{GOOS}_{GOARCH}".

$ beku -R github.com/shuLhan/beku --recursive
$ beku -Rs github.com/shuLhan/beku

Remove package "github.com/shuLhan/beku" source in "{prefix}/src", their installed binaries in "{prefix}/bin", their installed archives on "{prefix}/pkg/{GOOS}_{GOARCH}", and all their dependencies.

Sync Operation

-S, --sync <pkg[@version]>

Synchronizes package. Given a package import path, beku will try to clone the package into source directory and set the package version to latest the tag. If no tag found, it will use the latest commit on master branch. A specific version can be set using "@version" suffix.

If package already exist, it will reset the HEAD to the version that is set on database file.

If no parameter is given, beku will do a rescan, checking for new packages.

Beku will install the package dependencies manually.

Options
[--into <destination>]

This option will install the package import path into custom directory. It is useful if you have the fork of the main package but want to install it to the legacy directory.

[-u,--update]

Fetch new tag or commit from remote repository. User will be asked for confirmation before upgrade.

Examples
$ beku -S golang.org/x/text

Download package golang.org/x/text into {prefix}/src/golang.org/x/text, and set their version to the latest commit on branch master.

$ beku -S github.com/golang/text --into golang.org/x/text

Download package github.com/golang/text into {prefix}/src/golang.org/x/text, and set their version to the latest commit on branch master.

$ beku -S golang.org/x/text@v0.3.0

Download package golang.org/x/text into {prefix}/src/golang.org/x/text and checkout the tag v0.3.0 as the working version.

$ beku -S golang.org/x/text@5c1cf69

Download package golang.org/x/text into {prefix}/src/golang.org/x/text and checkout the commit 5c1cf69 as the working version.

$ beku -Su

Update all packages in database to new tag or commits with approval from user.

Development

This repository use git submodules to test functionalities that use git clone. Command for cloning git repository for new development:

$ git clone --recurse-submodules <URL>

or for existing clone,

$ git submodule update --init --recursive

Then run make to make sure all test run well,

$ make

Known Limitations

  • Only work with package hosted with Git on HTTPS or SSH.

  • Tested only on Git v2.17 or greater

References

[1] https://www.archlinux.org/pacman/

[2] https://github.com/kardianos/govendor/issues/348

[3] https://github.com/sparrc/gdm

Documentation

Overview

Package beku provide library for managing Go packages in user's environment (GOPATH or vendor directory).

Index

Constants

View Source 
const (
	// DefDBName define default database name, where the dependencies will
	// be saved and loaded.
	DefDBName = "beku.db"
)
View Source 
const (
	VCSModeGit = "git"
)

Variables

View Source 
var (
	ErrGOROOT = errors.New("GOROOT is not defined")

	// ErrVersion define an error when directory have VCS metadata (e.g.
	// `.git` directory) but did not have any tag or commit.
	ErrVersion = errors.New("no tag or commit found")

	// ErrRemote define an error when package remote URL is empty or
	// invalid.
	ErrRemote = errors.New("empty or invalid remote URL found")

	// ErrPackageName define an error if package name is empty or invalid.
	ErrPackageName = errors.New("empty or invalid package name")
)

List of error messages.

Functions

func GetCompareURL 

func GetCompareURL(remoteURL, oldVer, newVer string) (url string)

GetCompareURL return the URL that compare two versions of package from given remote URL. Remote URL can be in git format ("git@github.com:<username>/<reponame>") or in HTTP format.

On package that hosted on Github, the compare URL format is, 

https://github.com/<username>/<reponame>/compare/<old-version>...<new-version>

func IsIgnoredDir 

func IsIgnoredDir(name string) bool

IsIgnoredDir will return true if directory start with "_" or ".", or equal with "vendor" or "testdata"; otherwise it will return false.

func IsTagVersion 

func IsTagVersion(version string) bool

IsTagVersion return true if "version" prefixed with "v" or contains at least one dot "." character.

Types

type Env 

type Env struct {
	NoConfirm bool
	// contains filtered or unexported fields
}

Env contains the environment of Go including GOROOT source directory, package root directory (prefix), list of packages, list of standard packages, and list of missing packages.

func NewEnvironment 

func NewEnvironment(vendor, noDeps bool) (env *Env, err error)

NewEnvironment will gather all information in user system.

func (*Env) Exclude 

func (env *Env) Exclude(importPaths []string)

Exclude mark list of packages to be excluded from future operations.

func (*Env) Freeze 

func (env *Env) Freeze() (err error)

Freeze all packages in database. Install all registered packages in database and remove non-registered from "src" and "pkg" directories.

func (*Env) GetLocalPackage added in v0.5.0 

func (env *Env) GetLocalPackage(importPath string) (pkg *Package, err error)

GetLocalPackage will return installed package from system.

func (*Env) GetPackageFromDB 

func (env *Env) GetPackageFromDB(importPath, remoteURL string) (int, *Package)

GetPackageFromDB will return index and package in database. If no package found, it will return -1 and nil.

func (*Env) GetUnused 

func (env *Env) GetUnused(srcPath string) (err error)

GetUnused will get all non-registered packages from "src" directory, without including all excluded packages.

func (*Env) IsExcluded 

func (env *Env) IsExcluded(importPath string) bool

IsExcluded will return true if import path is registered as one of excluded package; otherwise it will return false.

func (*Env) Load 

func (env *Env) Load(file string) (err error)

Load will read saved dependencies from file.

func (*Env) Query 

func (env *Env) Query(pkgs []string)

Query the package database. If package is not empty, it will only show the information about that package.

func (*Env) Remove 

func (env *Env) Remove(rmPkg string, recursive bool) (err error)

Remove package from environment. If recursive is true, it will also remove their dependencies, as long as they are not required by other package.

func (*Env) Rescan 

func (env *Env) Rescan(firstTime bool) (ok bool, err error)

Rescan for new packages.

func (*Env) Save 

func (env *Env) Save(file string) (err error)

Save the dependencies to `file` only if it's dirty flag is true.

func (*Env) Scan 

func (env *Env) Scan() (err error)

Scan will gather all package information in user system to start `beku`-ing.

func (*Env) String 

func (env *Env) String() string

String return formatted output of the environment instance.

func (*Env) Sync 

func (env *Env) Sync(pkgName, importPath string) (err error)

Sync will download and install a package including their dependencies. If the importPath is defined, it will be downloaded into that directory.

func (*Env) SyncAll 

func (env *Env) SyncAll() (err error)

SyncAll packages into latest version (tag or commit).

func (*Env) SyncMany 

func (env *Env) SyncMany(pkgs []string) (err error)

SyncMany packages at once.

type Package 

type Package struct {
	ImportPath   string
	FullPath     string
	RemoteName   string
	RemoteURL    string
	RemoteBranch string
	Version      string
	VersionNext  string
	DepsMissing  []string
	Deps         []string
	RequiredBy   []string
	// contains filtered or unexported fields
}

Package define Go package information: path to package, version, whether is tag or not, and VCS mode.

func NewPackage 

func NewPackage(gopathSrc, name, importPath string) (pkg *Package, err error)

NewPackage create a package set the package version, tag status, and dependencies.

func (*Package) CheckoutVersion 

func (pkg *Package) CheckoutVersion(newVersion string) (err error)

CheckoutVersion will set the package version to new version.

func (*Package) CompareVersion 

func (pkg *Package) CompareVersion(newPkg *Package) (err error)

CompareVersion will compare package version using current package as base.

func (*Package) FetchLatestVersion added in v0.5.0 

func (pkg *Package) FetchLatestVersion() (err error)

FetchLatestVersion will try to update the package and get the latest version (tag or commit).

func (*Package) Freeze added in v0.5.0 

func (pkg *Package) Freeze() (err error)

func (*Package) GetRecursiveImports 

func (pkg *Package) GetRecursiveImports(env *Env) (
	imports []string, err error,
)

GetRecursiveImports will get all import path recursively using `go list` and return it as slice of string without any duplication.

func (*Package) GoClean 

func (pkg *Package) GoClean() (err error)

GoClean will remove the package binaries and archives.

func (*Package) GoInstall 

func (pkg *Package) GoInstall(envPath string) (err error)

GoInstall a package recursively ("./...").

Set PATH to let go install that require gcc work when invoked from non-interactive shell (e.g. buildbot).

func (*Package) Install 

func (pkg *Package) Install() (err error)

Install a package. Clone package "src" directory, set to the latest tag if exist or to the latest commit, and scan dependencies.

func (*Package) IsEqual 

func (pkg *Package) IsEqual(other *Package) bool

IsEqual will return true if current package have the same import path, remote name, remote URL, and version with other package; otherwise it will return false.

func (*Package) IsNewer added in v0.5.0 

func (pkg *Package) IsNewer(older *Package) bool

IsNewer will return true if current package is using tag and have newer version that other package. If current package is not using tag, it's always return true.

func (*Package) Remove 

func (pkg *Package) Remove() (err error)

Remove package installed binaries, archives, and source.

func (*Package) RemoveRequiredBy 

func (pkg *Package) RemoveRequiredBy(importPath string) (ok bool)

RemoveRequiredBy will remove package importPath from list of required-by. It will return true if importPath is removed from list, otherwise it will return false.

func (*Package) Scan 

func (pkg *Package) Scan() (err error)

Scan will set the package version, `isTag` status, and remote URL using metadata in package repository.

func (*Package) ScanDeps 

func (pkg *Package) ScanDeps(env *Env) (err error)

ScanDeps will scan package dependencies, removing standard packages, keep only external dependencies.

func (*Package) String 

func (pkg *Package) String() string

String return formatted output of the package instance.

func (*Package) Update 

func (pkg *Package) Update(newPkg *Package) (err error)

Update the current package to the new package. The new package may contain new remote or new version.

func (*Package) UpdateMissingDep 

func (pkg *Package) UpdateMissingDep(newPkg *Package, addAsDep bool) (found bool)

UpdateMissingDep will remove missing package if it's already provided by new package import-path.

If "addAsDep" is true, it will also, (1) add new package as one of package dependencies of current package, and (2) add current package as required by new package.

It will return true if new package solve the missing deps on current package, otherwise it will return false.

Source Files

View all Source files

Directories

Path Synopsis
cmd
beku
Beku is a command line program to manage packages in user's environment (GOPATH or vendor) directory.
 Beku is a command line program to manage packages in user's environment (GOPATH or vendor) directory.
go
vcs
Package vcs exposes functions for resolving import paths and using version control systems, which can be used to implement behavior similar to the standard "go get" command.
 Package vcs exposes functions for resolving import paths and using version control systems, which can be used to implement behavior similar to the standard "go get" command.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.