Misc Fixes and Improvements (#3)

* for starlet new v010

* less dep

* update go sum

* simple

* save mod names

* fast convert

* __mod tests

* refine load mod tetss

* add summary

* more testings

* for complex testing

* for getter modules

* no modules

* update readme

Author: hyorigo

.github/workflows/build.yml

@@ -67,17 +67,25 @@ jobs:
           CODACY_PROJECT_TOKEN: ${{ secrets.CODACY_PROJECT_TOKEN }}
         run:
           bash <(curl -Ls https://coverage.codacy.com/get.sh) report --force-coverage-parser go -r coverage.txt
-      - name: Analyze
+      - name: Analyze on Linux
         if: ${{ runner.os == 'Linux' }}
         run: |
-          # tokei -- count
+          # Setup
           wget -cqL https://github.com/XAMPPRocky/tokei/releases/download/v12.1.2/tokei-i686-unknown-linux-musl.tar.gz -O tokei.tgz
           tar zxf tokei.tgz tokei && chmod +x tokei && $SUDO mv tokei /usr/local/bin && rm tokei.tgz
-          echo "=== Tokei Result ==="
-          tokei
-          # revive -- lint
-          wget -cqL https://github.com/mgechev/revive/releases/download/v1.2.4/revive_1.2.4_Linux_x86_64.tar.gz -O revive.tgz
+          wget -cqL https://github.com/mgechev/revive/releases/download/v1.3.7/revive_linux_amd64.tar.gz -O revive.tgz
           tar zxf revive.tgz revive && chmod +x revive && $SUDO mv revive /usr/local/bin && rm revive.tgz
           wget -cqL https://raw.githubusercontent.com/1set/meta/master/revive.toml -O revive.toml
-          echo "=== Revive Result ==="
-          revive -config revive.toml -formatter friendly ./...
+          # Analyze
+          echo "# Analysis on Linux" > $GITHUB_STEP_SUMMARY
+          uname -a >> $GITHUB_STEP_SUMMARY
+          # --- count lines of code
+          echo "## Tokei Result" >> $GITHUB_STEP_SUMMARY
+          printf '\n```\n' >> $GITHUB_STEP_SUMMARY
+          tokei >> $GITHUB_STEP_SUMMARY
+          printf '```\n\n' >> $GITHUB_STEP_SUMMARY
+          # --- lint
+          echo "## Revive Result" >> $GITHUB_STEP_SUMMARY
+          printf '\n```\n' >> $GITHUB_STEP_SUMMARY
+          revive -config revive.toml -formatter friendly ./... >> $GITHUB_STEP_SUMMARY
+          printf '```\n\n' >> $GITHUB_STEP_SUMMARY

README.md

@@ -1,15 +1,88 @@
-# 🥡 starbox - Another Starlark runtime in a box
+# :takeout_box: Starbox - Another Starlark runtime in a box
 
 [![godoc](https://pkg.go.dev/badge/github.com/1set/starbox.svg)](https://pkg.go.dev/github.com/1set/starbox)
 [![codecov](https://codecov.io/github/1set/starbox/graph/badge.svg?token=8v1rqUSOfD)](https://codecov.io/github/1set/starbox)
 [![codacy](https://app.codacy.com/project/badge/Grade/c706bea001fa48d3a958f609c7463200)](https://app.codacy.com/gh/1set/starbox/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![codeclimate](https://api.codeclimate.com/v1/badges/23baa9f82df1c504d2da/maintainability)](https://codeclimate.com/github/1set/starbox/maintainability)
 [![go report](https://goreportcard.com/badge/github.com/1set/starbox)](https://goreportcard.com/report/github.com/1set/starbox)
 
-Starlark in a box -- a simple Starlark REPL and script runner.
+*Starbox* is a pragmatic Go wrapper around the [*Starlark in Go*](https://github.com/google/starlark-go) project, making it easier to execute Starlark scripts, exchange data between Go and Starlark, and call functions across the Go-Starlark boundary. With a focus on simplicity and usability, *Starbox* aims to provide an enhanced experience for developers integrating Starlark scripting into their Go applications.
 
-It provides three main features:
+## 🚀 Key Features
 
-- **Execute** a Starlark script file or REPL
-- **Data** exchange between Starlark and Go
-- **Function** call from Starlark to Go, or vice versa
+A host of powerful features are provided to supercharge your Starlark scripting experience:
+
+- **Streamlined Script Execution**: Simplifies setting up and running Starlark scripts, offering a seamless interface for both script execution and interactive REPL sessions.
+- **Efficient Data Interchange**: Enables robust and smooth data exchange between Go and Starlark, enhancing the interoperability and simplifying the integration process.
+- **Versatile Module Management**: Extends Starlark's capabilities with a suite of built-in functions and the ability to load custom and override existing modules, covering functionalities from data processing to HTTP handling and file manipulation.
+- **Cross-Language Function Calls:** Leverage the power of both languages by calling Go functions from Starlark and vice versa, creating powerful integrations.
+- **Integrated HTTP Context**: Facilitates handling HTTP requests and responses within Starlark scripts, catering to web application development and server-side scripting.
+- **Collective Memory Sharing**: Introduces a shared memory concept, enabling data sharing across different script executions and instances, fostering a more connected and dynamic scripting environment.
+- **Advanced Scripting Tools:** Utilize features like REPL for interactive exploration and debugging, along with script caching for improved performance.
+
+## 📦 Installation
+
+To include `starbox` in your Go project, use the following command:
+
+```bash
+go get github.com/1set/starbox
+```
+
+## ⚙️ Usage
+
+Here's a quick example of how you can use Starbox:
+
+```go
+import "github.com/1set/starbox"
+
+// Define your box with global variables and modules
+box := starbox.New("quick")
+box.AddKeyValue("greet", func(name string) string {
+    return fmt.Sprintf("Hello, %s!", name)
+})
+box.AddNamedModules("random")
+
+// Run a Starlark script
+script := starbox.HereDoc(`
+    target = random.choice(["World", "Starlark", "Starbox"])
+    text = greet(target)
+    print("Starlark:", text)
+    print(__modules__)
+`)
+res, err := box.Run(script)
+
+// Check for errors and results
+if err != nil {
+    fmt.Println("Error executing script:", err)
+    return
+}
+fmt.Println("Go:", res["text"].(string))
+```
+
+This may output:
+
+```
+[⭐|quick](15:50:27.677) Starlark: Hello, Starbox!
+[⭐|quick](15:50:27.677) ["random"]
+Go: Hello, Starbox!
+```
+
+## 👥 Contributing
+
+We welcome contributions to the *Starbox* project. If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request. Before undertaking any significant changes, please let us know by filing an issue or claiming an existing one to ensure there is no duplication of effort.
+
+## 📜 License
+
+*Starbox* is licensed under the [MIT License](LICENSE).
+
+## 🙌 Credits
+
+This project is inspired by and builds upon several open-source projects:
+
+- [Starlark in Go](https://github.com/google/starlark-go): The official Starlark interpreter in Go, created by Google.
+- [Starlight](https://github.com/starlight-go/starlight): A well-known Go wrapper and data conversion tool between Go and Starlark.
+- [Starlight Enhanced](https://github.com/1set/starlight): A sophisticated fork of the original Starlight, with bug fixes and enhancement features.
+- [Starlib](https://github.com/qri-io/starlib): A collection of third-party libraries for Starlark.
+- [Starlet](https://github.com/1set/starlet): A Go wrapper that simplifies usage, offers data conversion, libraries and extensions for Starlark.
+
+We thank the authors and contributors of these projects for their excellent works 🎉

ctor.go

@@ -8,7 +8,6 @@ import (
 	"sync"
 	"time"
 
-	"bitbucket.org/ai69/amoy"
 	"github.com/1set/starlet"
 	"github.com/1set/starlet/dataconv"
 	libhttp "github.com/1set/starlet/lib/http"
@@ -36,6 +35,7 @@ type Starbox struct {
 	loadMods   starlet.ModuleLoaderMap
 	scriptMods map[string]string
 	modFS      fs.FS
+	modNames   []string
 }
 
 // New creates a new Starbox instance with default settings.
@@ -51,7 +51,7 @@ func newStarMachine(name string) *starlet.Machine {
 	// m.SetOutputConversionEnabled(true)
 	m.SetPrintFunc(func(thread *starlark.Thread, msg string) {
 		prefix := fmt.Sprintf("[⭐|%s](%s)", name, time.Now().UTC().Format(`15:04:05.000`))
-		amoy.Eprintln(prefix, msg)
+		eprintln(prefix, msg)
 	})
 	return m
 }
@@ -63,6 +63,9 @@ func (s *Starbox) String() string {
 
 // GetMachine returns the underlying starlet.Machine instance.
 func (s *Starbox) GetMachine() *starlet.Machine {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
 	return s.mac
 }
 
@@ -79,6 +82,14 @@ func (s *Starbox) GetSteps() uint64 {
 	return 0
 }
 
+// GetModuleNames returns the names of the modules loaded after execution.
+func (s *Starbox) GetModuleNames() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	return s.modNames
+}
+
 // SetStructTag sets the custom tag of Go struct fields for Starlark.
 // It panics if called after execution.
 func (s *Starbox) SetStructTag(tag string) {
@@ -316,6 +327,7 @@ func (s *Starbox) AddStructData(structName string, structData starlark.StringDic
 
 // AddModuleScript creates a module with given module script in virtual filesystem, and adds it to the preload and lazyload registry.
 // The given module script can be accessed in script via load("module_name", "key1") or load("module_name.star", "key1") if module name has no ".star" suffix.
+// All the module scripts added by this method would be overridden by SetFS() if it's not nil.
 // It panics if called after execution.
 func (s *Starbox) AddModuleScript(moduleName, moduleScript string) {
 	s.mu.Lock()

ctor_test.go

@@ -3,10 +3,10 @@ package starbox_test
 import (
 	"encoding/json"
 	"fmt"
+	"reflect"
 	"strings"
 	"testing"
 
-	"bitbucket.org/ai69/amoy"
 	"github.com/1set/starbox"
 	"github.com/1set/starlet"
 	"github.com/1set/starlet/dataconv"
@@ -15,7 +15,7 @@ import (
 )
 
 var (
-	hereDoc   = amoy.HereDocf
+	hereDoc   = starbox.HereDocf
 	noopPrint = func(thread *starlark.Thread, msg string) {
 		return
 	}
@@ -159,6 +159,8 @@ func TestSetFS(t *testing.T) {
 	out, err := b.Run(hereDoc(`
 		load("test.star", "a", "b")
 		c = a + b
+		print(__modules__)
+		m = len(__modules__)
 	`))
 	if err != nil {
 		t.Error(err)
@@ -168,14 +170,18 @@ func TestSetFS(t *testing.T) {
 		t.Error("expect not nil, got nil")
 		return
 	}
-	if len(out) != 1 {
-		t.Errorf("expect 1, got %d", len(out))
+	if len(out) != 2 {
+		t.Errorf("expect 2, got %d", len(out))
 		return
 	}
 	if es := int64(30); out["c"] != es {
 		t.Errorf("expect %d, got %v", es, out["c"])
 		return
 	}
+	if es := int64(0); out["m"] != es {
+		t.Errorf("expect %d, got %v", es, out["m"])
+		return
+	}
 
 	// rerun the script with the same virtual filesystem
 	out, err = b.Run(hereDoc(`
@@ -262,11 +268,12 @@ func TestSetModuleSet(t *testing.T) {
 			// check for existing modules
 			for _, m := range tt.hasMod {
 				b := getBox()
-				_, err := b.Run(hereDoc(fmt.Sprintf(`print(type(%s))`, m)))
+				res, err := b.Run(hereDoc(fmt.Sprintf(`print(type(%s)); m = __modules__`, m)))
 				if err != nil {
 					t.Errorf("expect nil for existing module %q, got %v", m, err)
 					return
 				}
+				t.Logf("{%s} modules: %v", tt.setName, res["m"])
 			}
 
 			// check for non-existing modules
@@ -426,27 +433,32 @@ func TestAddBuiltin(t *testing.T) {
 // 4. Check the output to see if the named modules are present.
 func TestAddNamedModules(t *testing.T) {
 	b := starbox.New("test")
+	b.AddNamedModules("runtime")
 	b.AddNamedModules("base64")
 	b.AddNamedModules("runtime")
 	out, err := b.Run(hereDoc(`
 		s = base64.encode('Aloha!')
 		t = type(runtime.pid)
+		m = __modules__
 	`))
 	if err != nil {
 		t.Error(err)
 	}
 	if out == nil {
 		t.Error("expect not nil, got nil")
 	}
-	if len(out) != 2 {
-		t.Errorf("expect 2, got %d", len(out))
+	if len(out) != 3 {
+		t.Errorf("expect 3, got %d", len(out))
 	}
 	if es := `QWxvaGEh`; out["s"] != es {
 		t.Errorf("expect %q, got %v", es, out["s"])
 	}
 	if es := `int`; out["t"] != es {
 		t.Errorf("expect %q, got %v", es, out["t"])
 	}
+	if es := []interface{}{"base64", "runtime"}; !reflect.DeepEqual(out["m"].([]interface{}), es) {
+		t.Errorf("expect %v, got %v", es, out["m"])
+	}
 }
 
 // TestAddModuleLoader tests the following:
@@ -482,6 +494,7 @@ func TestAddModuleLoader(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 2},
 		{`c = shift(a=10, b=4) + num`, 265},
 		{`load("mine", "shift", "num"); c = shift(a=10, b=5) * num`, 32500},
 		{`c = less.plus(a=10, b=4) + less.num + num`, 314},
@@ -524,6 +537,7 @@ func TestAddModuleData(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 1},
 		{`c = data.a + data.b`, 30},
 		{`load("data", "a", "b"); c = a * b`, 200},
 		{`load("data", "a", "b"); c = data.c * (a+b)`, 9000},
@@ -569,6 +583,7 @@ func TestAddModuleFunctions(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 1},
 		{`c = data.shift(a=10, b=4) + 100`, 267},
 		{`load("data", "shift"); c = shift(a=10, b=5) * 10`, 3270},
 		{`c = int(str(data.shift) == '<built-in function data.shift>')`, 1},
@@ -616,6 +631,7 @@ func TestAddStructData(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 1},
 		{`c = data.A + data.B`, 30},
 		{`c = data.A * data.B`, 200},
 		{`c = data.C * (data.A + data.B)`, 9000},
@@ -663,6 +679,7 @@ func TestAddStructFunctions(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 1},
 		{`c = data.shift(a=10, b=4) + 100`, 267},
 		{`load("data", "shift"); c = shift(a=10, b=5) * 10`, 3270},
 		{`c = int(str(data.shift) == '<built-in function data.shift>')`, 1},
@@ -707,6 +724,7 @@ func TestAddModuleScript(t *testing.T) {
 		script string
 		want   int64
 	}{
+		{`print(__modules__); c = len(__modules__)`, 1},
 		{`load("data.star", "a", "b"); c = a * b`, 200},
 		{`load("data", "shift"); c = shift(2, 10)`, 2058},
 	}
@@ -730,3 +748,53 @@ func TestAddModuleScript(t *testing.T) {
 		})
 	}
 }
+
+// TestAddNamedModuleAndModuleScript tests the following:
+// 1. Create a new Starbox instance.
+// 2. Add named modules and module script.
+// 3. Run a script that uses function from the named modules and module script.
+// 4. Check the output to see if the named modules and module script conflict.
+func TestAddNamedModuleAndModuleScript(t *testing.T) {
+	b := starbox.New("test")
+	b.AddNamedModules("base64")
+	b.AddNamedModules("csv")
+	b.AddNamedModules("runtime")
+	b.AddModuleScript("runtime", hereDoc(`
+		pid = "ABC"
+	`))
+	out, err := b.Run(hereDoc(`
+		v1 = runtime.pid	# builtin
+		print("v1[b]", type(v1), v1)
+
+		load("runtime", p2="pid")	# builtin
+		v2 = p2
+		print("v2[b]", type(v2), v2)
+
+		load("runtime.star", p3="pid") # script
+		v3 = p3
+		print("v3[s]", type(v3), v3)
+
+		s = " ".join([type(v1), type(v2), type(v3)])
+		m = __modules__
+		print(__modules__)
+	`))
+	if err != nil {
+		t.Error(err)
+	}
+	if out == nil {
+		t.Error("expect not nil, got nil")
+	}
+	if len(out) != 5 {
+		t.Errorf("expect 5, got %d", len(out))
+	}
+	if es := `int int string`; out["s"] != es {
+		t.Errorf("expect %q, got %v", es, out["s"])
+	}
+	if es := []interface{}{"base64", "csv", "runtime", "runtime.star"}; !reflect.DeepEqual(out["m"].([]interface{}), es) {
+		t.Errorf("expect %v, got %v", es, out["m"])
+	}
+	if em := []string{"base64", "csv", "runtime", "runtime.star"}; !reflect.DeepEqual(em, b.GetModuleNames()) {
+		t.Errorf("expect %v, got %v", em, b.GetModuleNames())
+		return
+	}
+}