*: Readlink and Symlink implementation (#32)

Author: mcuadros

fs.go

@@ -39,21 +39,14 @@ type Filesystem interface {
 	MkdirAll(filename string, perm os.FileMode) error
 	Join(elem ...string) string
 	Dir(path string) Filesystem
-	Base() string
-}
-
-// Symlinker is a Filesystem with support for creating symlinks.
-type Symlinker interface {
-	Filesystem
-
 	// Symlink creates a symbolic-link from link to target. target may be an
 	// absolute or relative path, and need not refer to an existing node.
 	// Parent directories of link are created as necessary.
 	Symlink(target, link string) error
-
 	// Readlink returns the target path of link. An error is returned if link is
 	// not a symbolic-link.
 	Readlink(link string) (string, error)
+	Base() string
 }
 
 // File implements io.Closer, io.Reader, io.Seeker, and io.Writer>

memfs/memory.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"gopkg.in/src-d/go-billy.v2"
@@ -20,13 +21,19 @@ type Memory struct {
 	s    *storage
 
 	tempCount int
+	links     map[string]internalLink
+}
+
+type internalLink struct {
+	Name, Target string
 }
 
 //New returns a new Memory filesystem
 func New() *Memory {
 	return &Memory{
-		base: string(separator),
-		s:    newStorage(),
+		base:  string(separator),
+		s:     newStorage(),
+		links: make(map[string]internalLink),
 	}
 }
 
@@ -42,8 +49,7 @@ func (fs *Memory) Open(filename string) (billy.File, error) {
 
 // OpenFile returns the file from a given name with given flag and permits.
 func (fs *Memory) OpenFile(filename string, flag int, perm os.FileMode) (billy.File, error) {
-	path := fs.Join(fs.base, filename)
-
+	path := fs.resolvePath(filename)
 	f, has := fs.s.Get(path)
 	if !has {
 		if !isCreate(flag) {
@@ -69,21 +75,48 @@ func (fs *Memory) OpenFile(filename string, flag int, perm os.FileMode) (billy.F
 	return f.Duplicate(filename, perm, flag), nil
 }
 
+func (fs *Memory) resolvePath(path string) string {
+	fullpath := clean(fs.Join(fs.base, path))
+	l, ok := fs.links[fullpath]
+	if !ok {
+		return fullpath
+	}
+
+	if isAbs(l.Target) {
+		return l.Target
+	}
+
+	return fs.resolvePath(fs.Join(filepath.Dir(fullpath), l.Target))
+}
+
+// On Windows OS, IsAbs validates if a path is valid based on if stars with a
+// unit (eg.: `C:\`)  to assert that is absolute, but in this mem implementation
+// any path starting by `separator` is also considered absolute.
+func isAbs(path string) bool {
+	return filepath.IsAbs(path) || strings.HasPrefix(path, string(separator))
+}
+
 // Stat returns a billy.FileInfo with the information of the requested file.
 func (fs *Memory) Stat(filename string) (billy.FileInfo, error) {
-	fullpath := fs.Join(fs.base, filename)
-
+	fullpath := fs.resolvePath(filename)
 	f, has := fs.s.Get(fullpath)
 	if !has {
 		return nil, os.ErrNotExist
 	}
 
-	return f.Stat(), nil
+	fi := f.Stat().(*fileInfo)
+
+	// the name of the file should always the name of the stated file, so we
+	// overwrite the Stat returned from the storage with it, since the
+	// filename may belong to a link.
+	fi.name = filepath.Base(filename)
+
+	return fi, nil
 }
 
 // ReadDir returns a list of billy.FileInfo in the given directory.
 func (fs *Memory) ReadDir(path string) ([]billy.FileInfo, error) {
-	path = fs.Join(fs.base, path)
+	path = fs.resolvePath(path)
 
 	var entries []billy.FileInfo
 	for _, f := range fs.s.Children(path) {
@@ -128,18 +161,49 @@ func (fs *Memory) getTempFilename(dir, prefix string) string {
 
 // Rename moves a the `from` file to the `to` file.
 func (fs *Memory) Rename(from, to string) error {
+	if fs.renameIfLink(from, to) {
+		return nil
+	}
+
 	from = fs.Join(fs.base, from)
 	to = fs.Join(fs.base, to)
 
 	return fs.s.Rename(from, to)
 }
 
+func (fs *Memory) renameIfLink(from, to string) bool {
+	from = clean(fs.Join(fs.base, from))
+	to = clean(fs.Join(fs.base, to))
+
+	if _, ok := fs.links[from]; !ok {
+		return false
+	}
+
+	fs.links[to] = fs.links[from]
+	delete(fs.links, from)
+	return true
+}
+
 // Remove deletes a given file from storage.
 func (fs *Memory) Remove(filename string) error {
+	if fs.removeIfLink(filename) {
+		return nil
+	}
+
 	fullpath := fs.Join(fs.base, filename)
 	return fs.s.Remove(fullpath)
 }
 
+func (fs *Memory) removeIfLink(filename string) bool {
+	fullpath := clean(fs.Join(fs.base, filename))
+	if _, ok := fs.links[fullpath]; !ok {
+		return false
+	}
+
+	delete(fs.links, fullpath)
+	return true
+}
+
 // Join joins any number of path elements into a single path, adding a Separator if necessary.
 func (fs *Memory) Join(elem ...string) string {
 	return filepath.Join(elem...)
@@ -154,6 +218,29 @@ func (fs *Memory) Dir(path string) billy.Filesystem {
 	}
 }
 
+func (fs *Memory) Symlink(target, link string) error {
+	if _, err := fs.Stat(link); err == nil {
+		return os.ErrExist
+	}
+
+	fullpath := clean(fs.Join(fs.base, link))
+	fs.links[fullpath] = internalLink{
+		Name:   link,
+		Target: clean(target),
+	}
+
+	return nil
+}
+
+func (fs *Memory) Readlink(link string) (string, error) {
+	fullpath := clean(fs.Join(fs.base, link))
+	if l, ok := fs.links[fullpath]; ok {
+		return l.Target, nil
+	}
+
+	return "", os.ErrNotExist
+}
+
 // Base returns the base path for the filesystem.
 func (fs *Memory) Base() string {
 	return fs.base

memfs/storage.go

@@ -22,14 +22,14 @@ func newStorage() *storage {
 }
 
 func (s *storage) Has(path string) bool {
-	path = filepath.Clean(path)
+	path = clean(path)
 
 	_, ok := s.files[path]
 	return ok
 }
 
 func (s *storage) New(path string, mode os.FileMode, flag int) (*file, error) {
-	path = filepath.Clean(path)
+	path = clean(path)
 	if s.Has(path) {
 		if !s.MustGet(path).mode.IsDir() {
 			return nil, fmt.Errorf("file already exists %q", path)
@@ -54,7 +54,7 @@ func (s *storage) New(path string, mode os.FileMode, flag int) (*file, error) {
 
 func (s *storage) createParent(path string, mode os.FileMode, f *file) error {
 	base := filepath.Dir(path)
-	base = filepath.Clean(base)
+	base = clean(base)
 	if f.Filename() == string(separator) {
 		return nil
 	}
@@ -72,7 +72,7 @@ func (s *storage) createParent(path string, mode os.FileMode, f *file) error {
 }
 
 func (s *storage) Children(path string) []*file {
-	path = filepath.Clean(path)
+	path = clean(path)
 
 	l := make([]*file, 0)
 	for _, f := range s.children[path] {
@@ -92,7 +92,7 @@ func (s *storage) MustGet(path string) *file {
 }
 
 func (s *storage) Get(path string) (*file, bool) {
-	path = filepath.Clean(path)
+	path = clean(path)
 	if !s.Has(path) {
 		return nil, false
 	}
@@ -102,8 +102,8 @@ func (s *storage) Get(path string) (*file, bool) {
 }
 
 func (s *storage) Rename(from, to string) error {
-	from = filepath.Clean(from)
-	to = filepath.Clean(to)
+	from = clean(from)
+	to = clean(to)
 
 	if !s.Has(from) {
 		return os.ErrNotExist
@@ -149,7 +149,7 @@ func (s *storage) move(from, to string) error {
 }
 
 func (s *storage) Remove(path string) error {
-	path = filepath.Clean(path)
+	path = clean(path)
 
 	f, has := s.Get(path)
 	if !has {
@@ -168,6 +168,10 @@ func (s *storage) Remove(path string) error {
 	return nil
 }
 
+func clean(path string) string {
+	return filepath.Clean(filepath.FromSlash(path))
+}
+
 type content struct {
 	bytes []byte
 }

osfs/os.go

@@ -6,6 +6,8 @@ import (
 	"os"
 	"path/filepath"
 
+	"strings"
+
 	"gopkg.in/src-d/go-billy.v2"
 )
 
@@ -35,7 +37,7 @@ func (fs *OS) Create(filename string) (billy.File, error) {
 // OpenFile is equivalent to standard os.OpenFile.
 // If flag os.O_CREATE is set, all parent directories will be created.
 func (fs *OS) OpenFile(filename string, flag int, perm os.FileMode) (billy.File, error) {
-	fullpath := fs.Join(fs.base, filename)
+	fullpath := fs.absolutize(filename)
 
 	if flag&os.O_CREATE != 0 {
 		if err := fs.createDir(fullpath); err != nil {
@@ -70,7 +72,7 @@ func (fs *OS) createDir(fullpath string) error {
 // ReadDir returns the filesystem info for all the archives under the specified
 // path.
 func (fs *OS) ReadDir(path string) ([]billy.FileInfo, error) {
-	fullpath := fs.Join(fs.base, path)
+	fullpath := fs.absolutize(path)
 
 	l, err := ioutil.ReadDir(fullpath)
 	if err != nil {
@@ -87,8 +89,8 @@ func (fs *OS) ReadDir(path string) ([]billy.FileInfo, error) {
 
 // Rename moves a file in disk from _from_ to _to_.
 func (fs *OS) Rename(from, to string) error {
-	from = fs.Join(fs.base, from)
-	to = fs.Join(fs.base, to)
+	from = fs.absolutize(from)
+	to = fs.absolutize(to)
 
 	if err := fs.createDir(to); err != nil {
 		return err
@@ -99,7 +101,7 @@ func (fs *OS) Rename(from, to string) error {
 
 // MkdirAll creates a directory.
 func (fs *OS) MkdirAll(path string, perm os.FileMode) error {
-	fullpath := fs.Join(fs.base, path)
+	fullpath := fs.absolutize(path)
 	return os.MkdirAll(fullpath, defaultDirectoryMode)
 }
 
@@ -108,21 +110,15 @@ func (fs *OS) Open(filename string) (billy.File, error) {
 	return fs.OpenFile(filename, os.O_RDONLY, 0)
 }
 
-// Stat returns the FileInfo structure describing file.
-func (fs *OS) Stat(filename string) (billy.FileInfo, error) {
-	fullpath := fs.Join(fs.base, filename)
-	return os.Stat(fullpath)
-}
-
 // Remove deletes a file in disk.
 func (fs *OS) Remove(filename string) error {
-	fullpath := fs.Join(fs.base, filename)
+	fullpath := fs.absolutize(filename)
 	return os.Remove(fullpath)
 }
 
 // TempFile creates a new temporal file.
 func (fs *OS) TempFile(dir, prefix string) (billy.File, error) {
-	fullpath := fs.Join(fs.base, dir)
+	fullpath := fs.absolutize(dir)
 	if err := fs.createDir(fullpath + string(os.PathSeparator)); err != nil {
 		return nil, err
 	}
@@ -153,7 +149,7 @@ func (fs *OS) Join(elem ...string) string {
 // Dir returns a new Filesystem from the same type of fs using as baseDir the
 // given path
 func (fs *OS) Dir(path string) billy.Filesystem {
-	return New(fs.Join(fs.base, path))
+	return New(fs.absolutize(path))
 }
 
 // Base returns the base path of the filesytem
@@ -170,12 +166,14 @@ func (fs *OS) RemoveAll(path string) error {
 
 // Symlink imlements billy.Symlinker.Symlink.
 func (fs *OS) Symlink(target, link string) error {
-	if filepath.IsAbs(target) {
-		// only rewrite target if it's already absolute
-		target = fs.Join(fs.base, target)
+	target = filepath.FromSlash(target)
+
+	// only rewrite target if it's already absolute
+	if filepath.IsAbs(target) || strings.HasPrefix(target, string(filepath.Separator)) {
+		target = fs.absolutize(target)
 	}
-	link = fs.Join(fs.base, link)
 
+	link = fs.absolutize(link)
 	if err := fs.createDir(link); err != nil {
 		return err
 	}
@@ -191,7 +189,7 @@ func (fs *OS) Readlink(link string) (string, error) {
 		return "", err
 	}
 
-	if !filepath.IsAbs(target) {
+	if !filepath.IsAbs(target) && !strings.HasPrefix(target, string(filepath.Separator)) {
 		return target, nil
 	}
 
@@ -237,3 +235,10 @@ func (f *osFile) Close() error {
 func (f *osFile) ReadAt(p []byte, off int64) (int, error) {
 	return f.file.ReadAt(p, off)
 }
+
+func (fs *OS) absolutize(relpath string) string {
+	fullpath := filepath.FromSlash(filepath.ToSlash(relpath))
+
+	fullpath = fs.Join(fs.base, fullpath)
+	return filepath.Clean(fullpath)
+}