Semver at ranges (#40)

* drop @latest from the lib, this is cli territory
* @range syntax is the concise representation 4 some

Author: mxcl

src/plumbing/resolve.test.ts

@@ -1,4 +1,5 @@
-import { assert, assertEquals, fail, assertRejects } from "deno/testing/asserts.ts"
+// deno-lint-ignore-file require-await
+import { assert, assertEquals, fail, assertRejects } from "deno/assert/mod.ts"
 import { Installation, Package, PackageRequirement } from "../types.ts"
 import { useTestConfig } from "../hooks/useTestConfig.ts"
 import useInventory from "../hooks/useInventory.ts"
@@ -9,14 +10,21 @@ import { stub } from "deno/testing/mock.ts"
 import SemVer from "../utils/semver.ts"
 import Path from "../utils/Path.ts"
 
-Deno.test("resolve cellar.has", async runner => {
+Deno.test("resolve cellar.has", {
+  permissions: {'read': true, 'env': ["TMPDIR", "TMP", "TEMP", "HOME"], 'write': [Deno.env.get("TMPDIR") || Deno.env.get("TMP") || Deno.env.get("TEMP") || "/tmp"] }
+}, async runner => {
   const prefix = useTestConfig().prefix
   const pkg = { project: "foo", version: new SemVer("1.0.0") }
 
   const cellar = useCellar()
-  const has = (_: Path | Package | PackageRequirement) => {
-    const a: Installation = {pkg, path: prefix.join(pkg.project, `v${pkg.version}`) }
-    return Promise.resolve(a)
+  const has = async (pkg_: Package | PackageRequirement | Path) => {
+    if (pkg_ instanceof Path) fail()
+    if (pkg.project == pkg_.project) {
+      if ('constraint' in pkg_ && !pkg_.constraint.satisfies(pkg.version)) return
+      if ('version' in pkg_ && !pkg_.version.eq(pkg.version)) return
+      const a: Installation = {pkg, path: prefix.join(pkg.project, `v${pkg.version}`) }
+      return a
+    }
   }
 
   await runner.step("happy path", async () => {
@@ -29,7 +37,7 @@ Deno.test("resolve cellar.has", async runner => {
     }))
 
     try {
-      const rv = await resolve([pkg])
+    const rv = await resolve([pkg])
       assertEquals(rv.pkgs[0].project, pkg.project)
       assertEquals(rv.installed[0].pkg.project, pkg.project)
     } finally {
@@ -60,7 +68,7 @@ Deno.test("resolve cellar.has", async runner => {
     assert(errord)
   })
 
-  await runner.step("uses existing version if even if update set", async () => {
+  await runner.step("uses existing version if it is the latest even if update set", async () => {
     const stub1 = stub(_internals, "useInventory", () => ({
       get: () => fail(),
       select: () => Promise.resolve(pkg.version),
@@ -78,6 +86,36 @@ Deno.test("resolve cellar.has", async runner => {
       stub2.restore()
     }
   })
+
+  await runner.step("updates version if latest is not installed", async runner => {
+    const stub1 = stub(_internals, "useInventory", () => ({
+      get: () => fail(),
+      select: () => Promise.resolve(new SemVer("1.0.1")),
+    }))
+    const stub2 = stub(_internals, "useCellar", () => ({
+      ...cellar, has
+    }))
+
+    try {
+      await runner.step("update: true", async () => {
+        const rv = await resolve([{ project: pkg.project, constraint: new semver.Range("^1") }], { update: true })
+        assertEquals(rv.pkgs[0].project, pkg.project)
+        assertEquals(rv.pending[0].project, pkg.project)
+        assertEquals(rv.pending[0].version, new SemVer("1.0.1"))
+      })
+
+      await runner.step("update: set", async () => {
+        const update = new Set([pkg.project])
+        const rv = await resolve([{ project: pkg.project, constraint: new semver.Range("^1") }], { update })
+        assertEquals(rv.pkgs[0].project, pkg.project)
+        assertEquals(rv.pending[0].project, pkg.project)
+        assertEquals(rv.pending[0].version, new SemVer("1.0.1"))
+      })
+    } finally {
+      stub1.restore()
+      stub2.restore()
+    }
+  })
 })
 
 const permissions = { net: false, read: true, env: ["TMPDIR", "HOME", "TMP", "TEMP"], write: true /*FIXME*/ }

src/plumbing/resolve.ts

@@ -32,7 +32,7 @@ export class ResolveError extends TeaError {
 /// that resolve so if we are resolving `node>=12`, node 13 is installed, but
 /// node 19 is the latest we return node 13. if `update` is true we return node
 /// 19 and *you will need to install it*.
-export default async function resolve(reqs: (Package | PackageRequirement)[], {update}: {update: boolean} = {update: false}): Promise<Resolution> {
+export default async function resolve(reqs: (Package | PackageRequirement)[], {update}: {update: boolean | Set<string>} = {update: false}): Promise<Resolution> {
   const inventory = _internals.useInventory()
   const cellar = _internals.useCellar()
   const rv: Resolution = { pkgs: [], installed: [], pending: [] }
@@ -41,7 +41,8 @@ export default async function resolve(reqs: (Package | PackageRequirement)[], {u
   const promises: Promise<void>[] = []
 
   for (const req of reqs) {
-    if (!update && (installation = await cellar.has(req))) {
+    const noup = !should_update(req.project)
+    if (noup && (installation = await cellar.has(req))) {
       // if something is already installed that satisfies the constraint then use it
       rv.installed.push(installation)
       rv.pkgs.push(installation.pkg)
@@ -67,6 +68,10 @@ export default async function resolve(reqs: (Package | PackageRequirement)[], {u
   await Promise.all(promises)
 
   return rv
+
+  function should_update(project: string) {
+    return update === true || (update instanceof Set && update.has(project))
+  }
 }
 
 export const _internals = {

src/utils/misc.test.ts

@@ -76,6 +76,10 @@ Deno.test("array compact", () => {
   // will fail to compile if the compiler cannot infer the type of the compact() return
   assertEquals([1, 2, undefined, null, false, 3].compact()[0] + 1, 2)
 
+  // verifies transforming the type gives singular type return
+  const foo = [1, 2, undefined, null, false, 3].compact((n) => isNumber(n) && `${n * 2}`)
+  assertEquals(foo, ["2", "4", "6"])
+
   const throws = () => {
     throw Error("test error")
   }

src/utils/misc.ts

@@ -32,6 +32,7 @@ export { validate }
 declare global {
   interface Array<T> {
     compact(): Array<Exclude<T, boolean | null | undefined>>
+    compact<S>(body: (t: T) => S | null | undefined | false): Array<S>
     compact<S>(body?: (t: T) => S | T | null | undefined | false, opts?: { rescue: boolean }): Array<S | T>
   }
 
@@ -49,7 +50,7 @@ Set.prototype.insert = function<T>(t: T) {
   }
 }
 
-Array.prototype.compact = function<T, S = T>(body?: (t: T) => S | null | undefined | false, opts?: { rescue: boolean }): S[] {
+Array.prototype.compact = function<T, S>(body?: (t: T) => S | null | undefined | false, opts?: { rescue: boolean }): S[] {
   const rv: S[] = []
   for (const e of this) {
     try {

src/utils/pkg.test.ts

@@ -46,13 +46,6 @@ Deno.test("pkg.str", async test => {
 })
 
 Deno.test("pkg.parse", async test => {
-  await test.step("@latest", () => {
-    const { constraint } = pkg.parse("test@latest")
-    assert(constraint.satisfies(new SemVer([5,0,0])))
-    assert(constraint.satisfies(new SemVer([5,1,0])))
-    assert(constraint.satisfies(new SemVer([6,0,0])))
-  })
-
   await test.step("@5", () => {
     const { constraint } = pkg.parse("test@5")
     assert(constraint.satisfies(new SemVer([5,0,0])))

src/utils/pkg.ts

@@ -8,13 +8,8 @@ export function parse(input: string): PackageRequirement {
   if (!match[2]) match[2] = "*"
 
   const project = match[1]
-
-  if (match[2] == "@latest") {
-    return { project, constraint: new semver.Range('*') }
-  } else {
-    const constraint = new semver.Range(match[2])
-    return { project, constraint }
-  }
+  const constraint = new semver.Range(match[2])
+  return { project, constraint }
 }
 
 export function compare(a: Package, b: Package): number {

src/utils/semver.test.ts

@@ -1,5 +1,5 @@
 // deno-lint-ignore-file no-explicit-any
-import { assert, assertEquals, assertFalse, assertThrows } from "deno/testing/asserts.ts"
+import { assert, assertEquals, assertFalse, assertThrows } from "deno/assert/mod.ts"
 import SemVer, * as semver from "./semver.ts"
 
 
@@ -160,7 +160,8 @@ Deno.test("semver", async test => {
 
     assertEquals(new semver.Range("@300").toString(), "^300")
     assertEquals(new semver.Range("@300.1").toString(), "~300.1")
-    assertEquals(new semver.Range("@300.1.0").toString(), ">=300.1<300.1.1")
+    assertEquals(new semver.Range("@300.1.0").toString(), "@300.1.0")
+    assertEquals(new semver.Range(">=300.1.0<300.1.1").toString(), "@300.1.0")
   })
 
   await test.step("intersection", async test => {
@@ -274,7 +275,7 @@ Deno.test("coverage", () => {
 
   assertEquals(semver.Range.parse("1")?.toString(), new semver.Range("^1").toString())
   assertEquals(semver.Range.parse("1.1")?.toString(), new semver.Range("~1.1").toString())
-  assertEquals(semver.Range.parse("1.1.2")?.toString(), new semver.Range(">=1.1.2<1.1.3").toString())
+  assertEquals(semver.Range.parse("1.1.2")?.toString(), new semver.Range("@1.1.2").toString())
 
   assertEquals(semver.Range.parse("a"), undefined)
 

src/utils/semver.ts

@@ -214,11 +214,41 @@ export class Range {
         } else if (v2.major == Infinity) {
           const v = chomp(v1)
           return `>=${v}`
+        } else if (at(v1, v2)) {
+          return `@${v1}`
         } else {
           return `>=${chomp(v1)}<${chomp(v2)}`
         }
       }).join(",")
     }
+
+    function at(v1: SemVer, {components: cc2}: SemVer) {
+      const cc1 = [...v1.components]
+
+      if (cc1.length > cc2.length) {
+        return false
+      }
+
+      // it's possible the components were short due to 0-truncation
+      // add them back so our algo works
+      while (cc1.length < cc2.length) {
+        cc1.push(0)
+      }
+
+      if (last(cc1) != last(cc2) - 1) {
+        return false
+      }
+
+      for (let i = 0; i < (cc1.length - 1); i++) {
+        if (cc1[i] != cc2[i]) return false
+      }
+
+      return true
+    }
+
+    function last<T>(arr: number[]) {
+      return arr[arr.length - 1]
+    }
   }
 
   // eq(that: Range): boolean {