Add remove sub-command

Author: code-asher

README.md

@@ -85,6 +85,16 @@ Or the Vim extension from GitHub:
 ./code-marketplace add https://github.com/VSCodeVim/Vim/releases/download/v1.24.1/vim-1.24.1.vsix --extensions-dir ./extensions
 ```
 
+## Removing extensions
+
+Extensions can be removed from the marketplace by ID and version (or use `--all`
+to remove all versions).
+
+```
+./code-marketplace remove ms-python.python-2022.14.0 --extensions-dir ./extensions
+./code-marketplace remove ms-python.python --all --extensions-dir ./extensions
+```
+
 ## Usage in code-server
 
 ```

api/api_test.go

@@ -30,6 +30,10 @@ func (s *fakeStorage) AddExtension(ctx context.Context, source string) (*storage
 	return nil, errors.New("not implemented")
 }
 
+func (s *fakeStorage) RemoveExtension(ctx context.Context, id string, all bool) ([]string, error) {
+	return nil, errors.New("not implemented")
+}
+
 func (s *fakeStorage) FileServer() http.Handler {
 	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/nonexistent" {

cli/remove.go

@@ -0,0 +1,82 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"cdr.dev/slog"
+	"cdr.dev/slog/sloggers/sloghuman"
+
+	"github.com/coder/code-marketplace/storage"
+)
+
+func remove() *cobra.Command {
+	var (
+		extdir string
+		all    bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "remove <id>",
+		Short: "Remove an extension from the marketplace",
+		Example: strings.Join([]string{
+			"  marketplace remove publisher.extension-1.0.0 --extensions-dir ./extensions",
+			"  marketplace remove publisher.extension --all --extensions-dir ./extensions",
+		}, "\n"),
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx, cancel := context.WithCancel(cmd.Context())
+			defer cancel()
+
+			verbose, err := cmd.Flags().GetBool("verbose")
+			if err != nil {
+				return err
+			}
+			logger := slog.Make(sloghuman.Sink(cmd.ErrOrStderr()))
+			if verbose {
+				logger = logger.Leveled(slog.LevelDebug)
+			}
+
+			extdir, err = filepath.Abs(extdir)
+			if err != nil {
+				return err
+			}
+
+			// Always local storage for now.
+			store := &storage.Local{
+				ExtDir: extdir,
+				Logger: logger,
+			}
+
+			removed, err := store.RemoveExtension(ctx, args[0], all)
+			if err != nil {
+				return err
+			}
+
+			removedCount := len(removed)
+			pluralVersions := "versions"
+			if removedCount == 1 {
+				pluralVersions = "version"
+			}
+			summary := []string{
+				fmt.Sprintf("Removed %d %s", removedCount, pluralVersions),
+			}
+			for _, id := range removed {
+				summary = append(summary, fmt.Sprintf("  - %s", id))
+			}
+
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), strings.Join(summary, "\n"))
+			return err
+		},
+	}
+
+	cmd.Flags().BoolVar(&all, "all", false, "Whether to delete all versions of the extension.")
+	cmd.Flags().StringVar(&extdir, "extensions-dir", "", "The path to extensions.")
+	_ = cmd.MarkFlagRequired("extensions-dir")
+
+	return cmd
+}

cli/remove_test.go

@@ -0,0 +1,25 @@
+package cli_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/code-marketplace/cli"
+)
+
+func TestRemove(t *testing.T) {
+	t.Parallel()
+
+	cmd := cli.Root()
+	cmd.SetArgs([]string{"remove", "--help"})
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	err := cmd.Execute()
+	require.NoError(t, err)
+
+	output := buf.String()
+	require.Contains(t, output, "Remove an extension", "has help")
+}

cli/root.go

@@ -16,7 +16,7 @@ func Root() *cobra.Command {
 		}, "\n"),
 	}
 
-	cmd.AddCommand(add(), server(), version())
+	cmd.AddCommand(add(), remove(), server(), version())
 
 	cmd.PersistentFlags().BoolP("verbose", "v", false, "Enable verbose output")
 

database/database_test.go

@@ -24,6 +24,10 @@ func (s *memoryStorage) AddExtension(ctx context.Context, source string) (*stora
 	return nil, errors.New("not implemented")
 }
 
+func (s *memoryStorage) RemoveExtension(ctx context.Context, id string, all bool) ([]string, error) {
+	return nil, errors.New("not implemented")
+}
+
 func (s *memoryStorage) FileServer() http.Handler {
 	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
 		http.Error(rw, "not implemented", http.StatusNotImplemented)

storage/local.go

@@ -3,17 +3,22 @@ package storage
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 
 	"golang.org/x/mod/semver"
+	"golang.org/x/xerrors"
 
 	"cdr.dev/slog"
+
+	"github.com/coder/code-marketplace/util"
 )
 
 // Local implements Storage.  It stores extensions locally on disk.
@@ -87,6 +92,64 @@ func (s *Local) AddExtension(ctx context.Context, source string) (*Extension, er
 	return ext, nil
 }
 
+func (s *Local) RemoveExtension(ctx context.Context, id string, all bool) ([]string, error) {
+	re := regexp.MustCompile(`^([^.]+)\.([^-]+)-?(.*)$`)
+	match := re.FindAllStringSubmatch(id, -1)
+	if match == nil {
+		return nil, xerrors.Errorf("expected ID in the format <publisher>.<name> or <publisher>.<name>-<version> but got invalid ID \"%s\"", id)
+	}
+
+	// Get the directory to delete.
+	publisher := match[0][1]
+	extension := match[0][2]
+	version := match[0][3]
+	dir := filepath.Join(s.ExtDir, publisher, extension)
+	if !all {
+		dir = filepath.Join(dir, version)
+	}
+
+	// We could avoid an error if extensions already do not exist but since we are
+	// explicitly being asked to remove an extension the extension not being there
+	// to be removed could be considered an error.
+	_, err := os.Stat(dir)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, xerrors.Errorf("%s does not exist", id)
+		}
+		return nil, err
+	}
+
+	allVersions := s.getDirNames(ctx, dir)
+	versionCount := len(allVersions)
+
+	// TODO: Probably should use a custom error instance since knowledge of --all
+	// is weird here.
+	if version != "" && all {
+		return nil, xerrors.Errorf("cannot specify both --all and version %s", version)
+	} else if version == "" && !all {
+		return nil, xerrors.Errorf(
+			"use %s-<version> to target a specific version or pass --all to delete %s of %s",
+			id,
+			util.Plural(versionCount, "version", ""),
+			id,
+		)
+	}
+
+	err = os.RemoveAll(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	var versions []string
+	if all {
+		versions = allVersions
+	} else {
+		versions = []string{version}
+	}
+	sort.Sort(sort.Reverse(semver.ByVersion(versions)))
+	return versions, nil
+}
+
 func (s *Local) FileServer() http.Handler {
 	return http.FileServer(http.Dir(s.ExtDir))
 }

storage/storage.go

@@ -102,6 +102,10 @@ type Storage interface {
 	// into the extension storage directory and returns details about the added
 	// extension.  The source may be an URI or a local file path.
 	AddExtension(ctx context.Context, source string) (*Extension, error)
+	// RemoveExtension removes the extension by id (publisher, name, and version)
+	// or all versions if all is true (in which case the id should omit the
+	// version) and returns the IDs removed.
+	RemoveExtension(ctx context.Context, name string, all bool) ([]string, error)
 	// FileServer provides a handler for fetching extension repository files from
 	// a client.
 	FileServer() http.Handler

storage/storage_test.go

@@ -46,6 +46,7 @@ func TestFileServer(t *testing.T) {
 	require.Equal(t, "bar", string(body))
 }
 
+// addExtension adds the provided test extension to the provided directory..
 func addExtension(t *testing.T, ext testutil.Extension, extdir, version string) *storage.VSIXManifest {
 	dir := filepath.Join(extdir, ext.Publisher, ext.Name, version)
 	err := os.MkdirAll(dir, 0o755)
@@ -512,3 +513,117 @@ func TestAddExtension(t *testing.T) {
 		}
 	})
 }
+
+func TestRemoveExtension(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		all      bool
+		error    string
+		expected []string
+		name     string
+		remove   string
+	}{
+		{
+			name:     "OK",
+			expected: []string{"a"},
+			remove:   fmt.Sprintf("%s.%s-a", testutil.Extensions[0].Publisher, testutil.Extensions[0].Name),
+		},
+		{
+			name:   "NoVersionMatch",
+			error:  "does not exist",
+			remove: fmt.Sprintf("%s.%s-d", testutil.Extensions[0].Publisher, testutil.Extensions[0].Name),
+		},
+		{
+			name:   "NoPublisherMatch",
+			error:  "does not exist",
+			remove: "test-test.test-test",
+		},
+		{
+			name:   "NoExtensionMatch",
+			error:  "does not exist",
+			remove: "foo.test-test",
+		},
+		{
+			name:   "MultipleDots",
+			error:  "does not exist",
+			remove: "foo.bar-test.test",
+		},
+		{
+			name:   "EmptyID",
+			error:  "invalid ID",
+			remove: "",
+		},
+		{
+			name:   "MissingPublisher",
+			error:  "invalid ID",
+			remove: ".qux-bar",
+		},
+		{
+			name:   "MissingExtension",
+			error:  "invalid ID",
+			remove: "foo.-baz",
+		},
+		{
+			name:   "MissingExtensionAndVersion",
+			error:  "invalid ID",
+			remove: "foo.",
+		},
+		{
+			name:   "MissingPublisherAndVersion",
+			error:  "invalid ID",
+			remove: ".qux",
+		},
+		{
+			name:   "InvalidID",
+			error:  "invalid ID",
+			remove: "publisher-version",
+		},
+		{
+			name:   "MissingVersion",
+			error:  "target a specific version or pass --all",
+			remove: fmt.Sprintf("%s.%s", testutil.Extensions[0].Publisher, testutil.Extensions[0].Name),
+		},
+		{
+			name:     "All",
+			expected: []string{"a", "b", "c"},
+			all:      true,
+			remove:   fmt.Sprintf("%s.%s", testutil.Extensions[0].Publisher, testutil.Extensions[0].Name),
+		},
+		{
+			name:   "AllWithVersion",
+			error:  "cannot specify both",
+			all:    true,
+			remove: fmt.Sprintf("%s.%s-a", testutil.Extensions[0].Publisher, testutil.Extensions[0].Name),
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			extdir := t.TempDir()
+			ext := testutil.Extensions[0]
+			addExtension(t, ext, extdir, "a")
+			addExtension(t, ext, extdir, "b")
+			addExtension(t, ext, extdir, "c")
+
+			ext = testutil.Extensions[1]
+			addExtension(t, ext, extdir, "a")
+			addExtension(t, ext, extdir, "b")
+			addExtension(t, ext, extdir, "c")
+
+			s := &storage.Local{ExtDir: extdir}
+
+			removed, err := s.RemoveExtension(context.Background(), test.remove, test.all)
+			if test.error != "" {
+				require.Error(t, err)
+				require.Regexp(t, test.error, err.Error())
+			} else {
+				require.NoError(t, err)
+			}
+			require.ElementsMatch(t, test.expected, removed)
+		})
+	}
+}