fix: user-installed plugins cannot always REPL.qexec other plugins

Fixes #2963

Author: starpit

.eslintignore

@@ -9,6 +9,7 @@ packages/core/index.js
 packages/core/api/
 packages/core/dist/
 packages/core/core/
+packages/core/commands/
 packages/core/main/
 packages/core/models/
 packages/core/plugins/
@@ -21,3 +22,5 @@ plugins/*/dist/
 **/*/node_modules/
 **/*.d.ts
 plugins/plugin-apache-composer/tests/data/composer/composer-source-expect-errors/if-bad.js
+kui-stage
+*flycheck*.js

packages/core/.gitignore

@@ -2,6 +2,7 @@ build
 dist
 /api/
 /core/
+/commands/
 /main/
 /models/
 /plugins/

packages/core/src/api/commands.ts

@@ -28,6 +28,7 @@ import * as Plugins from '../models/plugin'
 import * as Entity from '../models/entity'
 import * as Sidecar from '../webapp/views/sidecar'
 import { optionsToString } from '@kui-shell/core/core/utility'
+import * as Context from '../commands/context'
 
 export namespace Commands {
   export import Arguments = _Commands.EvaluatorArgs
@@ -39,6 +40,8 @@ export namespace Commands {
   export import ExecOptions = _ExecOptions.ExecOptions
   export import withLanguage = _ExecOptions.withLanguage
 
+  export import getCurrentContext = Context.getCurrentContext
+
   export import ExecType = _Commands.ExecType
   export import Registrar = _Commands.CommandRegistrar
   export import ParsedOptions = _Commands.ParsedOptions

packages/core/src/commands/context.ts

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2017-19 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { theme } from '../core/settings'
+
+/**
+ * Parse a serialized command context
+ *
+ */
+function parseCommandContext(str: string): string[] {
+  if (str) {
+    try {
+      // let's assume str is of the form '["a", "b"]'
+      return JSON.parse(str)
+    } catch (err1) {
+      // ok, that didn't work; let's see if it's of the form '/a/b'
+      try {
+        return str.split('/').filter(_ => _)
+      } catch (err2) {
+        console.error(`Could not parse command context ${str}`, err1, err2)
+      }
+    }
+  }
+  return undefined
+}
+
+/**
+ * The default command execution context. For example, if the
+ * execution context is /foo/bar, and there is a command /foo/bar/baz,
+ * then the issuance of a command "baz" will resolve to /foo/bar/baz.
+ *
+ * The default can be overridden either by changing the next line, or
+ * by calling `setDefaultCommandContext`.
+ *
+ */
+let _defaultContext: string[] =
+  (theme && theme.defaultContext) || parseCommandContext(process.env.KUI_COMMAND_CONTEXT) || []
+
+/**
+ * The command context model, defaulting to the _defaultContext, which
+ * can be overridden via `setDefaultCommandContext`.
+ *
+ */
+export const Context = {
+  current: _defaultContext
+}
+
+/**
+ * When commands are executed, the command resolver will use a
+ * fallback prefix. This routine tries to discover, from the
+ * environment, what the default fallback prefix should be.
+ *
+ */
+export const setDefaultCommandContext = (commandContext: string[]) => {
+  Context.current = _defaultContext = commandContext
+}
+
+export function getCurrentContext() {
+  return Context.current
+}

packages/core/src/commands/resolution.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2017-19 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CommandHandlerWithEvents, CommandTreeResolution } from '../models/command'
+
+/**
+ * A call to `read` may or may not have successfully resolved the
+ * given `argv.` This method clarifies the situation.
+ *
+ */
+export function isSuccessfulCommandResolution(
+  resolution: CommandTreeResolution
+): resolution is CommandHandlerWithEvents {
+  return (resolution as CommandHandlerWithEvents).eval !== undefined
+}

packages/core/src/commands/tree.ts

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2017-19 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CatchAllHandler, Command, CommandTree, CommandTreeResolution, Disambiguator } from '../models/command'
+
+import { ExecOptions } from '../models/execOptions'
+
+/**
+ * The exported interface around the internal command model
+ * implementation.
+ *
+ */
+interface CommandModel {
+  catchalls: CatchAllHandler[]
+
+  /**
+   * Look up a command handler for the given `argv`. This is the main
+   * Read part of a REPL.
+   *
+   */
+  read(argv: string[], execOptions: ExecOptions): Promise<CommandTreeResolution>
+
+  /**
+   * Call the given callback function `fn` for each node in the command tree
+   *
+   */
+  forEachNode(fn: (command: Command) => void): void
+}
+
+/**
+ * The internal implementation of the command tree
+ *
+ */
+export class CommandModelImpl implements CommandModel {
+  /** root of the tree model */
+  private readonly _root: CommandTree = this.newTree()
+  public get root(): CommandTree {
+    return this._root
+  }
+
+  /** map from command name to disambiguations */
+  private readonly _disambiguator: Disambiguator = {}
+  public get disambiguator(): Disambiguator {
+    return this._disambiguator
+  }
+
+  /** handlers for command not found */
+  private readonly _catchalls: CatchAllHandler[] = []
+  public get catchalls(): CatchAllHandler[] {
+    return this._catchalls
+  }
+
+  /**
+   * Look up a command handler for the given `argv`. This is the main
+   * Read part of a REPL.
+   *
+   */
+  public async read(argv: string[], execOptions: ExecOptions): Promise<CommandTreeResolution> {
+    const { read: readImpl } = await import('../core/command-tree')
+    return readImpl(this.root, argv, undefined, undefined, execOptions)
+  }
+
+  /**
+   * Call the given callback function `fn` for each node in the command tree
+   *
+   */
+  public forEachNode(fn: (command: Command) => void) {
+    const iter = (root: Command) => {
+      if (root) {
+        fn(root)
+        if (root.children) {
+          for (const cmd in root.children) {
+            iter(root.children[cmd])
+          }
+        }
+      }
+    }
+
+    iter(this.root)
+  }
+
+  private newTree(): CommandTree {
+    return {
+      $: undefined,
+      key: '/',
+      route: '/',
+      children: {},
+      parent: undefined
+    }
+  }
+}
+
+interface WindowWithModel extends Window {
+  _kuiCommandModel: CommandModelImpl
+}
+
+function isWindowWithModel(win: Window): win is WindowWithModel {
+  return win && (win as WindowWithModel)._kuiCommandModel !== undefined
+}
+
+/**
+ * Global state representing the current tree of registered commands
+ *
+ */
+let theCommandModel: CommandModelImpl
+
+/**
+ * @return the command tree model for internal consumption within this
+ * file
+ *
+ */
+export function getModelInternal(): CommandModelImpl {
+  return (typeof window !== 'undefined' && isWindowWithModel(window) && window._kuiCommandModel) || theCommandModel
+}
+
+/**
+ * @return the command tree model for public consumption within the
+ * rest of @kui-shell/core. For the model we present to plugins, see
+ * `ImplForPlugins` in command-tree.ts
+ *
+ */
+export function getModel(): CommandModel {
+  return getModelInternal()
+}
+
+interface WindowWithModel extends Window {
+  _kuiCommandModel: CommandModelImpl
+}
+
+export function init() {
+  theCommandModel = new CommandModelImpl()
+
+  if (typeof window !== 'undefined') {
+    ;((window as any) as WindowWithModel)._kuiCommandModel = theCommandModel
+  }
+}
+
+export function initIfNeeded() {
+  if (!theCommandModel) {
+    init()
+  }
+}