Several code-hosters like GitLab allow to have subgroups. These were previously not suppported because we weren't able to tell if something was a subgroup or a subdir.
By letting users specify the `.git` part of the http string as well, this now work for all protocol, including https.
The go-modules approach is a bit broken: https://github.com/golang/go/issues/29228
To resolve that, we now compute that version using `git describe` and
set it using `ldflags`.
While this is not as nice/builtin as the other approach, it at least
works all the time and across go versions.
Furthermore, I did refactor the Makefile in preparation for an AUR
package that builds from source and for building release artifacts in CI.
Previously, only `github.com` was supported for HTTP cloning of packages.
With this change, every git host using the http protocol (GitHub, Gitlab, Gitea) is supported :D
* fix(deps): proper git ssh scheme
* feat(deps): git scp style
Adds support for the git ssh-scp style (`git@github.com:user/repo.git`),
which is an alternative form for ssh (note no ssh://).
* fix(deps): githubSlug also matching gitSSH
* test(deps): other hosts than github
* feat: go-like import style
jb now creates a directory structure inside of vendor/ that is similar to how go
does (github.com/grafana/jsonnet-libs). This is reflected in the final import
paths, which means they will be go-like
* refactor(spec/deps): named regexs
* feat: make goImportStyle configurable
Defaults to off, can be enabled in `jsonnetfile.json`
* fix: integration test
* doc: license headers
* fix(deps): remove GO_IMPORT_STYLE
not an option anymore, will always do so and symlink
* feat: symlink to legacy location
* feat: allow to disable legacy links
* fix(test): legacyImports in integration tests
* fix(spec): test
* fix: respect legacyName aliases
It was possible to alias packages by changing `name` previously.
While names are now absolute (and computed), legacy links should still respect
old aliases to avoid breaking code.
* fix(test): integration
* fix(init): keep legacyImports enabled for now
* feat: rewrite imports
adds a command to automatically rewrite imports from legacy to absolute style
* fix(tool): rewrite confused by prefixing packages
When a package was a prefix of another one, it broke.
Fixed that by using a proper regular expression. Added a test to make sure it
works as expected
* Update cmd/jb/init.go
* fix: exclude local packages from legacy linking
They actually still use the old style, which is fine. LegacyLinking
messed them up, but from now on it just ignores symlinks that match a localPackage.
* feat(cli): version flag
Adds a --version flag to jb. Only available on go versions greater than 1.12
* style: add license headers
* chore(ci): generate only on latest go
* fix: unique step names
* doc: include version in README help text
* fix: rebuild .drone.yml using drone.cli
* fix: remove race condidion from CI
Adding a dep, or updating a dependency version makes writes to the
jsonnet files.
We evaluate the changes on each of the files. An empty jsonnetfile.json
does not create a corresponding lockfile, as a missing lockfile is not
different from its previous (non existent).
- allow to install pkg that is already locked
- clean unknown files from vendor
- correctly handle checksums and locked versions (was accidentally ignoring
- these before)
Packages are unique anyways so it makes sense to use a map to avoid having
duplicates.
For compatibility reasons custom json (un)marshallers hide this change from the
end user
rewrites the installation of packages from scratch to solve several issues with
the existing implementation:
- does not need to choose between lockfile and jsonnetfile anymore. The
jsonnetfile what to be installed, while the lockfile also has versions and
checksums of all packages, even nested ones.
- the lockfile is regenerated on every run, preserving the locked values
- downloaded packages are hashed using sha256 to make sure we receive what we
expect. If files on the local disk are modified, they are downloaded again.
So far, `pkg` and `pkg/jsonnetfile` had overlapping functionality when it came
to choosing and loading jsonnetfiles.
This fully switches to the separate package `pkg/jsonnetfile` that seems to be
created for exactly this purpose
Refactors the dependency parsing function chain to evaluate the type of the
dependency right in `parseDependency` to make it clearer what is going on while
reading the code. Before, functions were returning if it was a different type,
which was not that clear from `parseDependency`.
