Merge branch 'main' of github.com:quarto-dev/quarto-cli into main

Author: jjallaire

src/command/command.ts

@@ -22,6 +22,7 @@ import { buildJsCommand } from "./build-js/cmd.ts";
 import { installCommand } from "./install/cmd.ts";
 import { publishCommand } from "./publish/cmd.ts";
 import { removeCommand } from "./remove/cmd.ts";
+import { listCommand } from "./list/cmd.ts";
 
 // deno-lint-ignore no-explicit-any
 export function commands(): Command<any>[] {
@@ -35,6 +36,7 @@ export function commands(): Command<any>[] {
     runCommand,
     installCommand,
     removeCommand,
+    listCommand,
     publishCommand,
     capabilitiesCommand,
     inspectCommand,

src/command/install/cmd.ts

@@ -5,44 +5,35 @@
 *
 */
 import { Command } from "cliffy/command/mod.ts";
-import { Select } from "cliffy/prompt/select.ts";
 import { initYamlIntelligenceResourcesFromFilesystem } from "../../core/schema/utils.ts";
 import { createTempContext } from "../../core/temp.ts";
 import { installExtension } from "../../extension/install.ts";
-import {
-  allTools,
-  installableTool,
-  installableTools,
-  installTool,
-  toolSummary,
-} from "../tools/tools.ts";
+import { installTool } from "../tools/tools.ts";
 
 import { info } from "log/mod.ts";
-import { withSpinner } from "../../core/console.ts";
-import { InstallableTool } from "../tools/types.ts";
+import { loadTools, selectTool } from "../remove/tools-console.ts";
 
 export const installCommand = new Command()
   .hidden()
   .name("install")
-  .arguments("[target:string]")
   .arguments("<type:string> [target:string]")
   .option(
     "--no-prompt",
-    "Do not prompt to confirm actions during installation",
+    "Do not prompt to confirm actions",
   )
   .description(
     "Installs an extension or global dependency.",
   )
   .example(
-    "Install extension from Github",
-    "quarto install extension <gh-organization>/<gh-repo>",
+    "Install extension (Github)",
+    "quarto install extension <gh-org>/<gh-repo>",
   )
   .example(
-    "Install extension from file",
-    "quarto install extension tools/my-extension.tar.gz",
+    "Install extension (file)",
+    "quarto install extension <path-to-zip>",
   )
   .example(
-    "Install extension from url",
+    "Install extension (url)",
     "quarto install extension <url>",
   )
   .example(
@@ -53,6 +44,10 @@ export const installCommand = new Command()
     "Install Chromium",
     "quarto install tool chromium",
   )
+  .example(
+    "Choose tool to install",
+    "quarto install tool",
+  )
   .action(
     async (options: { prompt?: boolean }, type: string, target?: string) => {
       await initYamlIntelligenceResourcesFromFilesystem();
@@ -71,37 +66,15 @@ export const installCommand = new Command()
             // Use the tool name
             await installTool(target);
           } else {
-            // Present a list of tools
-            const toolsToInstall = await notInstalledTools();
-            if (toolsToInstall.length === 0) {
-              info("All tools already installed.");
-              const summaries = [];
-              for (const tool of installableTools()) {
-                const summary = await toolSummary(tool);
-                summaries.push(summary);
-              }
+            // Not provided, give the user a list to choose from
+            const allTools = await loadTools();
+            if (allTools.filter((tool) => !tool.installed).length === 0) {
+              info("All tools are already installed.");
             } else {
-              const toolsWithSummary = [];
-              for (const tool of toolsToInstall) {
-                const summary = await toolSummary(tool.name);
-                toolsWithSummary.push({ tool, summary });
-              }
-
-              const toolTarget: string = await Select.prompt({
-                message: "Select a tool to install",
-                options: toolsWithSummary.map((toolWithSummary) => {
-                  return {
-                    name: `${toolWithSummary.tool.name}${
-                      toolWithSummary.summary?.latestRelease.version
-                        ? " (" +
-                          toolWithSummary.summary?.latestRelease.version + ")"
-                        : ""
-                    }`,
-                    value: toolWithSummary.tool.name,
-                  };
-                }),
-              });
+              // Select which tool should be installed
+              const toolTarget = await selectTool(allTools, "install");
               if (toolTarget) {
+                info("");
                 await installTool(toolTarget);
               }
             }
@@ -117,12 +90,3 @@ export const installCommand = new Command()
       }
     },
   );
-
-async function notInstalledTools() {
-  const toolsToInstall: InstallableTool[] = [];
-  await withSpinner({ message: "Inspecting tools" }, async () => {
-    const all = await allTools();
-    toolsToInstall.push(...all.notInstalled);
-  });
-  return toolsToInstall;
-}

src/command/list/cmd.ts

@@ -0,0 +1,105 @@
+/*
+* cmd.ts
+*
+* Copyright (C) 2021 by RStudio, PBC
+*
+*/
+import { Command } from "cliffy/command/mod.ts";
+import { Table } from "cliffy/table/mod.ts";
+import { initYamlIntelligenceResourcesFromFilesystem } from "../../core/schema/utils.ts";
+import { createTempContext } from "../../core/temp.ts";
+
+import { info } from "log/mod.ts";
+import { outputTools } from "../remove/tools-console.ts";
+import { createExtensionContext } from "../../extension/extension.ts";
+import {
+  Extension,
+  ExtensionContext,
+  extensionIdString,
+} from "../../extension/extension-shared.ts";
+import { projectContext } from "../../project/project-context.ts";
+
+export const listCommand = new Command()
+  .hidden()
+  .name("list")
+  .arguments("<type:string>")
+  .description(
+    "Lists an extension or global dependency.",
+  )
+  .example(
+    "List installed extensions",
+    "quarto list extensions",
+  )
+  .example(
+    "List global tools",
+    "quarto list tools",
+  )
+  .action(
+    async (_options: unknown, type: string) => {
+      await initYamlIntelligenceResourcesFromFilesystem();
+      const temp = createTempContext();
+      const extensionContext = createExtensionContext();
+      try {
+        if (type.toLowerCase() === "extensions") {
+          await outputExtensions(Deno.cwd(), extensionContext);
+        } else if (type.toLowerCase() === "tools") {
+          await outputTools();
+        } else {
+          // This is an unrecognized type option
+          info(
+            `Unrecognized option '${type}' - please choose 'tools' or 'extensions'.`,
+          );
+        }
+      } finally {
+        temp.cleanup();
+      }
+    },
+  );
+
+async function outputExtensions(
+  path: string,
+  extensionContext: ExtensionContext,
+) {
+  // Provide the with with a list
+  const project = await projectContext(path);
+  const extensions = extensionContext.extensions(path, project);
+
+  const extensionEntries: string[][] = [];
+
+  const provides = (extension: Extension) => {
+    const contribs: string[] = [];
+    if (
+      extension.contributes.filters && extension.contributes.filters?.length > 0
+    ) {
+      contribs.push("filter");
+    }
+
+    if (
+      extension.contributes.shortcodes &&
+      extension.contributes.shortcodes?.length > 0
+    ) {
+      contribs.push("shortcodes");
+    }
+
+    if (
+      extension.contributes.format
+    ) {
+      contribs.push("formats");
+    }
+    return contribs.join(", ");
+  };
+
+  extensions.forEach((ext) => {
+    const row = [
+      extensionIdString(ext.id),
+      ext.version?.toString() || "(none)",
+      `[${provides(ext)}]`,
+    ];
+    extensionEntries.push(row);
+  });
+
+  const table = new Table().header(["Id", "Version", "Type"]).body(
+    extensionEntries,
+  ).padding(4);
+  info(table.toString());
+}