Use GitHub API for basic checks/info during publishing (#554)
* Use GitHub API for basic checks/info during publish
* Code review fix
* Fix: new config values unavailable during same run
New config entries were stored on disk but not added to the memory map. As the
Config.Set subprogram isn't aware of the level of configuration being set,
there is no direct way to both store to disk and to memory; instead the
solution is that the configuration is reloaded every time. This is a bit of
overkill and a candidate for later optimization.
Alire.Utils.User_Input: add function to query user's name, email and GitHub login (#461)
* Alire.Utils.User_Input: add function to query user's name, email and github login
* Break circular elaboration issue
Since Config uses Utils.User_Input indirectly via Deplyers.System, a
possibility is to move new User_Input functions that need Config into a new
package.
Co-authored-by: Alejandro R. Mosteo <amosteo@unizar.es>
It seems GNAT's Normalize_Arguments does its own escaping, so we do not need to
do it ourselves. Also, the test checks that indeed the `alire` folder is
excluded when tar'ing manually.
For fetching from github, it is safe to do this transformation, whereas users
working with the repo may find more convenient the use of private git@ URLs.
* Detect github URLs missing a trailing ".git"
* Testsuite: more cases for git remotes
* Allow controlling the git@ -> https:// transformation
* Generalize checks beyond github
* Unit test for Alire.VCSs.Git.Transform_To_Public
Use local repository as reference for publishing (#519)
* Publish using local repo and revision as reference
We still require the remote is ready (in essence, that the local repo is not
ahead of the remote), but now it is simply a matter of issuing `alr publish` or
`alr publish <commit|tag|branch>`, and the corresponding commit will be used.
* Refactor long function name to more sensible one
* Fix comments due to bad refactoring
* Test for publishing from inside a repo
* Fixes uncovered by testsuite
Adding defaults for <URL> <commit> complicates things somewhat as we use local
paths for testing that would otherwise be rejected, so a few corner cases have
to be explicitly considered now.
The extra indirection level was not required, as os.walk already gives us the
proper paths we need. This wasn't detected until we tried to build an unzipped
release zipped by ourselves.
After fixing the manifest file name to `alire.toml`, there is no possible
confusion with other toml files in the same directory, so we can explicitly
give .toml extension to config files.
Move out a possible upstream-provided manifest (#487)
When doing `alr get` we want to use the index-provided manifest for
reproducibility. So, an eventual upstream manifest provided with the sources is
renamed with an extra ".upstream" coda.
In most cases, the Root has to be valid so it can be used. This patch moves the
Is_Valid code smell to a separate child type (Alire.Roots.Optional.Root) that
can be used in the few cases where all the root states have to be treated
separately.
This is done by using newline characters to insert a new error prefix. A couple
of new facilities to encourage splitting of long errors are defined:
Errors.Wrap and Errors.Set (Wrapping_Message, Wrapped_Exception)
* Rename Last_Chance_Handler to Alr.Last_Chance_...
To avoid possible conflicts with other libraries and follow the naming of
other packages.
* Append new dependencies to the end of the manifest
* Conservative removal of dependencies in `alr with`
This action will also not touch lines that aren't involved in the deletion.
Only a simple dependency, and trivially empty [[depends-on]] array entries will
be removed. As an improvement over the previous situation, dynamic expressions
will not preclude using `alr with` for static dependencies, leaving the dynamic
ones untouched.
* Use lexicographical order for printing dependencies
This was happening before by chance in several tests. The `alr with` changes
have surfaced that the order on file is kept in tree; while this has no
secondary effects, for presentation to the user is better to be always
consistent. Solutions already use ordered sets, so for lists within conditional
trees we do the same (only for presentation).
Move origin information to its own top-level table (#480)
* Script to patch manifest with separate origin table
A self-contained origin table is cleaner and allow each origin kind to have its
own fields without polluting the rest of the properties top-level table
* Alire:Index: bump expected index version
* Load/Save new [origin] table
* Testsuite: migrated indexes to new [origin] format
* Migrate testsuite indexes to new split manifests
* Alire.Index: update community version
* Refactor Alr.OS_Lib.Traverse_Folder into Alire
As Alire.Directories.Traverse_Tree
* Alire.TOML_Index: traverse new folder structure
Also adapt the checks to the new structure, and double-check that the file name
matches the manifest contents (name, version).
* Refactor Crate internals for new flat manifests
Since now each release is truly independent, crates need not to store the
common information as previously. This is done now only for external
definitions in a narrower scope.
Several loading functions can also be streamlined since now it's simpler to get
a proper complete release without requiring its enclosing crate.
The bulk of the refactoring emanates from merging Alire.Crates.With_Releases
into simply Alire.Crates, and repurposing the Alire.Crates.Sections enum.
* Use new [[depends-on]] dependencies
Nothing outwards has changed yet; the manifest is still entirely machine
generated. This commit only changes the table [depends-on] into an array of
[[depends-on]] tables.
* Testsuite fixes for new format
Fixes in code detected by the testsuite, and small changes in output due to
code refactorings.
Script to migrate indexes to per-release files (#478)
* Ignore JetBrains IDE config folders and virtualenvs
* s/libhello/li (index subfolder improper name)
* Fix invalid semantic version in some test crates
s/_/-/, turns out only hyphens are allowed in the pre-release portion.
* Script to split crate files into releases
It applies the foreseeable needed transformations: one release per file, one
file for external definitions; dependencies moved to an array; added name and
version keys.
Update automatically after manual manifest edition or missing dependency detection (#472)
* Remove redundant parameter in Alire.Workspace
Environment can now be retrieved from Alire.Roots.Root.
* New Alire.Roots.Sync_Solution_And_Deps
This procedure verifies that the lockfile is not older than the manifest, and
that all dependencies in the solution exist on disk. Otherwise, dependencies
are redeployed.
* Refactor/cleanup paths from Alire.Paths
The dependency path is always used in the context of an Alire.Roots.Root, so it
is more meaningful being defined there.
Also removed the cache path that wasn't used anywhere.
* Checks against reexporting the same environment
* Refactor Alr.Commands.Requires_Full_Index into Alire
This way, the index loading can be triggered by logic in Alire that absolutely
requires the index to be loaded.
* Do not auto update before `alr update`
* Refactor Confirm_Solution_Changes into Alire
From Alr.Commands.User_Input into Alire.Utils.User_Input.
* Tests for the new sync features
- Test that a manually modified manifest results in an autosync
- Test that missing dependencies in the cache are redeployed
Alr.Commands.Init: add library type handling in generated project (#470)
type Library_Type_Type is ("relocatable", "static", "static-pic");
Library_Type : Library_Type_Type :=
external ("XXX_LIBRARY_TYPE",
external ("LIBRARY_TYPE", "static"));
for Library_Kind use Library_Type;
New `alr with --versions` for version-related info of dependencies (#464)
* New `alr with --versions` for version-related info
This new version focuses on showing: which constraints were found for each
dependency, which version was used to fulfill them, and what's the latest
existing version for a crate (hence pointing to possible wanted updates).
Move ASCII graph to `--graph` switch, and add a `--tree` alternative & fallback (#465)
* New `alr with --tree`, `alr show --tree` switch
Prints dependency graph in tree form, as an alternative to the ascii-art plots
that 1) not always will be available, depending in libgraph-easy-perl and 2)
quickly become big and broken.
* Move ASCII graph to dedicated --graph switch
Previously, it was always attempted to be shown with `--solve`, which could be
an unnecessary pollution for an otherwise useful command.
Set up environment before post-fetch actions (#456)
* Alire.Environment: take release paths from a Root
The path lookup has three levels:
1. For the root release, the own root folder
2. For a regular release, the dependencies folder "/" release unique folder
3. For a pinned softlink, the absolute path of the softlink
The root contains the solution which in turn contains the softlinks, so the
query for the path can be directly made to the root.
* Set up build env before deploying dependencies
* Tests for softlink nested path and env export
* Review fixes
* Alire.Environment.Load: Remove unused parameter
This flies by CE but is detected by FSF (?)
* Alire.Roots: move expression functions to body
There's some bug manifesting when a lot of code is in the spec in which the
linker complaints about missing references.
* Spelling fixes
* Updated new tests index versions
* Rename dir_separator/path_separator to match GNAT...
... in the Python testsuite
* Remove trailing '/' separator in extra prj paths
This is to match the output of full path normalization by Ada.Directories.
Rework Solutions.Diffs internals to use States (#457)
* Rework Solutions.Diffs internals to use States
Now that the Solution type stores all relevant information via
Dependencies.States, making the diffs directly from the solution is both
simpler, more maintainable and more accurate.
implementation of an automatic gpr file with (#458)
* First prototype implementation of an automatic gpr file with
* Add user query and config option for Auto-gpr-with
* Introduce Boolean properties
* Alire.Properties.Labeled: check TOML_Kind for labels
* auto-gpr-with: add crate entry to disable auto-gpr-with feature
* testsuite: allow custom indexes to reference fixtures/crates/
This removes duplication of several sources and archives.
* Bump index version to 0.3 for auto-gpr-with feature
* auto-gpr-with: do not add default project file for extern crates
* Bump alire-index in CI scripts
* tests/workflows/auto-gpr-with: rename test crate to avoid conflicts with scripts
* Review fixes
* tests/get/external-tool-dependency: make the test more robust
On Windows when using msys2, the make seen by alr can be different than
the one seen from the testsuite scripts. The means that the current way
to identify make's version will fail in some cases.
This patch introduces a different way to workaround the different
version numbers of make.
Testsuite: canonicalize line endings in "alr" outputs (#460)
A recent e3-core update changed the behavior of e3.os.process.Run's
behavior regarding line endings, which are now left unchanged. This
creates discrepancies in process outputs depending on the platform.
Show linked paths and per-release dependencies (#453)
In the graph section of the solution printout, the concrete dependency for each
release that brings in another release is now shown. This may help in
understanding why a release is chosen, particularly when there are different
restrictions on a same crate introduced by different releases.
For the new linked folders with alire metadata, the source folder is shown in
the releases section. Otherwise, such source folders are listed in the
externals section without a concrete release (as we cannot determine a version
for them).
A new test shows this feature and also shows that the solver is able to
downgrade a dependency whenever this is needed to obtain a complete solution.
Detect and use Alire metadata found in pinned directory (#450)
* Detect crate at linked dir and use its deps/paths
If a path given to with/pin --use contains a loadable alire workspace (i.e.,
for a crate manually initialized, or retrieved with `get`), the release found
there will be used to retrieve additional dependencies, and its project paths
will also be used.
* `with` directory with autodetection of crate
When adding a dependency as a pinned dir, and the target dir is a regular Alire
crate, we can autodetect the crate we are adding as dependency. In that case
the command becomes `alr with --use <path>`. This can also be useful in the
future for remote URLs that will also provide the crate being retrieved.
While this has no implications for the crate being pinned, any regularly solved
crates will be missing afterwards unless the index is loaded pre-pinning.
Allow incomplete solutions in relevant commands (#451)
* Allow get with missing deps (with confirmation)
Up to now, trying to retrieve a release with non-solvable dependencies resulted
in an opaque "can't get a solution", leaving the only resort of doing an `alr
get --only`. With this patch, the best partial solution found is used and
displayed. The user can accept a partial deployment, understanding that the
build will fail unless missing dependencies are manually provided.
It would be relatively easy to allow the user to reject the proposal and
continue seeing other incomplete solutions (as, e.g., `aptitude` does) until
one of them is selected.
* Allow pinning to unavailable versions
The user may want for some reason to specify versions that are not in the
index, for work-in-progress releases or when switching between several indexes.
Instead of blocking him entirely, the incomplete solution is displayed and he
can accept it regardless. Forcing is required when not interactive.
* Allow update to complete with incomplete solution
When the solution is already incomplete we emit a warning to remind the user
about this, but we need not to err, since there are no changes to the solution,
or we might find a less incomplete one.
Also added a test for the behavior when trying to update a pinned version
* Allow withing dependencies with incomplete solution
This is the last of the commands that previously erred out with "Cannot solve
dependencies". Now, it can be forced into accepting any dependency as long as
the user is OK with having an incomplete solution.
* Remove deprecated Alire.Solutions.Valid
Instead, .Is_Complete or .Composition should be used for better granularity.
Is_Complete is more stringent than before (hints make the solution incomplete),
but the new flexibility to work with incomplete solutions makes the difference
secondary; the user is less restricted than before.
* Minor fixes to tests for Is_Complete change
By making solutions with any external (including hints) incomplete, it is
necessary to force a few commands in the tests that before succeeded normally.
Some tests that checked for exact text were now failing due to the extra
information/interaction caused by incomplete solutions.
The stderr warning on incomplete solutions in setenv also requires fixing its
output.
This bug would manifest when a regular release other than the root one in the
solution depends on a linked dependency. With the proposed change we should be
covered for any future dependency kind that is not fulfilled by a regular release.
Ability to use a local folder to fulfill a dependency (#439)
* New Alire.Externals.Softlink to support WIP crates
* Implement alr with --url to add/pin in one step
A dependency can now be added simultaneously with a target directory that
fulfils it. Minimal check of the folder existing is performed; the buildability
of the whole is now the responsibility of the user.
* Implement softlinks in Alr.Dependencies.States
The placeholder `linked` fulfilment is now properly implemented to
hold/load/save the information about a directory to be used to fulfill a
dependency.
* Implement softlinks in Alire.Solutions.Solution
Add a Alire.Solutions.Linking subprogram that includes a linked dependency into
a solution.
* Modify solver to use soflinks for dependencies
When a softlink for the dependency being solved exists in the starting
solution, that dependency can be considered fulfilled without further ado.
* Implement `alr pin --url` to pin existing dep
This is the delayed counterpart to `alr with --url`; i.e., users can add the
dependency normally with `alr with` and later decide to pin it to a folder with
`alr pin`, without needing to remove it completely first with `alr with --del`.
We present pinning to versions and to folders to users under the same idea of
pinning. Internally, alr distinguishes between pinning (to versions) and
linking (to URLs). Currently only local paths can be used for links, but in the
future we may add remote files to fetch or repositories to clone.
* New Alire.URI to centralize URL knowledge
* Include pinned dirs' paths in project paths
The logic of collecting all necessary paths has been moved from Alr.Build_Env
to Alire.Roots.Project_Paths. A Root was already necessary to collect the
paths, and furthermore the root has all the necessary information: the root
release and the complete solution, which includes releases and linked dirs.
To make Roots self-contained, the platform properties are copied during startup
to Alire.Root. This is a temporary measure until these properties are
refactored from Alr into Alire.
* New tests for within/pinning to folders
* Testsuite fixes for minor changes in output
Information shown for external (lacking a release) dependencies is more
comprehensive now, showing transitivity, pin information, hinting status.
The subprograms in Alr.Checkout, which disappears, are refactored into
Alire.Workspace. This will enable better logic for retrieval/updates, without
the need to internally reroute to Alr.Commands.Update, which causes some
unrelated side-effects (like re-resolving even when unnecessary).
Minor change: now all crates leave a trace in the form of their dependency
folder within the cache, even if this folder is empty for dependencies whose
deployment does not require such a folder. This is more homogeneous and might
be useful in the future to store status about dependency deployment
completeness right there.
A couple tests are fixed to account for minor output changes and a change in
behavior between Python 2 and 3 (not sure why it not arose initially).
Fabien Chouteau [Mon, 15 Jun 2020 10:27:43 +0000 (12:27 +0200)]
Alire.Config: add support of built-in options (#446)
* Alire.Config: add support of built-in options
Built-in options have a type that is checked when setting or loading a configuration file.
They also have a short help text to explain their meaning and usage.
Remove some unnecessary code after Solution changes (#431)
The solution stores platform-dependent releases, hence the Environment
parameter is not needed at the moment of writing the corresponding lockfile.
A stray exception handler in Alr.Commands.Withing was unneeded and masking as a
regular error some Constraint_Errors that should escalate to the main handler
to be reported as unexpected internal errors.
Dead code in Alire.Utils that is not going to be useful again has been removed.
Safeguards for changes in lockfile/crate format (#436)
If the lockfile is not loadable we presume it is in an old format. In this case
we recreate it from scratch, which entails the loss of any stored pins. If the
alire/crate.toml file is not loadable we advice the user to recreate the
workspace from scratch.
Note that both crate.toml and crate.lock use the index format to store
releases. Hence, any change in index format may impact these files. While the
lockfile is not that problematic, for the crate.toml file we have no easy
workaround since we cannot know to which crate the workspace belongs.
There are possible mitigations but as long as we don't have stable releases the
complexity/benefit ratio is unclear. If we eventually make the crate.toml file
only manually editable that could also impact how to deal with this issue, so
not doing anything about it yet.
Internal enhancements to Solution and Dependency states (#429)
* Remove obsolete Alire.Dependencies.Unavailable
This fake dependency was used in the old Ada index to store an unavailable
dependency. There is no longer any use for this constant.
* Image functions for newly tagged Alire.Milestones
Make the type tagged to gain dot notation, and add [TTY_]Image subprograms for
simpler printing elsewhere.
* New Alire.Dependencies.States type
This type is used to store the actual way in which a dependency was solved. All
possibilities are stored, which allows to properly cache a solution, and detect
changes in solutions across operations that modify the solution: pinning,
withing, updating...
* New Alire.Dependencies.States.Maps
A crate name -> dep state mapping which is at the core of the cached Solution,
with a couple of functional-style modifiers for use in expression functions.
* Remove pinning info from Releases
This information is now stored in the dependency State where it better belongs.
This way it doesn't matter if the solution contains a release for the pinned
dependency; the pinning information is always preserved.
* Reworked Solution internals to use States
(Doesn't build.) Changes to Alire.Solutions to use the new dependency states.
With these changes there is no loss of information when going from a valid to
an invalid solution (information about partial solutions is stored the same as
for complete solutions), which enables down the road better feedback to users
and simpler implementation of other improvements, like pinning of crates to
local folders.
* Solver improvements based on new dependency states
(Only alire-solver.adb builds.) With these changes, the solver needs not to
check the complete validity of a solution once all dependencies are processed
(which is an expensive test), because validity is guaranteed for any partial
solution (that is, no incompatible release can make into the solution). Also,
while the solver was previously complete in regard to valid solutions (with
releases or hints), now it is also complete for invalid solutions (those
missing releases and hints for some dependency). This means that the solver
will return the "best" incomplete solution when a complete one cannot be found.
* Tweaks to achieve build with new Solution
A few minor changes due to changes in the Solution public methods are needed
here and there, without functional implications.
* Tweaks for testsuite compliance
A few changes are needed to ensure the same output as before is produced, or to
adapt a few tests to minimal output changes caused by the homogenization of
dependency images.
* Make Alire.Crate_Name a proper private type
Our Dynamic_Predicate in the publicly defined Crate_Name as new String is
rejected by GNAT 9, and I couldn't find a workaround short of making all of
Alire.* non-preelaborable. Defining privately Crate_Name as new String in turn
caused numerous errors in child packages due to some mixing between the public
and private views. In the end, making it a record was the simplest change
without introducing the risk of missing checks (as if we had made it simply a
subtype of String).
So, given the change, I bit the bullet to make it tagged and provide a couple
of convenience functions.
This global modifier is available in Alire.Force. Other candidate locations,
like Alire.Config, Alire.Errors, Alire.Utils.User_Input cannot be used because
they bring in non-preelaborable units and it snowballs from there.
The recommended usage is through Alire.Recoverable_Error, which will warn or
raise appropriately depending on the flag. The boolean Alire.Force is also
available for less straightforward situations (interaction defaults for
example).
Exit code fix for `get --build` with build failure (#428)
We were not erroring if the build failed, which is counterintuitive. We now
require successful retrieval and build to exit with code 0. A test to verify
this situation has been added.
Remove unnecessary forced exit from `Alr.Main` (#425)
Historically, something was causing an extra empty line in the output of every
command. At some point this has been fixed inadvertently, so we can remove the
forced exit call, which in turn will allow finalization to complete normally,
if it were ever needed.
projects / alire.git / log