v0.5.0 (#245)

CHANGELOG.md

@@ -1,5 +1,20 @@
 # run-that-app changelog
 
+### 0.5.0 (2024-03-14)
+
+#### New Features
+
+The `.tool-versions` file can now define multiple versions. RTA tries versions from left to right until it finds one that it can run on your hardware.
+
+The `--which` command now returns a non-zero exit code if the given app isn't available on your machine.
+
+All apps now have all-lowercase names. The `mdBook` app is now `mdbook`.
+
+When running externally installed apps, _run-that-app_ now verifies that the executable it found is actually is the app. It also
+determines whether the version of the globally installed application matches version restrictions declared by your code base.
+
+End-to-end tests: run `cargo run -- --test` to verify that all installation methods of all apps work for the latest app version. See `DEVELOPMENT.md` for details.
+
 ### 0.4.1 (2024-02-29)
 
 #### Bug Fixes
@@ -10,8 +25,7 @@
 
 #### New Features
 
-- can now execute in subfolders of the folder that contains the
-  `.tools-versions` file
+- can now execute in subfolders of the folder that contains the `.tools-versions` file
 - `--error-on-output` option
 - print available versions using `--versions` and `--versions=<amount>`
 - apps: go, goda, gofmt, npx, mdBook
@@ -48,13 +62,10 @@
 
 #### New Features
 
-- `--available` command indicates via the exit code whether an application is
-  available
-- `--show-path` command displays the path of the executable instead of running
-  it
+- `--available` command indicates via the exit code whether an application is available
+- `--show-path` command displays the path of the executable instead of running it
 - `--optional` parameter makes the app do nothing if the app isn't available
-- `--include-global` parameter runs a globally installed app if the app cannot
-  be installed
+- `--include-global` parameter runs a globally installed app if the app cannot be installed
 - config file (.tool-versions) for defining the versions of tools to run
 
 #### Bug Fixes
@@ -83,7 +94,6 @@
 ### 0.0.1 (2023-11-14)
 
 - installation methods: downloading binaries, compile from source
-- apps: alphavet, depth, dprint, gh, gofumpt, golangci-lint, scc, shellcheck,
-  shfmt
+- apps: alphavet, depth, dprint, gh, gofumpt, golangci-lint, scc, shellcheck, shfmt
 - logging with namespaces for downloading and extracting
 - shell output

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rta"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 rust-version = "1.75"
 

DEVELOPMENT.md

@@ -13,16 +13,23 @@ test for your app (see below).
 ### End-to-end tests
 
 The end-to-end tests verify that all installation methods of all apps work with
-the latest version of their app.
+the latest version of their app. They run via an undocumented command of the RTA
+executable.
+
+````fish
+rta --test [--verbose] [app name]
+```
+
+or while developing on app definitions:
 
 ```fish
 cargo run -- --test [--verbose] [app name]
-```
+````
 
-The end-to-end test installs into a temporary location and deletes the
-installation when done, so re-running it re-downloads all apps again.
+The end-to-end test creates a Yard in a temporary location and deletes the
+installation when done. Re-running the tests re-downloads all apps again.
 
-The `--verbose` switch outputs all individual activities.
+The `--verbose` switch outputs more details around individual activities.
 
 If you provide an application name, the end-to-end test only tests this
-application.
+application, otherwise tests all apps.

README.md

@@ -119,6 +119,22 @@ Runs [ShellCheck](https://shellcheck.net) version 0.9.0 with the arguments
 rta [email protected] --color=always myscript.sh
 ```
 
+#### Use globally installed applications
+
+If your system already has certain apps installed, _run-that-app_ can use them.
+Consider this `.tool-versions` file:
+
+```
+go system 1.21.3
+```
+
+If your computer has Go installed, _run-that-app_ would try to run it. Only if
+that fails would it install and run Go version 1.21.3.
+
+_Run-that-app_ considers restrictions declared by your code base. If your
+codebase has a file `go.mod` containing `go 1.21` and the externally installed
+Go version is older, _run-that-app_ would not use the external version.
+
 #### Ignore unavailable applications
 
 ShellCheck is just a linter. If it isn't available on a particular platform, the
@@ -142,7 +158,7 @@ rta --available alphavet && go vet "-vettool=$(rta --which alphavet)" ./...
 Here is a template for installing and using run-that-app in a `Makefile`:
 
 ```make
-RTA_VERSION = 0.4.1
+RTA_VERSION = 0.5.0
 
 # an example Make target that uses run-that-app
 test: tools/rta@${RTA_VERSION}

RELEASE.md

@@ -2,11 +2,11 @@
 
 - in a branch:
   - update [CHANGELOG.md](CHANGELOG.md)
-  - update all occurrences of `0.4.1`
+  - update all occurrences of `0.5.0`
   - ship into `main`
 - create a new tag:
 
   ```bash
-  git tag v0.4.1 && git push --tags
+  git tag v0.5.0 && git push --tags
   ```
 - the CI server creates a draft release - review and publish it

download.ps1

@@ -1,6 +1,6 @@
 $ErrorActionPreference = "Stop"
 
-Set-Variable -Name "version" -Value "0.4.1" -Option Constant
+Set-Variable -Name "version" -Value "0.5.0" -Option Constant
 
 function Welcome() {
   Write-Output "RUN-THAT-APP DOWNLOAD SCRIPT"

download.sh

@@ -9,7 +9,7 @@ print_welcome() {
 	echo
 }
 
-VERSION="0.4.1" # the version of run-that-app to download
+VERSION="0.5.0" # the version of run-that-app to download
 TMP_DIR=./run_that_app_install
 
 main() {