Update: implement general manipulation of resulting left/right buffer (which also supports parametrized expansion)

Author: relastle

resources/test_setting.json

@@ -1,35 +1,51 @@
 [
   {
     "regexpLeft": "^cd +(?P<path>.*)$",
-    "command": "\\ls ${PMY_LS_OPTION} -1 <path> | egrep '/$'"
+    "command": "\\ls ${PMY_LS_OPTION} -1 <path> | egrep '/$'",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
     "regexpLeft": "^python.* ",
-    "command": "\\find . | egrep py$"
+    "command": "\\find . | egrep py$",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
     "regexpLeft": "^go ",
-    "command": "\\find . | egrep go$"
+    "command": "\\find . | egrep go$",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
     "regexpLeft": "^make ",
     "regexpRight": "",
-    "command": "cat Makefile"
+    "command": "cat Makefile",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
     "regexpLeft": "git +add +",
-    "command": "git status --short | git status -s | grep -Ev \"^(A|C|D|M|R|T|U|X|B)\" | cut -c4-"
+    "command": "git status --short | git status -s | grep -Ev \"^(A|C|D|M|R|T|U|X|B)\" | cut -c4-",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
     "regexpLeft": "^export ",
-    "command": "printenv"
+    "command": "printenv",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   },
   {
-    "regexpLeft": "ls.for",
-    "command": "echo 'for file in $(ls); do something; done'"
+    "regexpLeft": "(?P<cmd>.+)\\.for",
+    "command": "echo ''",
+    "bufferLeft": "for x in $(<cmd>); do ",
+    "bufferRight": "; done"
   },
   {
     "regexpLeft": "^(vi||vim|nvim) ",
-    "command": "find . -maxdepth 2"
+    "command": "find . -maxdepth 2",
+    "bufferLeft": "[]",
+    "bufferRight": "[]"
   }
 ]

shell/pmy.zsh

@@ -5,11 +5,15 @@ export PMY_CONFIG_PATH="${GOPATH}/src/github.com/relastle/pmy/resources/test_set
 pmy-widget() {
     local buffer_left=${LBUFFER}
     local buffer_right=${RBUFFER}
-    local cmd=$(pmy --bufferLeft=${buffer_left} --bufferRight=${buffer_right} 2>/dev/null)
-    if [[ -z $cmd  ]] then
+    local out=$(pmy --bufferLeft=${buffer_left} --bufferRight=${buffer_right} 2>/dev/null)
+    local lbuffer=$(echo ${out} | awk -F ':::' '{print $1}')
+    local rbuffer=$(echo ${out} | awk -F ':::' '{print $2}')
+    local cmd=$(echo ${out} | awk -F ':::' '{print $3}')
+    if [[ -z $out  ]] then
         echo "No rule was matched"
     else
-        LBUFFER="${LBUFFER}$(eval ${cmd} | fzf -0 -1)"
+        LBUFFER="${lbuffer}$(eval ${cmd} | fzf -0 -1)"
+        RBUFFER="${rbuffer}"
     fi
     zle reset-prompt
 }

src/core.go

@@ -3,14 +3,28 @@ package pmy
 import (
 	"fmt"
 	"log"
+	"os/exec"
 )
 
+// ccheckJq checks whether `jq` command is available
+func checkJq() bool {
+	_, err := exec.LookPath("jq")
+	if err != nil {
+		return false
+	}
+	return true
+}
+
 // Run runs the main process of pmy
 func Run(cfgPath string, bufferLeft string, bufferRight string) {
+
+	// Load rules from config file
 	rules, err := loadAllRules(cfgPath)
 	if err != nil {
 		log.Fatal(err)
 	}
+
+	// Fetch rule using LBUFFER and RBUFFER
 	var fetcher ruleFetcher
 	fetcher = &ruleFetcherImpl{}
 	resRules, err := fetcher.fetch(rules, bufferLeft, bufferRight)
@@ -22,6 +36,9 @@ func Run(cfgPath string, bufferLeft string, bufferRight string) {
 		return
 	}
 	rule := resRules[0]
-	fmt.Print(rule.CommandExpanded)
+	out := newPmyOutFromRule(&rule)
+
+	// Ouput result
+	fmt.Println(out.serialize())
 	return
 }

src/out.go

@@ -0,0 +1,58 @@
+package pmy
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+const delimiter string = ":::"
+
+// pmyOut represents Output of pmy against zsh routine.
+// This struct has strings exported to shell, whose embedded
+// variables are all expanded.
+type pmyOut struct {
+	BufferLeft  string `json:"bufferLeft"`
+	BufferRight string `json:"bufferRight"`
+	Command     string `json:"command"`
+}
+
+// newPmyOutFromRule create new pmyOut from rule
+// which matches query and already has paramMap
+func newPmyOutFromRule(rule *pmyRule) pmyOut {
+	out := pmyOut{}
+	out.Command = rule.Command
+	out.BufferLeft = rule.BufferLeft
+	out.BufferRight = rule.BufferRight
+	out.expandAll(rule.paramMap)
+	return out
+}
+
+func expand(org string, paramMap map[string]string) string {
+	res := org
+	for name, value := range paramMap {
+		res = strings.ReplaceAll(
+			res,
+			fmt.Sprintf("<%v>", name),
+			value,
+		)
+	}
+	return res
+}
+
+func (out *pmyOut) expandAll(paramMap map[string]string) {
+	out.BufferLeft = expand(out.BufferLeft, paramMap)
+	out.BufferRight = expand(out.BufferRight, paramMap)
+	out.Command = expand(out.Command, paramMap)
+	return
+}
+
+func (out *pmyOut) toJSON() string {
+	bytes, _ := json.Marshal(out)
+	str := string(bytes)
+	return str
+}
+
+func (out *pmyOut) serialize() string {
+	return out.BufferLeft + delimiter + out.BufferRight + delimiter + out.Command
+}

src/rule.go

@@ -2,9 +2,7 @@ package pmy
 
 import (
 	"encoding/json"
-	"fmt"
 	"io/ioutil"
-	"log"
 	"os"
 	"regexp"
 	"strings"
@@ -14,12 +12,14 @@ type replaceMap map[string]string
 
 // Rule is a struct representing one rule
 type pmyRule struct {
-	Matcher         string `json:"matcher"`
-	Description     string `json:"description"`
-	RegexpLeft      string `json:"regexpLeft"`
-	RegexpRight     string `json:"regexpRight"`
-	Command         string `json:"command"`
-	CommandExpanded string
+	Matcher     string `json:"matcher"`
+	Description string `json:"description"`
+	RegexpLeft  string `json:"regexpLeft"`
+	RegexpRight string `json:"regexpRight"`
+	Command     string `json:"command"`
+	BufferLeft  string `json:"bufferLeft"`
+	BufferRight string `json:"bufferRight"`
+	paramMap    map[string]string
 }
 
 type pmyRules []pmyRule
@@ -56,14 +56,16 @@ func (rule *pmyRule) match(bufferLeft string, bufferRight string) (bool, error)
 			paramMap[name] = matches[i]
 		}
 	}
-	rule.CommandExpanded = rule.Command
-	for name, value := range paramMap {
-		rule.CommandExpanded = strings.ReplaceAll(
-			rule.CommandExpanded,
-			fmt.Sprintf("<%v>", name),
-			value,
-		)
-	}
-	log.Println(paramMap)
+	rule.BufferLeft = strings.ReplaceAll(
+		rule.BufferLeft,
+		"[]",
+		bufferLeft,
+	)
+	rule.BufferRight = strings.ReplaceAll(
+		rule.BufferRight,
+		"[]",
+		bufferRight,
+	)
+	rule.paramMap = paramMap
 	return true, nil
 }