func (b *Bubbler) Bubble(s string) (string, error) {
env := core.Import(vm.NewEnv())
f := fizzer{b}
// columns:
env.Define("add_column", f.AddColumn())
env.Define("drop_column", f.DropColumn())
env.Define("rename_column", f.RenameColumn())
env.Define("raw", f.RawSql())
// indexes:
env.Define("add_index", f.AddIndex())
env.Define("drop_index", f.DropIndex())
env.Define("rename_index", f.RenameIndex())
// tables:
env.Define("create_table", f.CreateTable())
env.Define("drop_table", f.DropTable())
env.Define("rename_table", f.RenameTable())
_, err := env.Execute(s)
return b.String(), errors.Wrap(err, "parse error")
}
func main() {
fs.Parse(os.Args[1:])
if *v {
fmt.Println(version)
os.Exit(0)
}
env := vm.NewEnv()
var code string
var b []byte
var reader *bufio.Reader
var following bool
var source string
repl := fs.NArg() == 0 && *e == ""
env.Define("args", reflect.ValueOf(fs.Args()))
if repl {
reader = bufio.NewReader(os.Stdin)
source = "typein"
os.Args = append([]string{os.Args[0]}, fs.Args()...)
} else {
if *e != "" {
b = []byte(*e)
source = "argument"
} else {
var err error
b, err = ioutil.ReadFile(fs.Arg(0))
if err != nil {
colortext(ct.Red, false, func() {
fmt.Fprintln(os.Stderr, err)
})
os.Exit(1)
}
env.Define("args", reflect.ValueOf(fs.Args()[1:]))
source = filepath.Clean(fs.Arg(0))
}
os.Args = fs.Args()
}
anko_core.Import(env)
tbl := map[string]func(env *vm.Env) *vm.Env{
"encoding/json": anko_encoding_json.Import,
"flag": anko_flag.Import,
"fmt": anko_fmt.Import,
"io": anko_io.Import,
"io/ioutil": anko_io_ioutil.Import,
"math": anko_math.Import,
"net": anko_net.Import,
"net/http": anko_net_http.Import,
"net/url": anko_net_url.Import,
"os": anko_os.Import,
"os/exec": anko_os_exec.Import,
"path": anko_path.Import,
"path/filepath": anko_path_filepath.Import,
"regexp": anko_regexp.Import,
"sort": anko_sort.Import,
"strings": anko_strings.Import,
"github.com/daviddengcn/go-colortext": anko_colortext.Import,
}
env.Define("import", reflect.ValueOf(func(s string) interface{} {
if loader, ok := tbl[s]; ok {
return loader(env)
}
panic(fmt.Sprintf("package '%s' not found", s))
}))
for {
if repl {
colortext(ct.Green, true, func() {
if following {
fmt.Print(" ")
} else {
fmt.Print("> ")
}
})
var err error
b, _, err = reader.ReadLine()
if err != nil {
break
}
if len(b) == 0 {
continue
}
if code != "" {
code += "\n"
}
code += string(b)
} else {
code = string(b)
}
scanner := new(parser.Scanner)
scanner.Init(code)
stmts, err := parser.Parse(scanner)
v := vm.NilValue
if repl {
if e, ok := err.(*parser.Error); ok {
if e.Pos.Column == len(b) && !e.Fatal {
following = true
continue
}
if e.Error() == "unexpected EOF" {
following = true
continue
}
}
}
following = false
code = ""
if err == nil {
v, err = vm.Run(stmts, env)
}
if err != nil {
colortext(ct.Red, false, func() {
if e, ok := err.(*vm.Error); ok {
fmt.Fprintf(os.Stderr, "%s:%d: %s\n", source, e.Pos.Line, err)
} else if e, ok := err.(*parser.Error); ok {
if e.Filename != "" {
source = e.Filename
}
fmt.Fprintf(os.Stderr, "%s:%d: %s\n", source, e.Pos.Line, err)
} else {
fmt.Fprintln(os.Stderr, err)
}
})
if repl {
continue
} else {
os.Exit(1)
}
} else {
if repl {
colortext(ct.Black, true, func() {
if v == vm.NilValue || !v.IsValid() {
fmt.Println("nil")
} else {
s, ok := v.Interface().(fmt.Stringer)
if v.Kind() != reflect.String && ok {
fmt.Println(s)
} else {
fmt.Printf("%#v\n", v.Interface())
}
}
})
} else {
break
}
}
}
}
func serveApiPlay(w http.ResponseWriter, r *http.Request) {
code := r.FormValue("code")
scanner := new(parser.Scanner)
scanner.Init(code)
stmts, err := parser.Parse(scanner)
if e, ok := err.(*parser.Error); ok {
w.WriteHeader(500)
fmt.Fprintf(w, "%d: %s\n", e.Pos.Line, err)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
env := vm.NewEnv()
anko_core.Import(env)
tbl := map[string]func(env *vm.Env) *vm.Env{
"encoding/json": anko_encoding_json.Import,
"flag": anko_flag.Import,
"fmt": anko_fmt.Import,
"io": anko_io.Import,
"io/ioutil": anko_io_ioutil.Import,
"math": anko_math.Import,
"net": anko_net.Import,
"net/http": anko_net_http.Import,
"net/url": anko_net_url.Import,
"os": anko_os.Import,
"os/exec": anko_os_exec.Import,
"path": anko_path.Import,
"path/filepath": anko_path_filepath.Import,
"regexp": anko_regexp.Import,
"sort": anko_sort.Import,
"strings": anko_strings.Import,
"github.com/daviddengcn/go-colortext": anko_colortext.Import,
}
env.Define("import", reflect.ValueOf(func(s string) interface{} {
if loader, ok := tbl[s]; ok {
return loader(env)
}
panic(fmt.Sprintf("package '%s' not found", s))
}))
env.Define("println", reflect.ValueOf(func(a ...interface{}) {
fmt.Fprint(w, fmt.Sprintln(a...))
}))
env.Define("print", reflect.ValueOf(func(a ...interface{}) {
fmt.Fprint(w, fmt.Sprint(a...))
}))
env.Define("panic", reflect.ValueOf(func(a ...interface{}) {
w.WriteHeader(500)
fmt.Fprintf(w, "Can't use panic()")
return
}))
env.Define("load", reflect.ValueOf(func(a ...interface{}) {
w.WriteHeader(500)
fmt.Fprintf(w, "Can't use load()")
return
}))
defer env.Destroy()
_, err = vm.Run(stmts, env)
if err != nil {
w.WriteHeader(500)
if e, ok := err.(*vm.Error); ok {
fmt.Fprintf(w, "%d: %s\n", e.Pos.Line, err)
} else if e, ok := err.(*parser.Error); ok {
fmt.Fprintf(w, "%d: %s\n", e.Pos.Line, err)
} else {
fmt.Fprintln(w, e.Error())
}
}
}
func ankoCmd(filename string) error {
fmt.Println("ANKO " + filename)
if len(filename) == 0 {
err := errors.New("Please specify an Anko script file")
printError(err)
return err
}
file, err := os.Open(filename)
if err != nil {
printError(err)
return err
}
env := vm.NewEnv()
anko_core.Import(env)
anko_flag.Import(env)
anko_net.Import(env)
anko_encoding.Import(env)
anko_os.Import(env)
anko_io.Import(env)
anko_math.Import(env)
anko_path.Import(env)
anko_regexp.Import(env)
anko_sort.Import(env)
anko_strings.Import(env)
anko_term.Import(env)
var ln, code string
lnScanner := bufio.NewScanner(file)
for lnScanner.Scan() {
ln = lnScanner.Text()
code = code + ln + "\n"
if err != nil {
break
printError(err)
return err
}
}
scanner := new(parser.Scanner)
scanner.Init(code)
stmts, err := parser.Parse(scanner)
if err != nil {
printError(err)
return err
}
_, err = vm.Run(stmts, env)
if err != nil {
printError(err)
return err
}
file.Close()
return err
}