Starlight 
Starlight is a wrapper library for google's starlark
embedded python-like language. Starlight is intended to give you an easier-to-use
interface for running starlark scripts directly from your Go programs. Starlark
is a dialect of python, and has a Go native interpreter, so you can let your
users extend your application without any external requirements.
Sample
You can call a script from go thusly:
import (
"fmt"
"github.com/starlight-go/starlight"
)
type contact struct {
Name string
}
func main() {
c := &contact{Name: "Bob"}
globals := map[string]interface{}{
"contact":c,
"Println":fmt.Println,
}
script := []byte(`
contact.Name = "Phil"
Println("hello " + contact.Name)
`)
// errors will tell you about syntax/runtime errors.
_, err := starlight.Eval(script, globals, nil)
}
// prints "hello Phil"
// also the value of c's Name field will now be Phil when referenced from Go code as well.
Eval expects either a filename, slice of bytes, or io.Reader as its argument
containing the code, and then a map of global variables to populate the script
with.
Usage
Starlight.New creates a script cache that will read and compile scripts on the fly, caching those it has already run.
Starlight.Eval does all the compilation at call time.
Inputs and Outputs
Starlark scripts (and starlight scripts by extension) use global variables in the
script as the input.
Thus if args are map[string]interface{}{"input":"hello"}, the script may act
on the variable called input thusly:
output = input + "world!"
When run, this script will create a value in the map returned with the
key "output" and with the value "hello world!".
Types
Starlight automatically translates go types to starlark types. Starlight
supports almost every go type except channels. You may also pass in types that
implement starlark.Value themselves, in which case they will be passed to the
script as-is (this is useful if you need custom behavior).
Functions
You can pass go functions that the script can call by passing your function in
with the rest of the globals. Positional args are passed to your function and
converted to their appropriate go type if possible. Kwargs passed from starlark
scripts are currently ignored.
Caching
Since parsing scripts is non-zero work, starlight caches the scripts it finds
after the first time they get run, so that further runs of the script will not
incur the disk read and parsing overhead. To make starlight reparse a file
(perhaps because it has changed) use the Forget method for the specific file, or
Reset to remove all cached files.
Example
The example
directory shows an example of using starlight to run scripts that modify the
output of a running web server.
Why?
Why not just use starlark-go directly?
Well, it's actually quite difficult to get go data into a starlark-go script. Starlark as written is made more for configuration, so you mostly get data out of scripts, and mostly just basic values.
For example, structs just aren't supported, unless you write a complicated wrapper (starlight does that for you). Adapting a function to starlark-go requires a bunch of boilerplate adapter and conversion code, and then if you're using anything other than basic types (int, string, bool, float, etc), you need adapters for those, too (starlight does that for you, too).
Why embed python in your Go application?
Because it lets you add flexibility without having to recompile. It lets users customize your application with just a few lines of python.
Also, Starlark is safe. You can run arbitrary code from third parties without worrying about it blowing up your machine or downloading nasty things from the internet (unless you give scripts the ability to do that). Starlark code can only call the functions you allow.
How?
Lots of reflection. It's not as slow as you think. Running a small pre-compiled script including the time to process the inputs using reflection, takes less than 2400ns on my 2017 macbook pro (that's 0.0024 milliseconds).
