init

Author: Philiphil

README.MD

@@ -0,0 +1,74 @@
+# Serializer
+
+This project is heavily inspired by the Symfony Serializer Component. 
+Its purpose is to facilitate the serialization and deserialization of golang structures in various formats while selectively excluding or including fields using serialization groups.
+
+## Overview
+
+The Serializer library provides a flexible way to serialize and deserialize data structures in multiple formats. It draws inspiration from the Symfony Serializer Component, offering similar functionality in the Go programming language.
+
+## Features
+
+- **Format Support:** Serializer currently supports various serialization formats, including JSON, CSV & XML.
+- **Serialization Groups:** You can use serialization groups to selectively include or exclude fields during the serialization process.
+- **Inspired by Symfony:** Leveraging concepts from the Symfony Serializer Component ensures familiarity for users familiar with Symfony.
+
+## Installation
+
+To use the Serializer library in your Go project, simply import the package:
+
+```shell
+go get github.com/philphil/serializer
+```
+
+
+## Example  
+```
+package main
+
+import (
+	"fmt"
+	"github.com/philiphil/serializer" 
+)
+
+type MyStruct struct {
+	Name  string `json:"name" group:"group1"`
+	Age   int    `json:"age" group:"group2"`
+	Email string `json:"email"`
+}
+
+func main() {
+	// Create an instance of Serializer
+	mySerializer := serializer.NewSerializer(serializer.Json)
+
+	// Data to serialize
+	dataToSerialize := MyStruct{
+		Name:  "John Doe",
+		Age:   30,
+		Email: "[email protected]",
+	}
+
+	// Serialize data to JSON with the "group1" group
+	serializedData, err := mySerializer.Serialize(dataToSerialize, "json", "group1")
+	if err != nil {
+		fmt.Println("Serialization error:", err)
+		return
+	}
+
+	fmt.Println("Serialized Data:", serializedData)
+
+	// New structure for deserialization
+	var deserializedData MyStruct
+
+	// Deserialize the data
+	err = mySerializer.Deserialize(serializedData, &deserializedData)
+	if err != nil {
+		fmt.Println("Deserialization error:", err)
+		return
+	}
+
+	// Display the deserialized data
+	fmt.Printf("Deserialized Data: %+v\n", deserializedData)
+}
+
+```

deserialize.go

@@ -0,0 +1,98 @@
+package serializer
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func (s *Serializer) Deserialize(data string, obj any) error {
+	if !isPointer(obj) {
+		return fmt.Errorf("object must be pointer")
+	}
+	switch s.Format {
+	case JSON:
+		return json.Unmarshal([]byte(data), obj)
+	case XML:
+		return xml.Unmarshal([]byte(data), obj)
+	case CSV:
+		return s.deserializeCSV(data, obj)
+	default:
+		return fmt.Errorf("Unsupported format: %s", s.Format)
+	}
+}
+
+func (s *Serializer) MergeObjects(target interface{}, source interface{}) error {
+	targetValue := reflect.ValueOf(target)
+	sourceValue := reflect.ValueOf(source)
+
+	if targetValue.Kind() != reflect.Ptr || sourceValue.Kind() != reflect.Ptr {
+		return fmt.Errorf("both target and source must be pointers")
+	}
+
+	targetValue = targetValue.Elem()
+	sourceValue = sourceValue.Elem()
+
+	for i := 0; i < targetValue.NumField(); i++ {
+		targetField := targetValue.Field(i)
+		sourceField := sourceValue.Field(i)
+
+		// Ne fusionner que les champs exportés non vides
+		if targetField.CanSet() && !isEmpty(sourceField) {
+			targetField.Set(sourceField)
+		}
+	}
+
+	return nil
+}
+
+func (s *Serializer) DeserializeAndMerge(data string, target interface{}) error {
+	source := reflect.New(reflect.TypeOf(target).Elem()).Interface()
+
+	if err := s.Deserialize(data, source); err != nil {
+		return err
+	}
+
+	return s.MergeObjects(target, source)
+}
+
+func isEmpty(v reflect.Value) bool {
+	zero := reflect.Zero(v.Type())
+	return reflect.DeepEqual(v.Interface(), zero.Interface())
+}
+
+func isPointer(v interface{}) bool {
+	t := reflect.TypeOf(v)
+	return t.Kind() == reflect.Ptr
+}
+
+func (s *Serializer) deserializeCSV(data string, obj any) error {
+	value := reflect.ValueOf(obj)
+	if value.Kind() != reflect.Ptr || value.IsNil() {
+		return fmt.Errorf("Invalid object type for CSV deserialization")
+	}
+
+	reader := csv.NewReader(strings.NewReader(data))
+	rows, err := reader.ReadAll()
+	if err != nil {
+		return err
+	}
+
+	elemType := value.Elem().Type()
+	elem := reflect.New(elemType).Elem()
+
+	for _, row := range rows {
+		for i, fieldValue := range row {
+			field := elem.Field(i)
+			if field.IsValid() && field.CanSet() {
+				field.SetString(fieldValue)
+			}
+		}
+	}
+
+	value.Elem().Set(elem)
+	return nil
+}

deserialize_test.go

@@ -0,0 +1,110 @@
+package serializer
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSerializer_Deserialize(t *testing.T) {
+	s := NewSerializer(JSON)
+	serialized, err := s.Serialize(test, "test")
+	if err != nil {
+		panic(err)
+	}
+	o := Test{}
+	err = s.Deserialize(serialized, &o)
+	if o != testDeserializedResult {
+		panic("!")
+	}
+
+}
+
+func TestSerializer_MergeObjects(t *testing.T) {
+	target := Test{
+		11, 11, 11, 11, 11, 11, 11,
+	}
+	result := Test{
+		9, 11, 7, 6, 11, 11, 3,
+	}
+	s := NewSerializer(JSON)
+	serialized, err := s.Serialize(test, "test")
+	if err != nil {
+		panic(err)
+	}
+	o := Test{}
+	err = s.Deserialize(serialized, &o)
+	err = s.MergeObjects(&target, &o)
+	if err != nil {
+		panic(err)
+	}
+	if target != result {
+		fmt.Println(target)
+		fmt.Println(result)
+		panic("!")
+	}
+
+}
+
+func TestSerializer_DeserializeAndMerge(t *testing.T) {
+	target := Test{
+		11, 11, 11, 11, 11, 11, 11,
+	}
+	result := Test{
+		9, 11, 7, 6, 11, 11, 3,
+	}
+	s := NewSerializer(JSON)
+	serialized, err := s.Serialize(test, "test")
+	if err != nil {
+		panic(err)
+	}
+	err = s.DeserializeAndMerge(serialized, &target)
+	if err != nil {
+		panic(err)
+	}
+	if target != result {
+		fmt.Println(target)
+		fmt.Println(result)
+		panic("!")
+	}
+
+}
+
+type MyStruct struct {
+	Name  string `json:"name" group:"group1"`
+	Age   int    `json:"age" group:"group2"`
+	Email string `json:"email"`
+}
+
+func main() {
+	// Create an instance of Serializer
+	mySerializer := NewSerializer(JSON)
+
+	// Data to serialize
+	dataToSerialize := MyStruct{
+		Name:  "John Doe",
+		Age:   30,
+		Email: "[email protected]",
+	}
+
+	// Serialize data to JSON with the "group1" group
+	serializedData, err := mySerializer.Serialize(dataToSerialize, "json", "group1")
+	if err != nil {
+		fmt.Println("Serialization error:", err)
+		return
+	}
+
+	fmt.Println("Serialized Data:", serializedData)
+
+	// New structure for deserialization
+	var deserializedData MyStruct
+
+	// Deserialize the data
+	err = mySerializer.Deserialize(serializedData, &deserializedData)
+	if err != nil {
+		fmt.Println("Deserialization error:", err)
+		return
+	}
+
+	// Display the deserialized data
+	fmt.Printf("Deserialized Data: %+v\n", deserializedData)
+}

filter.go

@@ -0,0 +1,57 @@
+package serializer
+
+import (
+	"reflect"
+	"strings"
+)
+
+func filterByGroups[T any](obj T, groups ...string) T {
+	value := reflect.ValueOf(obj)
+	elemType := value.Type()
+
+	var newFields []reflect.StructField
+
+	for i := 0; i < elemType.NumField(); i++ {
+		field := elemType.Field(i)
+		if isFieldExported(field) && isFieldIncluded(field, groups) {
+			newFields = append(newFields, field)
+		}
+	}
+
+	newStructType := reflect.StructOf(newFields)
+	newValue := reflect.New(newStructType).Elem()
+
+	for i, field := range newFields {
+		fieldName := field.Name
+		fieldValue := value.FieldByName(fieldName)
+		newValue.Field(i).Set(fieldValue)
+	}
+
+	return newValue.Interface().(T)
+}
+
+func isFieldIncluded(field reflect.StructField, groups []string) bool {
+	if len(groups) == 0 {
+		return true //No filtration then
+	}
+
+	tag := field.Tag.Get("group")
+	if tag == "" {
+		return false
+	}
+
+	groupList := strings.Split(tag, ",")
+	for _, group := range groups {
+		for _, g := range groupList {
+			if group == g {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func isFieldExported(field reflect.StructField) bool {
+	return field.PkgPath == ""
+}

filter_test.go

@@ -0,0 +1,32 @@
+package serializer
+
+import (
+	"testing"
+)
+
+type Test struct {
+	Test0 int `group:"test"`
+	Test1 int `group:"testo"`
+	Test2 int `group:"test"`
+	Test3 int `group:"testo,test"`
+	Test4 int
+	test5 int
+	Test6 int `group:"test"`
+}
+
+var test = Test{
+	9, -8, 7, 6, -5, -4, 3,
+}
+var testDeserializedResult = Test{
+	9, 0, 7, 6, 0, 0, 3,
+}
+
+func TestExecute(t *testing.T) {
+	s := NewSerializer(JSON)
+	serialized, err := s.Serialize(test, "test")
+	if err != nil {
+		panic(err)
+	}
+	o := Test{}
+	err = s.Deserialize(serialized, &o)
+}

format.go

@@ -0,0 +1,10 @@
+package serializer
+
+type Format string
+
+const (
+	undefined Format = "undefined"
+	JSON             = "JSON"
+	XML              = "XML"
+	CSV              = "CSV"
+)

go.mod

@@ -0,0 +1,3 @@
+module github.com/philiphil/serializer
+
+go 1.19