Add support for semver version ranges (#82)

Closes: #38

src/download/download-version.ts

@@ -4,15 +4,21 @@ import * as path from "path";
 import { OWNER, REPO, TOOL_CACHE_NAME } from "../utils/constants";
 import { Architecture, Platform } from "../utils/platforms";
 import { validateChecksum } from "./checksum/checksum";
+import * as github from "@actions/github";
 
 export function tryGetFromToolCache(
   arch: Architecture,
   version: string,
-): string | undefined {
+): { version: string; installedPath: string | undefined } {
   core.debug(`Trying to get uv from tool cache for ${version}...`);
   const cachedVersions = tc.findAllVersions(TOOL_CACHE_NAME, arch);
   core.debug(`Cached versions: ${cachedVersions}`);
-  return tc.find(TOOL_CACHE_NAME, version, arch);
+  let resolvedVersion = tc.evaluateVersions(cachedVersions, version);
+  if (resolvedVersion === "") {
+    resolvedVersion = version;
+  }
+  const installedPath = tc.find(TOOL_CACHE_NAME, resolvedVersion, arch);
+  return { version: resolvedVersion, installedPath };
 }
 
 export async function downloadVersion(
@@ -20,10 +26,11 @@ export async function downloadVersion(
   arch: Architecture,
   version: string,
   checkSum: string | undefined,
-  githubToken: string | undefined,
-): Promise<string> {
+  githubToken: string,
+): Promise<{ version: string; cachedToolDir: string }> {
+  const resolvedVersion = await resolveVersion(version, githubToken);
   const artifact = `uv-${arch}-${platform}`;
-  let downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/download/${version}/${artifact}`;
+  let downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/download/${resolvedVersion}/${artifact}`;
   if (platform === "pc-windows-msvc") {
     downloadUrl += ".zip";
   } else {
@@ -36,7 +43,13 @@ export async function downloadVersion(
     undefined,
     githubToken,
   );
-  await validateChecksum(checkSum, downloadPath, arch, platform, version);
+  await validateChecksum(
+    checkSum,
+    downloadPath,
+    arch,
+    platform,
+    resolvedVersion,
+  );
 
   let uvDir: string;
   if (platform === "pc-windows-msvc") {
@@ -46,6 +59,37 @@ export async function downloadVersion(
     const extractedDir = await tc.extractTar(downloadPath);
     uvDir = path.join(extractedDir, artifact);
   }
-
-  return await tc.cacheDir(uvDir, TOOL_CACHE_NAME, version, arch);
+  const cachedToolDir = await tc.cacheDir(
+    uvDir,
+    TOOL_CACHE_NAME,
+    resolvedVersion,
+    arch,
+  );
+  return { version: resolvedVersion, cachedToolDir };
+}
+
+async function resolveVersion(
+  version: string,
+  githubToken: string,
+): Promise<string> {
+  if (tc.isExplicitVersion(version)) {
+    core.debug(`Version ${version} is an explicit version.`);
+    return version;
+  }
+  const availableVersions = await getAvailableVersions(githubToken);
+  const resolvedVersion = tc.evaluateVersions(availableVersions, version);
+  if (resolvedVersion === "") {
+    throw new Error(`No version found for ${version}`);
+  }
+  return resolvedVersion;
+}
+
+async function getAvailableVersions(githubToken: string): Promise<string[]> {
+  const octokit = github.getOctokit(githubToken);
+
+  const response = await octokit.paginate(octokit.rest.repos.listReleases, {
+    owner: OWNER,
+    repo: REPO,
+  });
+  return response.map((release) => release.tag_name);
 }

src/setup-uv.ts

@@ -41,8 +41,8 @@ async function run(): Promise<void> {
     );
 
     addUvToPath(setupResult.uvDir);
-    core.setOutput("uv-version", version);
-    core.info(`Successfully installed uv version ${version}`);
+    core.setOutput("uv-version", setupResult.version);
+    core.info(`Successfully installed uv version ${setupResult.version}`);
 
     addMatchers();
     setCacheDir(cacheLocalPath);
@@ -50,10 +50,10 @@ async function run(): Promise<void> {
     if (enableCache) {
       await restoreCache(setupResult.version);
     }
+    process.exit(0);
   } catch (err) {
     core.setFailed((err as Error).message);
   }
-  process.exit(0);
 }
 
 async function setupUv(
@@ -61,29 +61,37 @@ async function setupUv(
   arch: Architecture,
   versionInput: string,
   checkSum: string | undefined,
-  githubToken: string | undefined,
+  githubToken: string,
 ): Promise<{ uvDir: string; version: string }> {
   let installedPath: string | undefined;
   let cachedToolDir: string;
   let version: string;
   if (versionInput === "latest") {
-    const result = await downloadLatest(platform, arch, checkSum, githubToken);
-    version = result.version;
-    cachedToolDir = result.cachedToolDir;
+    const latestResult = await downloadLatest(
+      platform,
+      arch,
+      checkSum,
+      githubToken,
+    );
+    version = latestResult.version;
+    cachedToolDir = latestResult.cachedToolDir;
   } else {
-    version = versionInput;
-    installedPath = tryGetFromToolCache(arch, versionInput);
+    const toolCacheResult = tryGetFromToolCache(arch, versionInput);
+    version = toolCacheResult.version;
+    installedPath = toolCacheResult.installedPath;
     if (installedPath) {
       core.info(`Found uv in tool-cache for ${versionInput}`);
       return { uvDir: installedPath, version };
     }
-    cachedToolDir = await downloadVersion(
+    const versionResult = await downloadVersion(
       platform,
       arch,
       versionInput,
       checkSum,
       githubToken,
     );
+    cachedToolDir = versionResult.cachedToolDir;
+    version = versionResult.version;
   }
 
   return { uvDir: cachedToolDir, version };