jcarr
/
guiprep
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: jcarr:master
Branches Tags
jcarr:master
jcarr:devel
jcarr:v0.0.11
jcarr:v0.0.10
jcarr:v0.0.8
jcarr:v0.0.7
jcarr:v0.0.6
jcarr:v0.0.5
jcarr:v0.0.4
jcarr:v0.0.3
jcarr:v0.0.2
jcarr:v0.0.1
..
compare: jcarr:v0.0.1
Branches Tags
jcarr:devel
jcarr:master
jcarr:v0.0.11
jcarr:v0.0.10
jcarr:v0.0.8
jcarr:v0.0.7
jcarr:v0.0.6
jcarr:v0.0.5
jcarr:v0.0.4
jcarr:v0.0.3
jcarr:v0.0.2
jcarr:v0.0.1

No commits in common. "master" and "v0.0.1" have entirely different histories.
master ... v0.0.1

8 changed files with 6 additions and 745 deletions
Show Stats Expand all files Collapse all files

10
Makefile
View File

@ -1,6 +1,6 @@
# git remote add github git@github.com:wit-go/gui-debugger.git
all: auto.pb.go goimports vet
all: goimports vet
@echo common init code for common packages
goimports:
@ -8,11 +8,3 @@ goimports:
vet:
@GO111MODULE=off go vet
clean:
rm -f *.pb.go *.patch
-rm -f go.*
go-mod-clean purge
auto.pb.go: auto.proto
autogenpb --proto auto.proto

31
auto.proto
View File

@ -1,31 +0,0 @@
// Copyright 2025 WIT.COM Inc Licensed GPL 3.0
syntax = "proto3";
package httppb;
import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
import "google/protobuf/duration.proto"; // for duration
message Auto { // `autogenpb:marshal` `autogenpb:sort` `autogenpb:nomutex`
google.protobuf.Timestamp ctime = 1; // when the user tried this autocomplete
google.protobuf.Duration duration = 2; // time since the last autocomplete
string argname = 3; // what the shell thinks the name of the executable is
string arg0 = 4; // what os.Exec() has as os.Argv[0] // not interesting
string arg1 = 5; // should always be "--auto-complete" // not interesting
string arg3 = 6; // usually argv3 == argv0
repeated string argv = 7; // use this to store whatever you want while the whole POST happens
string cmd = 8; // the cmd being processed. For "git pull <tab>", cmd would be "pull"
string partial = 9; // set to the partial string trying to be matched
bool isAuto = 10; // is true if '--auto-complete' is set
bool setupAuto = 11; // is true if '--bash' is set // setup bash autocomplete here
bool debug = 12; // print debugging info if true
bool newline = 13; // was a newline was sent to STDERR?
string last = 14; // the last arg
}
message Autos { // `autogenpb:marshal` `autogenpb:sort` `autogenpb:nomutex`
string uuid = 1; // `autogenpb:uuid:94210ebf-a534-4b33-aadd-2f5e1f56ae38`
string version = 2; // `autogenpb:version:v0.0.1`
repeated Auto autos = 3; // THIS MUST BE HttpRequest and then HttpRequests
}

114
bash.orig.go
View File

@ -1,114 +0,0 @@
package prep
// initializes logging and command line options
import (
"fmt"
"os"
"path/filepath"
"strings"
"go.wit.com/dev/alexflint/arg"
"go.wit.com/lib/gui/shell"
"go.wit.com/log"
)
/*
This struct can be used with the go-arg package. These
are the generic default command line arguments for the 'GUI' package
*/
var argBash ArgsBash
type ArgsBash struct {
Bash bool `arg:"--bash" help:"generate bash completion"`
}
// try this struct out (?)
var myAuto *AutoArgs
// this is a work in progress
type AutoArgs struct {
id int // should be unique
hidden bool // don't update the toolkits when it's hidden
Auto func([]string) // the function for shell autocomplete
appName string // a good way to track the name of the binary ?
pp *arg.Parser // for parsing the command line args. Yay to alexf lint!
autoFunc func(*Auto) // also a function for autocomplete
match map[string]string // maps for strings
}
// argname is the name of the executable
func Bash(argname string, autocomplete func([]string)) *AutoArgs {
myAuto = new(AutoArgs)
myAuto.appName = argname
if len(os.Args) > 1 && os.Args[1] == "--bash" {
doBash(argname)
os.Exit(0)
}
if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
autocomplete(os.Args[2:])
os.Exit(0)
}
arg.Register(&argBash)
// parse go.Arg here?
return myAuto
}
// print out auto complete debugging info
func (pb *Auto) PrintDebug() {
dur := pb.Duration.AsDuration()
pb.Debugf("AUTOCOMPLETE: arg0='%s' arg1='%s' partial='%s' cmd='%s' age=%s argv=%v\n", pb.Arg0, pb.Arg1, pb.Partial, pb.Cmd, shell.FormatDuration(dur), pb.Argv)
}
// returns the last command (is blank if the current arg is not blank)
func GetLast(cur string, argv []string) string {
if cur != "''" {
return ""
}
for _, s := range argv {
if strings.HasPrefix(s, "-") {
continue
}
return s
}
return ""
}
// returns the name of the executable registered for shell autocomplete
func AppName() string {
return myAuto.appName
}
// makes a bash autocomplete file for your command
func doBash(argname string) {
fmt.Println(makeBashCompletionText(argname))
homeDir, err := os.UserHomeDir()
if err != nil {
log.Printf("%v\n", err)
os.Exit(0)
}
filename := filepath.Join(homeDir, ".local/share/bash-completion/completions", argname)
if shell.Exists(filename) {
log.Println(filename, "file already exists")
os.Exit(0)
}
basedir, _ := filepath.Split(filename)
if !shell.IsDir(basedir) {
os.MkdirAll(basedir, os.ModePerm)
}
if f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
f.Write([]byte(makeBashCompletionText(argname)))
f.Close()
log.Println("bash file created:", filename)
log.Println("restart bash")
} else {
log.Info(filename, err)
}
os.Exit(0)
}

388
complete.go
View File

@ -1,388 +0,0 @@
package prep
// initializes logging and command line options
import (
"fmt"
"os"
"path/filepath"
"strings"
"time"
"go.wit.com/dev/alexflint/arg"
"go.wit.com/lib/gui/shell"
"go.wit.com/log"
durationpb "google.golang.org/protobuf/types/known/durationpb"
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)
// makes a bash autocomplete file for your command
func doBash2(argname string) {
fmt.Println(makeBashCompletionText2(argname))
homeDir, err := os.UserHomeDir()
if err != nil {
log.Printf("%v\n", err)
os.Exit(0)
}
filename := filepath.Join(homeDir, ".local/share/bash-completion/completions", argname)
if shell.Exists(filename) {
log.Println(filename, "file already exists")
// os.Exit(0)
}
basedir, _ := filepath.Split(filename)
if !shell.IsDir(basedir) {
os.MkdirAll(basedir, os.ModePerm)
}
if f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
f.Write([]byte(makeBashCompletionText2(argname)))
f.Close()
log.Println("bash file created:", filename)
log.Println("restart bash")
} else {
log.Info(filename, err)
}
os.Exit(0)
}
func (pb *Auto) Debugf(fmts string, parts ...any) {
fmts = strings.TrimSpace(fmts)
fmts += "\n"
// NOTE: env doesn't work probably most (all?) the time because bash
// doesn't send all the ENV to autocomplete. so, trap on a "--autodebug" command line arg
if os.Getenv("AUTOCOMPLETE_VERBOSE") == "true" || pb.Debug {
if !pb.Newline {
fmt.Fprintf(os.Stderr, "\n")
pb.Newline = true
}
fmt.Fprintf(os.Stderr, fmts, parts...)
} else {
// fmt.Fprintf(os.Stderr, "NOT DOING ANYTHING\n")
}
}
// makes a bash autocomplete file for your command
func (pb *Auto) doHandlePB() error {
homeDir, err := os.UserHomeDir()
if err != nil {
return err
}
basedir := filepath.Join(homeDir, ".cache/autocomplete")
os.MkdirAll(basedir, os.ModePerm)
fullname := filepath.Join(basedir, pb.Argname+".pb")
all := NewAutos()
var last *Auto
data, err := os.ReadFile(fullname)
if err == nil {
err = all.Unmarshal(data)
if err == nil {
for found := range all.IterAll() {
dur := time.Since(found.Ctime.AsTime())
pb.Duration = durationpb.New(dur)
// found.PrintDebug()
cmd := fmt.Sprintf("cmd='%s'", found.Cmd)
arglast := fmt.Sprintf("last='%s'", found.Last)
pb.Debugf("AUTO HISTORY: age=%-6.6s %-18.18s %-18.18s partial='%s' argv='%v'", shell.FormatDuration(dur), cmd, arglast, found.Partial, found.Argv)
last = found
}
}
}
if all.Len() > 15 {
pb.Debugf("DEBUG: trim() history is over 100 len=%d vs new=%d", all.Len(), all.Len()-90)
all.Autos = all.Autos[all.Len()-10:]
// newall.Autos = all.Autos[0:10]
// for _, found := range all.Autos[0:10] {
// newall.Append(found)
// }
}
// need this for the first time the user runs autocomplete
if last == nil {
last = new(Auto)
}
now := time.Now()
pb.Ctime = timestamppb.New(now)
duration := time.Since(last.Ctime.AsTime())
all.Append(pb)
data, err = all.Marshal()
if err != nil {
return err
}
f, err := os.OpenFile(fullname, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
defer f.Close()
if err != nil {
return err
}
_, err = f.Write(data)
pb.Debugf("WRITE DEBUG: write PB='%s' len(pb)=%d len(data)=%d dur=%v err=%v", fullname, all.Len(), len(data), duration, err)
return err
}
/*
// prints help to STDERR // TODO: move everything below this to go-args
func (args) doBashHelp() {
if argv.BashAuto[1] != "''" {
// if this is not blank, then the user has typed something
return
}
if argv.BashAuto[0] != ARGNAME {
// if this is not the name of the command, the user already started doing something
return
}
if argv.BashAuto[0] == ARGNAME {
me.pp.WriteHelp(os.Stderr)
return
}
fmt.Fprintln(os.Stderr, "")
fmt.Fprintln(os.Stderr, "hello world")
fmt.Fprintln(os.Stderr, "")
}
*/
func (pb *Auto) Autocomplete(notsure any, sendthis string) {
parts := strings.Split(sendthis, " ")
var all []string
for _, part := range parts {
var found bool
for _, s := range os.Args {
if s == part {
found = true
}
}
if found {
continue
}
all = append(all, part)
}
fmt.Printf("%s", strings.Join(all, " "))
}
func (pb *Auto) Autocomplete2(sendthis string) {
dur := pb.Duration.AsDuration()
if dur < time.Millisecond*200 {
pb.Debug = true
/*
pb.Debugf("TODO: show extended help here '%s' '%s' %v dur=%v\n", pb.Arg0, pb.Arg1, pb.Argv, shell.FormatDuration(dur))
pb.PrintDebug()
fmt.Println(" ")
*/
if myAuto.pp == nil {
pb.Debugf("myAuto.pp == nil")
} else {
pb.Debugf("myAuto.pp != nil")
if pb.Cmd == "" {
myAuto.pp.WriteHelp(os.Stderr)
} else {
myAuto.pp.WriteHelpForSubcommand(os.Stderr, pb.Cmd)
}
}
}
parts := strings.Split(sendthis, " ")
var all []string
for _, part := range parts {
var found bool
for _, s := range os.Args {
if s == part {
found = true
}
}
if found {
continue
}
all = append(all, part)
}
fmt.Printf("%s", strings.Join(all, " "))
/*
if dur > time.Millisecond*200 {
if dur < time.Millisecond*800 {
// fmt.Println("a b")
fmt.Println(pb.Partial + " hello world")
}
}
*/
}
func parseArgv(argname string) *Auto {
pb := new(Auto)
pb.Argname = argname
if len(os.Args) == 0 {
return pb
}
if len(os.Args) > 1 && os.Args[1] == "--bash" {
pb.SetupAuto = true
return pb
}
// HACK: set debug flag if --autodebug is passed
for _, s := range os.Args {
if s == "--autodebug" {
pb.Debug = true
}
}
// should we do auto complete here?
if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
pb.IsAuto = true
pb.Arg0 = os.Args[0]
pb.Arg1 = os.Args[1]
pb.Partial = os.Args[2]
pb.Arg3 = os.Args[3]
if len(os.Args) < 5 {
// the user is doing autocomplete on the command itself
pb.Partial = ""
pb.Cmd = ""
pb.Argv = []string{""}
return pb
}
pb.Argv = os.Args[4:]
if pb.Partial == "''" {
pb.Partial = ""
pb.Cmd = "todo:findme"
}
// set pb.Cmd to the first thing that doesn't have a '-' arg
for _, s := range pb.Argv {
if strings.HasPrefix(s, "-") {
continue
}
pb.Cmd = s
break
}
if pb.Partial == "'"+pb.Cmd+"'" {
// not really a command, it's just a partially inputed string from the user
pb.Cmd = ""
}
// try to figure out what the last argv is
for _, s := range pb.Argv {
p := fmt.Sprintf("'%s'", s)
if pb.Partial == p {
pb.Debugf("DEBUG: MATCH Partial %s %s", s, p)
continue
} else {
pb.Debugf("DEBUG: NO MATCH Partial %s %s", s, p)
}
pb.Last = s
}
// if pb.Cmd == "" {
// pb.Cmd = strings.Join(pb.Argv, "BLAH")
// }
}
return pb
}
// also try to parse/send cur (?)
func Bash2(argname string, appAutoFunc func(*Auto)) *Auto {
pb := parseArgv(argname)
if pb.SetupAuto {
// --bash was passed. try to configure bash-completion
doBash2(argname)
os.Exit(0)
}
if pb.Debug {
// dump debug info
pb.PrintDebug()
}
if pb.IsAuto {
pb.doHandlePB()
if pb.Debug {
// TODO:
// check here to see if there was any completion text sent
// if not, send "reset bash newline\n" to cause bash to redraw PS1 for the user
}
arg.Register(&argBash)
// flags := []string{pb.Arg3, pb.Arg0}
// arg.InitFlags(flags)
appAutoFunc(pb) // run the autocomplete function the user made for their application
os.Exit(0)
}
arg.Register(&argBash)
return pb
}
// also try to parse/send cur (?)
// func Bash3(appAutoFunc func(*Auto), dest any) *Auto {
func Bash3(dest any) *Auto {
myAuto = new(AutoArgs)
findAppInfo(dest) // parses back to main() for argv info
pb := parseArgv(myAuto.appName)
if pb.SetupAuto {
// --bash was passed. try to configure bash-completion
doBash2(myAuto.appName)
os.Exit(0)
}
myAuto.match = make(map[string]string)
myAuto.match["--gui"] = "andlabs gocui"
if pb.Debug {
// dump debug info
pb.PrintDebug()
}
pb.doHandlePB() // read in the history protobuf file
// turn on debugging if duration < 200 milliseconds
dur := pb.Duration.AsDuration()
if dur < time.Millisecond*200 {
pb.Debug = true
}
// prepart["--gui"] = "andlabs gocui"
arg.Register(&argBash)
flags := []string{}
for _, s := range pb.Argv {
if s == "--autodebug" {
continue
}
flags = append(flags, s)
}
// pb.Debug = true
pb.Debugf("DEBUG: MustParse(%v)", flags)
var err error
myAuto.pp, err = arg.ParseFlags(flags, dest)
if err != nil {
pb.Debugf("DEBUG: Parse error: %v", err)
}
if myAuto.pp == nil {
pb.Debugf("DEBUG: myAuto.pp == nil after ParseFlags()")
} else {
pb.Debugf("DEBUG: myAuto.pp is ok after ParseFlags()")
}
if pb.IsAuto {
for key, val := range myAuto.match {
if pb.Last == key {
pb.Debugf("DEBUG: last=%s found key %s = %s", pb.Last, key, val)
pb.Autocomplete2(val)
os.Exit(0)
} else {
pb.Debugf("DEBUG: NO MATCH last='%s' found key '%s' = %s", pb.Last, key, val)
}
}
myAuto.autoFunc(pb) // run the autocomplete function the user made for their application
if pb.Debug {
// TODO:
// check here to see if there was any completion text sent
// if not, send "reset bash newline\n" to cause bash to redraw PS1 for the user
}
os.Exit(0)
}
arg.Register(&argBash)
myAuto.pp = arg.MustParse(dest)
return pb
}

29
debugger.go
View File

@ -40,32 +40,3 @@ func Debugger() {
CHAN = log.NewFlag("CHAN", true, full, short, "chan() test code output")
WARN = log.NewFlag("WARN", true, full, short, "should warn the user")
}
// Versioned is the interface that the destination struct should implement to
// make a version string appear at the top of the help message.
type Appnamed interface {
// Version returns the version string that will be printed on a line by itself
// at the top of the help message.
Appname() string
}
type AutoFuncd interface {
// Version returns the version string that will be printed on a line by itself
// at the top of the help message.
DoAutoComplete(*Auto)
}
// Described is the interface that the destination struct should implement to
func findAppInfo(tmp interface{}) {
if tmp, ok := tmp.(Appnamed); ok {
myAuto.appName = tmp.Appname()
} else {
panic("you need to make the function argv.Appname()")
}
if tmp, ok := tmp.(AutoFuncd); ok {
myAuto.autoFunc = tmp.DoAutoComplete
} else {
panic("you need to make the function argv.DoAutoComplete()")
}
}

58
gui.go
View File

@ -3,12 +3,8 @@ package prep
// initializes logging and command line options
import (
"os"
"go.wit.com/dev/alexflint/arg"
"go.wit.com/gui"
"go.wit.com/lib/fhelp"
"go.wit.com/log"
)
var argGui ArgsGui
@ -18,8 +14,7 @@ This struct can be used with the go-arg package. These
are the generic default command line arguments for the 'GUI' package
*/
type ArgsGui struct {
GuiPlugin string `arg:"--gui" help:"select the plugin (andlabs,gocui,etc)"`
GuiVerbose bool `arg:"--gui-verbose" help:"enable all logging"`
GuiPluginHack string `arg:"--gui-check-plugin" help:"hack to verify GO plugins load"`
}
/*
@ -51,57 +46,14 @@ func ArgToolkit() string {
func postMustParse(s string) string {
switch s {
case "PluginHack":
case "VERBOSE":
if argGui.GuiVerbose == true {
return "true"
}
return "false"
case "DEFAULT":
if argGui.GuiPlugin != "" {
return argGui.GuiPlugin
}
return "gocui"
case "FILE":
return "someplugin"
return argGui.GuiPluginHack
default:
return ""
}
return "unknown"
}
var prepGui *GuiPrep
func Gui() *gui.Node {
arg.Register(&argDebugger)
type GuiPrep struct {
rootn *gui.Node
hidden bool // don't update the toolkits when it's hidden
Auto func([]string)
}
func Gui() *GuiPrep {
if len(os.Args) > 1 && os.Args[1] == "--gui-check-plugin" {
gui.TestPluginAndExitNew(os.Args[2])
os.Exit(0)
}
arg.Register(&argGui)
prepGui = new(GuiPrep)
prepGui.rootn = gui.PreInit(postMustParse)
return prepGui
}
func (g *GuiPrep) Start() error {
// me.myGui.InitEmbed(resources)
if pname, err := g.rootn.Default(); err != nil {
if !fhelp.BuildPlugin("gocui") {
log.Info("You can't run the forge GUI since the plugins did not build", pname)
return nil
}
if err := g.rootn.LoadToolkitNew("gocui"); err != nil {
log.Info("The plugins built, but still failed to load", pname)
return err
}
} else {
log.Info("The plugins built and loaded!", pname)
}
return nil
return gui.PreInit(postMustParse)
}

103
shell.go
View File

@ -1,103 +0,0 @@
package prep
// initializes logging and command line options
import (
"fmt"
)
func makeBashCompletionText(argname string) string {
var out string
out += fmt.Sprintf("# add this in your bashrc:\n")
out += fmt.Sprintf("\n")
out += fmt.Sprintf("# todo: add this to go-arg as a 'hidden' go-arg option --bash\n")
out += fmt.Sprintf("#\n")
out += fmt.Sprintf("# Put the below in the file: ~/.local/share/bash-completion/completions/%s\n", argname)
out += fmt.Sprintf("#\n")
out += fmt.Sprintf("# todo: make this output work/parse with:\n")
out += fmt.Sprintf("# complete -C %s --bash go\n", argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf("_%s_complete()\n", argname)
out += fmt.Sprintf("{\n")
out += fmt.Sprintf(" # sets local to this func vars\n")
out += fmt.Sprintf(" local cur prev all\n")
out += fmt.Sprintf(" cur=${COMP_WORDS[COMP_CWORD]}\n")
out += fmt.Sprintf(" prev=${COMP_WORDS[COMP_CWORD-1]}\n")
out += fmt.Sprintf(" all=${COMP_WORDS[@]}\n")
out += fmt.Sprintf("\n")
out += fmt.Sprintf(" # this is where we generate the go-arg output\n")
out += fmt.Sprintf(" GOARGS=$(%s --auto-complete $prev \\'$cur\\' $all)\n", argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf(" # this compares the command line input from the user\n")
out += fmt.Sprintf(" # to whatever strings we output\n")
out += fmt.Sprintf(" COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) ) # THIS WORKS\n")
out += fmt.Sprintf(" return 0\n")
out += fmt.Sprintf("}\n")
out += fmt.Sprintf("complete -F _%s_complete %s\n", argname, argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf("# copy and paste the above into your bash shell should work\n")
return out
}
func makeBashCompletionText2(argname string) string {
var out string
out += fmt.Sprintf("# add this in your bashrc:\n")
out += fmt.Sprintf("\n")
out += fmt.Sprintf("# todo: add this to go-arg as a 'hidden' go-arg option --bash\n")
out += fmt.Sprintf("#\n")
out += fmt.Sprintf("# Put the below in the file: ~/.local/share/bash-completion/completions/%s\n", argname)
out += fmt.Sprintf("#\n")
out += fmt.Sprintf("# todo: make this output work/parse with:\n")
out += fmt.Sprintf("# complete -C %s --bash go\n", argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf("_%s_complete()\n", argname)
out += fmt.Sprintf("{\n")
out += fmt.Sprintf(" # sets local to this func vars\n")
out += fmt.Sprintf(" local cur prev all\n")
out += fmt.Sprintf(" cur=${COMP_WORDS[COMP_CWORD]}\n")
out += fmt.Sprintf(" # prev=${COMP_WORDS[COMP_CWORD-1]}\n")
out += fmt.Sprintf(" all=${COMP_WORDS[@]}\n")
out += fmt.Sprintf("\n")
out += fmt.Sprintf(" # this is where we generate the go-arg output\n")
out += fmt.Sprintf(" GOARGS=$(%s --auto-complete \\'$cur\\' $all)\n", argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf(" # this compares the command line input from the user\n")
out += fmt.Sprintf(" # to whatever strings we output\n")
out += fmt.Sprintf(" COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) ) # THIS WORKS\n")
out += fmt.Sprintf(" return 0\n")
out += fmt.Sprintf("}\n")
out += fmt.Sprintf("complete -F _%s_complete %s\n", argname, argname)
out += fmt.Sprintf("\n")
out += fmt.Sprintf("# copy and paste the above into your bash shell should work\n")
return out
}
// zsh:
/*
#compdef forge
# Zsh completion function for the 'forge' command.
_forge_completions() {
local -a words
local -i CURRENT
# Zsh's equivalent of Bash's COMP_WORDS and COMP_CWORD
words=("${(@)words}")
CURRENT=$CURRENT
# Generate the completion suggestions by calling the forge command.
# The output is split into an array.
local -a suggestions
suggestions=("${(@f)$(forge --auto-complete "'${words[CURRENT]}'" "${words[@]}")}")
# Pass the suggestions to the Zsh completion system.
_describe 'completions' suggestions
}
# Register the function to be called for the 'forge' command.
_forge_completions "$@"
*/

18
smartcd.test
View File

@ -1,18 +0,0 @@
_cd_complete()
{
# sets local to this func vars
local cur prev all
cur=${COMP_WORDS[COMP_CWORD]}
# prev=${COMP_WORDS[COMP_CWORD-1]}
all=${COMP_WORDS[@]}
# this is where we generate the go-arg output
GOARGS=$(smartcd --auto-complete \'$cur\' $all)
# this compares the command line input from the user
# to whatever strings we output
COMPREPLY=( $(compgen -W "$GOARGS" -- $cur) ) # THIS WORKS
return 0
}
complete -F _cd_complete cd