fix: bring os_js.go up to date with os.go

Recent changes to os_js.go added WithBoundOS and ChrootOSFS.

These changes were not propagated to os_js.go, which results in
the following build failures in go-git:

% GOOS=js GOARCH=wasm gb ./...
github.com/go-git/go-git/v6
./remote.go:214:32: undefined: osfs.WithBoundOS
./repository.go:348:29: undefined: osfs.WithBoundOS
./repository.go:353:28: undefined: osfs.WithBoundOS
./repository.go:460:28: undefined: osfs.WithBoundOS
./repository.go:468:44: undefined: osfs.WithBoundOS
./repository.go:528:32: undefined: osfs.WithBoundOS
./repository.go:531:46: undefined: osfs.WithBoundOS
./repository.go:551:36: undefined: osfs.WithBoundOS
./repository.go:553:62: undefined: osfs.WithBoundOS

This commit brings os_js.go up to date with os.go to fix this.

All tests pass with GOOS=js GOARCH=wasm now.

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

osfs/os_js.go

@@ -3,21 +3,192 @@
 package osfs
 
 import (
+	iofs "io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
 	"github.com/go-git/go-billy/v6"
 	"github.com/go-git/go-billy/v6/helper/chroot"
 	"github.com/go-git/go-billy/v6/memfs"
+	"github.com/go-git/go-billy/v6/util"
 )
 
-// globalMemFs is the global memory fs
+// globalMemFs is the global memory fs.
 var globalMemFs = memfs.New()
 
-// Default Filesystem representing the root of in-memory filesystem for a
-// js/wasm environment.
-var Default = memfs.New()
+// Default Filesystem representing the root of the os filesystem.
+var Default = &ChrootOS{}
 
 // New returns a new OS filesystem.
-func New(baseDir string, _ ...Option) billy.Filesystem {
+// By default paths are deduplicated, but still enforced
+// under baseDir. For more info refer to WithDeduplicatePath.
+func New(baseDir string, opts ...Option) billy.Filesystem {
+	o := &options{
+		deduplicatePath: true,
+	}
+	for _, opt := range opts {
+		opt(o)
+	}
+
+	if o.Type == BoundOSFS {
+		return newBoundOS(baseDir, o.deduplicatePath)
+	}
+
+	return newChrootOS(baseDir)
+}
+
+// ChrootOS is a legacy filesystem based on a "soft chroot" of the js/wasm
+// in-memory filesystem.
+type ChrootOS struct{}
+
+func newChrootOS(baseDir string) billy.Filesystem {
 	return chroot.New(Default, Default.Join("/", baseDir))
 }
 
-type options struct{}
+func (fs *ChrootOS) Create(filename string) (billy.File, error) {
+	return globalMemFs.Create(filename)
+}
+
+func (fs *ChrootOS) OpenFile(filename string, flag int, perm iofs.FileMode) (billy.File, error) {
+	return globalMemFs.OpenFile(filename, flag, perm)
+}
+
+func (fs *ChrootOS) ReadDir(dir string) ([]iofs.DirEntry, error) {
+	return globalMemFs.ReadDir(dir)
+}
+
+func (fs *ChrootOS) Rename(from, to string) error {
+	return globalMemFs.Rename(from, to)
+}
+
+func (fs *ChrootOS) MkdirAll(path string, perm iofs.FileMode) error {
+	return globalMemFs.MkdirAll(path, perm)
+}
+
+func (fs *ChrootOS) Open(filename string) (billy.File, error) {
+	return globalMemFs.Open(filename)
+}
+
+func (fs *ChrootOS) Stat(filename string) (os.FileInfo, error) {
+	return globalMemFs.Stat(filename)
+}
+
+func (fs *ChrootOS) Remove(filename string) error {
+	return globalMemFs.Remove(filename)
+}
+
+func (fs *ChrootOS) Chmod(path string, mode iofs.FileMode) error {
+	return globalMemFs.(billy.Chmod).Chmod(path, mode)
+}
+
+func (fs *ChrootOS) TempFile(dir, prefix string) (billy.File, error) {
+	return globalMemFs.TempFile(dir, prefix)
+}
+
+func (fs *ChrootOS) Join(elem ...string) string {
+	return globalMemFs.Join(elem...)
+}
+
+func (fs *ChrootOS) RemoveAll(path string) error {
+	return util.RemoveAll(globalMemFs, path)
+}
+
+func (fs *ChrootOS) Lstat(filename string) (os.FileInfo, error) {
+	return globalMemFs.Lstat(filename)
+}
+
+func (fs *ChrootOS) Symlink(target, link string) error {
+	return globalMemFs.Symlink(target, link)
+}
+
+func (fs *ChrootOS) Readlink(link string) (string, error) {
+	return globalMemFs.Readlink(link)
+}
+
+// Capabilities implements the Capable interface.
+func (fs *ChrootOS) Capabilities() billy.Capability {
+	return billy.Capabilities(globalMemFs)
+}
+
+// BoundOS is a fs implementation based on the js/wasm in-memory filesystem
+// which is bound to a base dir.
+type BoundOS struct {
+	billy.Filesystem
+	baseDir         string
+	deduplicatePath bool
+}
+
+func newBoundOS(d string, deduplicatePath bool) billy.Filesystem {
+	baseDir := globalMemFs.Join("/", d)
+	return &BoundOS{
+		Filesystem:      chroot.New(globalMemFs, baseDir),
+		baseDir:         baseDir,
+		deduplicatePath: deduplicatePath,
+	}
+}
+
+// Chroot returns a new BoundOS filesystem, with the base dir set to the
+// result of joining the provided path with the underlying base dir.
+func (fs *BoundOS) Chroot(path string) (billy.Filesystem, error) {
+	joined, err := fs.abs(path)
+	if err != nil {
+		return nil, err
+	}
+	return New(joined, WithBoundOS(), WithDeduplicatePath(fs.deduplicatePath)), nil
+}
+
+// Root returns the current base dir of the billy.Filesystem.
+func (fs *BoundOS) Root() string {
+	return fs.baseDir
+}
+
+func (fs *BoundOS) abs(filename string) (string, error) {
+	if filename == "." || filename == "" {
+		return fs.baseDir, nil
+	}
+
+	filename = filepath.ToSlash(filename)
+	filename = filepath.Clean(filename)
+	if strings.HasPrefix(filename, "..") {
+		return "", billy.ErrCrossedBoundary
+	}
+
+	filename = strings.TrimPrefix(filename, string(filepath.Separator))
+	return filepath.Clean(filepath.Join(fs.baseDir, filepath.FromSlash(filename))), nil
+}
+
+// WithBoundOS returns the option of using a Bound filesystem OS.
+func WithBoundOS() Option {
+	return func(o *options) {
+		o.Type = BoundOSFS
+	}
+}
+
+// WithChrootOS returns the option of using a Chroot filesystem OS.
+func WithChrootOS() Option {
+	return func(o *options) {
+		o.Type = ChrootOSFS
+	}
+}
+
+// WithDeduplicatePath toggles the deduplication of the base dir in the path.
+// This option is accepted for API parity with non-js builds and has no effect
+// on the js/wasm in-memory implementation.
+func WithDeduplicatePath(enabled bool) Option {
+	return func(o *options) {
+		o.deduplicatePath = enabled
+	}
+}
+
+type options struct {
+	Type
+	deduplicatePath bool
+}
+
+type Type int
+
+const (
+	ChrootOSFS Type = iota
+	BoundOSFS
+)

osfs/os_js_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/go-git/go-billy/v6"
-	"github.com/go-git/go-billy/v6/helper/chroot"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -33,13 +32,21 @@ func TestCapabilities(t *testing.T) {
 }
 
 func TestDefault(t *testing.T) {
-	want := &chroot.ChrootHelper{} // memfs is wrapped around ChrootHelper.
+	want := &ChrootOS{}
 	got := Default
 
 	if reflect.TypeOf(got) != reflect.TypeOf(want) {
 		t.Errorf("wanted Default to be %T got %T", want, got)
 	}
 }
 
+func TestWithBoundOSReturnsBoundOS(t *testing.T) {
+	got := New(t.TempDir(), WithBoundOS())
+	assert.IsType(t, &BoundOS{}, got)
+}
+
 // API call assertions
 var _ = New("/")
+var _ = New("/", WithBoundOS())
+var _ = New("/", WithChrootOS())
+var _ = New("/", WithDeduplicatePath(false))