Add production dependencies & build

.github/workflows/checkin.yml

@@ -0,0 +1,36 @@
+name: "PR Checks"
+on: [pull_request, push]
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+jobs:
+  check_pr:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version-file: '.tool-versions'
+
+    - name: "npm ci"
+      run: npm ci
+
+    - name: "npm run build"
+      run: npm run build
+
+    - name: "npm run test"
+      run: npm run test
+
+    - name: "check for uncommitted changes"
+      # 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 ci && npm run build'" \
+                 "and check in all changes" \
+            && exit 1)

.github/workflows/example-builds.yml

@@ -27,13 +27,6 @@ jobs:
         exclude:
           - os: macOS-latest
             julia-arch: x86
-        include:
-          - os: macOS-latest
-            julia-arch: aarch64
-            julia-version: 'lts'
-          - os: macOS-latest
-            julia-arch: aarch64
-            julia-version: '1'
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/pr_checks.yml

@@ -1,222 +0,0 @@
-name: PR Checks
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-    tags: '*'
-concurrency:
-  # Skip intermediate builds: all builds except for builds on the `master` branch
-  # Cancel intermediate builds: only pull request builds
-  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.run_number }}
-  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
-permissions:
-  contents: read
-jobs:
-  finalize-pr-checks:
-    if: always() # this line is important to keep the `finalize` job from being marked as skipped; do not change or delete this line
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    needs:
-      - checked-in-files
-      - build
-      - npm-run-test
-      - make-targets
-      - stalecheck-npm-install
-    steps:
-      - run: |
-          echo checked-in-files: ${{ needs.checked-in-files.result }}
-          echo build: ${{ needs.build.result }}
-          echo npm-run-test: ${{ needs.npm-run-test.result }}
-          echo make-targets: ${{ needs.make-targets.result }}
-          echo stalecheck-npm-install: ${{ needs.stalecheck-npm-install.result }}
-      - run: exit 1
-        if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
-  checked-in-files:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@05e0d2ed97b598bfce82fd30daf324ae0c4570e6
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make pack
-      ### Clean (not cleanall!):
-      - run: make clean
-      ### Make sure there are no uncommited changes
-      - uses: julia-actions/setup-julia@9b79636afcfb07ab02c256cede01fe2db6ba808c # v2.6.0
-        with:
-          version: '1'
-      - run: git --no-pager status
-      - run: git --no-pager diff
-      - run: julia ./ci/check_uncommitted_changes.jl
-  build:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@05e0d2ed97b598bfce82fd30daf324ae0c4570e6
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make build
-      - run: make pack
-      ### Make sure some other `make` targets don't bitrot:
-      - name: Run some other `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-      - name: Run all of the "cleaning" `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-  npm-run-test:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@05e0d2ed97b598bfce82fd30daf324ae0c4570e6
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make build
-      - run: make test
-  make-targets: # This is a job to make sure that none of the `make` targets bitrot
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@05e0d2ed97b598bfce82fd30daf324ae0c4570e6
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Make sure some other `make` targets don't bitrot:
-      - name: Run some other `make` targets to ensure that they don't bitrot
-        run: |
-          make unix-asdf-install
-          make install-packages
-          make build
-          make pack
-          make everything-from-scratch
-      - name: Run all of the "cleaning" `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-  stalecheck-npm-install:
-    # In this job, we are basically trying to check if `package-lock.json` is in
-    # sync with `package-lock.json`.
-    #
-    # So, for example, if someone manually edits the `package.json` file, we want
-    # to make sure that the `package-lock.json` file is not out of sync with the
-    # `package.json` file.
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@05e0d2ed97b598bfce82fd30daf324ae0c4570e6
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      ### Run the master commands for this job:
-      - run: make clean
-      - run: npm ci
-      # - run: npm install --package-lock-only
-      - run: npm install
-      ### Make sure there are no uncommited changes
-      - uses: julia-actions/setup-julia@9b79636afcfb07ab02c256cede01fe2db6ba808c # v2.6.0
-        with:
-          version: '1'
-      - run: git --no-pager status
-      - run: git --no-pager diff
-      - run: julia ./ci/check_uncommitted_changes.jl

.gitignore

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

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bin"]
+	path = bin
+	url = git@github.com:julia-actions/bin.git

Makefile

@@ -1,49 +0,0 @@
-.NOTPARALLEL:
-
-# This is the default target:
-.PHONY: pack
-pack: build
-	npm run pack
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.PHONY: everything-from-scratch
-everything-from-scratch: cleanall install-packages build pack clean
-
-# build does `npm run build`, but does not run `npm run pack`
-.PHONY: build
-build:
-	npm run build
-
-.PHONY: test
-test:
-	npm run test
-
-.PHONY: install-packages
-install-packages:
-	rm -rf node_modules/
-	# Note: we use `npm ci` instead of `npm install`, because we want to make sure
-	# that we respect the versions in the `package-lock.json` lockfile.
-	npm ci
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.PHONY: clean
-clean:
-	rm -rf node_modules/
-
-.PHONY: cleanall
-cleanall: clean
-	rm -rf lib/
-	rm -rf dist/
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-# asdf does not support Windows.
-# On Windows, users need to install the correct version of NodeJS themselves.
-.PHONY: unix-asdf-install
-unix-asdf-install:
-	asdf plugin add nodejs # update this list when we add more tools to `.tool-versions`
-	asdf install
-
-# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

README.md

@@ -71,11 +71,6 @@ 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
@@ -122,12 +117,10 @@ You can either specify specific Julia versions or version ranges. If you specify
 - `'~1.3.0-rc1'` is a **tilde** version range that includes pre-releases of `1.3.0` starting at `rc1`. It matches all versions `≥ 1.3.0-rc1` and `< 1.4.0`.
 - `'^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`.
-- `'1'` will install the latest v1 version of Julia.
 - `'lts'` will install the latest LTS 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).
 
@@ -194,18 +187,12 @@ jobs:
     strategy:
       matrix:
         julia-version: ['1.0', '1.2.0', '^1.3.0-rc1']
-        julia-arch: [x64, x86, aarch64]
+        julia-arch: [x64, x86]
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        # exclude unavailable/unwanted architectures
+        # 32-bit Julia binaries are not available on macOS
         exclude:
           - os: macOS-latest
             julia-arch: x86
-          - os: macOS-latest
-            julia-arch: x64 # can be run but via rosetta on apple silicon runners
-          - os: ubuntu-latest
-            julia-arch: aarch64
-          - os: windows-latest
-            julia-arch: aarch64
 
     steps:
       - uses: actions/checkout@v4

__tests__/installer.test.ts

@@ -26,8 +26,8 @@ const testVersions = [
     '1.7.0', '1.7.0-beta1', '1.7.0-beta2', '1.7.0-beta3', '1.7.0-beta4', '1.7.0-rc1', '1.7.0-rc2', '1.7.0-rc3', '1.7.1', '1.7.2', '1.7.3',
     '1.8.0', '1.8.0-beta1', '1.8.0-beta2', '1.8.0-beta3', '1.8.0-rc1', '1.8.0-rc2', '1.8.0-rc3', '1.8.0-rc4', '1.8.1', '1.8.2', '1.8.3', '1.8.4', '1.8.5',
     '1.9.0', '1.9.0-alpha1', '1.9.0-beta1', '1.9.0-beta2', '1.9.0-beta3', '1.9.0-beta4', '1.9.0-rc1', '1.9.0-rc2', '1.9.0-rc3', '1.9.1', '1.9.2', '1.9.3', '1.9.4',
-    '1.10.0', '1.10.0-alpha1', '1.10.0-beta1', '1.10.0-beta2', '1.10.0-beta3', '1.10.0-rc1', '1.10.0-rc2', '1.10.0-rc3', '1.10.1', '1.10.2', '1.10.3', '1.10.4', '1.10.5',
+    '1.10.0', '1.10.0-alpha1', '1.10.0-beta1', '1.10.0-beta2', '1.10.0-beta3', '1.10.0-rc1', '1.10.0-rc2', '1.10.0-rc3', '1.10.1', '1.10.2',
-    '1.11.0', '1.11.0-alpha1', '1.11.0-alpha2', '1.11.0-beta1', '1.11.0-beta2', '1.11.0-rc1', '1.11.0-rc2', '1.11.0-rc3', '1.11.0-rc4',
+    '1.11.0-alpha1', '1.11.0-alpha2', '1.11.0-beta1'
 ]
 
 const toolDir = path.join(__dirname, 'runner', 'tools')
@@ -38,135 +38,6 @@ 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', () => {
@@ -187,30 +58,30 @@ describe('version matching tests', () => {
 
         it('LTS', () => {
             // Update test when LTS is updated
-            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual(installer.getJuliaVersion(testVersions, '1.10'))
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual(installer.getJuliaVersion(testVersions, '1.6'))
-            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual('1.10.5')
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual('1.6.7')
         })
 
         it('pre', () => {
-            expect(installer.getJuliaVersion(testVersions, 'pre')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, 'pre')).toEqual('1.11.0-beta1')
         })
     })
 
     describe('version ranges', () => {
         it('Chooses the highest available version that matches the input', () => {
-            expect(installer.getJuliaVersion(testVersions, '1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '1')).toEqual('1.10.2')
             expect(installer.getJuliaVersion(testVersions, '1.0')).toEqual('1.0.5')
-            expect(installer.getJuliaVersion(testVersions, '^1.3.0-rc1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.3.0-rc1')).toEqual('1.10.2')
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-rc1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-rc1')).toEqual('1.10.2')
-            expect(installer.getJuliaVersion(testVersions, '^1.10.0-rc1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.10.0-rc1')).toEqual('1.10.2')
         })
     })
 
     describe('include-prereleases', () => {
         it('Chooses the highest available version that matches the input including prereleases', () => {
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', true)).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', true)).toEqual('1.11.0-beta1')
-            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.11.0-beta1')
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.10.2')
         })
     })
 
@@ -224,34 +95,6 @@ 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

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

ci/check_uncommitted_changes.jl

@@ -1,16 +0,0 @@
-const cmd = `git --no-pager diff --exit-code --stat`
-
-const proc = run(pipeline(cmd; stdin, stdout, stderr); wait = false)
-
-wait(proc)
-
-@info "" success(proc) proc.exitcode
-
-if !success(proc)
-    recommended_cmd = "make everything-from-scratch"
-    msg = "##[error] found changed files after build. " *
-           "Please run `$(recommended_cmd)` and " *
-           "then check in all changes."
-    println(stderr, msg)
-    exit(1)
-end

devdocs/local_setup.md

@@ -42,8 +42,6 @@ First, `cd` to your clone of the repo. Now you can run the following commands:
 npm ci
 
 npm run build
-
-npm run pack
 ```
 
 When you are ready, you can commit your changes and push them to your PR.

devdocs/making_a_new_release.md

@@ -1,56 +1,128 @@
 # Making a new release of this action (requires commit access)
 
-In this guide, as an example, `v2.2.0` refers to the version number of the new release that you want to make.
+If you have commit access to this repo, you can make a new release.
 
-## Part 1: Use the Git CLI to create and push the Git tags
+Here are the instructions.
 
-Step 1: Create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
+## Step 1: Clone a fresh copy of the repo
+
+We intentionally work in a brand-new copy of the repo.
 
 ```bash
 git clone git@github.com:julia-actions/setup-julia.git
 cd setup-julia
-git fetch --all --tags
+git checkout master
-
+git submodule init
-git checkout main
+git submodule update
-
-git --no-pager log -1
-# Take note of the commit hash here.
-
-# Now, create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
-#
-# Replace `commit_hash` with the commit hash that you obtained from the
-# `git log -1` step.
-#
-# Replace `v2.2.0` with the actual version number that you want to use.
-git tag v2.2.0 commit_hash
 ```
 
-Step 2: Once you've created the new release, you need to update the `v2` tag to point to the new release. For example, suppose that the previous release was `v2.1.0`, and suppose that you just created the new release `v2.2.0`. You need to update the `v2` tag so that it points to `v2.2.0`. Here are the commands:
+## Step 2: Make sure you have the right version of NodeJS
+
+If you use [`asdf`](https://asdf-vm.com/), this is as simple as:
 
 ```bash
-# Create/update the new v2 tag locally, where the new v2 tag will point to the
+asdf plugin add nodejs
-# release that you created in the previous step.
+asdf install
-#
-# Make sure to change `v2.2.0` to the actual value for the tag that you just
-# created in the previous step.
-#
-# The `-f` flag forcibly overwrites the old
-# `v2` tag (if it exists).
-git tag -f v2 v2.2.0
 ```
 
-Step 3: Now you need to push the tags:
+If you don't use `asdf`, then you need to:
+1. Open the `./tool-versions` file in the root of the repo.
+2. Make note of the NodeJS version listed in the `.tool-versions` file.
+3. Install that same version of NodeJS on your machine.
+4. Make sure that you are currently using that version of NodeJS (i.e. it is at the front of your PATH).
+
+## Step 3: Edit the `version` field in `package.json`
 
 ```bash
-# Regular-push the new `v2.2.0` tag:
+vim package.json
-git push origin tag v2.2.0
 
-# Force-push the new v2 tag:
+# Edit the `version` number (should be line 2)
-git push origin tag v2 --force
+# Save your changes in Vim. Then exit Vim.
+
+# For the remaining of this guide, let MAJOR.MINOR.PATCH refer
+# to the new version number that you set.
+
+git add package.json
+
+# No need to commit yet.
+# The release script will run `git commit`.
 ```
 
-## Part 2: Create the GitHub Release
+## Step 4: Remove the `dist/` line from the `.gitignore` file
 
-Go to the [Releases](https://github.com/julia-actions/setup-julia/releases) section of this repo and create a new release (using the GitHub web interface).
+```bash
+vim .gitignore
+# Delete the line that says `dist/` (it should be line 3)
+# Save your changes in Vim. Then exit Vim.
 
-For the "choose a tag" drop-down field, select the `v2.2.0` tag that you created and pushed in Part 1 of this guide.
+git add .gitignore
+
+# No need to commit yet.
+# The release script will run `git commit`.
+```
+
+## Step 5: Make sure you have the necessary dependencies
+
+The `build-release.sh` script requires the following dependencies:
+
+1. Bash
+2. `curl`
+3. `git`
+4. `jq`
+5. `sed`
+
+## Step 6: Run the `build-release.sh` script
+
+```bash
+ls -l bin/build-release.sh
+chmod +x bin/build-release.sh
+ls -l bin/build-release.sh
+
+./bin/build-release.sh julia-actions/setup-julia
+```
+
+Wait a minute or two. The script will build everything and will create a new release branch named `releases/vMAJOR.MINOR.PATCH`.
+
+## Step 7: Push ONLY the `releases/vMAJOR.MINOR.PATCH` branch
+
+Only push the `releases/` branch. Do NOT push any tags yet.
+
+```bash
+git push origin releases/vMAJOR.MINOR.PATCH
+```
+
+Now you need to go to https://github.com/julia-actions/setup-julia/tree/releases/vMAJOR.MINOR.PATCH and wait for CI to finish running.
+
+Do NOT proceed to the next step until CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch.
+
+## Step 8: Push the tags (only after CI is all green)
+
+Once CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch, you can push the tags.
+
+You need to force-push.
+
+```bash
+git push --tags --force
+```
+
+## Step 9: Use the GitHub web UI to create a new GitHub Release
+
+Go to https://github.com/julia-actions/setup-julia/releases  and create a new release for the now-existant `vMAJOR.MINOR.PATCH` tag using the GitHub web interface.
+
+## Step 10: Clean up your local repo
+
+```bash
+git submodule deinit --force .
+git submodule update --init
+git fetch --all --prune
+git checkout master
+git reset --hard origin/master
+```
+
+## Step 11: Delete your local repo
+
+```bash
+cd ..
+ls setup-julia
+rm -rf setup-julia
+```

lib/installer.js

@@ -34,9 +34,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getJuliaVersionInfo = getJuliaVersionInfo;
 exports.getJuliaVersions = getJuliaVersions;
-exports.getProjectFilePath = getProjectFilePath;
-exports.validJuliaCompatRange = validJuliaCompatRange;
-exports.readJuliaCompatRange = readJuliaCompatRange;
 exports.getJuliaVersion = getJuliaVersion;
 exports.getFileInfo = getFileInfo;
 exports.getDownloadURL = getDownloadURL;
@@ -51,8 +48,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 LTS_VERSION = '1.10';
 const MAJOR_VERSION = '1'; // Could be deduced from versions.json
 // Translations between actions input and Julia arch names
 const osMap = {
@@ -116,106 +112,20 @@ function getJuliaVersions(versionInfo) {
         return versions;
     });
 }
-/**
+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
-        version = versionInput;
+        return versionInput;
     }
-    else if (versionInput == "min") {
+    if (versionInput == 'lts') {
-        // Resolve "min" to the minimum supported Julia version compatible with the project file
+        return getJuliaVersion(availableReleases, LTS_VERSION, false);
-        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") {
+    if (versionInput == 'pre') {
-        version = semver.maxSatisfying(availableReleases, LTS_VERSION, { includePrerelease: false });
+        return getJuliaVersion(availableReleases, MAJOR_VERSION, true);
     }
-    else if (versionInput == "pre") {
+    // Use the highest available version that matches versionInput
-        version = semver.maxSatisfying(availableReleases, MAJOR_VERSION, { includePrerelease: true });
+    let version = semver.maxSatisfying(availableReleases, versionInput, { includePrerelease });
-    }
+    if (version == null) {
-    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

lib/setup-julia.js

@@ -46,7 +46,6 @@ const installer = __importStar(require("./installer"));
 const archSynonyms = {
     'x86': 'x86',
     'x64': 'x64',
-    'x86_64': 'x64',
     'aarch64': 'aarch64',
     'arm64': 'aarch64'
 };
@@ -73,7 +72,6 @@ function run() {
             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.
@@ -88,9 +86,6 @@ function run() {
             if (!originalArchInput) { // if `originalArchInput` is an empty string
                 throw new Error(`Arch input must not be null`);
             }
-            if (originalArchInput == 'x64' && os.platform() == 'darwin' && os.arch() == 'arm64') {
-                core.warning('[setup-julia] x64 arch has been requested on a macOS runner that has an arm64 (Apple Silicon) architecture. You may have meant to use the "aarch64" arch instead (or left it unspecified for the correct default).');
-            }
             let processedArchInput;
             if (originalArchInput == "default") {
                 // If the user sets the `arch` input to `default`, then we use the
@@ -105,15 +100,9 @@ function run() {
             // 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, juliaCompatRange);
+            const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases);
             core.debug(`selected Julia version: ${arch}/${version}`);
             core.setOutput('julia-version', version);
             // Search in cache

package.json

@@ -1,5 +1,6 @@
 {
   "name": "setup-julia",
+  "version": "2.3.0",
   "private": true,
   "description": "setup Julia action",
   "main": "lib/setup-julia.js",
@@ -20,26 +21,25 @@
   "author": "Sascha Mann <git@mail.saschamann.eu>",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.11.1",
+    "@actions/core": "^1.10.1",
     "@actions/exec": "^1.1.1",
     "@actions/io": "^1.1.3",
     "@actions/tool-cache": "^2.0.1",
     "async-retry": "^1.3.3",
-    "semver": "^7.6.3",
+    "semver": "^7.6.3"
-    "toml": "^3.0.0"
   },
   "devDependencies": {
-    "@types/async-retry": "^1.4.9",
+    "@types/async-retry": "^1.4.8",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^29.5.12",
-    "@types/node": "^22.9.0",
+    "@types/node": "^20.14.11",
     "@types/retry": "^0.12.5",
     "@types/semver": "^7.5.8",
-    "@vercel/ncc": "^0.38.2",
+    "@vercel/ncc": "^0.38.1",
     "jest": "^29.7.0",
     "jest-circus": "^29.7.0",
     "nock": "^13.5.4",
     "prettier": "^3.3.3",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.3",
-    "typescript": "^5.6.3"
+    "typescript": "^5.5.3"
   }
 }

src/installer.ts

@@ -9,9 +9,8 @@ import * as path from 'path'
 import retry = require('async-retry')
 
 import * as semver from 'semver'
-import * as toml from 'toml'
 
-const LTS_VERSION = '1.10'
+const LTS_VERSION = '1.6'
 const MAJOR_VERSION = '1' // Could be deduced from versions.json
 
 // Translations between actions input and Julia arch names
@@ -80,116 +79,23 @@ 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
-        version = versionInput
+        return 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 (!version) {
+    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) {
         throw new Error(`Could not find a Julia version that matches ${versionInput}`)
     }
 

src/setup-julia.ts

@@ -15,7 +15,6 @@ import * as installer from './installer'
 const archSynonyms = {
     'x86': 'x86',
     'x64': 'x64',
-    'x86_64': 'x64',
     'aarch64': 'aarch64',
     'arm64': 'aarch64'
 }
@@ -45,7 +44,6 @@ async function run() {
         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 }}`.
@@ -62,10 +60,6 @@ async function run() {
             throw new Error(`Arch input must not be null`)
         }
 
-        if (originalArchInput == 'x64' && os.platform() == 'darwin' && os.arch() == 'arm64') {
-            core.warning('[setup-julia] x64 arch has been requested on a macOS runner that has an arm64 (Apple Silicon) architecture. You may have meant to use the "aarch64" arch instead (or left it unspecified for the correct default).')
-        }
-
         let processedArchInput: string;
         if (originalArchInput == "default") {
             // If the user sets the `arch` input to `default`, then we use the
@@ -80,16 +74,9 @@ async function run() {
         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, juliaCompatRange)
+        const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases)
         core.debug(`selected Julia version: ${arch}/${version}`)
         core.setOutput('julia-version', version)