From b28e301e65571d4b92b1d06c5d14600de8debd9e Mon Sep 17 00:00:00 2001
From: Mark Bates <mark@markbates.com>
Date: Sat, 21 Sep 2019 17:22:59 -0400
Subject: [PATCH] party

---
 pkger.go       | 89 ++++++++++++--------------------------------------
 pkging/wrap.go |  8 +++++
 2 files changed, 28 insertions(+), 69 deletions(-)

diff --git a/pkger.go b/pkger.go
index 0a100da..2347997 100644
--- a/pkger.go
+++ b/pkger.go
@@ -1,6 +1,7 @@
 package pkger
 
 import (
+	"fmt"
 	"log"
 	"os"
 	"path/filepath"
@@ -18,117 +19,67 @@ var disk = func() pkging.Pkger {
 	return n
 }()
 
-func Parse(p string) (pkging.Path, error) {
+func impl() pkging.Pkger {
 	gil.RLock()
 	defer gil.RUnlock()
 	if current == nil {
-		return disk.Parse(p)
+		return disk
 	}
-	return current.Parse(p)
+	fmt.Printf("!> using %s\n", current)
+	return current
+}
+
+func Parse(p string) (pkging.Path, error) {
+	return impl().Parse(p)
 }
 
 func Abs(p string) (string, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Abs(p)
-	}
-	return current.Abs(p)
+	return impl().Abs(p)
 }
 
 func AbsPath(p pkging.Path) (string, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.AbsPath(p)
-	}
-	return current.AbsPath(p)
+	return impl().AbsPath(p)
 }
 
 func Current() (here.Info, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Current()
-	}
-	return current.Current()
+	return impl().Current()
 }
 
 func Info(p string) (here.Info, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Info(p)
-	}
-	return current.Info(p)
+	return impl().Info(p)
 }
 
 // Create creates the named file with mode 0666 (before umask) - It's actually 0644, truncating it if it already exists. If successful, methods on the returned File can be used for I/O; the associated file descriptor has mode O_RDWR.
 func Create(p string) (pkging.File, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Create(p)
-	}
-	return current.Create(p)
+	return impl().Create(p)
 }
 
 // MkdirAll creates a directory named path, along with any necessary parents, and returns nil, or else returns an error. The permission bits perm (before umask) are used for all directories that MkdirAll creates. If path is already a directory, MkdirAll does nothing and returns nil.
 func MkdirAll(p string, perm os.FileMode) error {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.MkdirAll(p, perm)
-	}
-	return current.MkdirAll(p, perm)
+	return impl().MkdirAll(p, perm)
 }
 
 // Open opens the named file for reading. If successful, methods on the returned file can be used for reading; the associated file descriptor has mode O_RDONLY.
 func Open(p string) (pkging.File, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Open(p)
-	}
-	return current.Open(p)
+	return impl().Open(p)
 }
 
 // Stat returns a FileInfo describing the named file.
 func Stat(name string) (os.FileInfo, error) {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Stat(name)
-	}
-	return current.Stat(name)
+	return impl().Stat(name)
 }
 
 // Walk walks the file tree rooted at root, calling walkFn for each file or directory in the tree, including root. All errors that arise visiting files and directories are filtered by walkFn. The files are walked in lexical order, which makes the output deterministic but means that for very large directories Walk can be inefficient. Walk does not follow symbolic links. - That is from the standard library. I know. Their grammar teachers can not be happy with them right now.
 func Walk(p string, wf filepath.WalkFunc) error {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Walk(p, wf)
-	}
-	return current.Walk(p, wf)
+	return impl().Walk(p, wf)
 }
 
 // Remove removes the named file or (empty) directory.
 func Remove(name string) error {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.Remove(name)
-	}
-	return current.Remove(name)
+	return impl().Remove(name)
 }
 
 // RemoveAll removes path and any children it contains. It removes everything it can but returns the first error it encounters. If the path does not exist, RemoveAll returns nil (no error).
 func RemoveAll(name string) error {
-	gil.RLock()
-	defer gil.RUnlock()
-	if current == nil {
-		return disk.RemoveAll(name)
-	}
-	return current.RemoveAll(name)
+	return impl().RemoveAll(name)
 }
diff --git a/pkging/wrap.go b/pkging/wrap.go
index 5c40519..20d0b5d 100644
--- a/pkging/wrap.go
+++ b/pkging/wrap.go
@@ -1,6 +1,7 @@
 package pkging
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
@@ -19,6 +20,13 @@ type withPkger struct {
 	parent Pkger
 }
 
+func (w withPkger) String() string {
+	if w.parent == nil {
+		return fmt.Sprintf("%T", w.base)
+	}
+	return fmt.Sprintf("%T > %T", w.base, w.parent)
+}
+
 func (w withPkger) Parse(p string) (Path, error) {
 	pt, err := w.base.Parse(p)
 	if err != nil {