X-Git-Url: https://git.josue.xyz/?a=blobdiff_plain;f=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201028153306-37f0764111ff%2Finternal%2Flsp%2Ffake%2Fworkdir.go;fp=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201028153306-37f0764111ff%2Finternal%2Flsp%2Ffake%2Fworkdir.go;h=f036d420d202162ef09af70f8f94dee796d5ace3;hb=4d07c77cf4d78cab8639e13ddc3c22495e585b0b;hp=0000000000000000000000000000000000000000;hpb=b3950616b54221c40a7dab9099bda675007e5b6e;p=dotfiles%2F.git

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/internal/lsp/fake/workdir.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/internal/lsp/fake/workdir.go
new file mode 100644
index 00000000..f036d420
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/internal/lsp/fake/workdir.go
@@ -0,0 +1,335 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fake
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/tools/internal/lsp/protocol"
+	"golang.org/x/tools/internal/span"
+	errors "golang.org/x/xerrors"
+)
+
+// FileEvent wraps the protocol.FileEvent so that it can be associated with a
+// workdir-relative path.
+type FileEvent struct {
+	Path, Content string
+	ProtocolEvent protocol.FileEvent
+}
+
+// RelativeTo is a helper for operations relative to a given directory.
+type RelativeTo string
+
+// AbsPath returns an absolute filesystem path for the workdir-relative path.
+func (r RelativeTo) AbsPath(path string) string {
+	fp := filepath.FromSlash(path)
+	if filepath.IsAbs(fp) {
+		return fp
+	}
+	return filepath.Join(string(r), filepath.FromSlash(path))
+}
+
+// RelPath returns a '/'-encoded path relative to the working directory (or an
+// absolute path if the file is outside of workdir)
+func (r RelativeTo) RelPath(fp string) string {
+	root := string(r)
+	if rel, err := filepath.Rel(root, fp); err == nil && !strings.HasPrefix(rel, "..") {
+		return filepath.ToSlash(rel)
+	}
+	return filepath.ToSlash(fp)
+}
+
+func writeTxtar(txt string, rel RelativeTo) error {
+	files := unpackTxt(txt)
+	for name, data := range files {
+		if err := WriteFileData(name, data, rel); err != nil {
+			return errors.Errorf("writing to workdir: %w", err)
+		}
+	}
+	return nil
+}
+
+// WriteFileData writes content to the relative path, replacing the special
+// token $SANDBOX_WORKDIR with the relative root given by rel.
+func WriteFileData(path string, content []byte, rel RelativeTo) error {
+	content = bytes.ReplaceAll(content, []byte("$SANDBOX_WORKDIR"), []byte(rel))
+	fp := rel.AbsPath(path)
+	if err := os.MkdirAll(filepath.Dir(fp), 0755); err != nil {
+		return errors.Errorf("creating nested directory: %w", err)
+	}
+	if err := ioutil.WriteFile(fp, []byte(content), 0644); err != nil {
+		return errors.Errorf("writing %q: %w", path, err)
+	}
+	return nil
+}
+
+// Workdir is a temporary working directory for tests. It exposes file
+// operations in terms of relative paths, and fakes file watching by triggering
+// events on file operations.
+type Workdir struct {
+	RelativeTo
+
+	watcherMu sync.Mutex
+	watchers  []func(context.Context, []FileEvent)
+
+	fileMu sync.Mutex
+	files  map[string]time.Time
+}
+
+// NewWorkdir writes the txtar-encoded file data in txt to dir, and returns a
+// Workir for operating on these files using
+func NewWorkdir(dir string) *Workdir {
+	return &Workdir{RelativeTo: RelativeTo(dir)}
+}
+
+func (w *Workdir) writeInitialFiles(txt string) error {
+	writeTxtar(txt, w.RelativeTo)
+	// Poll to capture the current file state.
+	if _, err := w.pollFiles(); err != nil {
+		return errors.Errorf("polling files: %w", err)
+	}
+	return nil
+}
+
+// RootURI returns the root URI for this working directory of this scratch
+// environment.
+func (w *Workdir) RootURI() protocol.DocumentURI {
+	return toURI(string(w.RelativeTo))
+}
+
+// AddWatcher registers the given func to be called on any file change.
+func (w *Workdir) AddWatcher(watcher func(context.Context, []FileEvent)) {
+	w.watcherMu.Lock()
+	w.watchers = append(w.watchers, watcher)
+	w.watcherMu.Unlock()
+}
+
+// URI returns the URI to a the workdir-relative path.
+func (w *Workdir) URI(path string) protocol.DocumentURI {
+	return toURI(w.AbsPath(path))
+}
+
+// URIToPath converts a uri to a workdir-relative path (or an absolute path,
+// if the uri is outside of the workdir).
+func (w *Workdir) URIToPath(uri protocol.DocumentURI) string {
+	fp := uri.SpanURI().Filename()
+	return w.RelPath(fp)
+}
+
+func toURI(fp string) protocol.DocumentURI {
+	return protocol.DocumentURI(span.URIFromPath(fp))
+}
+
+// ReadFile reads a text file specified by a workdir-relative path.
+func (w *Workdir) ReadFile(path string) (string, error) {
+	b, err := ioutil.ReadFile(w.AbsPath(path))
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func (w *Workdir) RegexpRange(path, re string) (Pos, Pos, error) {
+	content, err := w.ReadFile(path)
+	if err != nil {
+		return Pos{}, Pos{}, err
+	}
+	return regexpRange(content, re)
+}
+
+// RegexpSearch searches the file corresponding to path for the first position
+// matching re.
+func (w *Workdir) RegexpSearch(path string, re string) (Pos, error) {
+	content, err := w.ReadFile(path)
+	if err != nil {
+		return Pos{}, err
+	}
+	start, _, err := regexpRange(content, re)
+	return start, err
+}
+
+// ChangeFilesOnDisk executes the given on-disk file changes in a batch,
+// simulating the action of changing branches outside of an editor.
+func (w *Workdir) ChangeFilesOnDisk(ctx context.Context, events []FileEvent) error {
+	for _, e := range events {
+		switch e.ProtocolEvent.Type {
+		case protocol.Deleted:
+			fp := w.AbsPath(e.Path)
+			if err := os.Remove(fp); err != nil {
+				return errors.Errorf("removing %q: %w", e.Path, err)
+			}
+		case protocol.Changed, protocol.Created:
+			if _, err := w.writeFile(ctx, e.Path, e.Content); err != nil {
+				return err
+			}
+		}
+	}
+	w.sendEvents(ctx, events)
+	return nil
+}
+
+// RemoveFile removes a workdir-relative file path.
+func (w *Workdir) RemoveFile(ctx context.Context, path string) error {
+	fp := w.AbsPath(path)
+	if err := os.Remove(fp); err != nil {
+		return errors.Errorf("removing %q: %w", path, err)
+	}
+	evts := []FileEvent{{
+		Path: path,
+		ProtocolEvent: protocol.FileEvent{
+			URI:  w.URI(path),
+			Type: protocol.Deleted,
+		},
+	}}
+	w.sendEvents(ctx, evts)
+	return nil
+}
+
+func (w *Workdir) sendEvents(ctx context.Context, evts []FileEvent) {
+	if len(evts) == 0 {
+		return
+	}
+	w.watcherMu.Lock()
+	watchers := make([]func(context.Context, []FileEvent), len(w.watchers))
+	copy(watchers, w.watchers)
+	w.watcherMu.Unlock()
+	for _, w := range watchers {
+		go w(ctx, evts)
+	}
+}
+
+// WriteFiles writes the text file content to workdir-relative paths.
+// It batches notifications rather than sending them consecutively.
+func (w *Workdir) WriteFiles(ctx context.Context, files map[string]string) error {
+	var evts []FileEvent
+	for filename, content := range files {
+		evt, err := w.writeFile(ctx, filename, content)
+		if err != nil {
+			return err
+		}
+		evts = append(evts, evt)
+	}
+	w.sendEvents(ctx, evts)
+	return nil
+}
+
+// WriteFile writes text file content to a workdir-relative path.
+func (w *Workdir) WriteFile(ctx context.Context, path, content string) error {
+	evt, err := w.writeFile(ctx, path, content)
+	if err != nil {
+		return err
+	}
+	w.sendEvents(ctx, []FileEvent{evt})
+	return nil
+}
+
+func (w *Workdir) writeFile(ctx context.Context, path, content string) (FileEvent, error) {
+	fp := w.AbsPath(path)
+	_, err := os.Stat(fp)
+	if err != nil && !os.IsNotExist(err) {
+		return FileEvent{}, errors.Errorf("checking if %q exists: %w", path, err)
+	}
+	var changeType protocol.FileChangeType
+	if os.IsNotExist(err) {
+		changeType = protocol.Created
+	} else {
+		changeType = protocol.Changed
+	}
+	if err := WriteFileData(path, []byte(content), w.RelativeTo); err != nil {
+		return FileEvent{}, err
+	}
+	return FileEvent{
+		Path: path,
+		ProtocolEvent: protocol.FileEvent{
+			URI:  w.URI(path),
+			Type: changeType,
+		},
+	}, nil
+}
+
+// ListFiles lists files in the given directory, returning a map of relative
+// path to modification time.
+func (w *Workdir) ListFiles(dir string) (map[string]time.Time, error) {
+	files := make(map[string]time.Time)
+	absDir := w.AbsPath(dir)
+	if err := filepath.Walk(absDir, func(fp string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if info.IsDir() {
+			return nil
+		}
+		path := w.RelPath(fp)
+		files[path] = info.ModTime()
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return files, nil
+}
+
+// CheckForFileChanges walks the working directory and checks for any files
+// that have changed since the last poll.
+func (w *Workdir) CheckForFileChanges(ctx context.Context) error {
+	evts, err := w.pollFiles()
+	if err != nil {
+		return err
+	}
+	w.sendEvents(ctx, evts)
+	return nil
+}
+
+// pollFiles updates w.files and calculates FileEvents corresponding to file
+// state changes since the last poll. It does not call sendEvents.
+func (w *Workdir) pollFiles() ([]FileEvent, error) {
+	w.fileMu.Lock()
+	defer w.fileMu.Unlock()
+
+	files, err := w.ListFiles(".")
+	if err != nil {
+		return nil, err
+	}
+	var evts []FileEvent
+	// Check which files have been added or modified.
+	for path, mtime := range files {
+		oldmtime, ok := w.files[path]
+		delete(w.files, path)
+		var typ protocol.FileChangeType
+		switch {
+		case !ok:
+			typ = protocol.Created
+		case oldmtime != mtime:
+			typ = protocol.Changed
+		default:
+			continue
+		}
+		evts = append(evts, FileEvent{
+			Path: path,
+			ProtocolEvent: protocol.FileEvent{
+				URI:  w.URI(path),
+				Type: typ,
+			},
+		})
+	}
+	// Any remaining files must have been deleted.
+	for path := range w.files {
+		evts = append(evts, FileEvent{
+			Path: path,
+			ProtocolEvent: protocol.FileEvent{
+				URI:  w.URI(path),
+				Type: protocol.Deleted,
+			},
+		})
+	}
+	w.files = files
+	return evts, nil
+}