Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
215 lines (176 sloc) 4.88 KB
package eclier
import (
"context"
"fmt"
"log"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"github.com/olekukonko/tablewriter"
lua "github.com/yuin/gopher-lua"
"layeh.com/asar"
)
// Router is the main subcommand router for eclier. At a high level what this is
// doing is similar to http.ServeMux, but for CLI commands instead of HTTP handlers.
type Router struct {
lock sync.Mutex
cmds map[string]Command
// configured data
gluaCreationHook func(*lua.LState)
scriptHomes []string
cartridge map[string]string
}
// NewRouter creates a new instance of Router and sets it up for use.
func NewRouter(opts ...RouterOption) (*Router, error) {
r := &Router{
cmds: map[string]Command{},
cartridge: map[string]string{},
}
for _, opt := range opts {
opt(r)
}
// scan r.scriptHome for lua scripts, load them into their own lua states and
// make a wrapper around them for the Command type.
for _, home := range r.scriptHomes {
err := filepath.Walk(home, func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Printf("error in arg: %v", err)
return err
}
if strings.HasSuffix(info.Name(), ".lua") {
fname := filepath.Join(home, info.Name())
fin, err := os.Open(fname)
if err != nil {
return err
}
defer fin.Close()
c := newGluaCommand(r.gluaCreationHook, fname, fin)
r.cmds[c.Verb()] = c
}
return nil
})
if err != nil {
return nil, err
}
}
var helpCommand Command = NewBuiltinCommand("help", "shows help for subcommands", "help [subcommand]", func(ctx context.Context, arg []string) error {
if len(arg) == 0 {
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Verb", "Author", "Version", "Help"})
for _, cmd := range r.cmds {
table.Append([]string{cmd.Verb(), cmd.Author(), cmd.Version(), cmd.Help()})
}
table.Render()
return nil
}
cmd, ok := r.cmds[arg[0]]
if !ok {
fmt.Printf("can't find help for %s", arg[0])
os.Exit(2)
}
fmt.Printf("Verb: %s\nAuthor: %s\nVersion: %s\nHelp: %s\nUsage: %s %s\n", cmd.Verb(), cmd.Author(), cmd.Version(), cmd.Help(), cmd.Verb(), cmd.Usage())
return nil
})
r.cmds["plugins"] = &pluginCommand{r: r}
r.cmds["help"] = helpCommand
return r, nil
}
// AddCommand adds a given command instance to the eclier router.
func (r *Router) AddCommand(cmd Command) {
r.lock.Lock()
defer r.lock.Unlock()
r.cmds[cmd.Verb()] = cmd
}
// Run executes a single command given in slot 0 of the argument array.
func (r *Router) Run(ctx context.Context, arg []string) error {
r.lock.Lock()
defer r.lock.Unlock()
if len(arg) == 0 {
fmt.Printf("please specify a subcommand, such as `%s help`\n", filepath.Base(os.Args[0]))
os.Exit(2)
}
cmd := arg[0]
arg = arg[1:]
ci, ok := r.cmds[cmd]
if !ok {
fmt.Printf("No such command %s could be run.\n", cmd)
os.Exit(2)
}
ci.Init()
return ci.Run(ctx, arg)
}
// RouterOption is a functional option for Router.
type RouterOption func(*Router)
// WithScriptHome sets the router's script home to the given directory. This is
// where lua files will be walked and parsed.
func WithScriptHome(dir string) RouterOption {
return func(r *Router) {
r.scriptHomes = append(r.scriptHomes, dir)
}
}
// WithGluaCreationHook adds a custom bit of code that runs every time a new
// gopher-lua LState is created. This allows users of this library to register
// custom libraries to the pile of states.
func WithGluaCreationHook(hook func(*lua.LState)) RouterOption {
return func(r *Router) {
r.gluaCreationHook = hook
}
}
// WithFilesystem loads a http.FileSystem full of lua scripts into this eclier
// router.
func WithFilesystem(shortName string, fs http.FileSystem) RouterOption {
return func(r *Router) {
fin, err := fs.Open("/")
if err != nil {
log.Fatal(err)
}
defer fin.Close()
childs, err := fin.Readdir(-1)
if err != nil {
log.Fatal(err)
}
for _, chl := range childs {
if strings.HasSuffix(chl.Name(), ".lua") {
fname := filepath.Join(shortName, chl.Name())
sFin, err := fs.Open(chl.Name())
if err != nil {
log.Fatal(err)
}
defer sFin.Close()
c := newGluaCommand(r.gluaCreationHook, fname, sFin)
r.cmds[c.Verb()] = c
}
}
}
}
// WithAsarFile loads an asar file full of lua scripts into this eclier router.
func WithAsarFile(shortName, fname string) RouterOption {
return func(r *Router) {
fin, err := os.Open(fname)
if err != nil {
log.Fatal(err)
}
defer fin.Close()
e, err := asar.Decode(fin)
if err != nil {
log.Fatal(err)
}
err = e.Walk(func(path string, info os.FileInfo, err error) error {
if strings.HasSuffix(info.Name(), ".lua") {
fname := filepath.Join(shortName, "::", path)
fin := e.Find(path)
if fin == nil {
return nil
}
c := newGluaCommand(r.gluaCreationHook, fname, fin.Open())
r.cmds[c.Verb()] = c
}
return nil
})
if err != nil {
log.Fatal(err)
}
}
}
You can’t perform that action at this time.