cli complete

cli.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 )
 
+var ErrQuit = errors.New("received quit")
+
 func main() {
 	conf, err := remote.NewConfig()
 	if err != nil {
@@ -24,7 +26,9 @@ func main() {
 	for {
 		line := readLine()
 		first := strings.Split(line, " ")[0]
-		if err := doLine(buffer, first, line); err != nil {
+		if err := doLine(buffer, first, line); err == ErrQuit {
+			break
+		} else if err != nil {
 			log.Printf("err doing %s: %v", first, err)
 		}
 	}
@@ -37,6 +41,7 @@ func readLine() string {
 }
 
 func doLine(buffer *mytinytodo.Buffer, key, line string) error {
+	segments := strings.Split(line, " ")
 	defer func() {
 		if err := recover(); err != nil {
 			log.Printf("err on %s: %v", key, err)
@@ -47,11 +52,6 @@ func doLine(buffer *mytinytodo.Buffer, key, line string) error {
 	case "refresh":
 		buffer.RefreshLocal()
 		err = nil
-	case "dequeue":
-		buffer.Dequeue()
-		err = nil
-	case "enqueue":
-		err = errors.New("not impl")
 	case "lists":
 		var lists remote.Lists
 		lists, err = buffer.Lists()
@@ -60,17 +60,54 @@ func doLine(buffer *mytinytodo.Buffer, key, line string) error {
 		}
 	case "tasks":
 		var tasks remote.Tasks
-		id := strings.Split(line, " ")[1]
+		id := segments[1]
 		tasks, err = buffer.Tasks(remote.List{ID: id})
 		if err == nil {
 			log.Printf("%s: %v", key, tasks)
 		}
+	case "enqueue":
+		action := segments[1]
+		err = fmt.Errorf("unknown enqueue op %v", action)
+		op := remote.OpFromString(action)
+		var listID, taskTitle, taskID string
+		var taskTags []string
+		switch op {
+		case remote.NEW:
+			op = remote.NEW
+			listID = segments[2]
+			taskTitle = strings.Join(segments[3:], " ")
+			taskTagsStr := segments[len(segments)-1]
+			if strings.HasPrefix(taskTagsStr, "/") && strings.HasSuffix(taskTagsStr, "/") {
+				taskTitle = strings.TrimSuffix(taskTitle, taskTagsStr)
+				taskTags = strings.Split(taskTagsStr[1:len(taskTagsStr)-1], ",")
+			}
+		case remote.CLOSE:
+			fallthrough
+		case remote.OPEN:
+			taskID = segments[2]
+		}
+		err = buffer.Enqueue(op, remote.List{ID: listID}, remote.Task{Title: taskTitle, ID: taskID}, taskTags...)
+	case "dequeue":
+		buffer.Dequeue()
+		err = nil
+	case "help":
+		fallthrough
+	case "h":
+		log.Printf("refresh")
+		log.Printf("lists")
+		log.Printf("tasks <list#>")
+		log.Printf("enqueue new <list#> <taskName> /tag1,tag2,tag3/")
+		log.Printf("enqueue <close,open> <task#>")
+		log.Printf("dequeue")
+		log.Printf("help")
+		log.Printf("quit")
+		err = nil
 	case "quit":
 		fallthrough
 	case "exit":
 		fallthrough
 	case "q":
-		err = errors.New("not impl")
+		err = ErrQuit
 	}
 	return err
 }

mytinytodo/buffer.go

@@ -45,13 +45,13 @@ func (buffer *Buffer) Close() {
 	close(buffer.done)
 }
 
-func (buffer *Buffer) Enqueue(op remote.Op, listID, taskTitle string, taskTags ...string) error {
+func (buffer *Buffer) Enqueue(op remote.Op, list remote.List, task remote.Task, taskTags ...string) error {
 	buffer.dbLock.Lock()
 	defer buffer.dbLock.Unlock()
 	qop := &QueuedOp{
 		Op:       op,
-		List:     remote.List{ID: listID},
+		List:     list,
-		Task:     remote.Task{Title: taskTitle},
+		Task:     task,
 		TaskTags: taskTags,
 	}
 	uuid, _ := uuid.NewRandom()
@@ -108,10 +108,13 @@ func (buffer *Buffer) Dequeue() {
 		switch qop.Op {
 		case remote.NEW:
 			err = client.NewTask(qop.List, qop.Task, strings.Join(qop.TaskTags, ","))
+			log.Printf("dequeue NEW(%v, %v, %v): %v", qop.List, qop.Task, qop.TaskTags, err)
 		case remote.CLOSE:
 			err = client.CloseTask(qop.Task)
+			log.Printf("dequeue CLOSE(%v): %v", qop.Task, err)
 		case remote.OPEN:
 			err = client.OpenTask(qop.Task)
+			log.Printf("dequeue OPEN(%v): %v", qop.Task, err)
 		default:
 			err = fmt.Errorf("cannot dequeue op %v", qop.Op)
 		}

mytinytodo/buffer_test.go

@@ -20,7 +20,7 @@ func TestBufferEnqueue(t *testing.T) {
 	defer b.Close()
 	defer s.Close()
 
-	if err := b.Enqueue(remote.NEW, "list", "task", "one", "tag", "two"); err != nil {
+	if err := b.Enqueue(remote.NEW, remote.List{ID: "list"}, remote.Task{Title: "task"}, "one", "tag", "two"); err != nil {
 		t.Errorf("cannot enqueue: %v", err)
 	}
 
@@ -35,7 +35,7 @@ func TestBufferDequeue(t *testing.T) {
 	defer b.Close()
 	defer s.Close()
 
-	if err := b.Enqueue(remote.NEW, "list", "task", "one", "tag", "two"); err != nil {
+	if err := b.Enqueue(remote.NEW, remote.List{ID: "list"}, remote.Task{Title: "task"}, "one", "tag", "two"); err != nil {
 		t.Fatalf("cannot enqueue to dequeue: %v", err)
 	}
 

mytinytodo/remote/op.go

@@ -26,6 +26,10 @@ func (op Op) String() string {
 	return ""
 }
 
+func OpFromString(s string) Op {
+	return fromString(s)
+}
+
 func fromString(s string) Op {
 	for i := 0; i < 20; i++ {
 		if Op(i).String() == s {