add json and yaml

build/build.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+git describe --tags --abbrev=0 > version.txt
+go install
+rm version.txt

cmd/cmd.go

@@ -25,6 +25,7 @@ import (
 	"github.com/dvaumoron/cornucopia/config"
 	"github.com/dvaumoron/cornucopia/glu"
 	go_glu "github.com/dvaumoron/cornucopia/glu/go"
+	marshal_glu "github.com/dvaumoron/cornucopia/glu/marshal"
 	text_glu "github.com/dvaumoron/cornucopia/glu/text"
 	"github.com/dvaumoron/cornucopia/module"
 	"github.com/spf13/cobra"
@@ -36,17 +37,18 @@ var conf config.Config
 func initCornucopiaGlobals() {
 	go_glu.InitCornucopiaGoGlobals()
 	text_glu.InitCornucopiaTextGlobals()
+	marshal_glu.InitCornucopiaMarshalGlobals()
 }
 
-func Init() *cobra.Command {
+func Init(version string) *cobra.Command {
 	defaultRepoPath, defaultRepoUrl, err := config.InitDefault("CORNUCOPIA_REPO_PATH", "CORNUCOPIA_REPO_URL")
 
 	cmd := &cobra.Command{
 		Use:   "cornucopia scriptname",
 		Short: "cornucopia run a code generation script.",
 		Long: `cornucopia run a code generation script, find more details at :
 https://github.com/dvaumoron/cornucopia`,
-		Version: "v1.1.0",
+		Version: version,
 		Args:    cobra.ExactArgs(1),
 		RunE: func(_ *cobra.Command, args []string) error {
 			if err != nil {
@@ -67,7 +69,7 @@ https://github.com/dvaumoron/cornucopia`,
 			}
 
 			_, err = starlark.ExecFile(thread, scriptname, nil, nil)
-			generated := len(glu.GeneratedFilenames) != 0
+			generated := len(glu.GeneratedFileNames) != 0
 			if err != nil {
 				if generated {
 					displayGeneratedFileNames("Before error, the following file have been generated :")
@@ -95,7 +97,7 @@ https://github.com/dvaumoron/cornucopia`,
 
 func displayGeneratedFileNames(msg string) {
 	fmt.Println(msg)
-	for _, fileName := range glu.GeneratedFilenames {
+	for _, fileName := range glu.GeneratedFileNames {
 		fmt.Println(fileName)
 	}
 }

cornucopia.go

@@ -19,14 +19,18 @@
 package main
 
 import (
+	_ "embed"
 	"fmt"
 	"os"
 
 	"github.com/dvaumoron/cornucopia/cmd"
 )
 
+//go:embed version.txt
+var version string
+
 func main() {
-	if err := cmd.Init().Execute(); err != nil {
+	if err := cmd.Init(version).Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}

glu/common.go

@@ -20,6 +20,10 @@ package glu
 
 import (
 	"errors"
+	"fmt"
+	"math"
+
+	"go.starlark.net/starlark"
 )
 
 var (
@@ -28,4 +32,42 @@ var (
 )
 
 // mutex not needed
-var GeneratedFilenames []string
+var GeneratedFileNames []string
+
+func ConvertToGoBaseType(value starlark.Value) any {
+	switch casted := value.(type) {
+	case starlark.Bool:
+		return bool(casted)
+	case starlark.Int:
+		if res, ok := casted.Int64(); ok {
+			if math.MinInt <= res && res <= math.MaxInt {
+				return int(res)
+			}
+			return res
+		}
+	case starlark.Float:
+		return float64(casted)
+	case starlark.String:
+		return string(casted)
+	}
+	return nil
+}
+
+func ConvertToString(value starlark.Value) string {
+	switch casted := value.(type) {
+	case starlark.Bool:
+		if casted {
+			return "true"
+		}
+		return "false"
+	case starlark.Int:
+		if res, ok := casted.Int64(); ok {
+			return fmt.Sprint(res)
+		}
+	case starlark.Float:
+		return fmt.Sprint(float64(casted))
+	case starlark.String:
+		return string(casted)
+	}
+	return ""
+}

glu/go/converter.go

@@ -19,32 +19,11 @@
 package go_glu
 
 import (
-	"math"
-
 	"github.com/dave/jennifer/jen"
 	"github.com/dvaumoron/cornucopia/glu"
 	"go.starlark.net/starlark"
 )
 
-func convertToGoBuiltin(value starlark.Value) any {
-	switch casted := value.(type) {
-	case starlark.Bool:
-		return bool(casted)
-	case starlark.Int:
-		if res, ok := casted.Int64(); ok {
-			if math.MinInt <= res && res <= math.MaxInt {
-				return int(res)
-			}
-			return res
-		}
-	case starlark.Float:
-		return float64(casted)
-	case starlark.String:
-		return string(casted)
-	}
-	return nil
-}
-
 func convertToGoByte(value starlark.Value) byte {
 	if casted, ok := value.(starlark.Int); ok {
 		if res, ok2 := casted.Int64(); ok2 {
@@ -72,7 +51,7 @@ func convertToCode(value starlark.Value) jen.Code {
 	if casted, ok := value.(glu.Coder); ok {
 		return casted.Code()
 	}
-	return jen.Lit(convertToGoBuiltin(value))
+	return jen.Lit(glu.ConvertToGoBaseType(value))
 }
 
 func convertToCodeSlice(args starlark.Tuple) []jen.Code {

glu/go/globals.go

@@ -89,7 +89,7 @@ func wrappedLit(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kw
 	if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value", &value); err != nil {
 		return nil, err
 	}
-	lit := jen.Lit(convertToGoBuiltin(value))
+	lit := jen.Lit(glu.ConvertToGoBaseType(value))
 	return glu.Wrapper{Inner: lit, WType: &jenStatementWrappedType}, nil
 }
 

glu/go/types.go

@@ -153,17 +153,17 @@ func jenFile_Line(_ *starlark.Thread, b *starlark.Builtin, _ starlark.Tuple, _ [
 }
 
 func jenFile_Save(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
-	var filename string
-	err := starlark.UnpackArgs(b.Name(), args, kwargs, "filename", &filename)
+	var fileName string
+	err := starlark.UnpackArgs(b.Name(), args, kwargs, "fileName", &fileName)
 	if err != nil {
 		return nil, err
 	}
 
-	if path.IsAbs(filename) {
+	if path.IsAbs(fileName) {
 		return nil, glu.ErrForbidAbsolute
 	}
 
-	if err = common.EnsureWrite(filename); err != nil {
+	if err = common.EnsureWrite(fileName); err != nil {
 		return nil, err
 	}
 
@@ -173,11 +173,11 @@ func jenFile_Save(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple,
 		return nil, glu.ErrCast
 	}
 
-	if err = file.Save(filename); err != nil {
+	if err = file.Save(fileName); err != nil {
 		return nil, err
 	}
 
-	glu.GeneratedFilenames = append(glu.GeneratedFilenames, filename)
+	glu.GeneratedFileNames = append(glu.GeneratedFileNames, fileName)
 	return starlark.None, nil
 }
 
@@ -258,7 +258,7 @@ func jenStatement_Lit(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tup
 		return nil, glu.ErrCast
 	}
 
-	lit := stmt.Lit(convertToGoBuiltin(value))
+	lit := stmt.Lit(glu.ConvertToGoBaseType(value))
 	return glu.Wrapper{Inner: lit, WType: &jenStatementWrappedType}, nil
 }
 

glu/marshal/globals.go

@@ -0,0 +1,85 @@
+/*
+ *
+ * Copyright 2023 cornucopia authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package marshal_glu
+
+import (
+	"encoding/json"
+	"path"
+
+	"github.com/dvaumoron/cornucopia/common"
+	"github.com/dvaumoron/cornucopia/glu"
+	"go.starlark.net/starlark"
+	"gopkg.in/yaml.v3"
+)
+
+func InitCornucopiaMarshalGlobals() {
+	starlark.Universe["SaveJsonFile"] = starlark.NewBuiltin("SaveJsonFile", wrappedSaveJsonFile)
+	starlark.Universe["SaveYamlFile"] = starlark.NewBuiltin("SaveYamlFile", wrappedSaveYamlFile)
+}
+
+func wrappedSaveJsonFile(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+	return saveMarshallFile(json.Marshal, b, args, kwargs)
+}
+
+func wrappedSaveYamlFile(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+	return saveMarshallFile(yaml.Marshal, b, args, kwargs)
+}
+
+func saveMarshallFile(marshalFunc func(any) ([]byte, error), b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+	var fileName string
+	var object starlark.Value
+	err := starlark.UnpackArgs(b.Name(), args, kwargs, "fileName", &fileName, "object", &object)
+	if err != nil {
+		return nil, err
+	}
+
+	if path.IsAbs(fileName) {
+		return nil, glu.ErrForbidAbsolute
+	}
+
+	data, err := marshalFunc(convertToMarshal(object))
+	if err != nil {
+		return nil, err
+	}
+
+	if err = common.WriteFile(fileName, data); err != nil {
+		return nil, err
+	}
+
+	glu.GeneratedFileNames = append(glu.GeneratedFileNames, fileName)
+	return starlark.None, nil
+}
+
+func convertToMarshal(value starlark.Value) any {
+	switch casted := value.(type) {
+	case starlark.Tuple:
+		res := make([]any, len(casted))
+		for _, elem := range casted {
+			res = append(res, convertToMarshal(elem))
+		}
+		return res
+	case *starlark.Dict:
+		res := make(map[string]any, casted.Len())
+		for _, item := range casted.Items() {
+			res[glu.ConvertToString(item[0])] = convertToMarshal(item[1])
+		}
+		return res
+	}
+	return glu.ConvertToGoBaseType(value)
+}

glu/text/converter.go

@@ -19,34 +19,14 @@
 package text_glu
 
 import (
-	"fmt"
-
+	"github.com/dvaumoron/cornucopia/glu"
 	"go.starlark.net/starlark"
 )
 
-func convertToString(value starlark.Value) string {
-	switch casted := value.(type) {
-	case starlark.Bool:
-		if casted {
-			return "true"
-		}
-		return "false"
-	case starlark.Int:
-		if res, ok := casted.Int64(); ok {
-			return fmt.Sprint(res)
-		}
-	case starlark.Float:
-		return fmt.Sprint(float64(casted))
-	case starlark.String:
-		return string(casted)
-	}
-	return ""
-}
-
 func convertToStringSlice(args starlark.Tuple) []string {
 	res := make([]string, 0, len(args))
 	for _, arg := range args {
-		res = append(res, convertToString(arg))
+		res = append(res, glu.ConvertToString(arg))
 	}
 	return res
 }

glu/text/globals.go

@@ -30,11 +30,6 @@ func InitCornucopiaTextGlobals() {
 }
 
 func wrappedNewTextFile(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
-	var packageName string
-	if err := starlark.UnpackArgs(b.Name(), args, kwargs, "packageName", &packageName); err != nil {
-		return nil, err
-	}
-
 	builder := new(strings.Builder)
 	return glu.Wrapper{Inner: builder, WType: &textFileWrappedType}, nil
 }

glu/text/types.go

@@ -27,7 +27,7 @@ import (
 	"go.starlark.net/starlark"
 )
 
-var textFileWrappedType = glu.MakeWrappedType("testFile", starlark.NewBuiltin("Line", textFile_Line), starlark.NewBuiltin("Save", textFile_Save))
+var textFileWrappedType = glu.MakeWrappedType("textFile", starlark.NewBuiltin("Line", textFile_Line), starlark.NewBuiltin("Save", textFile_Save))
 
 func textFile_Line(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, _ []starlark.Tuple) (starlark.Value, error) {
 	recv, _ := b.Receiver().(glu.Wrapper)
@@ -44,13 +44,13 @@ func textFile_Line(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple,
 }
 
 func textFile_Save(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
-	var filename string
-	err := starlark.UnpackArgs(b.Name(), args, kwargs, "filename", &filename)
+	var fileName string
+	err := starlark.UnpackArgs(b.Name(), args, kwargs, "fileName", &fileName)
 	if err != nil {
 		return nil, err
 	}
 
-	if path.IsAbs(filename) {
+	if path.IsAbs(fileName) {
 		return nil, glu.ErrForbidAbsolute
 	}
 
@@ -60,10 +60,10 @@ func textFile_Save(_ *starlark.Thread, b *starlark.Builtin, args starlark.Tuple,
 		return nil, glu.ErrCast
 	}
 
-	if err = common.WriteFile(filename, []byte(casted.String())); err != nil {
+	if err = common.WriteFile(fileName, []byte(casted.String())); err != nil {
 		return nil, err
 	}
 
-	glu.GeneratedFilenames = append(glu.GeneratedFilenames, filename)
+	glu.GeneratedFileNames = append(glu.GeneratedFileNames, fileName)
 	return starlark.None, nil
 }