Merge pull request #96 from asdf-vm/tb/version-improvements-2

feat(golang-rewrite): misc. version improvements part 2

cli/cli.go

@@ -36,6 +36,14 @@ Manage all your runtime versions with one tool!
 
 Complete documentation is available at https://asdf-vm.com/`
 
+const updateCommandRemovedText = `
+Upgrading asdf via asdf update is no longer supported. Please use your OS
+package manager (Homebrew, APT, etc...) to upgrade asdf or download the
+latest asdf binary manually from the asdf website.
+
+Please visit https://asdf-vm.com/ or https://github.com/asdf-vm/asdf for more
+details.`
+
 // Execute defines the full CLI API and then runs it
 func Execute(version string) {
 	logger := log.New(os.Stderr, "", 0)
@@ -263,6 +271,13 @@ func Execute(version string) {
 					return uninstallCommand(logger, tool, version)
 				},
 			},
+			{
+				Name: "update",
+				Action: func(_ *cli.Context) error {
+					fmt.Println(updateCommandRemovedText)
+					return errors.New("command removed")
+				},
+			},
 			{
 				Name: "where",
 				Action: func(cCtx *cli.Context) error {
@@ -647,7 +662,7 @@ func pluginAddCommand(_ *cli.Context, conf config.Config, logger *log.Logger, pl
 		return cli.Exit("usage: asdf plugin add <name> [<git-url>]", 1)
 	}
 
-	err := plugins.Add(conf, pluginName, pluginRepo)
+	err := plugins.Add(conf, pluginName, pluginRepo, "")
 	if err != nil {
 		logger.Printf("%s", err)
 
@@ -853,19 +868,20 @@ func pluginUpdateCommand(cCtx *cli.Context, logger *log.Logger, pluginName, ref
 		}
 
 		for _, plugin := range installedPlugins {
-			updatedToRef, err := plugins.Update(conf, plugin.Name, "")
+			updatedToRef, err := plugin.Update(conf, "", os.Stdout, os.Stderr)
 			formatUpdateResult(logger, plugin.Name, updatedToRef, err)
 		}
 
 		return nil
 	}
 
-	updatedToRef, err := plugins.Update(conf, pluginName, ref)
+	plugin := plugins.New(conf, pluginName)
+	updatedToRef, err := plugin.Update(conf, ref, os.Stdout, os.Stderr)
 	formatUpdateResult(logger, pluginName, updatedToRef, err)
 	return err
 }
 
-func pluginTestCommand(l *log.Logger, args []string, toolVersion, _ string) {
+func pluginTestCommand(l *log.Logger, args []string, toolVersion, ref string) {
 	conf, err := config.LoadConfig()
 	if err != nil {
 		l.Printf("error loading config: %s", err)
@@ -882,7 +898,7 @@ func pluginTestCommand(l *log.Logger, args []string, toolVersion, _ string) {
 	testName := fmt.Sprintf("asdf-test-%s", name)
 
 	// Install plugin
-	err = plugins.Add(conf, testName, url)
+	err = plugins.Add(conf, testName, url, ref)
 	if err != nil {
 		failTest(l, fmt.Sprintf("%s was not properly installed", name))
 	}

cmd/asdf/main_test.go

@@ -63,9 +63,9 @@ func TestBatsTests(t *testing.T) {
 		runBatsFile(t, dir, "plugin_test_command.bats")
 	})
 
-	//t.Run("plugin_update_command", func(t *testing.T) {
+	t.Run("plugin_update_command", func(t *testing.T) {
-	//  runBatsFile(t, dir, "plugin_update_command.bats")
+		runBatsFile(t, dir, "plugin_update_command.bats")
-	//})
+	})
 
 	t.Run("remove_command", func(t *testing.T) {
 		runBatsFile(t, dir, "remove_command.bats")

docs/guide/upgrading-from-v0-14-to-v0-15.md

@@ -28,11 +28,16 @@ versions are supported. The affected commands:
 * `asdf plugin-test` -> `asdf plugin test`
 * `asdf shim-versions` -> `asdf shimversions`
 
-### `asdf global` and `asdf local` commands have been replaced by the `asdf set` command
+### `asdf global` and `asdf local` commands have been removed
 
-`asdf global` and `asdf local` have been replaced by `asdf set`, which aims to
+`asdf global` and `asdf local` have been removed. The "global" and "local"
-provide the same functionality while using terminology that is less likely to
+terminology was wrong and also misleading. asdf doesn't actually support
-mislead the user. TODO: Add more details here
+"global" versions that apply everywhere. Any version that was specified with
+`asdf global` could easily be overridden by a `.tool-versions` file in your
+current directory specifying a different version. This was confusing to users.
+The plan is to introduce an `asdf set` command in the near future that better
+conveys how asdf works and provides similar functionality to `asdf global` and
+`asdf local`.
 
 ### `asdf update` command has been removed
 

internal/git/git.go

@@ -20,10 +20,10 @@ const DefaultRemoteName = "origin"
 // and upgrade plugins. If other approaches are supported this will be
 // extracted into the `plugins` module.
 type Repoer interface {
-	Clone(pluginURL string) error
+	Clone(pluginURL, ref string) error
 	Head() (string, error)
 	RemoteURL() (string, error)
-	Update(ref string) (string, error)
+	Update(ref string) (string, string, string, error)
 }
 
 // Repo is a struct to contain the Git repository details
@@ -38,10 +38,17 @@ func NewRepo(directory string) Repo {
 }
 
 // Clone installs a plugin via Git
-func (r Repo) Clone(pluginURL string) error {
+func (r Repo) Clone(pluginURL, ref string) error {
-	_, err := git.PlainClone(r.Directory, false, &git.CloneOptions{
+	options := git.CloneOptions{
 		URL: pluginURL,
-	})
+	}
+
+	// if ref is provided set it on CloneOptions
+	if ref != "" {
+		options.ReferenceName = plumbing.NewBranchReferenceName(ref)
+	}
+
+	_, err := git.PlainClone(r.Directory, false, &options)
 	if err != nil {
 		return fmt.Errorf("unable to clone plugin: %w", err)
 	}
@@ -81,10 +88,15 @@ func (r Repo) RemoteURL() (string, error) {
 
 // Update updates the plugin's Git repository to the ref if provided, or the
 // latest commit on the current branch
-func (r Repo) Update(ref string) (string, error) {
+func (r Repo) Update(ref string) (string, string, string, error) {
 	repo, err := gitOpen(r.Directory)
 	if err != nil {
-		return "", err
+		return "", "", "", err
+	}
+
+	oldHash, err := repo.ResolveRevision(plumbing.Revision("HEAD"))
+	if err != nil {
+		return "", "", "", err
 	}
 
 	var checkoutOptions git.CheckoutOptions
@@ -93,11 +105,11 @@ func (r Repo) Update(ref string) (string, error) {
 		// If no ref is provided checkout latest commit on current branch
 		head, err := repo.Head()
 		if err != nil {
-			return "", err
+			return "", "", "", err
 		}
 
 		if !head.Name().IsBranch() {
-			return "", fmt.Errorf("not on a branch, unable to update")
+			return "", "", "", fmt.Errorf("not on a branch, unable to update")
 		}
 
 		// If on a branch checkout the latest version of it from the remote
@@ -116,21 +128,21 @@ func (r Repo) Update(ref string) (string, error) {
 	err = repo.Fetch(&fetchOptions)
 
 	if err != nil && err != git.NoErrAlreadyUpToDate {
-		return "", err
+		return "", "", "", err
 	}
 
 	worktree, err := repo.Worktree()
 	if err != nil {
-		return "", err
+		return "", "", "", err
 	}
 
 	err = worktree.Checkout(&checkoutOptions)
 	if err != nil {
-		return "", err
+		return "", "", "", err
 	}
 
-	hash, err := repo.ResolveRevision(plumbing.Revision("HEAD"))
+	newHash, err := repo.ResolveRevision(plumbing.Revision("HEAD"))
-	return hash.String(), err
+	return ref, oldHash.String(), newHash.String(), err
 }
 
 func gitOpen(directory string) (*git.Repository, error) {

internal/git/git_test.go

@@ -11,23 +11,50 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestPluginClone(t *testing.T) {
+func TestRepoClone(t *testing.T) {
-	t.Run("when plugin name is valid but URL is invalid prints an error", func(t *testing.T) {
+	t.Run("when repo name is valid but URL is invalid prints an error", func(t *testing.T) {
-		plugin := NewRepo(t.TempDir())
+		repo := NewRepo(t.TempDir())
-		err := plugin.Clone("foobar")
+		err := repo.Clone("foobar", "")
 
 		assert.ErrorContains(t, err, "unable to clone plugin: repository not found")
 	})
 
-	t.Run("clones provided Git URL to plugin directory when URL is valid", func(t *testing.T) {
+	t.Run("clones provided Git URL to repo directory when URL is valid", func(t *testing.T) {
 		repoDir := generateRepo(t)
 		directory := t.TempDir()
-		plugin := NewRepo(directory)
+		repo := NewRepo(directory)
 
-		err := plugin.Clone(repoDir)
+		err := repo.Clone(repoDir, "")
 		assert.Nil(t, err)
 
-		// Assert plugin directory contains Git repo with bin directory
+		// Assert repo directory contains Git repo with bin directory
+		_, err = os.ReadDir(directory + "/.git")
+		assert.Nil(t, err)
+
+		entries, err := os.ReadDir(directory + "/bin")
+		assert.Nil(t, err)
+		assert.Equal(t, 12, len(entries))
+	})
+
+	t.Run("when repo name and URL are valid but ref is invalid prints an error", func(t *testing.T) {
+		repoDir := generateRepo(t)
+		directory := t.TempDir()
+		repo := NewRepo(directory)
+
+		err := repo.Clone(repoDir, "non-existent")
+
+		assert.ErrorContains(t, err, "unable to clone plugin: reference not found")
+	})
+
+	t.Run("clones a provided Git URL and checks out a specific ref when URL is valid and ref is provided", func(t *testing.T) {
+		repoDir := generateRepo(t)
+		directory := t.TempDir()
+		repo := NewRepo(directory)
+
+		err := repo.Clone(repoDir, "master")
+		assert.Nil(t, err)
+
+		// Assert repo directory contains Git repo with bin directory
 		_, err = os.ReadDir(directory + "/.git")
 		assert.Nil(t, err)
 
@@ -37,47 +64,47 @@ func TestPluginClone(t *testing.T) {
 	})
 }
 
-func TestPluginHead(t *testing.T) {
+func TestRepoHead(t *testing.T) {
 	repoDir := generateRepo(t)
 	directory := t.TempDir()
 
-	plugin := NewRepo(directory)
+	repo := NewRepo(directory)
 
-	err := plugin.Clone(repoDir)
+	err := repo.Clone(repoDir, "")
 	assert.Nil(t, err)
 
-	head, err := plugin.Head()
+	head, err := repo.Head()
 	assert.Nil(t, err)
 	assert.NotZero(t, head)
 }
 
-func TestPluginRemoteURL(t *testing.T) {
+func TestRepoRemoteURL(t *testing.T) {
 	repoDir := generateRepo(t)
 	directory := t.TempDir()
 
-	plugin := NewRepo(directory)
+	repo := NewRepo(directory)
 
-	err := plugin.Clone(repoDir)
+	err := repo.Clone(repoDir, "")
 	assert.Nil(t, err)
 
-	url, err := plugin.RemoteURL()
+	url, err := repo.RemoteURL()
 	assert.Nil(t, err)
 	assert.NotZero(t, url)
 }
 
-func TestPluginUpdate(t *testing.T) {
+func TestRepoUpdate(t *testing.T) {
 	repoDir := generateRepo(t)
 	directory := t.TempDir()
 
-	plugin := NewRepo(directory)
+	repo := NewRepo(directory)
 
-	err := plugin.Clone(repoDir)
+	err := repo.Clone(repoDir, "")
 	assert.Nil(t, err)
 
-	t.Run("returns error when plugin with name does not exist", func(t *testing.T) {
+	t.Run("returns error when repo with name does not exist", func(t *testing.T) {
 		nonexistantPath := filepath.Join(directory, "nonexistant")
-		nonexistantPlugin := NewRepo(nonexistantPath)
+		nonexistantRepo := NewRepo(nonexistantPath)
-		updatedToRef, err := nonexistantPlugin.Update("")
+		updatedToRef, _, _, err := nonexistantRepo.Update("")
 
 		assert.NotNil(t, err)
 		assert.Equal(t, updatedToRef, "")
@@ -85,15 +112,15 @@ func TestPluginUpdate(t *testing.T) {
 		assert.ErrorContains(t, err, expectedErrMsg)
 	})
 
-	t.Run("returns error when plugin repo does not exist", func(t *testing.T) {
+	t.Run("returns error when repo repo does not exist", func(t *testing.T) {
-		badPluginName := "badplugin"
+		badRepoName := "badrepo"
-		badPluginDir := filepath.Join(directory, badPluginName)
+		badRepoDir := filepath.Join(directory, badRepoName)
-		err := os.MkdirAll(badPluginDir, 0o777)
+		err := os.MkdirAll(badRepoDir, 0o777)
 		assert.Nil(t, err)
 
-		badPlugin := NewRepo(badPluginDir)
+		badRepo := NewRepo(badRepoDir)
 
-		updatedToRef, err := badPlugin.Update("")
+		updatedToRef, _, _, err := badRepo.Update("")
 
 		assert.NotNil(t, err)
 		assert.Equal(t, updatedToRef, "")
@@ -101,25 +128,25 @@ func TestPluginUpdate(t *testing.T) {
 		assert.ErrorContains(t, err, expectedErrMsg)
 	})
 
-	t.Run("does not return error when plugin is already updated", func(t *testing.T) {
+	t.Run("does not return error when repo is already updated", func(t *testing.T) {
-		// update plugin twice to test already updated case
+		// update repo twice to test already updated case
-		updatedToRef, err := plugin.Update("")
+		updatedToRef, _, _, err := repo.Update("")
 		assert.Nil(t, err)
-		updatedToRef2, err := plugin.Update("")
+		updatedToRef2, _, _, err := repo.Update("")
 		assert.Nil(t, err)
 		assert.Equal(t, updatedToRef, updatedToRef2)
 	})
 
-	t.Run("updates plugin when plugin when plugin exists", func(t *testing.T) {
+	t.Run("updates repo when repo when repo exists", func(t *testing.T) {
 		latestHash, err := getCurrentCommit(directory)
 		assert.Nil(t, err)
 
 		_, err = checkoutPreviousCommit(directory)
 		assert.Nil(t, err)
 
-		updatedToRef, err := plugin.Update("")
+		updatedToRef, _, _, err := repo.Update("")
 		assert.Nil(t, err)
-		assert.Equal(t, latestHash, updatedToRef)
+		assert.Equal(t, "refs/heads/master", updatedToRef)
 
 		currentHash, err := getCurrentCommit(directory)
 		assert.Nil(t, err)
@@ -128,26 +155,27 @@ func TestPluginUpdate(t *testing.T) {
 
 	t.Run("Returns error when specified ref does not exist", func(t *testing.T) {
 		ref := "non-existant"
-		updatedToRef, err := plugin.Update(ref)
+		updatedToRef, _, _, err := repo.Update(ref)
 		assert.Equal(t, updatedToRef, "")
 		expectedErrMsg := "couldn't find remote ref \"non-existant\""
 		assert.ErrorContains(t, err, expectedErrMsg)
 	})
 
-	t.Run("updates plugin to ref when plugin with name and ref exist", func(t *testing.T) {
+	t.Run("updates repo to ref when repo with name and ref exist", func(t *testing.T) {
 		ref := "master"
 
 		hash, err := getCommit(directory, ref)
 		assert.Nil(t, err)
 
-		updatedToRef, err := plugin.Update(ref)
+		updatedToRef, _, newHash, err := repo.Update(ref)
 		assert.Nil(t, err)
-		assert.Equal(t, hash, updatedToRef)
+		assert.Equal(t, "master", updatedToRef)
 
-		// Check that plugin was updated to ref
+		// Check that repo was updated to ref
 		latestHash, err := getCurrentCommit(directory)
 		assert.Nil(t, err)
 		assert.Equal(t, hash, latestHash)
+		assert.Equal(t, newHash, latestHash)
 	})
 }
 

internal/help/help.txt

@@ -18,9 +18,6 @@ asdf current                            Display current version set or being
                                         used for all packages
 asdf current <name>                     Display current version set or being
                                         used for package
-asdf global <name> <version>            Set the package global version
-asdf global <name> latest[:<version>]   Set the package global version to the
-                                        latest provided version
 asdf help <name> [<version>]            Output documentation for plugin and tool
 asdf install                            Install all the package versions listed
                                         in the .tool-versions file
@@ -38,9 +35,6 @@ asdf list <name> [version]              List installed versions of a package and
                                         optionally filter the versions
 asdf list all <name> [<version>]        List all versions of a package and
                                         optionally filter the returned versions
-asdf local <name> <version>             Set the package local version
-asdf local <name> latest[:<version>]    Set the package local version to the
-                                        latest provided version
 asdf shell <name> <version>             Set the package version to
                                         `ASDF_${LANG}_VERSION` in the current shell
 asdf uninstall <name> <version>         Remove a specific version of a package
@@ -58,8 +52,6 @@ asdf version                            Print the currently installed version of
 asdf reshim <name> <version>            Recreate shims for version of a package
 asdf shim-versions <command>            List the plugins and versions that
                                         provide a command
-asdf update                             Update asdf to the latest stable release
-asdf update --head                      Update asdf to the latest on the master branch
 
 RESOURCES
 GitHub: https://github.com/asdf-vm/asdf

internal/pluginindex/pluginindex.go

@@ -77,7 +77,7 @@ func (p PluginIndex) Refresh() (bool, error) {
 
 	if len(files) == 0 {
 		// directory empty, clone down repo
-		err := p.repo.Clone(p.url)
+		err := p.repo.Clone(p.url, "")
 		if err != nil {
 			return false, fmt.Errorf("unable to initialize index: %w", err)
 		}
@@ -104,7 +104,7 @@ func (p PluginIndex) Refresh() (bool, error) {
 func (p PluginIndex) doUpdate() (bool, error) {
 	// pass in empty string as we want the repo to figure out what the latest
 	// commit is
-	_, err := p.repo.Update("")
+	_, _, _, err := p.repo.Update("")
 	if err != nil {
 		return false, fmt.Errorf("unable to update plugin index: %w", err)
 	}

internal/pluginindex/pluginindex_test.go

@@ -31,7 +31,7 @@ type MockIndex struct {
 func (m *MockIndex) Head() (string, error)      { return "", nil }
 func (m *MockIndex) RemoteURL() (string, error) { return "", nil }
 
-func (m *MockIndex) Clone(URL string) error {
+func (m *MockIndex) Clone(URL, _ string) error {
 	m.URL = URL
 
 	if m.URL == badIndexURL {
@@ -46,18 +46,18 @@ func (m *MockIndex) Clone(URL string) error {
 	return nil
 }
 
-func (m *MockIndex) Update(_ string) (string, error) {
+func (m *MockIndex) Update(_ string) (string, string, string, error) {
 	if m.URL == badIndexURL {
-		return "", errors.New("unable to clone: repository not found")
+		return "", "", "", errors.New("unable to clone: repository not found")
 	}
 
 	// Write another plugin file to mimic update
 	err := writeMockPluginFile(m.Directory, "erlang", erlangPluginURL)
 	if err != nil {
-		return "", err
+		return "", "", "", err
 	}
 
-	return "", nil
+	return "", "", "", nil
 }
 
 func writeMockPluginFile(dir, pluginName, pluginURL string) error {

internal/plugins/plugins.go

@@ -237,6 +237,37 @@ func (p Plugin) ExtensionCommandPath(name string) (string, error) {
 	return path, nil
 }
 
+// Update a plugin to a specific ref, or if no ref provided update to latest
+func (p Plugin) Update(conf config.Config, ref string, out, errout io.Writer) (string, error) {
+	err := p.Exists()
+	if err != nil {
+		return "", fmt.Errorf("no such plugin: %s", p.Name)
+	}
+
+	repo := git.NewRepo(p.Dir)
+
+	hook.Run(conf, "pre_asdf_plugin_update", []string{p.Name})
+	hook.Run(conf, fmt.Sprintf("pre_asdf_plugin_update_%s", p.Name), []string{p.Name})
+
+	newRef, oldSHA, newSHA, err := repo.Update(ref)
+	if err != nil {
+		return newRef, err
+	}
+
+	env := map[string]string{
+		"ASDF_PLUGIN_PATH":     p.Dir,
+		"ASDF_PLUGIN_PREV_REF": oldSHA,
+		"ASDF_PLUGIN_POST_REF": newSHA,
+	}
+
+	err = p.RunCallback("post-plugin-update", []string{}, env, out, errout)
+
+	hook.Run(conf, "post_asdf_plugin_update", []string{p.Name})
+	hook.Run(conf, fmt.Sprintf("post_asdf_plugin_update_%s", p.Name), []string{})
+
+	return newRef, err
+}
+
 // List takes config and flags for what to return and builds a list of plugins
 // representing the currently installed plugins on the system.
 func List(config config.Config, urls, refs bool) (plugins []Plugin, err error) {
@@ -256,7 +287,7 @@ func List(config config.Config, urls, refs bool) (plugins []Plugin, err error) {
 				var url string
 				var refString string
 				location := filepath.Join(pluginsDir, file.Name())
-				plugin := git.NewRepo(location)
+				repo := git.NewRepo(location)
 
 				// TODO: Improve these error messages
 				if err != nil {
@@ -264,14 +295,14 @@ func List(config config.Config, urls, refs bool) (plugins []Plugin, err error) {
 				}
 
 				if refs {
-					refString, err = plugin.Head()
+					refString, err = repo.Head()
 					if err != nil {
 						return plugins, err
 					}
 				}
 
 				if urls {
-					url, err = plugin.RemoteURL()
+					url, err = repo.RemoteURL()
 					if err != nil {
 						return plugins, err
 					}
@@ -297,7 +328,7 @@ func List(config config.Config, urls, refs bool) (plugins []Plugin, err error) {
 
 // Add takes plugin name and Git URL and installs the plugin if it isn't
 // already installed
-func Add(config config.Config, pluginName, pluginURL string) error {
+func Add(config config.Config, pluginName, pluginURL, ref string) error {
 	err := validatePluginName(pluginName)
 	if err != nil {
 		return err
@@ -344,7 +375,7 @@ func Add(config config.Config, pluginName, pluginURL string) error {
 	hook.Run(config, "pre_asdf_plugin_add", []string{plugin.Name})
 	hook.Run(config, fmt.Sprintf("pre_asdf_plugin_add_%s", plugin.Name), []string{})
 
-	err = git.NewRepo(plugin.Dir).Clone(plugin.URL)
+	err = git.NewRepo(plugin.Dir).Clone(plugin.URL, ref)
 	if err != nil {
 		return err
 	}
@@ -413,24 +444,6 @@ func Remove(config config.Config, pluginName string, stdout, stderr io.Writer) e
 	return err3
 }
 
-// Update a plugin to a specific ref, or if no ref provided update to latest
-func Update(config config.Config, pluginName, ref string) (string, error) {
-	exists, err := PluginExists(config.DataDir, pluginName)
-	if err != nil {
-		return "", fmt.Errorf("unable to check if plugin exists: %w", err)
-	}
-
-	if !exists {
-		return "", fmt.Errorf("no such plugin: %s", pluginName)
-	}
-
-	pluginDir := data.PluginDirectory(config.DataDir, pluginName)
-
-	plugin := git.NewRepo(pluginDir)
-
-	return plugin.Update(ref)
-}
-
 // PluginExists returns a boolean indicating whether or not a plugin with the
 // provided name is currently installed
 func PluginExists(dataDir, pluginName string) (bool, error) {

internal/plugins/plugins_test.go

@@ -21,7 +21,7 @@ func TestList(t *testing.T) {
 	testRepo, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 	assert.Nil(t, err)
 
-	err = Add(conf, testPluginName, testRepo)
+	err = Add(conf, testPluginName, testRepo, "")
 	assert.Nil(t, err)
 
 	t.Run("when urls and refs are set to false returns plugin names", func(t *testing.T) {
@@ -89,7 +89,7 @@ func TestAdd(t *testing.T) {
 
 		for _, invalid := range invalids {
 			t.Run(invalid, func(t *testing.T) {
-				err := Add(config.Config{}, invalid, "never-cloned")
+				err := Add(config.Config{}, invalid, "never-cloned", "")
 
 				expectedErrMsg := "is invalid. Name may only contain lowercase letters, numbers, '_', and '-'"
 				if !strings.Contains(err.Error(), expectedErrMsg) {
@@ -106,13 +106,13 @@ func TestAdd(t *testing.T) {
 		repoPath, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 		assert.Nil(t, err)
 
-		err = Add(conf, testPluginName, repoPath)
+		err = Add(conf, testPluginName, repoPath, "")
 		if err != nil {
 			t.Fatal("Expected to be able to add plugin")
 		}
 
 		// Add it again to trigger error
-		err = Add(conf, testPluginName, repoPath)
+		err = Add(conf, testPluginName, repoPath, "")
 
 		if err == nil {
 			t.Fatal("expected error got nil")
@@ -127,7 +127,7 @@ func TestAdd(t *testing.T) {
 	t.Run("when plugin name is valid but URL is invalid prints an error", func(t *testing.T) {
 		conf := config.Config{DataDir: testDataDir}
 
-		err := Add(conf, "foo", "foobar")
+		err := Add(conf, "foo", "foobar", "")
 
 		assert.ErrorContains(t, err, "unable to clone plugin: repository not found")
 	})
@@ -138,7 +138,7 @@ func TestAdd(t *testing.T) {
 		pluginPath, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 		assert.Nil(t, err)
 
-		err = Add(conf, testPluginName, pluginPath)
+		err = Add(conf, testPluginName, pluginPath, "")
 
 		assert.Nil(t, err, "Expected to be able to add plugin")
 
@@ -160,7 +160,7 @@ func TestAdd(t *testing.T) {
 		repoPath, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 		assert.Nil(t, err)
 
-		err = Add(conf, testPluginName, repoPath)
+		err = Add(conf, testPluginName, repoPath, "")
 		assert.Nil(t, err)
 
 		// Assert download dir exists
@@ -177,7 +177,7 @@ func TestRemove(t *testing.T) {
 	repoPath, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 	assert.Nil(t, err)
 
-	err = Add(conf, testPluginName, repoPath)
+	err = Add(conf, testPluginName, repoPath, "")
 	assert.Nil(t, err)
 
 	t.Run("returns error when plugin with name does not exist", func(t *testing.T) {
@@ -212,7 +212,7 @@ func TestRemove(t *testing.T) {
 	t.Run("removes plugin download dir when passed name of installed plugin", func(t *testing.T) {
 		var stdout strings.Builder
 		var stderr strings.Builder
-		err := Add(conf, testPluginName, repoPath)
+		err := Add(conf, testPluginName, repoPath, "")
 		assert.Nil(t, err)
 
 		err = Remove(conf, testPluginName, &stdout, &stderr)
@@ -232,7 +232,7 @@ func TestUpdate(t *testing.T) {
 	repoPath, err := repotest.GeneratePlugin("dummy_plugin", testDataDir, testPluginName)
 	assert.Nil(t, err)
 
-	err = Add(conf, testPluginName, repoPath)
+	err = Add(conf, testPluginName, repoPath, "")
 	assert.Nil(t, err)
 
 	badPluginName := "badplugin"
@@ -276,7 +276,9 @@ func TestUpdate(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.desc, func(t *testing.T) {
-			updatedToRef, err := Update(tt.givenConf, tt.givenName, tt.givenRef)
+			var blackhole strings.Builder
+			plugin := New(conf, tt.givenName)
+			updatedToRef, err := plugin.Update(tt.givenConf, tt.givenRef, &blackhole, &blackhole)
 
 			if tt.wantErrMsg == "" {
 				assert.Nil(t, err)

test/plugin_update_command.bats

@@ -12,221 +12,224 @@ teardown() {
   clean_asdf_dir
 }
 
-@test "asdf plugin-update should pull latest default branch (refs/remotes/origin/HEAD) for plugin" {
+@test "asdf plugin update should pull latest default branch (refs/remotes/origin/HEAD) for plugin" {
-  run asdf plugin-update dummy
+  run asdf plugin update dummy
   repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
   [ "$status" -eq 0 ]
-  [[ "$output" =~ "Updating dummy to master"* ]]
+  [[ "$output" =~ "updated dummy to ref refs/heads/master"* ]]
   [ "$repo_head" = "master" ]
 }
 
-@test "asdf plugin-update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if default branch changes" {
+#@test "asdf plugin update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if default branch changes" {
-  install_mock_plugin_repo "dummy-remote"
+#  install_mock_plugin_repo "dummy-remote"
-  remote_dir="$BASE_DIR/repo-dummy-remote"
+#  remote_dir="$BASE_DIR/repo-dummy-remote"
-  # set HEAD to refs/head/main in dummy-remote
+#  # set HEAD to refs/head/main in dummy-remote
-  git -C "${remote_dir}" checkout -b main
+#  git -C "${remote_dir}" checkout -b main
-  # track & fetch remote repo (dummy-remote) in plugin (dummy)
+#  # track & fetch remote repo (dummy-remote) in plugin (dummy)
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
 
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
+#  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
 
-  [ "$status" -eq 0 ]
+#  [ "$status" -eq 0 ]
-  [[ "$output" =~ "Updating dummy to main"* ]]
+#  [[ "$output" =~ "Updating dummy to main"* ]]
-  [ "$repo_head" = "main" ]
+#  [ "$repo_head" = "main" ]
-}
+#}
 
-@test "asdf plugin-update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if the default branch contains a forward slash" {
+#@test "asdf plugin update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if the default branch contains a forward slash" {
-  install_mock_plugin_repo "dummy-remote"
+#  install_mock_plugin_repo "dummy-remote"
-  remote_dir="$BASE_DIR/repo-dummy-remote"
+#  remote_dir="$BASE_DIR/repo-dummy-remote"
-  # set HEAD to refs/head/my/default in dummy-remote
+#  # set HEAD to refs/head/my/default in dummy-remote
-  git -C "${remote_dir}" checkout -b my/default
+#  git -C "${remote_dir}" checkout -b my/default
-  # track & fetch remote repo (dummy-remote) in plugin (dummy)
+#  # track & fetch remote repo (dummy-remote) in plugin (dummy)
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
 
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
+#  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
 
-  [ "$status" -eq 0 ]
+#  [ "$status" -eq 0 ]
-  [[ "$output" =~ "Updating dummy to my/default"* ]]
+#  [[ "$output" =~ "Updating dummy to my/default"* ]]
-  [ "$repo_head" = "my/default" ]
+#  [ "$repo_head" = "my/default" ]
-}
+#}
 
-@test "asdf plugin-update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if already set to specific ref" {
+#@test "asdf plugin update should pull latest default branch (refs/remotes/origin/HEAD) for plugin even if already set to specific ref" {
-  # set plugin to specific sha
+#  # set plugin to specific sha
-  current_sha="$(git --git-dir "${BASE_DIR}/repo-dummy/.git" --work-tree "$BASE_DIR/repo-dummy" rev-parse HEAD)"
+#  current_sha="$(git --git-dir "${BASE_DIR}/repo-dummy/.git" --work-tree "$BASE_DIR/repo-dummy" rev-parse HEAD)"
-  run asdf plugin-update dummy "${current_sha}"
+#  run asdf plugin update dummy "${current_sha}"
 
-  # setup mock plugin remote
+#  # setup mock plugin remote
-  install_mock_plugin_repo "dummy-remote"
+#  install_mock_plugin_repo "dummy-remote"
-  remote_dir="$BASE_DIR/repo-dummy-remote"
+#  remote_dir="$BASE_DIR/repo-dummy-remote"
-  # set HEAD to refs/head/main in dummy-remote
+#  # set HEAD to refs/head/main in dummy-remote
-  git -C "${remote_dir}" checkout -b main
+#  git -C "${remote_dir}" checkout -b main
-  # track & fetch remote repo (dummy-remote) in plugin (dummy)
+#  # track & fetch remote repo (dummy-remote) in plugin (dummy)
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote remove origin
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" remote add origin "$remote_dir"
-  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
+#  git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" fetch origin
 
-  # update plugin to the default branch
+#  # update plugin to the default branch
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
+#  repo_head="$(git --git-dir "$ASDF_DIR/plugins/dummy/.git" --work-tree "$ASDF_DIR/plugins/dummy" rev-parse --abbrev-ref HEAD)"
 
-  [ "$status" -eq 0 ]
+#  [ "$status" -eq 0 ]
-  [[ "$output" =~ "Updating dummy to main"* ]]
+#  [[ "$output" =~ "Updating dummy to main"* ]]
-  [ "$repo_head" = "main" ]
+#  [ "$repo_head" = "main" ]
-}
+#}
 
-@test "asdf plugin-update should not remove plugin versions" {
+@test "asdf plugin update should not remove plugin versions" {
   run asdf install dummy 1.1
   [ "$status" -eq 0 ]
   [ "$(cat "$ASDF_DIR/installs/dummy/1.1/version")" = "1.1" ]
-  run asdf plugin-update dummy
+  run asdf plugin update dummy
   [ "$status" -eq 0 ]
   [ -f "$ASDF_DIR/installs/dummy/1.1/version" ]
-  run asdf plugin-update --all
+  run asdf plugin update --all
   [ "$status" -eq 0 ]
   [ -f "$ASDF_DIR/installs/dummy/1.1/version" ]
 }
 
-@test "asdf plugin-update should not remove plugins" {
+@test "asdf plugin update should not remove plugins" {
   # dummy plugin is already installed
-  run asdf plugin-update dummy
+  run asdf plugin update dummy
   [ "$status" -eq 0 ]
   [ -d "$ASDF_DIR/plugins/dummy" ]
-  run asdf plugin-update --all
+  run asdf plugin update --all
   [ "$status" -eq 0 ]
   [ -d "$ASDF_DIR/plugins/dummy" ]
 }
 
-@test "asdf plugin-update should not remove shims" {
+@test "asdf plugin update should not remove shims" {
   run asdf install dummy 1.1
   [ -f "$ASDF_DIR/shims/dummy" ]
-  run asdf plugin-update dummy
+  run asdf plugin update dummy
   [ "$status" -eq 0 ]
   [ -f "$ASDF_DIR/shims/dummy" ]
-  run asdf plugin-update --all
+  run asdf plugin update --all
   [ "$status" -eq 0 ]
   [ -f "$ASDF_DIR/shims/dummy" ]
 }
 
-@test "asdf plugin-update done for all plugins" {
+# TODO: Get these tests passing
-  local command="asdf plugin-update --all"
+#@test "asdf plugin update done for all plugins" {
-  # Count the number of update processes remaining after the update command is completed.
+#  local command="asdf plugin update --all"
-  run bash -c "${command} >/dev/null && ps -o 'ppid,args' | awk '{if(\$1==1 && \$0 ~ /${command}/ ) print}' | wc -l"
+#  # Count the number of update processes remaining after the update command is completed.
-  [[ 0 -eq "$output" ]]
+#  run bash -c "${command} >/dev/null && ps -o 'ppid,args' | awk '{if(\$1==1 && \$0 ~ /${command}/ ) print}' | wc -l"
-}
+#  [[ 0 -eq "$output" ]]
+#}
 
-@test "asdf plugin-update executes post-plugin update script" {
+#@test "asdf plugin update executes post-plugin update script" {
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
-  [[ "$output" = *"${expected_output}" ]]
+#  [[ "$output" = *"${expected_output}" ]]
-}
+#}
 
-@test "asdf plugin-update executes post-plugin update script if git-ref updated" {
+#@test "asdf plugin update executes post-plugin update script if git-ref updated" {
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  # setup mock plugin remote
+#  # setup mock plugin remote
-  install_mock_plugin_repo "dummy-remote"
+#  install_mock_plugin_repo "dummy-remote"
-  remote_dir="$BASE_DIR/repo-dummy-remote"
+#  remote_dir="$BASE_DIR/repo-dummy-remote"
-  # set HEAD to refs/head/main in dummy-remote
+#  # set HEAD to refs/head/main in dummy-remote
-  git -C "${remote_dir}" checkout -b main
+#  git -C "${remote_dir}" checkout -b main
-  # track & fetch remote repo (dummy-remote) in plugin (dummy)
+#  # track & fetch remote repo (dummy-remote) in plugin (dummy)
-  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" remote remove origin
+#  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" remote remove origin
-  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" remote add origin "$remote_dir"
+#  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" remote add origin "$remote_dir"
-  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" fetch origin
+#  git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" fetch origin
 
-  # update plugin to the default branch
+#  # update plugin to the default branch
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
-  [[ "$output" = *"${expected_output}" ]]
+#  [[ "$output" = *"${expected_output}" ]]
-}
+#}
 
-@test "asdf plugin-update executes configured pre hook (generic)" {
+#@test "asdf plugin update executes configured pre hook (generic)" {
-  cat >"$HOME/.asdfrc" <<-'EOM'
+#  cat >"$HOME/.asdfrc" <<-'EOM'
-pre_asdf_plugin_update = echo UPDATE ${@}
+#pre_asdf_plugin_update = echo UPDATE ${@}
-EOM
+#EOM
 
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
-  [[ "$output" = *"UPDATE dummy"*"${expected_output}" ]]
+#  [[ "$output" = *"UPDATE dummy"*"${expected_output}" ]]
-}
+#}
 
-@test "asdf plugin-update executes configured pre hook (specific)" {
+#@test "asdf plugin update executes configured pre hook (specific)" {
-  cat >"$HOME/.asdfrc" <<-'EOM'
+#  cat >"$HOME/.asdfrc" <<-'EOM'
-pre_asdf_plugin_update_dummy = echo UPDATE
+#pre_asdf_plugin_update_dummy = echo UPDATE
-EOM
+#EOM
 
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}"
-  [[ "$output" = *"UPDATE"*"${expected_output}" ]]
+#  [[ "$output" = *"UPDATE"*"${expected_output}" ]]
-}
+#}
 
-@test "asdf plugin-update executes configured post hook (generic)" {
+#@test "asdf plugin update executes configured post hook (generic)" {
-  cat >"$HOME/.asdfrc" <<-'EOM'
+#  cat >"$HOME/.asdfrc" <<-'EOM'
-post_asdf_plugin_update = echo UPDATE ${@}
+#post_asdf_plugin_update = echo UPDATE ${@}
-EOM
+#EOM
 
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}
-UPDATE dummy"
+#UPDATE dummy"
-  [[ "$output" = *"${expected_output}" ]]
+#  [[ "$output" = *"${expected_output}" ]]
-}
+#}
 
-@test "asdf plugin-update executes configured post hook (specific)" {
+#@test "asdf plugin update executes configured post hook (specific)" {
-  cat >"$HOME/.asdfrc" <<-'EOM'
+#  cat >"$HOME/.asdfrc" <<-'EOM'
-post_asdf_plugin_update_dummy = echo UPDATE
+#post_asdf_plugin_update_dummy = echo UPDATE
-EOM
+#EOM
 
-  local plugin_path
+#  local plugin_path
-  plugin_path="$(get_plugin_path dummy)"
+#  plugin_path="$(get_plugin_path dummy)"
 
-  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  old_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
-  run asdf plugin-update dummy
+#  run asdf plugin update dummy
-  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
+#  new_ref="$(git --git-dir "$plugin_path/.git" --work-tree "$plugin_path" rev-parse --short HEAD)"
 
-  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}
+#  local expected_output="plugin updated path=${plugin_path} old git-ref=${old_ref} new git-ref=${new_ref}
-UPDATE"
+#UPDATE
-  [[ "$output" = *"${expected_output}" ]]
+#updated dummy to ref refs/heads/master"
-}
+#  [[ "$output" = *"${expected_output}" ]]
+#}
 
-@test "asdf plugin-update prints the location of plugin (specific)" {
+# No longer supported
-  local plugin_path
+#@test "asdf plugin update prints the location of plugin (specific)" {
-  plugin_path="$(get_plugin_path dummy)"
+#  local plugin_path
-  run asdf plugin-update dummy
+#  plugin_path="$(get_plugin_path dummy)"
+#  run asdf plugin update dummy
 
-  local expected_output="Location of dummy plugin: $plugin_path"
+#  local expected_output="Location of dummy plugin: $plugin_path"
-  [[ "$output" == *"$expected_output"* ]]
+#  [[ "$output" == *"$expected_output"* ]]
-}
+#}