daviddengcn / gosl

Go Script Language

gosl

This is an application that can make you write script with the Go language.

It is NOT an interpreter but the pure Go. The preprocessor tranforms the script into a Go program, instantly compiles and runs. So it is almost same as the standard Go with the same efficiency.

Benefit

1. Pure Go language. No need to learn a new script language.
2. Pre-imported packages and pre-defined functions make it easy to code.
3. Seamless integration with the Go project. E.g. can easily load configuration or data file from the Go project.
4. Running efficiency same as Go, much faster than Python.

Example

• Simple

#!/bin/gosl

import "encoding/json"

toJson := func(lines []string) string {
  res, _ := json.Marshal(struct {
    Lines []string `json:"lines"`
  }{
    Lines: lines,
  })
  return string(res)
}

files := BashEval("ls -l %s", "/tmp/")

Println(toJson(Split(files, "\n")))
    

• Go Search is now operating with gosl. So you can find some good examples at: https://github.com/daviddengcn/gcse/tree/master/scripts
• go-diff also provides scripts in gosl: https://github.com/daviddengcn/go-diff/tree/master/scripts

Installation and Usage

Download and install the package

go get github.com/daviddengcn/gosl
go install github.com/daviddengcn/gosl

(Optional) Link to /bin

sudo ln -s $GOPATH/bin/gosl /bin/gosl

If you don't want to do this, the interpreter line can be like this, assuming $GOPATH/bin is in your $PATH:

#!/usr/bin/env gosl

Run a script

If a script starts with the bash interpreter line: #!/bin/gosl. You can run it like this

chmod a+x example.gs
./example.gs [params...]

Or you can explictly call gosl to run it:

gosl example.gs [params...]

Pre-imported Packages

The following packages are pre-imported with ., i.e. you can directly use the methods exported by them. No complain of the compiler if you don't use them.

fmt, os, strings, strconv, math, time, and github.com/daviddengcn/gosl/builtin

Frequently Used builtin Functions

Method	Description	Example
S	Convert anything to a string	S(1234) == "123"
I	Convert anything to an int	I("1234") == 1234
BashEval	Similar to bash backtick substitution.	lsstr := BashEval("ls -l")
Exec	Execute an command with arguments	err, code := Exec("rm", "-rf" "tmp")
Bash	Execute a bash line	err, code := Bash("rm -rf tmp")
ScriptDir	Returns the directory of the script	file := ScriptDir() + "/" + fn

More functions are defined in package daviddengcn/gosl/builtin/ (godoc)

License

Apache License V2

gosl's Issues

Is all the code executed in a single main function?

As I can figure from this post http://golanghome.com/post/331 , the whole script code is executed in a single go main function, is that true?

feature request: caching

It might make sense to maintain some small cache of recently run scripts. You could do this by generating a hash of the file contents and using that when you generate the file name to use, if the file already exists, execute it and leave the binary, if not, generate it.

You'd have to decide how many recent files to keep and make sure old entries are cleaned up so that binaries don't end up taking up a lot of space, but you could touch the files and purge least recently used files after some threshold size is reached.

This would be useful for scripts that are run very frequently I think, which is probably a common use case.