Add Capability function to query fs capabilities

fs.go

@@ -13,6 +13,28 @@ var (
 	ErrCrossedBoundary = errors.New("chroot boundary crossed")
 )
 
+// Capability holds the supported features of a filesystem.
+type Capability uint64
+
+const (
+	// CapWrite means that the fs is writable.
+	CapWrite Capability = 1 << iota
+	// CapRead means that the fs is readable.
+	CapRead
+	// CapReadAndWrite is the ability to open a file in read and write mode.
+	CapReadAndWrite
+	// CapSeek means it is able to move position inside the file.
+	CapSeek
+	// CapTruncate means that a file can be truncated.
+	CapTruncate
+	// CapLock is the ability to lock a file.
+	CapLock
+
+	// CapAll lists all capable features.
+	CapAll Capability = CapWrite | CapRead | CapReadAndWrite |
+		CapSeek | CapTruncate | CapLock
+)
+
 // Filesystem abstract the operations in a storage-agnostic interface.
 // Each method implementation mimics the behavior of the equivalent functions
 // at the os package from the standard library.
@@ -143,3 +165,27 @@ type File interface {
 	// Truncate the file.
 	Truncate(size int64) error
 }
+
+// Capable interface can return the available features of a filesystem.
+type Capable interface {
+	// Capabilities returns the capabilities of a filesystem in bit flags.
+	Capabilities() Capability
+}
+
+// Capabilities returns the features supported by a filesystem. If the FS
+// does not implement Capable interface it returns all features.
+func Capabilities(fs Basic) Capability {
+	capable, ok := fs.(Capable)
+	if !ok {
+		return CapAll
+	}
+
+	return capable.Capabilities()
+}
+
+// CapabilityCheck tests the filesystem for the provided capabilities and
+// returns true in case it supports all of them.
+func CapabilityCheck(fs Basic, capabilities Capability) bool {
+	fsCaps := Capabilities(fs)
+	return fsCaps&capabilities == capabilities
+}

fs_test.go

@@ -0,0 +1,37 @@
+package billy_test
+
+import (
+	"testing"
+
+	. "gopkg.in/src-d/go-billy.v4"
+	"gopkg.in/src-d/go-billy.v4/memfs"
+
+	. "gopkg.in/check.v1"
+)
+
+type FSSuite struct{}
+
+func Test(t *testing.T) { TestingT(t) }
+
+var _ = Suite(&FSSuite{})
+
+func (s *FSSuite) TestCapabilities(c *C) {
+	cases := []struct {
+		caps     Capability
+		expected bool
+	}{
+		{CapLock, false},
+		{CapRead, true},
+		{CapRead | CapWrite, true},
+		{CapRead | CapWrite | CapReadAndWrite | CapTruncate, true},
+		{CapRead | CapWrite | CapReadAndWrite | CapTruncate | CapLock, false},
+		{CapTruncate | CapLock, false},
+	}
+
+	// This filesystem supports all capabilities except for CapLock
+	mem := memfs.New()
+
+	for _, e := range cases {
+		c.Assert(CapabilityCheck(mem, e.caps), Equals, e.expected)
+	}
+}

helper/chroot/chroot.go

@@ -217,6 +217,11 @@ func (fs *ChrootHelper) Underlying() billy.Basic {
 	return fs.underlying
 }
 
+// Capabilities implements the Capable interface.
+func (fs *ChrootHelper) Capabilities() billy.Capability {
+	return billy.Capabilities(fs.underlying)
+}
+
 type file struct {
 	billy.File
 	name string

helper/mount/mount.go

@@ -167,6 +167,11 @@ func (h *Mount) Underlying() billy.Basic {
 	return h.underlying
 }
 
+// Capabilities implements the Capable interface.
+func (fs *Mount) Capabilities() billy.Capability {
+	return billy.Capabilities(fs.underlying)
+}
+
 func (fs *Mount) getBasicAndPath(path string) (billy.Basic, string) {
 	path = cleanPath(path)
 	if !fs.isMountpoint(path) {

helper/polyfill/polyfill.go

@@ -98,3 +98,8 @@ func (h *Polyfill) Root() string {
 func (h *Polyfill) Underlying() billy.Basic {
 	return h.Basic
 }
+
+// Capabilities implements the Capable interface.
+func (h *Polyfill) Capabilities() billy.Capability {
+	return billy.Capabilities(h.Basic)
+}

memfs/memory.go

@@ -190,6 +190,15 @@ func (fs *Memory) Readlink(link string) (string, error) {
 	return string(f.content.bytes), nil
 }
 
+// Capabilities implements the Capable interface.
+func (fs *Memory) Capabilities() billy.Capability {
+	return billy.CapWrite |
+		billy.CapRead |
+		billy.CapReadAndWrite |
+		billy.CapSeek |
+		billy.CapTruncate
+}
+
 type file struct {
 	name     string
 	content  *content
@@ -273,7 +282,7 @@ func (f *file) Close() error {
 func (f *file) Truncate(size int64) error {
 	if size < int64(len(f.content.bytes)) {
 		f.content.bytes = f.content.bytes[:size]
-	} else if more := int(size)-len(f.content.bytes); more > 0 {
+	} else if more := int(size) - len(f.content.bytes); more > 0 {
 		f.content.bytes = append(f.content.bytes, make([]byte, more)...)
 	}
 

memfs/memory_test.go

@@ -3,6 +3,7 @@ package memfs
 import (
 	"testing"
 
+	"gopkg.in/src-d/go-billy.v4"
 	"gopkg.in/src-d/go-billy.v4/test"
 
 	. "gopkg.in/check.v1"
@@ -20,3 +21,11 @@ var _ = Suite(&MemorySuite{})
 func (s *MemorySuite) SetUpTest(c *C) {
 	s.FilesystemSuite = test.NewFilesystemSuite(New())
 }
+
+func (s *MemorySuite) TestCapabilities(c *C) {
+	_, ok := s.FS.(billy.Capable)
+	c.Assert(ok, Equals, true)
+
+	caps := billy.Capabilities(s.FS)
+	c.Assert(caps, Equals, billy.CapAll&^billy.CapLock)
+}

osfs/os.go

@@ -127,6 +127,11 @@ func (fs *OS) Readlink(link string) (string, error) {
 	return os.Readlink(link)
 }
 
+// Capabilities implements the Capable interface.
+func (fs *OS) Capabilities() billy.Capability {
+	return billy.CapAll
+}
+
 // file is a wrapper for an os.File which adds support for file locking.
 type file struct {
 	*os.File

osfs/os_test.go

@@ -6,8 +6,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "gopkg.in/check.v1"
+	"gopkg.in/src-d/go-billy.v4"
 	"gopkg.in/src-d/go-billy.v4/test"
+
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }
@@ -36,3 +38,11 @@ func (s *OSSuite) TestOpenDoesNotCreateDir(c *C) {
 	_, err = os.Stat(filepath.Join(s.path, "dir"))
 	c.Assert(os.IsNotExist(err), Equals, true)
 }
+
+func (s *OSSuite) TestCapabilities(c *C) {
+	_, ok := s.FS.(billy.Capable)
+	c.Assert(ok, Equals, true)
+
+	caps := billy.Capabilities(s.FS)
+	c.Assert(caps, Equals, billy.CapAll)
+}