Added base64 library with encoders/decoders and json encoders/decoders (#31)

* To prep for json/yaml encoder/decoder, write wrappers for golang io to lua's file.

* Add json.Encoder and Decoder - mainly so that (A) decode could be done from file, and (B) encoding could do pretty printing by setting the indentation.

* Added strings.Reader and strings.Builder support.

* Add a test for pretty printing.

* Minor style fix

* Add examples in READMEs

* Added more tests for reading and writing multiple values.

* Add comment for CheckIOReader and CheckIOWriter.

* Use os.ModePerm; not fs.ModePerm.

* 2001 (one millisecond over 2s) is too slim a margin; bumping to 3.001s.

* Just a small adjustment to convert to []byte (in case encoding unfurls to lareger size than the size of unicode string)

* Check possible error in encode.

* Add a base64 module from the golang's encoding/base64 encodings.

* Set example for encode to not bother with err.

* Also adjust tests to not get/check err when not returned.

* Add TODO for the other PR.

* Added preload for base64.

* Combine base64 work with encoders so that the io stuff could be shared.

* Added test for reading a count.

* Added ioutil.copy as well.

* Remove TODOs as they were done.

* Use return of copy as n (num bytes)

* Added more to the readme.

* Add README and test for strings reader and builder string().

* Update README to use `:` method.

Co-authored-by: Sheridan C Rawlins <[email protected]>

Author: scr-oath

README.md

@@ -16,6 +16,7 @@ go get github.com/vadv/gopher-lua-libs
 
 ## Index
 
+* [base64](/base64) [encoding/base64](https://pkg.go.dev/encoding/base64) api
 * [cloudwatch](/aws/cloudwatch) aws cloudwatch log access
 * [cert_util](/cert_util) monitoring ssl certs
 * [chef](/chef) chef client api

base64/README.md

@@ -0,0 +1,54 @@
+# base64 [![GoDoc](https://godoc.org/github.com/vadv/gopher-lua-libs/base64?status.svg)](https://godoc.org/github.com/vadv/gopher-lua-libs/base64)
+
+Lua module for [encoding/base64](https://pkg.go.dev/encoding/base64)
+
+## Usage
+
+### Encoding
+
+```lua
+local base64 = require("base64")
+
+s = base64.RawStdEncoding:encode_to_string("foo\01bar")
+print(s)
+Zm9vAWJhcg
+
+s = base64.StdEncoding:encode_to_string("foo\01bar")
+print(s)
+Zm9vAWJhcg==
+
+s = base64.RawURLEncoding:encode_to_string("this is a <tag> and should be encoded")
+print(s)
+dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA
+
+s = base64.URLEncoding:encode_to_string("this is a <tag> and should be encoded")
+print(s)
+dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==
+
+```
+
+### Decoding
+
+```lua
+local base64 = require("base64")
+
+s, err = base64.RawStdEncoding:decode_string("Zm9vAWJhcg")
+assert(not err, err)
+print(s)
+foo
bar
+
+s, err = base64.StdEncoding:decode_string("Zm9vAWJhcg==")
+assert(not err, err)
+print(s)
+foo
bar
+
+s, err = base64.RawURLEncoding:decode_string("dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA")
+assert(not err, err)
+print(s)
+this is a <tag> and should be encoded
+
+s, err = base64.URLEncoding:decode_string("dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==")
+assert(not err, err)
+print(s)
+this is a <tag> and should be encoded
+```

base64/api.go

@@ -0,0 +1,126 @@
+// Package base64 implements base64 encode/decode functionality for lua.
+package base64
+
+import (
+	"encoding/base64"
+	lio "github.com/vadv/gopher-lua-libs/io"
+	lua "github.com/yuin/gopher-lua"
+	"io"
+)
+
+const (
+	base64EncodingType = "base64.Encoding"
+	base64EncoderType  = "base64.Encoder"
+	base64DecoderType  = "base64.Decoder"
+)
+
+//CheckBase64Encoding checks the argument at position n is a *base64.Encoding
+func CheckBase64Encoding(L *lua.LState, n int) *base64.Encoding {
+	ud := L.CheckUserData(n)
+	if encoding, ok := ud.Value.(*base64.Encoding); ok {
+		return encoding
+	}
+	L.ArgError(n, base64EncodingType+" expected")
+	return nil
+}
+
+//LVBase64Encoding converts encoding to a UserData type for lua
+func LVBase64Encoding(L *lua.LState, encoding *base64.Encoding) lua.LValue {
+	ud := L.NewUserData()
+	ud.Value = encoding
+	L.SetMetatable(ud, L.GetTypeMetatable(base64EncodingType))
+	return ud
+}
+
+func LVBase64Encoder(L *lua.LState, writer io.Writer) lua.LValue {
+	ud := L.NewUserData()
+	ud.Value = writer
+	L.SetMetatable(ud, L.GetTypeMetatable(base64EncoderType))
+	return ud
+}
+
+func LVBase64Decoder(L *lua.LState, reader io.Reader) lua.LValue {
+	ud := L.NewUserData()
+	ud.Value = reader
+	L.SetMetatable(ud, L.GetTypeMetatable(base64DecoderType))
+	return ud
+}
+
+//DecodeString decodes the encoded string with the encoding
+func DecodeString(L *lua.LState) int {
+	encoding := CheckBase64Encoding(L, 1)
+	encoded := L.CheckString(2)
+	L.Pop(L.GetTop())
+	decoded, err := encoding.DecodeString(encoded)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	L.Push(lua.LString(decoded))
+	return 1
+}
+
+//EncodeToString decodes the string with the encoding
+func EncodeToString(L *lua.LState) int {
+	encoding := CheckBase64Encoding(L, 1)
+	decoded := L.CheckString(2)
+	L.Pop(L.GetTop())
+	encoded := encoding.EncodeToString([]byte(decoded))
+	L.Push(lua.LString(encoded))
+	return 1
+}
+
+//registerBase64Encoding Registers the encoding type and its methods
+func registerBase64Encoding(L *lua.LState) {
+	mt := L.NewTypeMetatable(base64EncodingType)
+	L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
+		"decode_string":    DecodeString,
+		"encode_to_string": EncodeToString,
+	}))
+}
+
+//registerBase64Encoder Registers the encoder type and its methods
+func registerBase64Encoder(L *lua.LState) {
+	mt := L.NewTypeMetatable(base64EncoderType)
+	L.SetGlobal(base64EncoderType, mt)
+	L.SetField(mt, "__index", lio.WriterFuncTable(L))
+}
+
+//registerBase64Decoder Registers the decoder type and its methods
+func registerBase64Decoder(L *lua.LState) {
+	mt := L.NewTypeMetatable(base64DecoderType)
+	L.SetGlobal(base64DecoderType, mt)
+	L.SetField(mt, "__index", lio.ReaderFuncTable(L))
+}
+
+func NewEncoding(L *lua.LState) int {
+	encoder := L.CheckString(1)
+	if len(encoder) != 64 {
+		L.ArgError(1, "encoder must have 64 characters")
+		return 0
+	}
+	L.Pop(L.GetTop())
+
+	encoding := base64.NewEncoding(encoder)
+	L.Push(LVBase64Encoding(L, encoding))
+	return 1
+}
+
+func NewEncoder(L *lua.LState) int {
+	encoding := CheckBase64Encoding(L, 1)
+	writer := lio.CheckIOWriter(L, 2)
+	L.Pop(L.GetTop())
+	encoder := base64.NewEncoder(encoding, writer)
+	L.Push(LVBase64Encoder(L, encoder))
+	return 1
+}
+
+func NewDecoder(L *lua.LState) int {
+	encoding := CheckBase64Encoding(L, 1)
+	reader := lio.CheckIOReader(L, 2)
+	L.Pop(L.GetTop())
+	decoder := base64.NewDecoder(encoding, reader)
+	L.Push(LVBase64Decoder(L, decoder))
+	return 1
+}

base64/api_test.go

@@ -0,0 +1,13 @@
+package base64
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/vadv/gopher-lua-libs/strings"
+	"github.com/vadv/gopher-lua-libs/tests"
+	"testing"
+)
+
+func TestApi(t *testing.T) {
+	preload := tests.SeveralPreloadFuncs(Preload, strings.Preload)
+	assert.NotZero(t, tests.RunLuaTestFile(t, preload, "./test/test_api.lua"))
+}

base64/example_test.go

@@ -0,0 +1,69 @@
+package base64
+
+import (
+	"log"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func ExampleEncodeToString() {
+	state := lua.NewState()
+	defer state.Close()
+	Preload(state)
+	source := `
+    local base64 = require("base64")
+	s = base64.RawStdEncoding:encode_to_string("foo\01bar")
+	print(s)
+
+	s = base64.StdEncoding:encode_to_string("foo\01bar")
+	print(s)
+
+	s = base64.RawURLEncoding:encode_to_string("this is a <tag> and should be encoded")
+	print(s)
+
+	s = base64.URLEncoding:encode_to_string("this is a <tag> and should be encoded")
+	print(s)
+
+`
+	if err := state.DoString(source); err != nil {
+		log.Fatal(err.Error())
+	}
+	// Output:
+	// Zm9vAWJhcg
+	// Zm9vAWJhcg==
+	// dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA
+	// dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==
+}
+
+func ExampleDecodeString() {
+	state := lua.NewState()
+	defer state.Close()
+	Preload(state)
+	source := `
+    local base64 = require("base64")
+	s, err = base64.RawStdEncoding:decode_string("Zm9vAWJhcg")
+	assert(not err, err)
+	print(s)
+
+	s, err = base64.StdEncoding:decode_string("Zm9vAWJhcg==")
+	assert(not err, err)
+	print(s)
+
+	s, err = base64.RawURLEncoding:decode_string("dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA")
+	assert(not err, err)
+	print(s)
+
+	s, err = base64.URLEncoding:decode_string("dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==")
+	assert(not err, err)
+	print(s)
+
+`
+	if err := state.DoString(source); err != nil {
+		log.Fatal(err.Error())
+	}
+	// Output:
+	// foo
bar
+	// foo
bar
+	// this is a <tag> and should be encoded
+	// this is a <tag> and should be encoded
+}

base64/loader.go

@@ -0,0 +1,35 @@
+package base64
+
+import (
+	"encoding/base64"
+	lua "github.com/yuin/gopher-lua"
+)
+
+// Preload adds yaml to the given Lua state's package.preload table. After it
+// has been preloaded, it can be loaded using require:
+//
+//  local yaml = require("yaml")
+func Preload(L *lua.LState) {
+	L.PreloadModule("base64", Loader)
+}
+
+// Loader is the module loader function.
+func Loader(L *lua.LState) int {
+	registerBase64Encoding(L)
+	registerBase64Encoder(L)
+	registerBase64Decoder(L)
+
+	// Register the encodings offered by base64 go module.
+	t := L.NewTable()
+	L.SetField(t, "RawStdEncoding", LVBase64Encoding(L, base64.RawStdEncoding))
+	L.SetField(t, "RawURLEncoding", LVBase64Encoding(L, base64.RawURLEncoding))
+	L.SetField(t, "StdEncoding", LVBase64Encoding(L, base64.StdEncoding))
+	L.SetField(t, "URLEncoding", LVBase64Encoding(L, base64.URLEncoding))
+	L.SetFuncs(t, map[string]lua.LGFunction{
+		"new_encoding": NewEncoding,
+		"new_encoder":  NewEncoder,
+		"new_decoder":  NewDecoder,
+	})
+	L.Push(t)
+	return 1
+}