Merge branch 'boombuler-params'

cmd/micro/actions.go

@@ -721,6 +721,8 @@ func (v *View) Save(usePlugin bool) bool {
 	if v.Buf.Path == "" {
 		filename, canceled := messenger.Prompt("Filename: ", "Save", NoCompletion)
 		if !canceled {
+			// the filename might or might not be quoted, so unquote first then join the strings.
+			filename = strings.Join(SplitCommandArgs(filename), " ")
 			v.Buf.Path = filename
 			v.Buf.Name = filename
 		} else {
@@ -1013,6 +1015,9 @@ func (v *View) OpenFile(usePlugin bool) bool {
 		if canceled {
 			return false
 		}
+		// the filename might or might not be quoted, so unquote first then join the strings.
+		filename = strings.Join(SplitCommandArgs(filename), " ")
+
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
 		file, err := ioutil.ReadFile(filename)

cmd/micro/command.go

@@ -225,7 +225,7 @@ func Bind(args []string) {
 // Run runs a shell command in the background
 func Run(args []string) {
 	// Run a shell command in the background (openTerm is false)
-	HandleShellCommand(strings.Join(args, " "), false)
+	HandleShellCommand(JoinCommandArgs(args...), false)
 }
 
 // Quit closes the main view
@@ -242,40 +242,20 @@ func Save(args []string) {
 
 // Replace runs search and replace
 func Replace(args []string) {
-	// This is a regex to parse the replace expression
-	// We allow no quotes if there are no spaces, but if you want to search
-	// for or replace an expression with spaces, you can add double quotes
-	r := regexp.MustCompile(`"[^"\\]*(?:\\.[^"\\]*)*"|[^\s]*`)
-	replaceCmd := r.FindAllString(strings.Join(args, " "), -1)
-	if len(replaceCmd) < 2 {
+	if len(args) < 2 {
 		// We need to find both a search and replace expression
 		messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
 		return
 	}
 
 	var flags string
-	if len(replaceCmd) == 3 {
+	if len(args) == 3 {
 		// The user included some flags
-		flags = replaceCmd[2]
+		flags = args[2]
 	}
 
-	search := string(replaceCmd[0])
-	replace := string(replaceCmd[1])
-
-	// If the search and replace expressions have quotes, we need to remove those
-	if strings.HasPrefix(search, `"`) && strings.HasSuffix(search, `"`) {
-		search = search[1 : len(search)-1]
-	}
-	if strings.HasPrefix(replace, `"`) && strings.HasSuffix(replace, `"`) {
-		replace = replace[1 : len(replace)-1]
-	}
-
-	// We replace all escaped double quotes to real double quotes
-	search = strings.Replace(search, `\"`, `"`, -1)
-	replace = strings.Replace(replace, `\"`, `"`, -1)
-	// Replace some things so users can actually insert newlines and tabs in replacements
-	replace = strings.Replace(replace, "\\n", "\n", -1)
-	replace = strings.Replace(replace, "\\t", "\t", -1)
+	search := string(args[0])
+	replace := string(args[1])
 
 	regex, err := regexp.Compile(search)
 	if err != nil {
@@ -346,8 +326,8 @@ func Replace(args []string) {
 
 // RunShellCommand executes a shell command and returns the output/error
 func RunShellCommand(input string) (string, error) {
-	inputCmd := strings.Split(input, " ")[0]
-	args := strings.Split(input, " ")[1:]
+	inputCmd := SplitCommandArgs(input)[0]
+	args := SplitCommandArgs(input)[1:]
 
 	cmd := exec.Command(inputCmd, args...)
 	outputBytes := &bytes.Buffer{}
@@ -363,7 +343,7 @@ func RunShellCommand(input string) (string, error) {
 // The openTerm argument specifies whether a terminal should be opened (for viewing output
 // or interacting with stdin)
 func HandleShellCommand(input string, openTerm bool) {
-	inputCmd := strings.Split(input, " ")[0]
+	inputCmd := SplitCommandArgs(input)[0]
 	if !openTerm {
 		// Simply run the command in the background and notify the user when it's done
 		messenger.Message("Running...")
@@ -388,7 +368,7 @@ func HandleShellCommand(input string, openTerm bool) {
 		screen.Fini()
 		screen = nil
 
-		args := strings.Split(input, " ")[1:]
+		args := SplitCommandArgs(input)[1:]
 
 		// Set up everything for the command
 		cmd := exec.Command(inputCmd, args...)
@@ -420,12 +400,12 @@ func HandleShellCommand(input string, openTerm bool) {
 
 // HandleCommand handles input from the user
 func HandleCommand(input string) {
-	inputCmd := strings.Split(input, " ")[0]
-	args := strings.Split(input, " ")[1:]
+	args := SplitCommandArgs(input)
+	inputCmd := args[0]
 
 	if _, ok := commands[inputCmd]; !ok {
 		messenger.Error("Unknown command ", inputCmd)
 	} else {
-		commands[inputCmd].action(args)
+		commands[inputCmd].action(args[1:])
 	}
 }

cmd/micro/messenger.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"strconv"
-	"strings"
 
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
@@ -206,7 +205,7 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 				response, canceled = m.response, false
 				m.history[historyType][len(m.history[historyType])-1] = response
 			case tcell.KeyTab:
-				args := strings.Split(m.response, " ")
+				args := SplitCommandArgs(m.response)
 				currentArgNum := len(args) - 1
 				currentArg := args[currentArgNum]
 				var completionType Completion
@@ -241,10 +240,7 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 				}
 
 				if chosen != "" {
-					if len(args) > 1 {
-						chosen = " " + chosen
-					}
-					m.response = strings.Join(args[:len(args)-1], " ") + chosen
+					m.response = JoinCommandArgs(append(args[:len(args)-1], chosen)...)
 					m.cursorx = Count(m.response)
 				}
 			}

cmd/micro/util.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -220,6 +221,76 @@ func Abs(n int) int {
 	return n
 }
 
+// FuncName returns the name of a given function object
 func FuncName(i interface{}) string {
 	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
 }
+
+// SplitCommandArgs seperates multiple command arguments which may be quoted.
+// The returned slice contains at least one string
+func SplitCommandArgs(input string) []string {
+	var result []string
+	curArg := new(bytes.Buffer)
+	inQuote := false
+	escape := false
+
+	appendResult := func() {
+		str := curArg.String()
+		inQuote = false
+		escape = false
+		if strings.HasPrefix(str, `"`) && strings.HasSuffix(str, `"`) {
+			if unquoted, err := strconv.Unquote(str); err == nil {
+				str = unquoted
+			}
+		}
+		result = append(result, str)
+		curArg.Reset()
+	}
+
+	for _, r := range input {
+		if r == ' ' && !inQuote {
+			appendResult()
+		} else {
+			curArg.WriteRune(r)
+
+			if r == '"' && !inQuote {
+				inQuote = true
+			} else {
+				if inQuote && !escape {
+					if r == '"' {
+						inQuote = false
+					}
+					if r == '\\' {
+						escape = true
+						continue
+					}
+				}
+			}
+		}
+
+		escape = false
+	}
+	appendResult()
+	return result
+}
+
+// JoinCommandArgs joins multiple command arguments and quote the strings if needed.
+func JoinCommandArgs(args ...string) string {
+	buf := new(bytes.Buffer)
+	first := true
+	for _, arg := range args {
+		if first {
+			first = false
+		} else {
+			buf.WriteRune(' ')
+		}
+		quoted := strconv.Quote(arg)
+		if quoted[1:len(quoted)-1] != arg || strings.ContainsRune(arg, ' ') {
+			buf.WriteString(quoted)
+		} else {
+			buf.WriteString(arg)
+		}
+	}
+
+	return buf.String()
+}

cmd/micro/util_test.go

@@ -1,6 +1,9 @@
 package main
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
 
 func TestNumOccurences(t *testing.T) {
 	var tests = []struct {
@@ -63,3 +66,48 @@ func TestIsWordChar(t *testing.T) {
 		t.Errorf("IsWordChar(\n)) = true")
 	}
 }
+
+func TestJoinAndSplitCommandArgs(t *testing.T) {
+	tests := []struct {
+		Query  []string
+		Wanted string
+	}{
+		{[]string{`test case`}, `"test case"`},
+		{[]string{`quote "test"`}, `"quote \"test\""`},
+		{[]string{`slash\\\ test`}, `"slash\\\\\\ test"`},
+		{[]string{`path 1`, `path\" 2`}, `"path 1" "path\\\" 2"`},
+		{[]string{`foo`}, `foo`},
+		{[]string{`foo\"bar`}, `"foo\\\"bar"`},
+		{[]string{``}, ``},
+		{[]string{`"`}, `"\""`},
+		{[]string{`a`, ``}, `a `},
+		{[]string{``, ``, ``, ``}, `   `},
+		{[]string{"\n"}, `"\n"`},
+		{[]string{"foo\tbar"}, `"foo\tbar"`},
+	}
+
+	for i, test := range tests {
+		if result := JoinCommandArgs(test.Query...); test.Wanted != result {
+			t.Errorf("JoinCommandArgs failed at Test %d\nGot: %q", i, result)
+		}
+
+		if result := SplitCommandArgs(test.Wanted); !reflect.DeepEqual(test.Query, result) {
+			t.Errorf("SplitCommandArgs failed at Test %d\nGot: `%q`", i, result)
+		}
+	}
+
+	splitTests := []struct {
+		Query  string
+		Wanted []string
+	}{
+		{`"hallo""Welt"`, []string{`"hallo""Welt"`}},
+		{`\"`, []string{`\"`}},
+		{`"\"`, []string{`"\"`}},
+	}
+
+	for i, test := range splitTests {
+		if result := SplitCommandArgs(test.Query); !reflect.DeepEqual(test.Wanted, result) {
+			t.Errorf("SplitCommandArgs failed at Split-Test %d\nGot: `%q`", i, result)
+		}
+	}
+}