add dist

* Support the special version "MIN"

* Support JULIA_PROJECT

* Add tests

* Add forgotten test fixtures

* Get latest prerelease/release

* No special pre-release behaviour

* Add test for NPM semver difference

* Robust test suite

* Disallow less-than-equal

* Refactor validJuliaCompatRange to return a validRange

* Rename MIN to min

* Rename getProjectFile to getProjectFilePath

* Comment on "project" input

* Additional tests for getProjectFilePath

* Add comment on `juliaCompatRange`

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>

* Update dependencies

---------

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>

.github/workflows/checkin.yml

@@ -31,6 +31,6 @@ jobs:
       # Ensure no changes, but ignore node_modules dir since dev/fresh ci deps installed.
       run: |
         git diff --exit-code --stat -- . ':!node_modules' \
-        || (echo "##[error] found changed files after build. please 'npm run build && npm run format'" \
+        || (echo "##[error] found changed files after build. please 'npm ci && npm run build'" \
                  "and check in all changes" \
             && exit 1)

.github/workflows/example-builds.yml

@@ -19,7 +19,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        julia-version: ['1.0.5', '1.2', '^1.5.0-beta1', '1', 'lts', 'pre']
+       # include '1.6' here to test info message about lts tag existing
+        julia-version: ['1.0.5', '1.2', '^1.5.0-beta1', '1', '1.6', 'lts', 'pre']
         julia-arch: [x64, x86]
         os: [ubuntu-latest, macOS-latest, windows-latest]
         # 32-bit Julia binaries are not available on macOS

.gitignore

@@ -1,3 +1,2 @@
 node_modules/
 __tests__/runner/*
-!dist/

README.md

@@ -5,17 +5,25 @@
 This action sets up a Julia environment for use in actions by downloading a specified version of Julia and adding it to PATH.
 
 ## Table of Contents
-- [Table of Contents](#table-of-contents)
-- [Usage](#usage)
-  - [Inputs](#inputs)
-  - [Outputs](#outputs)
-  - [Basic](#basic)
-  - [Julia Versions](#julia-versions)
-  - [Matrix Testing](#matrix-testing)
-  - [versioninfo](#versioninfo)
-- [Versioning](#versioning)
-- [Debug logs](#debug-logs)
-- [Third party information](#third-party-information)
+- [setup-julia Action](#setup-julia-action)
+  - [Table of Contents](#table-of-contents)
+  - [Usage](#usage)
+    - [Inputs](#inputs)
+    - [Outputs](#outputs)
+    - [Basic](#basic)
+    - [Julia Versions](#julia-versions)
+      - [Examples](#examples)
+      - [Prereleases](#prereleases)
+      - [Recently released versions](#recently-released-versions)
+    - [Matrix Testing](#matrix-testing)
+      - [64-bit Julia only](#64-bit-julia-only)
+      - [32-bit Julia](#32-bit-julia)
+    - [versioninfo](#versioninfo)
+  - [Versioning](#versioning)
+  - [Using Dependabot version updates to keep your GitHub Actions up to date](#using-dependabot-version-updates-to-keep-your-github-actions-up-to-date)
+  - [Debug logs](#debug-logs)
+  - [Third party information](#third-party-information)
+  - [Contributing to this repo](#contributing-to-this-repo)
 
 ## Usage
 
@@ -30,7 +38,7 @@ This action sets up a Julia environment for use in actions by downloading a spec
     # Warning: It is strongly recommended to wrap this value in quotes.
     #          Otherwise, the YAML parser used by GitHub Actions parses certain
     #          versions as numbers which causes the wrong version to be selected.
-    #          For example, `1.0` may be parsed as `1`.
+    #          For example, `1.10` may be parsed as `1.1`.
     #
     # Default: '1'
     version: ''
@@ -63,6 +71,11 @@ This action sets up a Julia environment for use in actions by downloading a spec
     #
     # Default: false
     show-versioninfo: ''
+
+    # Set the path to the project directory or file to use when resolving some versions (e.g. `min`).
+    #
+    # Defaults to using JULIA_PROJECT if defined, otherwise '.'
+    project: ''
 ```
 
 ### Outputs
@@ -110,9 +123,10 @@ You can either specify specific Julia versions or version ranges. If you specify
 - `'^1.3.0-0'` is a **caret** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 2.0.0`.
 - `'~1.3.0-0'` is a **tilde** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 1.4.0`.
 - `'lts'` will install the latest LTS build.
-- `'pre'` will install the latest prerelease build.
+- `'pre'` will install the latest prerelease build (RCs, betas, and alphas).
 - `'nightly'` will install the latest nightly build.
 - `'1.7-nightly'` will install the latest nightly build for the upcoming 1.7 release. This version will only be available during certain phases of the Julia release cycle.
+- `'min'` will install the earliest supported version of Julia compatible with the project. Especially useful in monorepos.
 
 Internally the action uses node's semver package to resolve version ranges. Its [documentation](https://github.com/npm/node-semver#advanced-range-syntax) contains more details on the version range syntax. You can test what version will be selected for a given input in this JavaScript [REPL](https://repl.it/@SaschaMann/setup-julia-version-logic).
 

__tests__/installer.test.ts

@@ -38,6 +38,135 @@ process.env['RUNNER_TOOL_CACHE'] = toolDir
 process.env['RUNNER_TEMP'] = tempDir
 
 import * as installer from '../src/installer'
+import exp from 'constants'
+
+describe("getProjectFilePath tests", () => {
+    let orgJuliaProject
+    let orgWorkingDir
+
+    beforeEach(() => {
+        orgJuliaProject = process.env["JULIA_PROJECT"]
+        orgWorkingDir = process.cwd()
+        delete process.env["JULIA_PROJECT"]
+    })
+
+    afterEach(() => {
+        process.env["JULIA_PROJECT"] = orgJuliaProject
+        process.chdir(orgWorkingDir)
+    })
+
+    it("Can determine project file is missing", () => {
+        expect(() => installer.getProjectFilePath("DNE.toml")).toThrow("Unable to locate project file")
+        expect(() => installer.getProjectFilePath(fixtureDir)).toThrow("Unable to locate project file")
+        expect(() => installer.getProjectFilePath()).toThrow("Unable to locate project file")
+    })
+
+    it('Can determine project file from a directory', () => {
+        expect(installer.getProjectFilePath(path.join(fixtureDir, "PkgA"))).toEqual(path.join(fixtureDir, "PkgA", "Project.toml"))
+        expect(installer.getProjectFilePath(path.join(fixtureDir, "PkgB"))).toEqual(path.join(fixtureDir, "PkgB", "JuliaProject.toml"))
+    })
+
+    it("Prefers using JuliaProject.toml over Project.toml", () => {
+        expect(installer.getProjectFilePath(path.join(fixtureDir, "PkgC"))).toEqual(path.join(fixtureDir, "PkgC", "JuliaProject.toml"))
+    })
+
+    it("Can determine project from JULIA_PROJECT", () => {
+        process.env["JULIA_PROJECT"] = path.join(fixtureDir, "PkgA")
+        expect(installer.getProjectFilePath()).toEqual(path.join(fixtureDir, "PkgA", "Project.toml"))
+    })
+
+    it("Can determine project from the current working directory", () => {
+        process.chdir(path.join(fixtureDir, "PkgA"));
+        expect(installer.getProjectFilePath()).toEqual("Project.toml")
+    })
+
+    it("Ignores JULIA_PROJECT when argument is used", () => {
+        process.env["JULIA_PROJECT"] = path.join(fixtureDir, "PkgB")
+        expect(installer.getProjectFilePath(path.join(fixtureDir, "PkgA"))).toEqual(path.join(fixtureDir, "PkgA", "Project.toml"))
+    })
+})
+
+describe("validJuliaCompatRange tests", () => {
+    it('Handles default caret specifier', () => {
+        expect(installer.validJuliaCompatRange("1")).toEqual(semver.validRange("^1"))
+        expect(installer.validJuliaCompatRange("1.2")).toEqual(semver.validRange("^1.2"))
+        expect(installer.validJuliaCompatRange("1.2.3")).toEqual(semver.validRange("^1.2.3"))
+
+        // TODO: Pkg.jl currently does not support pre-release entries in compat so ideally this would fail
+        expect(installer.validJuliaCompatRange("1.2.3-rc1")).toEqual(semver.validRange("^1.2.3-rc1"))
+    })
+
+    it('Handle surrounding whitespace', () => {
+        expect(installer.validJuliaCompatRange(" 1")).toEqual(semver.validRange("^1"))
+        expect(installer.validJuliaCompatRange("1 ")).toEqual(semver.validRange("^1"))
+        expect(installer.validJuliaCompatRange(" 1 ")).toEqual(semver.validRange("^1"))
+    })
+
+    it('Handles version ranges with specifiers', () => {
+        expect(installer.validJuliaCompatRange("^1.2.3")).toEqual(semver.validRange("^1.2.3"))
+        expect(installer.validJuliaCompatRange("~1.2.3")).toEqual(semver.validRange("~1.2.3"))
+        expect(installer.validJuliaCompatRange("=1.2.3")).toEqual(semver.validRange("=1.2.3"))
+        expect(installer.validJuliaCompatRange(">=1.2.3")).toEqual(">=1.2.3")
+        expect(installer.validJuliaCompatRange("≥1.2.3")).toEqual(">=1.2.3")
+        expect(installer.validJuliaCompatRange("<1.2.3")).toEqual("<1.2.3")
+    })
+
+    it('Handles whitespace after specifiers', () => {
+        expect(installer.validJuliaCompatRange("^ 1.2.3")).toBeNull()
+        expect(installer.validJuliaCompatRange("~ 1.2.3")).toBeNull()
+        expect(installer.validJuliaCompatRange("= 1.2.3")).toBeNull()
+        expect(installer.validJuliaCompatRange(">= 1.2.3")).toEqual(">=1.2.3")
+        expect(installer.validJuliaCompatRange("≥ 1.2.3")).toEqual(">=1.2.3")
+        expect(installer.validJuliaCompatRange("< 1.2.3")).toEqual("<1.2.3")
+    })
+
+    it('Handles hypen ranges', () => {
+        expect(installer.validJuliaCompatRange("1.2.3 - 4.5.6")).toEqual(semver.validRange("1.2.3 - 4.5.6"))
+        expect(installer.validJuliaCompatRange("1.2.3-rc1 - 4.5.6")).toEqual(semver.validRange("1.2.3-rc1 - 4.5.6"))
+        expect(installer.validJuliaCompatRange("1.2.3-rc1-4.5.6")).toEqual(semver.validRange("^1.2.3-rc1-4.5.6"))  // A version number and not a hypen range
+        expect(installer.validJuliaCompatRange("1.2.3-rc1 -4.5.6")).toBeNull()
+        expect(installer.validJuliaCompatRange("1.2.3-rc1- 4.5.6")).toBeNull()  // Whitespace separate version ranges
+    })
+
+    it("Returns null AND operator on version ranges", () => {
+        expect(installer.validJuliaCompatRange("")).toBeNull()
+        expect(installer.validJuliaCompatRange("1 2 3")).toBeNull()
+        expect(installer.validJuliaCompatRange("1- 2")).toBeNull()
+        expect(installer.validJuliaCompatRange("<1 <1")).toBeNull()
+        expect(installer.validJuliaCompatRange("< 1 < 1")).toBeNull()
+        expect(installer.validJuliaCompatRange("<  1 <  1")).toBeNull()
+    })
+
+    it('Returns null with invalid specifiers', () => {
+        expect(installer.validJuliaCompatRange("<=1.2.3")).toBeNull()
+        expect(installer.validJuliaCompatRange("≤1.2.3")).toBeNull()
+        expect(installer.validJuliaCompatRange("*")).toBeNull()
+    })
+
+    it("Handles OR operator on version ranges", () => {
+        expect(installer.validJuliaCompatRange("1, 2, 3")).toEqual(semver.validRange("^1 || ^2 || ^3"))
+        expect(installer.validJuliaCompatRange("1, 2 - 3, ≥ 4")).toEqual(semver.validRange("^1 || >=2 <=3 || >=4"))
+        expect(installer.validJuliaCompatRange(",")).toBeNull()
+    })
+})
+
+describe("readJuliaCompatRange tests", () => {
+    it('Can determine Julia compat entries', () => {
+        const toml = '[compat]\njulia = "1, ^1.1, ~1.2, >=1.3, 1.4 - 1.5"'
+        expect(installer.readJuliaCompatRange(toml)).toEqual(semver.validRange("^1 || ^1.1 || ~1.2 || >=1.3 || 1.4 - 1.5"))
+    })
+
+    it('Throws with invalid version ranges', () => {
+        expect(() => installer.readJuliaCompatRange('[compat]\njulia = ""')).toThrow("Invalid version range")
+        expect(() => installer.readJuliaCompatRange('[compat]\njulia = "1 2 3"')).toThrow("Invalid version range")
+    })
+
+    it('Handle missing compat entries', () => {
+        expect(installer.readJuliaCompatRange("")).toEqual("*")
+        expect(installer.readJuliaCompatRange("[compat]")).toEqual("*")
+
+    })
+})
 
 describe('version matching tests', () => {
     describe('specific versions', () => {
@@ -95,6 +224,34 @@ describe('version matching tests', () => {
             })
         })
     })
+
+    describe('julia compat versions', () => {
+        it('Understands "min"', () => {
+            let versions = ["1.6.7", "1.7.1-rc1", "1.7.1-rc2", "1.7.1", "1.7.2", "1.8.0"]
+            expect(installer.getJuliaVersion(versions, "min", false, "^1.7")).toEqual("1.7.1")
+            expect(installer.getJuliaVersion(versions, "min", true, "^1.7")).toEqual("1.7.1-rc1")
+
+            versions = ["1.6.7", "1.7.3-rc1", "1.7.3-rc2", "1.8.0"]
+            expect(installer.getJuliaVersion(versions, "min", false, "^1.7")).toEqual("1.8.0")
+            expect(installer.getJuliaVersion(versions, "min", true, "^1.7")).toEqual("1.7.3-rc1")
+
+            expect(installer.getJuliaVersion(versions, "min", false, "~1.7 || ~1.8 || ~1.9")).toEqual("1.8.0")
+            expect(installer.getJuliaVersion(versions, "min", true, "~1.7 || ~1.8 || ~1.9")).toEqual("1.7.3-rc1")
+            expect(installer.getJuliaVersion(versions, "min", false, "~1.8 || ~1.7 || ~1.9")).toEqual("1.8.0")
+            expect(installer.getJuliaVersion(versions, "min", true, "~1.8 || ~1.7 || ~1.9")).toEqual("1.7.3-rc1")
+
+            expect(installer.getJuliaVersion(versions, "min", false, "1.7 - 1.9")).toEqual("1.8.0")
+            expect(installer.getJuliaVersion(versions, "min", true, "1.7 - 1.9")).toEqual("1.7.3-rc1")
+
+            expect(installer.getJuliaVersion(versions, "min", true, "< 1.9.0")).toEqual("1.6.7")
+            expect(installer.getJuliaVersion(versions, "min", true, ">= 1.6.0")).toEqual("1.6.7")
+
+            // NPM's semver package treats "1.7" as "~1.7" instead of "^1.7" like Julia
+            expect(() => installer.getJuliaVersion(versions, "min", false, "1.7")).toThrow("Could not find a Julia version that matches")
+
+            expect(() => installer.getJuliaVersion(versions, "min", true, "")).toThrow("Julia project file does not specify a compat for Julia")
+        })
+    })
 })
 
 describe('installer tests', () => {

action.yml

@@ -1,9 +1,9 @@
 name: 'Setup Julia environment'
 description: 'Setup a Julia environment and add it to the PATH'
 author: 'Sascha Mann'
-inputs: 
+inputs:
   version:
-    description: 'The Julia version to download (if necessary) and use. Example: 1.0.4'
+    description: 'The Julia version to download (if necessary) and use. Use a string input to avoid unwanted decimal conversion e.g. 1.10 without quotes will be interpreted as 1.1. Examples: "1", "1.10", "lts", "pre"'
     default: '1'
   include-all-prereleases:
     description: 'Include prereleases when matching the Julia version to available versions.'
@@ -12,11 +12,15 @@ inputs:
   arch:
     description: 'Architecture of the Julia binaries. Defaults to the architecture of the runner executing the job.'
     required: false
-    default: '${{ runner.arch }}'
+    default: 'default'
   show-versioninfo:
     description: 'Display InteractiveUtils.versioninfo() after installing'
     required: false
     default: 'false'
+  project:
+    description: 'The path to the project directory or file to use when resolving some versions (e.g. min)'
+    required: false
+    default: ''  # Special value which fallsback to using JULIA_PROJECT if defined, otherwise "."
 outputs:
   julia-version:
     description: 'The installed Julia version. May vary from the version input if a version range was given as input.'

lib/installer.js

@@ -32,7 +32,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.showVersionInfo = exports.installJulia = exports.getDownloadURL = exports.getFileInfo = exports.getJuliaVersion = exports.getJuliaVersions = exports.getJuliaVersionInfo = void 0;
+exports.getJuliaVersionInfo = getJuliaVersionInfo;
+exports.getJuliaVersions = getJuliaVersions;
+exports.getProjectFilePath = getProjectFilePath;
+exports.validJuliaCompatRange = validJuliaCompatRange;
+exports.readJuliaCompatRange = readJuliaCompatRange;
+exports.getJuliaVersion = getJuliaVersion;
+exports.getFileInfo = getFileInfo;
+exports.getDownloadURL = getDownloadURL;
+exports.installJulia = installJulia;
+exports.showVersionInfo = showVersionInfo;
 const core = __importStar(require("@actions/core"));
 const exec = __importStar(require("@actions/exec"));
 const tc = __importStar(require("@actions/tool-cache"));
@@ -42,6 +51,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const retry = require("async-retry");
 const semver = __importStar(require("semver"));
+const toml = __importStar(require("toml"));
 const LTS_VERSION = '1.6';
 const MAJOR_VERSION = '1'; // Could be deduced from versions.json
 // Translations between actions input and Julia arch names
@@ -94,7 +104,6 @@ function getJuliaVersionInfo() {
         return JSON.parse(fs.readFileSync(versionsFile).toString());
     });
 }
-exports.getJuliaVersionInfo = getJuliaVersionInfo;
 /**
  * @returns An array of all Julia versions available for download
  */
@@ -107,28 +116,112 @@ function getJuliaVersions(versionInfo) {
         return versions;
     });
 }
-exports.getJuliaVersions = getJuliaVersions;
-function getJuliaVersion(availableReleases, versionInput, includePrerelease = false) {
+/**
+ * @returns The path to the Julia project file
+ */
+function getProjectFilePath(projectInput = "") {
+    let projectFilePath = "";
+    // Default value for projectInput
+    if (!projectInput) {
+        projectInput = process.env.JULIA_PROJECT || ".";
+    }
+    if (fs.existsSync(projectInput) && fs.lstatSync(projectInput).isFile()) {
+        projectFilePath = projectInput;
+    }
+    else {
+        for (let projectFilename of ["JuliaProject.toml", "Project.toml"]) {
+            let p = path.join(projectInput, projectFilename);
+            if (fs.existsSync(p) && fs.lstatSync(p).isFile()) {
+                projectFilePath = p;
+                break;
+            }
+        }
+    }
+    if (!projectFilePath) {
+        throw new Error(`Unable to locate project file with project input: ${projectInput}`);
+    }
+    return projectFilePath;
+}
+/**
+ * @returns A valid NPM semver range from a Julia compat range or null if it's not valid
+ */
+function validJuliaCompatRange(compatRange) {
+    let ranges = [];
+    for (let range of compatRange.split(",")) {
+        range = range.trim();
+        // An empty range isn't supported by Julia
+        if (!range) {
+            return null;
+        }
+        // NPM's semver doesn't understand unicode characters such as `≥` so we'll convert to alternatives
+        range = range.replace("≥", ">=").replace("≤", "<=");
+        // Cleanup whitespace. Julia only allows whitespace between the specifier and version with certain specifiers
+        range = range.replace(/\s+/g, " ").replace(/(?<=(>|>=|≥|<)) (?=\d)/g, "");
+        if (!semver.validRange(range) || range.split(/(?<! -) (?!- )/).length > 1 || range.startsWith("<=") || range === "*") {
+            return null;
+        }
+        else if (range.search(/^\d/) === 0 && !range.includes(" ")) {
+            // Compat version is just a basic version number (e.g. 1.2.3). Since Julia's Pkg.jl's uses caret
+            // as the default specifier (e.g. `1.2.3 == ^1.2.3`) and NPM's semver uses tilde as the default
+            // specifier (e.g. `1.2.3 == 1.2.x == ~1.2.3`) we will introduce the caret specifier to ensure the
+            // orignal intent is respected.
+            // https://pkgdocs.julialang.org/v1/compatibility/#Version-specifier-format
+            // https://github.com/npm/node-semver#x-ranges-12x-1x-12-
+            range = "^" + range;
+        }
+        ranges.push(range);
+    }
+    return semver.validRange(ranges.join(" || "));
+}
+/**
+ * @returns An array of version ranges compatible with the Julia project
+ */
+function readJuliaCompatRange(projectFileContent) {
+    var _a;
+    let compatRange;
+    let meta = toml.parse(projectFileContent);
+    if (((_a = meta.compat) === null || _a === void 0 ? void 0 : _a.julia) !== undefined) {
+        compatRange = validJuliaCompatRange(meta.compat.julia);
+    }
+    else {
+        compatRange = "*";
+    }
+    if (!compatRange) {
+        throw new Error(`Invalid version range found in Julia compat: ${compatRange}`);
+    }
+    return compatRange;
+}
+function getJuliaVersion(availableReleases, versionInput, includePrerelease = false, juliaCompatRange = "") {
+    // Note: `juliaCompatRange` is ignored unless `versionInput` is `min`
+    let version;
     if (semver.valid(versionInput) == versionInput || versionInput.endsWith('nightly')) {
         // versionInput is a valid version or a nightly version, use it directly
-        return versionInput;
+        version = versionInput;
     }
-    if (versionInput == 'lts') {
-        return getJuliaVersion(availableReleases, LTS_VERSION, false);
+    else if (versionInput == "min") {
+        // Resolve "min" to the minimum supported Julia version compatible with the project file
+        if (!juliaCompatRange) {
+            throw new Error('Unable to use version "min" when the Julia project file does not specify a compat for Julia');
+        }
+        version = semver.minSatisfying(availableReleases, juliaCompatRange, { includePrerelease });
     }
-    if (versionInput == 'pre') {
-        return getJuliaVersion(availableReleases, MAJOR_VERSION, true);
+    else if (versionInput == "lts") {
+        version = semver.maxSatisfying(availableReleases, LTS_VERSION, { includePrerelease: false });
     }
-    // Use the highest available version that matches versionInput
-    let version = semver.maxSatisfying(availableReleases, versionInput, { includePrerelease });
-    if (version == null) {
+    else if (versionInput == "pre") {
+        version = semver.maxSatisfying(availableReleases, MAJOR_VERSION, { includePrerelease: true });
+    }
+    else {
+        // Use the highest available version that matches versionInput
+        version = semver.maxSatisfying(availableReleases, versionInput, { includePrerelease });
+    }
+    if (!version) {
         throw new Error(`Could not find a Julia version that matches ${versionInput}`);
     }
     // GitHub tags start with v, remove it
     version = version.replace(/^v/, '');
     return version;
 }
-exports.getJuliaVersion = getJuliaVersion;
 function getDesiredFileExts() {
     let fileExt1;
     let hasFileExt2;
@@ -214,6 +307,7 @@ function getFileInfo(versionInfo, version, arch) {
         return null;
     }
     if (!versionInfo[version]) {
+        core.error(`Encountered error: ${err}`);
         throw err;
     }
     for (let file of versionInfo[version].files) {
@@ -232,10 +326,35 @@ function getFileInfo(versionInfo, version, arch) {
                 }
             }
         }
+        // The following block is just to provide improved log messages in the CI logs.
+        // We specifically want to improve the case where someone is trying to install
+        // Julia 1.6 or 1.7 on Apple Silicon (aarch64) macOS.
+        {
+            const one_fileext_is_targz = (fileExt1 == "tar.gz") || (fileExt2 == "tar.gz");
+            const one_fileext_is_dmg = (fileExt1 == "dmg") || (fileExt2 == "dmg");
+            const one_fileext_is_targz_and_other_is_dmg = one_fileext_is_targz && one_fileext_is_dmg;
+            // We say that "this Julia version does NOT have native binaries for Apple Silicon"
+            // if and only if "this Julia version is < 1.8.0"
+            const this_julia_version_does_NOT_have_native_binaries_for_apple_silicon = semver.lt(version, '1.8.0');
+            const this_is_macos = osPlat == 'darwin';
+            if (this_is_macos && one_fileext_is_targz_and_other_is_dmg && this_julia_version_does_NOT_have_native_binaries_for_apple_silicon) {
+                const msg = `It looks like you are trying to install Julia 1.6 or 1.7 on ` +
+                    `the "macos-latest" runners.\n` +
+                    `"macos-latest" now resolves to "macos-14", which run on Apple ` +
+                    `Silicon (aarch64) macOS machines.\n` +
+                    `Unfortunately, Julia 1.6 and 1.7 do not have native binaries ` +
+                    `available for Apple Silicon macOS.\n` +
+                    `Therefore, it is not possible to install Julia with the current ` +
+                    `constraints.\n` +
+                    `For instructions on how to fix this error, please see the following Discourse post: ` +
+                    `https://discourse.julialang.org/t/how-to-fix-github-actions-ci-failures-with-julia-1-6-or-1-7-on-macos-latest-and-macos-14/117019`;
+                core.error(msg);
+            }
+        }
     }
+    core.error(`Encountered error: ${err}`);
     throw err;
 }
-exports.getFileInfo = getFileInfo;
 function getDownloadURL(fileInfo, version, arch) {
     const baseURL = `https://julialangnightlies-s3.julialang.org/bin/${osMap[osPlat]}/${arch}`;
     // release branch nightlies, e.g. 1.6-nightlies should return .../bin/linux/x64/1.6/julia-latest-linux64.tar.gz
@@ -253,7 +372,6 @@ function getDownloadURL(fileInfo, version, arch) {
     }
     return fileInfo.url;
 }
-exports.getDownloadURL = getDownloadURL;
 function installJulia(dest, versionInfo, version, arch) {
     return __awaiter(this, void 0, void 0, function* () {
         // Download Julia
@@ -321,7 +439,6 @@ function installJulia(dest, versionInfo, version, arch) {
         }
     });
 }
-exports.installJulia = installJulia;
 /**
  * Test if Julia has been installed and print the version.
  *
@@ -358,4 +475,3 @@ function showVersionInfo(showVersionInfoInput, version) {
         }
     });
 }
-exports.showVersionInfo = showVersionInfo;

lib/setup-julia.js

@@ -36,15 +36,17 @@ const core = __importStar(require("@actions/core"));
 const tc = __importStar(require("@actions/tool-cache"));
 const fs = __importStar(require("fs"));
 const https = __importStar(require("https"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const installer = __importStar(require("./installer"));
+// Note: before we index into this dict, we always first do `.toLowerCase()` on
+// the key.
+//
+// Therefore, this dict does not need to account for differences in case.
 const archSynonyms = {
     'x86': 'x86',
-    'X86': 'x86',
     'x64': 'x64',
-    'X64': 'x64',
     'aarch64': 'aarch64',
-    'ARM64': 'aarch64',
     'arm64': 'aarch64'
 };
 function run() {
@@ -65,25 +67,49 @@ function run() {
                     core.debug(`ERROR: Could not retrieve runner IP: ${err}`);
                 });
             }
-            // Inputs
-            const versionInput = core.getInput('version');
-            const includePrereleases = core.getInput('include-all-prereleases') == 'true';
-            const originalArchInput = core.getInput('arch');
+            // Inputs.
+            // Note that we intentionally strip leading and lagging whitespace by using `.trim()`
+            const versionInput = core.getInput('version').trim();
+            const includePrereleases = core.getInput('include-all-prereleases').trim() == 'true';
+            const originalArchInput = core.getInput('arch').trim();
+            const projectInput = core.getInput('project').trim(); // Julia project file
             // It can easily happen that, for example, a workflow file contains an input `version: ${{ matrix.julia-version }}`
             // while the strategy matrix only contains a key `${{ matrix.version }}`.
             // In that case, we want the action to fail, rather than trying to download julia from an URL that's missing parts and 404ing.
             // We _could_ fall back to the default but that means that builds silently do things differently than they're meant to, which
             // is worse than failing the build.
-            if (!versionInput) {
+            if (!versionInput) { // if `versionInput` is an empty string
                 throw new Error('Version input must not be null');
             }
-            if (!originalArchInput) {
+            if (versionInput == '1.6') {
+                core.notice('[setup-julia] If you are testing 1.6 as a Long Term Support (lts) version, consider using the new "lts" version specifier instead of "1.6" explicitly, which will automatically resolve the current lts.');
+            }
+            if (!originalArchInput) { // if `originalArchInput` is an empty string
                 throw new Error(`Arch input must not be null`);
             }
-            const arch = archSynonyms[originalArchInput];
+            let processedArchInput;
+            if (originalArchInput == "default") {
+                // If the user sets the `arch` input to `default`, then we use the
+                // architecture of the machine that we are running on.
+                processedArchInput = os.arch();
+                core.debug(`The "arch" input is "default", so we will use the machine arch: ${processedArchInput}`);
+            }
+            else {
+                processedArchInput = originalArchInput;
+            }
+            // Note: we convert the key `processedArchInput` to lower case
+            // before we index into the `archSynonyms` dict.
+            const arch = archSynonyms[processedArchInput.toLowerCase()];
+            core.debug(`Mapped the "arch" from ${processedArchInput} to ${arch}`);
+            // Determine the Julia compat ranges as specified by the Project.toml only for special versions that require them.
+            let juliaCompatRange = "";
+            if (versionInput === "min") {
+                const projectFilePath = installer.getProjectFilePath(projectInput);
+                juliaCompatRange = installer.readJuliaCompatRange(fs.readFileSync(projectFilePath).toString());
+            }
             const versionInfo = yield installer.getJuliaVersionInfo();
             const availableReleases = yield installer.getJuliaVersions(versionInfo);
-            const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases);
+            const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases, juliaCompatRange);
             core.debug(`selected Julia version: ${arch}/${version}`);
             core.setOutput('julia-version', version);
             // Search in cache

package.json

@@ -1,6 +1,6 @@
 {
   "name": "setup-julia",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "private": true,
   "description": "setup Julia action",
   "main": "lib/setup-julia.js",
@@ -26,20 +26,21 @@
     "@actions/io": "^1.1.3",
     "@actions/tool-cache": "^2.0.1",
     "async-retry": "^1.3.3",
-    "semver": "^7.6.2"
+    "semver": "^7.6.3",
+    "toml": "^3.0.0"
   },
   "devDependencies": {
     "@types/async-retry": "^1.4.8",
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.6",
+    "@types/node": "^22.5.1",
     "@types/retry": "^0.12.5",
     "@types/semver": "^7.5.8",
     "@vercel/ncc": "^0.38.1",
     "jest": "^29.7.0",
     "jest-circus": "^29.7.0",
     "nock": "^13.5.4",
-    "prettier": "^3.3.2",
-    "ts-jest": "^29.1.5",
-    "typescript": "^5.4.5"
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.5.4"
   }
 }

src/installer.ts

@@ -9,6 +9,7 @@ import * as path from 'path'
 import retry = require('async-retry')
 
 import * as semver from 'semver'
+import * as toml from 'toml'
 
 const LTS_VERSION = '1.6'
 const MAJOR_VERSION = '1' // Could be deduced from versions.json
@@ -79,23 +80,116 @@ export async function getJuliaVersions(versionInfo): Promise<string[]> {
     return versions
 }
 
-export function getJuliaVersion(availableReleases: string[], versionInput: string, includePrerelease: boolean = false): string {
+/**
+ * @returns The path to the Julia project file
+ */
+export function getProjectFilePath(projectInput: string = ""): string {
+    let projectFilePath: string = ""
+
+    // Default value for projectInput
+    if (!projectInput) {
+        projectInput = process.env.JULIA_PROJECT || "."
+    }
+
+    if (fs.existsSync(projectInput) && fs.lstatSync(projectInput).isFile()) {
+        projectFilePath = projectInput
+    } else {
+        for (let projectFilename of ["JuliaProject.toml", "Project.toml"]) {
+            let p = path.join(projectInput, projectFilename)
+            if (fs.existsSync(p) && fs.lstatSync(p).isFile()) {
+                projectFilePath = p
+                break
+            }
+        }
+    }
+
+    if (!projectFilePath) {
+        throw new Error(`Unable to locate project file with project input: ${projectInput}`)
+    }
+
+    return projectFilePath
+}
+
+/**
+ * @returns A valid NPM semver range from a Julia compat range or null if it's not valid
+ */
+export function validJuliaCompatRange(compatRange: string): string | null {
+    let ranges: Array<string> = []
+    for(let range of compatRange.split(",")) {
+        range = range.trim()
+
+        // An empty range isn't supported by Julia
+        if (!range) {
+            return null
+        }
+
+        // NPM's semver doesn't understand unicode characters such as `≥` so we'll convert to alternatives
+        range = range.replace("≥", ">=").replace("≤", "<=")
+
+        // Cleanup whitespace. Julia only allows whitespace between the specifier and version with certain specifiers
+        range = range.replace(/\s+/g, " ").replace(/(?<=(>|>=|≥|<)) (?=\d)/g, "")
+
+        if (!semver.validRange(range) || range.split(/(?<! -) (?!- )/).length > 1 || range.startsWith("<=") || range === "*") {
+            return null
+        } else if (range.search(/^\d/) === 0 && !range.includes(" ")) {
+            // Compat version is just a basic version number (e.g. 1.2.3). Since Julia's Pkg.jl's uses caret
+            // as the default specifier (e.g. `1.2.3 == ^1.2.3`) and NPM's semver uses tilde as the default
+            // specifier (e.g. `1.2.3 == 1.2.x == ~1.2.3`) we will introduce the caret specifier to ensure the
+            // orignal intent is respected.
+            // https://pkgdocs.julialang.org/v1/compatibility/#Version-specifier-format
+            // https://github.com/npm/node-semver#x-ranges-12x-1x-12-
+            range = "^" + range
+        }
+
+        ranges.push(range)
+    }
+
+    return semver.validRange(ranges.join(" || "))
+}
+
+/**
+ * @returns An array of version ranges compatible with the Julia project
+ */
+export function readJuliaCompatRange(projectFileContent: string): string {
+    let compatRange: string | null
+    let meta = toml.parse(projectFileContent)
+
+    if (meta.compat?.julia !== undefined) {
+        compatRange = validJuliaCompatRange(meta.compat.julia)
+    } else {
+        compatRange = "*"
+    }
+
+    if (!compatRange) {
+        throw new Error(`Invalid version range found in Julia compat: ${compatRange}`)
+    }
+
+    return compatRange
+}
+
+export function getJuliaVersion(availableReleases: string[], versionInput: string, includePrerelease: boolean = false, juliaCompatRange: string = ""): string {
+    // Note: `juliaCompatRange` is ignored unless `versionInput` is `min`
+    let version: string | null
+
     if (semver.valid(versionInput) == versionInput || versionInput.endsWith('nightly')) {
         // versionInput is a valid version or a nightly version, use it directly
-        return versionInput
+        version = versionInput
+    } else if (versionInput == "min") {
+        // Resolve "min" to the minimum supported Julia version compatible with the project file
+        if (!juliaCompatRange) {
+            throw new Error('Unable to use version "min" when the Julia project file does not specify a compat for Julia')
+        }
+        version = semver.minSatisfying(availableReleases, juliaCompatRange, {includePrerelease})
+    } else if (versionInput == "lts") {
+        version = semver.maxSatisfying(availableReleases, LTS_VERSION, { includePrerelease: false });
+    } else if (versionInput == "pre") {
+        version = semver.maxSatisfying(availableReleases, MAJOR_VERSION, { includePrerelease: true });
+    } else {
+        // Use the highest available version that matches versionInput
+        version = semver.maxSatisfying(availableReleases, versionInput, {includePrerelease})
     }
 
-    if (versionInput == 'lts') {
-        return getJuliaVersion(availableReleases, LTS_VERSION, false)
-    }
-
-    if (versionInput == 'pre') {
-        return getJuliaVersion(availableReleases, MAJOR_VERSION, true)
-    }
-
-    // Use the highest available version that matches versionInput
-    let version = semver.maxSatisfying(availableReleases, versionInput, {includePrerelease})
-    if (version == null) {
+    if (!version) {
         throw new Error(`Could not find a Julia version that matches ${versionInput}`)
     }
 
@@ -184,6 +278,7 @@ export function getFileInfo(versionInfo, version: string, arch: string) {
     }
 
     if (!versionInfo[version]) {
+       core.error(`Encountered error: ${err}`)
        throw err
     }
 
@@ -204,8 +299,39 @@ export function getFileInfo(versionInfo, version: string, arch: string) {
                 }
             }
         }
+
+        // The following block is just to provide improved log messages in the CI logs.
+        // We specifically want to improve the case where someone is trying to install
+        // Julia 1.6 or 1.7 on Apple Silicon (aarch64) macOS.
+        {
+            const one_fileext_is_targz = (fileExt1 == "tar.gz") || (fileExt2 == "tar.gz");
+            const one_fileext_is_dmg = (fileExt1 == "dmg") || (fileExt2 == "dmg");
+            const one_fileext_is_targz_and_other_is_dmg = one_fileext_is_targz && one_fileext_is_dmg;
+
+            // We say that "this Julia version does NOT have native binaries for Apple Silicon"
+            // if and only if "this Julia version is < 1.8.0"
+            const this_julia_version_does_NOT_have_native_binaries_for_apple_silicon = semver.lt(
+                version,
+                '1.8.0',
+            );
+            const this_is_macos = osPlat == 'darwin';
+            if (this_is_macos && one_fileext_is_targz_and_other_is_dmg && this_julia_version_does_NOT_have_native_binaries_for_apple_silicon) {
+                const msg = `It looks like you are trying to install Julia 1.6 or 1.7 on ` +
+                            `the "macos-latest" runners.\n` +
+                            `"macos-latest" now resolves to "macos-14", which run on Apple ` +
+                            `Silicon (aarch64) macOS machines.\n` +
+                            `Unfortunately, Julia 1.6 and 1.7 do not have native binaries ` +
+                            `available for Apple Silicon macOS.\n` +
+                            `Therefore, it is not possible to install Julia with the current ` +
+                            `constraints.\n` +
+                            `For instructions on how to fix this error, please see the following Discourse post: ` +
+                            `https://discourse.julialang.org/t/how-to-fix-github-actions-ci-failures-with-julia-1-6-or-1-7-on-macos-latest-and-macos-14/117019`
+                core.error(msg);
+            }
+        }
     }
 
+    core.error(`Encountered error: ${err}`)
     throw err
 }
 

src/setup-julia.ts

@@ -3,17 +3,19 @@ import * as tc from '@actions/tool-cache'
 
 import * as fs from 'fs'
 import * as https from 'https'
+import * as os from 'os'
 import * as path from 'path'
 
 import * as installer from './installer'
 
+// Note: before we index into this dict, we always first do `.toLowerCase()` on
+// the key.
+//
+// Therefore, this dict does not need to account for differences in case.
 const archSynonyms = {
     'x86': 'x86',
-    'X86': 'x86',
     'x64': 'x64',
-    'X64': 'x64',
     'aarch64': 'aarch64',
-    'ARM64': 'aarch64',
     'arm64': 'aarch64'
 }
 
@@ -37,28 +39,52 @@ async function run() {
             })
         }
 
-        // Inputs
-        const versionInput = core.getInput('version')
-        const includePrereleases = core.getInput('include-all-prereleases') == 'true'
-        const originalArchInput = core.getInput('arch')
+        // Inputs.
+        // Note that we intentionally strip leading and lagging whitespace by using `.trim()`
+        const versionInput = core.getInput('version').trim()
+        const includePrereleases = core.getInput('include-all-prereleases').trim() == 'true'
+        const originalArchInput = core.getInput('arch').trim()
+        const projectInput = core.getInput('project').trim()  // Julia project file
 
         // It can easily happen that, for example, a workflow file contains an input `version: ${{ matrix.julia-version }}`
         // while the strategy matrix only contains a key `${{ matrix.version }}`.
         // In that case, we want the action to fail, rather than trying to download julia from an URL that's missing parts and 404ing.
         // We _could_ fall back to the default but that means that builds silently do things differently than they're meant to, which
         // is worse than failing the build.
-        if (!versionInput) {
+        if (!versionInput) { // if `versionInput` is an empty string
             throw new Error('Version input must not be null')
         }
-        if (!originalArchInput) {
+        if (versionInput == '1.6') {
+            core.notice('[setup-julia] If you are testing 1.6 as a Long Term Support (lts) version, consider using the new "lts" version specifier instead of "1.6" explicitly, which will automatically resolve the current lts.')
+        }
+        if (!originalArchInput) { // if `originalArchInput` is an empty string
             throw new Error(`Arch input must not be null`)
         }
 
-        const arch = archSynonyms[originalArchInput]
+        let processedArchInput: string;
+        if (originalArchInput == "default") {
+            // If the user sets the `arch` input to `default`, then we use the
+            // architecture of the machine that we are running on.
+            processedArchInput = os.arch();
+            core.debug(`The "arch" input is "default", so we will use the machine arch: ${processedArchInput}`)
+        } else {
+            processedArchInput = originalArchInput;
+        }
+        // Note: we convert the key `processedArchInput` to lower case
+        // before we index into the `archSynonyms` dict.
+        const arch = archSynonyms[processedArchInput.toLowerCase()]
+        core.debug(`Mapped the "arch" from ${processedArchInput} to ${arch}`)
+
+        // Determine the Julia compat ranges as specified by the Project.toml only for special versions that require them.
+        let juliaCompatRange: string = "";
+        if (versionInput === "min") {
+            const projectFilePath = installer.getProjectFilePath(projectInput)
+            juliaCompatRange = installer.readJuliaCompatRange(fs.readFileSync(projectFilePath).toString())
+        }
 
         const versionInfo = await installer.getJuliaVersionInfo()
         const availableReleases = await installer.getJuliaVersions(versionInfo)
-        const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases)
+        const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases, juliaCompatRange)
         core.debug(`selected Julia version: ${arch}/${version}`)
         core.setOutput('julia-version', version)