added fs tool shell screen for DFS FileSystem

Author: freakmaxi

fs-tool/common/animation.go

@@ -1,9 +1,10 @@
 package common
 
 import (
-	"fmt"
 	"sync"
 	"time"
+
+	"github.com/freakmaxi/kertish-dfs/fs-tool/terminal"
 )
 
 type animation struct {
@@ -12,20 +13,22 @@ type animation struct {
 	stop   chan bool
 	cancel chan bool
 
+	output terminal.Output
 	header string
 }
 
-func NewAnimation(header string) *animation {
+func NewAnimation(output terminal.Output, header string) *animation {
 	return &animation{
 		waitGroup: sync.WaitGroup{},
 		stop:      make(chan bool),
 		cancel:    make(chan bool),
+		output:    output,
 		header:    header,
 	}
 }
 
 func (p *animation) Start() {
-	fmt.Printf("%s |", p.header)
+	p.output.Printf("%s |", p.header)
 
 	p.waitGroup.Add(1)
 	go func() {
@@ -37,17 +40,17 @@ func (p *animation) Start() {
 		for {
 			select {
 			case <-p.stop:
-				fmt.Printf("\033[%dD", 1)
-				fmt.Printf("ok.\n")
+				p.output.Remove(1)
+				p.output.Printf("ok.\n")
 				return
 			case <-p.cancel:
-				fmt.Printf("\033[%dD", 1)
-				fmt.Printf("failed.\n")
+				p.output.Remove(1)
+				p.output.Printf("failed.\n")
 				return
 			default:
 				c := chars[i%len(chars)]
-				fmt.Printf("\033[%dD", 1)
-				fmt.Printf(string(c))
+				p.output.Remove(1)
+				p.output.Printf(string(c))
 				time.Sleep(time.Millisecond * 100)
 			}
 			i++

fs-tool/common/helpers.go

@@ -0,0 +1,93 @@
+package common
+
+import (
+	"fmt"
+	"path"
+	"strings"
+)
+
+const pathSeparator = "/"
+
+func CorrectPaths(paths []string) []string {
+	for i := range paths {
+		folderPath := paths[i]
+
+		if strings.Index(folderPath, pathSeparator) != 0 {
+			folderPath = fmt.Sprintf("%s%s", pathSeparator, folderPath)
+		}
+		folderPath = path.Clean(folderPath)
+
+		if len(folderPath) == 0 {
+			folderPath = pathSeparator
+		}
+
+		paths[i] = folderPath
+	}
+	return paths
+}
+
+func CorrectPath(folderPath string) string {
+	return CorrectPaths([]string{folderPath})[0]
+}
+
+func PathTree(folderPath string) []string {
+	folderPath = CorrectPath(folderPath)
+
+	folderTree := make([]string, 0)
+	split := strings.Split(folderPath, pathSeparator)
+	for len(split) > 0 {
+		p := strings.Join(split, pathSeparator)
+		folderTree = append([]string{CorrectPath(p)}, folderTree...)
+
+		split = split[:len(split)-1]
+	}
+
+	return folderTree
+}
+
+func Split(path string) (string, string) {
+	path = CorrectPath(path)
+	if strings.Compare(path, pathSeparator) == 0 {
+		return pathSeparator, ""
+	}
+
+	idx := strings.LastIndex(path, pathSeparator)
+	if idx == 0 {
+		return pathSeparator, path[1:]
+	}
+
+	return path[:idx], path[idx+1:]
+}
+
+func Join(inputs ...string) string {
+	for i, p := range inputs {
+		if strings.Index(p, pathSeparator) == 0 {
+			p = p[1:]
+		}
+		inputs[i] = p
+	}
+	return CorrectPath(strings.Join(inputs, pathSeparator))
+}
+
+func DivideParts(folderPath string) []string {
+	return strings.Split(folderPath, pathSeparator)
+}
+
+func Absolute(basePath string, folderPath string) string {
+	if strings.Index(folderPath, pathSeparator) == 0 {
+		basePath = pathSeparator
+	}
+
+	targetParts := DivideParts(folderPath)
+	for len(targetParts) > 0 {
+		if strings.Compare(targetParts[0], "..") != 0 {
+			basePath = Join(basePath, targetParts[0])
+			targetParts = targetParts[1:]
+			continue
+		}
+		parentPath, _ := Split(basePath)
+		basePath = parentPath
+		targetParts = targetParts[1:]
+	}
+	return basePath
+}

fs-tool/dfs/head.go

@@ -100,7 +100,7 @@ func Change(headAddresses []string, sources []string, target string, overwrite b
 	case 412:
 		return fmt.Errorf("%s have conflicts between file(s)/folder(s)", sourcesErrorString(sources))
 	case 422:
-		return fmt.Errorf("%s and %s should be absolute paths", sourcesErrorString(sources), target)
+		return fmt.Errorf("%s and %s should be full and absolute paths", sourcesErrorString(sources), target)
 	case 500:
 		if strings.Compare(action, "m") == 0 {
 			action = "move"

fs-tool/flags/change_directory.go

@@ -0,0 +1,69 @@
+package flags
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/freakmaxi/kertish-dfs/fs-tool/common"
+	"github.com/freakmaxi/kertish-dfs/fs-tool/dfs"
+	"github.com/freakmaxi/kertish-dfs/fs-tool/terminal"
+)
+
+type changeDirectoryCommand struct {
+	headAddresses []string
+	output        terminal.Output
+	args          []string
+
+	target string
+
+	CurrentFolder *common.Folder
+}
+
+func NewChangeDirectory(headAddresses []string, output terminal.Output, args []string) execution {
+	return &changeDirectoryCommand{
+		headAddresses: headAddresses,
+		output:        output,
+		args:          args,
+	}
+}
+
+func (c *changeDirectoryCommand) Parse() error {
+	if len(c.args) != 1 {
+		return fmt.Errorf("cd command needs only target parameter")
+	}
+
+	c.target = c.args[0]
+
+	return nil
+}
+
+func (c *changeDirectoryCommand) PrintUsage() {
+	c.output.Println("  cd          Change folders.")
+	c.output.Println("              Ex: cd [target]")
+	c.output.Println("")
+	c.output.Refresh()
+}
+
+func (c *changeDirectoryCommand) Name() string {
+	return "cd"
+}
+
+func (c *changeDirectoryCommand) Execute() error {
+	if strings.Index(c.target, local) == 0 {
+		return fmt.Errorf("cd works only for dfs folder(s)")
+	}
+
+	anim := common.NewAnimation(c.output, "processing...")
+	anim.Start()
+
+	folder, err := dfs.List(c.headAddresses, c.target, false)
+	if err != nil {
+		anim.Cancel()
+		return err
+	}
+	anim.Stop()
+
+	c.CurrentFolder = folder
+
+	return nil
+}

fs-tool/flags/command.go

@@ -2,7 +2,10 @@ package flags
 
 import (
 	"fmt"
+	"os"
 	"path"
+
+	"github.com/freakmaxi/kertish-dfs/fs-tool/terminal"
 )
 
 const local = "local:"
@@ -52,6 +55,7 @@ func (c *Command) printUsage() {
 	fmt.Println("  cp      Copy file or folder.")
 	fmt.Println("  mv      Move file or folder.")
 	fmt.Println("  rm      Remove files and/or folders.")
+	fmt.Println("  sh      Enter shell mode of fs-tool.")
 	fmt.Println()
 }
 
@@ -85,14 +89,14 @@ func (c *Command) Parse() bool {
 		}
 
 		switch arg {
-		case "mkdir", "ls", "cp", "mv", "rm":
+		case "mkdir", "ls", "cp", "mv", "rm", "sh":
 			mrArgs := make([]string, 0)
 			if i+1 < len(c.args) {
 				mrArgs = c.args[i+1:]
 			}
 
 			var err error
-			c.command, err = newExecution([]string{c.headAddress}, arg, mrArgs)
+			c.command, err = newExecution([]string{c.headAddress}, terminal.NewStdOut(), arg, string(os.PathSeparator), mrArgs, c.version)
 			if err != nil {
 				fmt.Println(err.Error())
 				fmt.Println()