core: Build _GO_PLUGINS_PATHS up, not down

I realized that the previous way `_GO_PLUGINS_PATHS` was getting built
would allow nested plugin paths to leak up into the environment of
plugins closer to the `_GO_PLUGINS_DIR` root. After considering how to
filter `_GO_PLUGINS_PATHS`, I realized the best solution was to build it
by walking up the directory tree whenever a plugin is executed.

Ironically, this is similar to another commit I'm working on in another
branch to find plugin files (specifically plugin modules, though the
mechanism is generic) in a similar fashion.

Author: mbland

go-core.bash

@@ -259,7 +259,7 @@ declare _GO_INJECT_MODULE_PATH="$_GO_INJECT_MODULE_PATH"
     return 1
   fi
 
-  if [[ "$__go_cmd_path" =~ ^$_GO_SCRIPTS_DIR/plugins ]]; then
+  if [[ "$__go_cmd_path" =~ ^$_GO_PLUGINS_DIR/ ]]; then
     _@go.run_plugin_command_script "$__go_cmd_path" "${__go_argv[@]}"
   else
     _@go.run_command_script "$__go_cmd_path" "${__go_argv[@]}"
@@ -275,8 +275,24 @@ _@go.source_builtin() {
 _@go.run_plugin_command_script() {
   local _GO_SCRIPTS_DIR="${__go_cmd_path%/*}"
   local _GO_ROOTDIR="${_GO_SCRIPTS_DIR%/*}"
-  local _GO_PLUGINS_PATHS=("${_GO_PLUGINS_PATHS[@]}")
   local _GO_SEARCH_PATHS=()
+  local _GO_PLUGINS_PATHS=()
+  local plugins_dir="$_GO_SCRIPTS_DIR/plugins"
+  local plugin_paths=()
+
+  # A plugin's own local plugin paths will appear before inherited ones. If
+  # there is a version incompatibility issue with other installed plugins, this
+  # allows a plugin's preferred version to take precedence.
+  while true; do
+    plugin_paths=("$plugins_dir"/*/bin)
+    if [[ "${plugin_paths[0]}" != "$plugins_dir/*/bin" ]]; then
+      _GO_PLUGINS_PATHS+=("${plugin_paths[@]}")
+    fi
+    if [[ "$plugins_dir" == "$_GO_PLUGINS_DIR" ]]; then
+      break
+    fi
+    plugins_dir="${plugins_dir%/plugins/*}/plugins"
+  done
 
   _@go.set_search_paths
   _@go.run_command_script "$__go_cmd_path" "${__go_argv[@]}"

lib/internal/path

@@ -1,21 +1,13 @@
 #! /bin/bash
 
 _@go.set_search_paths() {
-  local plugins_paths=("$_GO_SCRIPTS_DIR"/plugins/*/bin)
   local plugin_path
 
   if [[ -n "$_GO_INJECT_SEARCH_PATH" ]]; then
     _GO_SEARCH_PATHS+=("$_GO_INJECT_SEARCH_PATH")
   fi
   _GO_SEARCH_PATHS+=("$_GO_CORE_DIR/libexec" "$_GO_SCRIPTS_DIR")
 
-  # A plugin's own local plugin paths will appear before inherited ones. If
-  # there is a version incompatibility issue with other installed plugins, this
-  # allows a plugin's preferred version to take precedence.
-  if [[ "${plugins_paths[0]}" != "$_GO_SCRIPTS_DIR/plugins/*/bin" ]]; then
-    _GO_PLUGINS_PATHS=("${plugins_paths[@]}" "${_GO_PLUGINS_PATHS[@]}")
-  fi
-
   # A plugin's _GO_SCRIPTS_DIR may continue to appear in _GO_PLUGINS_PATHS so
   # that it's available to other plugins that depend upon it as a circular
   # dependency (though such dependencies are strongly discouraged). However, we
@@ -28,8 +20,13 @@ _@go.set_search_paths() {
 }
 
 if [[ "${#_GO_SEARCH_PATHS[@]}" -eq 0 ]]; then
-  _@go.set_search_paths
   _GO_PLUGINS_DIR="$_GO_SCRIPTS_DIR/plugins"
+  _GO_PLUGINS_PATHS=("$_GO_PLUGINS_DIR"/*/bin)
+
+  if [[ "${_GO_PLUGINS_PATHS[0]}" == "$_GO_PLUGINS_DIR/*/bin" ]]; then
+    unset '_GO_PLUGINS_PATHS[0]'
+  fi
+  _@go.set_search_paths
 fi
 
 _@go.list_available_commands() {

tests/core/plugin-scope-execution.bats

@@ -140,3 +140,15 @@ teardown() {
   run "$TEST_GO_SCRIPT" 'foo'
   assert_success "$TEST_GO_SCRIPTS_DIR/plugins/baz/bin/baz"
 }
+
+@test "$SUITE: nested plugins dir doesn't leak to sibling plugin" {
+  @go.create_test_command_script 'plugins/foo/bin/foo' '@go bar'
+  @go.create_test_command_script 'plugins/foo/bin/plugins/bar/bin/bar' '@go baz'
+  @go.create_test_command_script 'plugins/foo/bin/plugins/quux/bin/quux' \
+    "$PRINT_SOURCE"
+  @go.create_test_command_script 'plugins/baz/bin/baz' '@go quux'
+
+  run "$TEST_GO_SCRIPT" 'foo'
+  assert_failure
+  assert_line_equals 0 'Unknown command: quux'
+}

tests/core/plugin-scope-variable-values.bats

@@ -25,14 +25,16 @@ setup() {
     'printf "TOP LEVEL SCOPE:\n"' \
     "${print_scope_implementation[@]}"
   @go.create_test_command_script 'plugins/first/bin/first' \
-    'printf "FIRST LEVEL PLUGIN SCOPE:\n"' \
+    'printf "FIRST PLUGIN SCOPE:\n"' \
     "${print_scope_implementation[@]}"
+
+  # This script will execute one of the other plugins based on its argument.
   @go.create_test_command_script 'plugins/second/bin/second' \
-    "@go third" \
-    'printf "FIRST LEVEL PLUGIN SCOPE:\n"' \
+    '@go "$1"' \
+    'printf "SECOND PLUGIN SCOPE:\n"' \
     "${print_scope_implementation[@]}"
   @go.create_test_command_script 'plugins/second/bin/plugins/third/bin/third' \
-    'printf "SECOND LEVEL PLUGIN SCOPE:\n"' \
+    'printf "THIRD PLUGIN SCOPE:\n"' \
     "${print_scope_implementation[@]}"
 
   EXPECTED_ROOT_SCOPE_PLUGINS_PATHS=("$TEST_GO_PLUGINS_DIR/first/bin"
@@ -96,7 +98,7 @@ assert_scope_values_equal() {
   # common plugin in the top-level _GO_PLUGINS_DIR. The plugin's _GO_SCRIPTS_DIR
   # will still appear in _GO_PLUGINS_PATHS, but won't be duplicated in
   # _GO_SEARCH_PATHS.
-  assert_scope_values_equal 'FIRST LEVEL PLUGIN' \
+  assert_scope_values_equal 'FIRST PLUGIN' \
     '_GO_ROOTDIR:' \
     "$TEST_GO_PLUGINS_DIR/first" \
     '_GO_SCRIPTS_DIR:' \
@@ -112,8 +114,8 @@ assert_scope_values_equal() {
   assert_scope_values_equal 'ROOT LEVEL' "${EXPECTED_ROOT_SCOPE_VALUES[@]}"
 }
 
-@test "$SUITE: second-level plugin script" {
-  run "$TEST_GO_SCRIPT" second
+@test "$SUITE: first-level plugin script invoking own second-level plugin" {
+  run "$TEST_GO_SCRIPT" second third
   assert_success
 
   # As with the previous test case, _GO_PLUGINS_PATHS is inherited, and the
@@ -123,7 +125,7 @@ assert_scope_values_equal() {
   # Its parent's _GO_SCRIPTS_DIR is in both _GO_PLUGINS_PATHS and
   # _GO_SEARCH_PATHS, since its parent is also a plugin. This could support a
   # circular dependency, though such dependencies are strongly discouraged.
-  assert_scope_values_equal 'SECOND LEVEL PLUGIN' \
+  assert_scope_values_equal 'THIRD PLUGIN' \
     '_GO_ROOTDIR:' \
     "$TEST_GO_PLUGINS_DIR/second/bin/plugins/third" \
     '_GO_SCRIPTS_DIR:' \
@@ -141,7 +143,45 @@ assert_scope_values_equal() {
   # The first level plugin's own plugin paths will appear before any inherited
   # _GO_PLUGINS_PATHS, to support a plugin's own installed plugin version to
   # take precedence over other installed versions.
-  assert_scope_values_equal 'FIRST LEVEL PLUGIN' \
+  assert_scope_values_equal 'SECOND PLUGIN' \
+    '_GO_ROOTDIR:' \
+    "$TEST_GO_PLUGINS_DIR/second" \
+    '_GO_SCRIPTS_DIR:' \
+    "$TEST_GO_PLUGINS_DIR/second/bin" \
+    '_GO_PLUGINS_PATHS:' \
+    "$TEST_GO_PLUGINS_DIR/second/bin/plugins/third/bin" \
+    "$TEST_GO_PLUGINS_DIR/first/bin" \
+    "$TEST_GO_PLUGINS_DIR/second/bin" \
+    '_GO_SEARCH_PATHS:' \
+    "$_GO_CORE_DIR/libexec" \
+    "$TEST_GO_PLUGINS_DIR/second/bin" \
+    "$TEST_GO_PLUGINS_DIR/second/bin/plugins/third/bin" \
+    "$TEST_GO_PLUGINS_DIR/first/bin"
+
+  assert_scope_values_equal 'ROOT LEVEL' "${EXPECTED_ROOT_SCOPE_VALUES[@]}"
+}
+
+@test "$SUITE: first-level plugin script invoking sibling first-level plugin" {
+  run "$TEST_GO_SCRIPT" second first
+  assert_success
+
+  # Since `second` is invoking its sibling `first`, its plugin directory
+  # shouldn't leak into the environment of `first`.
+  assert_scope_values_equal 'FIRST PLUGIN' \
+    '_GO_ROOTDIR:' \
+    "$TEST_GO_PLUGINS_DIR/first" \
+    '_GO_SCRIPTS_DIR:' \
+    "$TEST_GO_PLUGINS_DIR/first/bin" \
+    '_GO_PLUGINS_PATHS:' \
+    "$TEST_GO_PLUGINS_DIR/first/bin" \
+    "$TEST_GO_PLUGINS_DIR/second/bin" \
+    '_GO_SEARCH_PATHS:' \
+    "$_GO_CORE_DIR/libexec" \
+    "$TEST_GO_PLUGINS_DIR/first/bin" \
+    "$TEST_GO_PLUGINS_DIR/second/bin"
+
+  # `second`'s plugin environment should be the same as it ever was.
+  assert_scope_values_equal 'SECOND PLUGIN' \
     '_GO_ROOTDIR:' \
     "$TEST_GO_PLUGINS_DIR/second" \
     '_GO_SCRIPTS_DIR:' \