which() can return all results

Author: mxcl

src/plumbing/which.test.ts

@@ -0,0 +1,24 @@
+import { assert, assertEquals } from "deno/testing/asserts.ts"
+import { isArray } from "is-what"
+import which from "./which.ts"
+
+Deno.test("which('ls')", async () => {
+  const foo = await which('ls')
+  assert(!isArray(foo))
+  assert(foo)
+})
+
+Deno.test("which('kill-port')", async () => {
+  const foo = await which('kill-port')
+  assert(!isArray(foo))
+  assert(foo)
+
+  const bar = await which('kill-port', { providers: false })
+  assertEquals(bar, undefined)
+})
+
+Deno.test("which('nvim')", async () => {
+  const foo = await which('kill-port', { all: true })
+  assert(isArray(foo))
+  assert(foo.length)
+})

src/plumbing/which.ts

@@ -6,29 +6,53 @@ export type WhichResult = PackageRequirement & {
   shebang: string[]
 }
 
-export default async function(arg0: string, opts = { providers: true }): Promise<WhichResult | undefined> {
+
+export default async function which(arg0: string, opts?: { providers?: boolean }): Promise<WhichResult | undefined>;
+export default async function which(arg0: string, opts: { providers?: boolean, all: false }): Promise<WhichResult | undefined>;
+export default async function which(arg0: string, opts: { providers?: boolean, all: true }): Promise<WhichResult[]>;
+export default async function which(arg0: string, opts_?: { providers?: boolean, all?: boolean }) {
+
+  const opts = { providers: opts_?.providers ?? true, all: opts_?.all ?? false }
+
+  const rv: WhichResult[] = []
+  for await (const result of _which(arg0, opts)) {
+    if (opts.all) {
+      rv.push(result)
+    } else {
+      return result
+    }
+  }
+  if (!opts.all && rv.length == 0) {
+    return
+  } else {
+    return rv
+  }
+}
+
+async function *_which(arg0: string, opts: { providers: boolean }): AsyncGenerator<WhichResult> {
   arg0 = arg0.trim()
   /// sanitize and reject anything with path components
   if (!arg0 || arg0.includes("/")) return
 
   const pantry = usePantry()
-  let found: { project: string, constraint: semver.Range, shebang: string[] } | undefined
+  let found: WhichResult[] = []
   const promises: Promise<void>[] = []
 
   for await (const entry of pantry.ls()) {
-    if (found) break
+    if (found.length) {
+      for (const f of found) yield f
+      found = []
+    }
     const p = pantry.project(entry).provides().then(providers => {
       for (const provider of providers) {
-        if (found) {
-          return
-        } else if (provider == arg0) {
+        if (provider == arg0) {
           const constraint = new semver.Range("*")
-          found = {...entry, constraint, shebang: [provider] }
+          found.push({...entry, constraint, shebang: [provider] })
         } else if (arg0.startsWith(provider)) {
           // eg. `node^16` symlink
           try {
             const constraint = new semver.Range(arg0.substring(provider.length))
-            found = {...entry, constraint, shebang: [provider] }
+            found.push({...entry, constraint, shebang: [provider] })
           } catch {
             // not a valid semver range; fallthrough
           }
@@ -46,35 +70,34 @@ export default async function(arg0: string, opts = { providers: true }): Promise
           match = arg0.match(rx)
           if (match) {
             const constraint = new semver.Range(`~${match[1]}`)
-            found = {...entry, constraint, shebang: [arg0] }
+            found.push({...entry, constraint, shebang: [arg0] })
           }
         }
       }
     }).swallow(PantryError)
+
     promises.push(p)
 
     if (opts.providers) {
       const pp = pantry.project(entry).provider().then(f => {
         if (!f) return
         const rv = f(arg0)
-        if (rv) found = {
+        if (rv) found.push({
           ...entry,
           constraint: new semver.Range('*'),
           shebang: [...rv, arg0]
-        }
+        })
       })
       promises.push(pp)
     }
   }
 
-  if (!found) {
-    // if we didn’t find anything yet then we have to wait on the promises
-    // otherwise we can ignore them
-    await Promise.all(promises)
-  }
+  // if we didn’t find anything yet then we have to wait on the promises
+  // otherwise we can ignore them
+  await Promise.all(promises)
 
-  if (found) {
-    return found
+  for (const f of found) {
+    yield f
   }
 }