Resolve min as the earliest compatible Julia version (compatible with the user's project)

README.md

@@ -63,6 +63,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
@@ -111,6 +116,7 @@ You can either specify specific Julia versions or version ranges. If you specify
 - `~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`.
 - `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

@@ -39,6 +39,45 @@ process.env['RUNNER_TEMP'] = tempDir
 
 import * as installer from '../src/installer'
 
+describe("getProjectFile tests", () => {
+    it("Can determine project file is missing", () => {
+        expect(() => installer.getProjectFile("DNE.toml")).toThrow("Unable to locate project file")
+        expect(() => installer.getProjectFile(fixtureDir)).toThrow("Unable to locate project file")
+    })
+
+    it('Can determine project file from a directory', () => {
+        expect(installer.getProjectFile(path.join(fixtureDir, "PkgA"))).toEqual(path.join(fixtureDir, "PkgA", "Project.toml"))
+        expect(installer.getProjectFile(path.join(fixtureDir, "PkgB"))).toEqual(path.join(fixtureDir, "PkgB", "JuliaProject.toml"))
+    })
+
+    it("Prefers using JuliaProject.toml over Project.toml", () => {
+        expect(installer.getProjectFile(path.join(fixtureDir, "PkgC"))).toEqual(path.join(fixtureDir, "PkgC", "JuliaProject.toml"))
+    })
+})
+
+describe("readJuliaCompatVersions tests", () => {
+    it('Can determine Julia compat entries', () => {
+        // Note: Julia's Pkg.jl uses caret as the default specifier (e.g. `1.2.3 == ^1.2.3`) where as
+        // NPM's semver uses tilde as the default specifier (e.g. `1.2.3 == 1.2.x == ~1.2.3`). In order
+        // to ensure the Julia default is respected we'll be sure to add the caret specify where needed.
+        // https://pkgdocs.julialang.org/v1/compatibility/#Version-specifier-format
+        // https://github.com/npm/node-semver#x-ranges-12x-1x-12-
+        const toml = '[compat]\njulia = "1, >=1.1, ^1.2, ~1.3"'
+        expect(installer.readJuliaCompatVersions(toml)).toEqual(["^1", ">=1.1", "^1.2", "~1.3"])
+    })
+
+    it('Handle whitespace', () => {
+        const toml = '[compat]\njulia = " 1,2 , 3 ,"'
+        expect(installer.readJuliaCompatVersions(toml)).toEqual(["^1", "^2", "^3"])
+    })
+
+    it('Handle missing compat entries', () => {
+        expect(installer.readJuliaCompatVersions("")).toEqual([])
+        expect(installer.readJuliaCompatVersions("[compat]")).toEqual([])
+        expect(installer.readJuliaCompatVersions("[compat]\njulia = \"\"")).toEqual([])
+    })
+})
+
 describe('version matching tests', () => {
     describe('specific versions', () => {
         it('Doesn\'t change the version when given a valid semver version', () => {
@@ -84,6 +123,23 @@ 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")
+
+            // 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

@@ -17,6 +17,10 @@ inputs:
     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.'

package.json

@@ -26,7 +26,8 @@
     "@actions/io": "^1.1.3",
     "@actions/tool-cache": "^2.0.1",
     "async-retry": "^1.3.3",
-    "semver": "^7.5.4"
+    "semver": "^7.5.4",
+    "toml": "^3.0.0"
   },
   "devDependencies": {
     "@types/async-retry": "^1.4.8",

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'
 
 // Translations between actions input and Julia arch names
 const osMap = {
@@ -76,15 +77,67 @@ export async function getJuliaVersions(versionInfo): Promise<string[]> {
     return versions
 }
 
-export function getJuliaVersion(availableReleases: string[], versionInput: string, includePrerelease: boolean = false): string {
+export function getProjectFile(projectInput: string = ""): string {
+    let projectFile: string = ""
+
+    // Default value for projectInput
+    if (!projectInput) {
+        projectInput = process.env.JULIA_PROJECT || "."
+    }
+
+    if (fs.existsSync(projectInput) && fs.lstatSync(projectInput).isFile()) {
+        projectFile = projectInput
+    } else {
+        for (let projectFilename of ["JuliaProject.toml", "Project.toml"]) {
+            let p = path.join(projectInput, projectFilename)
+            if (fs.existsSync(p) && fs.lstatSync(p).isFile()) {
+                projectFile = p
+                break
+            }
+        }
+    }
+
+    if (!projectFile) {
+        throw new Error(`Unable to locate project file with project input: ${projectInput}`)
+    }
+
+    return projectFile
+}
+
+/**
+ * @returns An array of version ranges compatible with the Julia project
+ */
+export function readJuliaCompatVersions(projectFileContent: string): string[] {
+    let compatVersions: string[] = []
+
+    let meta = toml.parse(projectFileContent)
+    for (let versionRange of meta.compat?.julia?.split(",") || []) {
+        compatVersions.push(versionRange.trim().replace(/^(?=\d)/, "^"))
+    }
+
+    return compatVersions.filter(v => v)
+}
+
+export function getJuliaVersion(availableReleases: string[], versionInput: string, includePrerelease: boolean = false, juliaCompatVersions: string[] = []): string {
+    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 (!juliaCompatVersions.length) {
+            throw new Error('Unable to use version "MIN" when the Julia project file does not specify a compat for Julia')
+        }
+        let minVersions = juliaCompatVersions.map(v => semver.minSatisfying(availableReleases, v, {includePrerelease}))
+        version = semver.sort(minVersions.filter((v): v is string => v !== null))[0]
+        console.log(`availableReleases: ${availableReleases}\njuliaCompatVersions: ${juliaCompatVersions}\nversion: ${version}`)
+    } else {
+        // Use the highest available version that matches versionInput
+        version = semver.maxSatisfying(availableReleases, versionInput, {includePrerelease})
     }
 
-    // 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}`)
     }
 

src/setup-julia.ts

@@ -42,6 +42,7 @@ async function run() {
         const versionInput = core.getInput('version')
         const includePrereleases = core.getInput('include-all-prereleases') == 'true'
         const originalArchInput = core.getInput('arch')
+        const projectInput = core.getInput('project')
 
         // 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 }}`.
@@ -57,9 +58,16 @@ async function run() {
 
         const arch = archSynonyms[originalArchInput]
 
+        // Determine the Julia compat ranges as specified by the Project.toml only for special versions that require them.
+        let juliaCompatVersions: Array<string> = [];
+        if (versionInput === "MIN") {
+            const projectFile = installer.getProjectFile(projectInput)
+            juliaCompatVersions = installer.readJuliaCompatVersions(fs.readFileSync(projectFile).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, juliaCompatVersions)
         core.debug(`selected Julia version: ${arch}/${version}`)
         core.setOutput('julia-version', version)