The tool failed to properly resolve nested local dependencies to jsonnet
bundles in different directory trees. This arises because the
installation command resolves and installs nested jsonnet local
dependencies relative to the root jsonnetfile, rather than track and
evaluate the installation path relative to the nested library's
jsonnetfile.
Consider a repository with multiple local jsonnet bundles in various
directory trees, organised as follows (lockfiles elided for brevity):
/top/of/tree
|- lib/module_A
|- jsonnetfile.json
|- lib/module_B
|- jsonnetfile.json
|- src/root_module
|- jsonnetfile.json
The modules depend on each other as follows:
┌───────────────────┐ ┌───────────────────┐ ┌───────────────────┐
│ │ │ │ │ │
│ src/root_module │──>│ lib/module_A │──>│ lib/module_B │
│ │ │ │ │ │
└───────────────────┘ └───────────────────┘ └───────────────────┘
where X ──> Y indicates bundle X depends on bundle Y, expressed by
adding a dependency of type local in bundle X's jsonnetfile.json, whose
path is the relative path from bundle X to bundle Y in the directory
structure. For example, src/root_module will express a local dependency
on path ../lib/module_A to depend on library module A.
Invoking jb install in src/root_module will result in an error:
jb: error: failed to install packages: downloading: symlink destination path does not exist: %w:
stat /top/of/tree/src/module_B: no such file or directory
This occurs because jsonnet-bundler improperly attempts to resolve the
nested dependency on library module B relative to the root module path,
i.e. src/root_module. The correct behaviour is to perform such
resolution relative to the depending module's jsonnetfile.json, i.e.
relative to lib/module_A.
* Enhancement: Subdir detect runtime os. If windows changes "\" to "/"
* Bug fix: for compare known, on windows, use "\" instead of "/"
* Bug fix: for compare known, on windows, use "\" instead of "/"
Co-authored-by: c0feec0der <>
* use filepath to check for known packages
this fixes an issue using windows. without this patch, jb would delete
the folder after installation since the path is not known
* reduce temp directory length by hashing
using this hash it is harder to reach the windows limit for filenames
and directories
* further reduce temp dir length
* do not build binaries for windows/amd*
Allows `installing` a package without pulling dependencies of that
package. This comes in handy when having multiple directories on
`JPATH`, which overlay each other.
Because dependencies may be already present at lesser ranked import
paths, it's not required to pull them, when only needing to bump a
single one.
* 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.
- 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
Previously even when installing dependencies from a lockfile,
jsonnet-bundler would attempt to resolve versions of transitive
dependencies to their latest floating version. Instead when a lock-file
is specified jsonnet-bundler should just install the specified versions.
