add which so run("node^16") works (#16)

Author: mxcl

README.md

@@ -74,11 +74,7 @@ Need a specific version of something? [tea][tea/cli] can install any version
 of any package:
 
 ```ts
-const { install, run } = porcelain;
-
-const node16 = await install("nodejs.org^16.18");  // ※ https://devhints.io/semver
-
-await run(['node', '-e', 'console.log(process.version)']);
+await run("node^16 -e 'console.log(process.version)'");
 // => v16.18.1
 ```
 

mod.ts

@@ -19,6 +19,7 @@ import useDownload from "./src/hooks/useDownload.ts"
 import useShellEnv from "./src/hooks/useShellEnv.ts"
 import useInventory from "./src/hooks/useInventory.ts"
 import hydrate from "./src/plumbing/hydrate.ts"
+import which from "./src/plumbing/which.ts"
 import link from "./src/plumbing/link.ts"
 import install, { ConsoleLogger } from "./src/plumbing/install.ts"
 import resolve from "./src/plumbing/resolve.ts"
@@ -49,7 +50,8 @@ const plumbing = {
   hydrate,
   link,
   install,
-  resolve
+  resolve,
+  which
 }
 
 const porcelain = {

src/plumbing/which.ts

@@ -0,0 +1,83 @@
+import { PackageRequirement } from "../types.ts"
+import usePantry from "../hooks/usePantry.ts"
+import * as semver from "../utils/semver.ts"
+
+export type WhichResult = PackageRequirement & {
+  shebang: string[]
+}
+
+export default async function(arg0: string, opts = { providers: true }): Promise<WhichResult | undefined> {
+  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
+  const promises: Promise<void>[] = []
+
+  for await (const entry of pantry.ls()) {
+    if (found) break
+    const p = pantry.project(entry).provides().then(providers => {
+      for (const provider of providers) {
+        if (found) {
+          return
+        } else if (provider == arg0) {
+          const constraint = new semver.Range("*")
+          found = {...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] }
+          } catch {
+            // not a valid semver range; fallthrough
+          }
+        } else {
+          //TODO more efficient to check the prefix fits arg0 first
+          // eg. if python3 then check if the provides starts with python before
+          // doing all the regex shit. Matters because there's a *lot* of YAMLs
+
+          let rx = /({{\s*version\.(marketing|major)\s*}})/
+          let match = provider.match(rx)
+          if (!match?.index) continue
+          const regx = match[2] == 'major' ? '\\d+' : '\\d+\\.\\d+'
+          const foo = subst(match.index, match.index + match[1].length, provider, `(${regx})`)
+          rx = new RegExp(`^${foo}$`)
+          match = arg0.match(rx)
+          if (match) {
+            const constraint = new semver.Range(`~${match[1]}`)
+            found = {...entry, constraint, shebang: [arg0] }
+          }
+        }
+      }
+    }).swallow(/^parser: pantry: package.yml/)
+    promises.push(p)
+
+    if (opts.providers) {
+      const pp = pantry.project(entry).provider().then(f => {
+        if (!f) return
+        const rv = f(arg0)
+        if (rv) found = {
+          ...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 (found) {
+    return found
+  }
+}
+
+const subst = function(start: number, end: number, input: string, what: string) {
+  return input.substring(0, start) + what + input.substring(end)
+}

src/porcelain/install.ts

@@ -1,12 +1,12 @@
-import { Installation, PackageSpecification } from "../types.ts"
 import install, { Logger as InstallLogger } from "../plumbing/install.ts"
+import { Installation, PackageSpecification } from "../types.ts"
+import resolve, { Resolution } from "../plumbing/resolve.ts"
 import usePantry from "../hooks/usePantry.ts"
 import hydrate from "../plumbing/hydrate.ts"
-import resolve, { Resolution } from "../plumbing/resolve.ts"
-import { isArray, isString } from "is-what"
+import useSync from "../hooks/useSync.ts"
 import { parse } from "../utils/pkg.ts"
 import link from "../plumbing/link.ts"
-import useSync from "../hooks/useSync.ts";
+import { isString } from "is-what"
 
 export interface Logger extends InstallLogger {
   resolved?(resolution: Resolution): void
@@ -15,7 +15,7 @@ export interface Logger extends InstallLogger {
 /// eg. install("python.org~3.10")
 export default async function(pkgs: PackageSpecification[] | string[] | string, logger?: Logger): Promise<Installation[]> {
 
-  if (!isArray(pkgs)) pkgs = [pkgs]
+  if (isString(pkgs)) pkgs = pkgs.split(/\s+/)
   pkgs = pkgs.map(pkg => isString(pkg) ? parse(pkg) : pkg)
 
   const pantry = usePantry()

src/porcelain/run.test.ts

@@ -1,4 +1,4 @@
-import { assertEquals, assertRejects } from "deno/testing/asserts.ts"
+import { assertEquals, assertMatch, assertRejects } from "deno/testing/asserts.ts"
 import { useTestConfig } from "../hooks/useTestConfig.ts"
 import run from "./run.ts"
 
@@ -11,6 +11,19 @@ Deno.test("porcelain.run", async runner => {
     assertEquals(status, 0)
   })
 
+  await runner.step("node^16", async runner => {
+    useTestConfig()
+    await runner.step("string", async () => {
+      const { stdout } = await run('node^16 --version', { stdout: true })
+      assertMatch(stdout, /^v16\./)
+    })
+
+    await runner.step("array", async () => {
+      const { stdout } = await run(['node^16', '--version'], { stdout: true })
+      assertMatch(stdout, /^v16\./)
+    })
+  })
+
   await runner.step("env", async () => {
     useTestConfig()
     await run(['node', '-e', 'if (process.env.FOO !== "FOO") throw new Error()'], { env: { FOO: "FOO" }})

src/porcelain/run.ts

@@ -1,11 +1,11 @@
 import install, { Logger } from "../plumbing/install.ts"
 import useShellEnv from '../hooks/useShellEnv.ts'
 import usePantry from '../hooks/usePantry.ts'
-import * as semver from "../utils/semver.ts"
 import hydrate from "../plumbing/hydrate.ts"
 import resolve from "../plumbing/resolve.ts"
 import { spawn } from "node:child_process"
 import useSync from "../hooks/useSync.ts"
+import which from "../plumbing/which.ts"
 import link from "../plumbing/link.ts"
 import Path from "../utils/Path.ts"
 import { isArray } from "is-what"
@@ -34,24 +34,33 @@ export default async function run(cmd: Cmd, opts: {stdout: true, status: true} &
 export default async function run(cmd: Cmd, opts: {stderr: true, status: true} & OptsEx): Promise<{ stderr: string, status: number }>;
 export default async function run(cmd: Cmd, opts: {stdout: true, stderr: true, status: true } & OptsEx): Promise<{ stdout: string, stderr: string, status: number }>;
 export default async function run(cmd: Cmd, opts?: Options): Promise<void|{ stdout?: string|undefined; stderr?: string|undefined; status?: number|undefined; }> {
-  const [arg0, [spawn0, args]] = (() => {
-    if (isArray(cmd)) {
-      if (cmd.length == 0) {
-        throw new RunError('EUSAGE', `\`cmd\` evaluated empty: ${cmd}`)
-      }
-      const arg0 = cmd.shift()!.toString()
-      return [arg0, [arg0, cmd.map(x => x.toString())]]
-    } else {
+
+  const { usesh, arg0: whom } = (() => {
+    if (!isArray(cmd)) {
       const s = cmd.trim()
       const i = s.indexOf(' ')
-      return [s.slice(0, i), ['/bin/sh', ['-c', cmd]]]
+      const usesh = i >= 0
+      const arg0 = s.slice(0, i)
+      cmd = s.slice(i + 1)
+      return { usesh, arg0 }
+    } else if (cmd.length == 0) {
+      throw new RunError('EUSAGE', `\`cmd\` evaluated empty: ${cmd}`)
+    } else {
+      return {
+        usesh: false,
+        arg0: cmd.shift()!.toString().trim()
+      }
     }
   })()
 
-  const env = await setup(arg0, opts?.env ?? Deno.env.toObject(), opts?.logger)
+  const { env, shebang } = await setup(whom, opts?.env ?? Deno.env.toObject(), opts?.logger)
+  const arg0 = usesh ? '/bin/sh' : shebang.shift()!
+  const args = usesh
+    ? ['-c', `${shebang.join(' ')} ${cmd}`]
+    : [...shebang, ...(cmd as (string | Path)[]).map(x => x.toString())]
 
   return new Promise((resolve, reject) => {
-    const proc = spawn(spawn0, args, {
+    const proc = spawn(arg0, args, {
       env,
       stdio: [
         "pipe",
@@ -84,18 +93,10 @@ async function setup(cmd: string, env: Record<string, string | undefined>, logge
     await useSync()
   }
 
-  const project = await (async () => {
-    for await (const { project } of pantry.ls()) {
-      const provides = await pantry.project(project).provides()
-      //TODO handle eg. node^16 here
-      if (provides.includes(cmd)) {
-        return project
-      }
-    }
-    throw new RunError('ENOENT', `No project in pantry provides ${cmd}`)
-  })()
+  const wut = await which(cmd)
+  if (!wut) throw new RunError('ENOENT', `No project in pantry provides ${cmd}`)
 
-  const { pkgs } = await hydrate({ project, constraint: new semver.Range('*') })
+  const { pkgs } = await hydrate(wut)
   const { pending, installed } = await resolve(pkgs)
   for (const pkg of pending) {
     const installation = await install(pkg, logger)
@@ -115,7 +116,7 @@ async function setup(cmd: string, env: Record<string, string | undefined>, logge
     }
   }
 
-  return sh.flatten(pkgenv)
+  return { env: sh.flatten(pkgenv), shebang: wut.shebang }
 }