commit cd63ed1fe4ef1f651d9b8be4b84ad3ef048c7740 Author: Reza Behzadan Date: Sun Feb 18 06:05:09 2024 +0330 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c4b327 --- /dev/null +++ b/.gitignore @@ -0,0 +1,32 @@ +# If you prefer the allow list template instead of the deny list, see community template: +# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore +# +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work + +# By Reza +build/ +dist/ +.archive/ +.vagrant/ +.env +*_[0-9] +*_[0-9][0-9] +*_????-??-?? +*.zip diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..ba6bb4b --- /dev/null +++ b/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2024, Reza Behzadan + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. The name of "Reza Behzadan" may not be used to endorse or promote products derived from this software without specific prior written permission. + +4. Modified versions of the software must be distributed under the same terms and conditions of this license, and the original name of "Reza Behzadan" must be credited as the original developer in any significant portions of the redistributed or modified code. + +5. The software, including any modified versions, must not be used, directly or indirectly, in any type of military project or in any project that may cause harm to any human being. + +6. The software, including any modified versions, must not be used, directly or indirectly, by any individual, organization, or entity involved in or supporting oppressive, totalitarian regimes, or in any project that supports such regimes or contributes to human rights violations. This includes, but is not limited to, entities known for systematic oppression, cruelty, and use of violence against defenseless individuals, or for supporting terrorism. + + +DISCLAIMER: + +THIS SOFTWARE IS PROVIDED BY REZA BEHZADAN "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL REZA BEHZADAN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..aed6e29 --- /dev/null +++ b/README.md @@ -0,0 +1,12 @@ +# GoDict + + +## Tests +```sh +go test -v ./... +``` + +## License + +This project is licensed under a custom license - see the [LICENSE](LICENSE) file for details. + diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..974ffb1 --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module git.behzadan.ir/reza/GoDict + +go 1.22.0 + +require gopkg.in/yaml.v3 v3.0.1 // indirect diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..4bc0337 --- /dev/null +++ b/go.sum @@ -0,0 +1,3 @@ +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/dict/dict.go b/internal/dict/dict.go new file mode 100644 index 0000000..713e842 --- /dev/null +++ b/internal/dict/dict.go @@ -0,0 +1,62 @@ +package dict + +type Dict map[string]interface{} + +func New() Dict { + return make(Dict) +} + +func IsDict(a interface{}) bool { + _, ok := a.(Dict) + return ok +} + +func (d Dict) HasKey(key string) bool { + _, ok := d[key] + return ok +} + +func Copy(dest *Dict, src Dict) { + if *dest == nil { + *dest = make(Dict) + } + for k, v := range src { + if vv, ok := v.(Dict); ok { + t := make(Dict) + Copy(&t, vv) + (*dest)[k] = t + } else { + (*dest)[k] = v + } + } +} + +func (dest *Dict) CopyFrom(src Dict) { + if *dest == nil { + *dest = make(Dict) + } + for k, v := range src { + if vv, ok := v.(Dict); ok { + t := make(Dict) + t.CopyFrom(vv) + (*dest)[k] = t + } else { + (*dest)[k] = v + } + } +} + +func (src Dict) CopyTo(dest *Dict) { + if *dest == nil { + *dest = make(Dict) + } + for k, v := range src { + if vv, ok := v.(Dict); ok { + t := make(Dict) + vv.CopyTo(&t) + (*dest)[k] = t + } else { + (*dest)[k] = v + } + } +} diff --git a/internal/dict/dict_merge.go b/internal/dict/dict_merge.go new file mode 100644 index 0000000..1ce3238 --- /dev/null +++ b/internal/dict/dict_merge.go @@ -0,0 +1,49 @@ +package dict + +func softMerge(a, b Dict) { + for k, v := range b { + if a.HasKey(k) && IsDict(a[k]) && IsDict(v) { + softMerge(a[k].(Dict), v.(Dict)) + } else if !a.HasKey(k) { + a[k] = v + } + } +} + +func SoftMerge(target *Dict, source Dict) { + if target == nil { + *target = make(Dict) + } + softMerge(*target, source) +} + +func (target *Dict) SoftMergeWith(source Dict) { + if target == nil { + *target = make(Dict) + } + softMerge(*target, source) +} + +func merge(a, b Dict) { + for k, v := range b { + if a.HasKey(k) && IsDict(a[k]) && IsDict(v) { + merge(a[k].(Dict), v.(Dict)) + } else { + a[k] = v + } + } +} + +func Merge(target *Dict, source Dict) { + if target == nil { + *target = make(Dict) + } + merge(*target, source) +} + +func (target *Dict) MergeWith(source Dict) { + if target == nil { + *target = make(Dict) + } + merge(*target, source) +} diff --git a/internal/dict/dict_merge_test.go b/internal/dict/dict_merge_test.go new file mode 100644 index 0000000..be947b7 --- /dev/null +++ b/internal/dict/dict_merge_test.go @@ -0,0 +1,46 @@ +package dict + +import ( + "reflect" + "testing" +) + +func TestSoftMerge(t *testing.T) { + testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml") + for _, testCase := range testCases { + SoftMerge(&testCase.Dict1, testCase.Dict2) + if !reflect.DeepEqual(testCase.Dict1, testCase.Result) { + t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1) + } + } +} + +func TestSoftMergeWith(t *testing.T) { + testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml") + for _, testCase := range testCases { + testCase.Dict1.SoftMergeWith(testCase.Dict2) + if !reflect.DeepEqual(testCase.Dict1, testCase.Result) { + t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1) + } + } +} + +func TestMerge(t *testing.T) { + testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml") + for _, testCase := range testCases { + Merge(&testCase.Dict1, testCase.Dict2) + if !reflect.DeepEqual(testCase.Dict1, testCase.Result) { + t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1) + } + } +} + +func TestMergeWith(t *testing.T) { + testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml") + for _, testCase := range testCases { + testCase.Dict1.MergeWith(testCase.Dict2) + if !reflect.DeepEqual(testCase.Dict1, testCase.Result) { + t.Errorf("Expected dict to be %v, got %v", testCase.Result, testCase.Dict1) + } + } +} diff --git a/internal/dict/dict_serialization.go b/internal/dict/dict_serialization.go new file mode 100644 index 0000000..bdc0370 --- /dev/null +++ b/internal/dict/dict_serialization.go @@ -0,0 +1,108 @@ +package dict + +import ( + "encoding/json" + "os" + + "gopkg.in/yaml.v3" +) + +func loadYaml(fn string) (Dict, error) { + content, err := os.ReadFile(fn) + if err != nil { + return nil, err + } + + var data Dict + err = yaml.Unmarshal(content, &data) + if err != nil { + return nil, err + } + return data, nil + +} + +func loadYamlStr(yamlStr string) (Dict, error) { + var data Dict + err := yaml.Unmarshal([]byte(yamlStr), &data) + if err != nil { + return nil, err + } + return data, nil +} + +func (d Dict) dumpYaml(fn string) error { + data, err := yaml.Marshal(d) + if err != nil { + return err + } + return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions +} + +func (d Dict) dumpYamlStr() (string, error) { + data, err := yaml.Marshal(d) + if err != nil { + return "", err + } + return string(data), nil +} + +// loadJson loads the dictionary from a JSON file. +func loadJson(fn string) (Dict, error) { + var data Dict + content, err := os.ReadFile(fn) + if err != nil { + return nil, err + } + + err = json.Unmarshal(content, &data) + if err != nil { + return nil, err + } + return data, nil +} + +func loadJsonStr(jsonStr string) (Dict, error) { + var data Dict + err := json.Unmarshal([]byte(jsonStr), &data) + if err != nil { + return nil, err + } + return data, nil +} + +// dumpJson writes the dictionary to a JSON file. +func (d Dict) dumpJson(fn string) error { + data, err := json.Marshal(d) + if err != nil { + return err + } + return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions +} + +// dumpJsonIndent writes the dictionary to a JSON file but applies indent first. +func (d Dict) dumpJsonIndent(fn string, prefix, indent string) error { + data, err := json.MarshalIndent(d, prefix, indent) + if err != nil { + return err + } + return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions +} + +// dumpJsonStr returns the dictionary as a JSON string. +func (d Dict) dumpJsonStr() (string, error) { + data, err := json.Marshal(d) + if err != nil { + return "", err + } + return string(data), nil +} + +// dumpJsonStr returns the dictionary as a JSON string. +func (d Dict) dumpJsonStrIndent(prefix, indent string) (string, error) { + data, err := json.MarshalIndent(d, prefix, indent) + if err != nil { + return "", err + } + return string(data), nil +} diff --git a/internal/dict/dict_serialization_test.go b/internal/dict/dict_serialization_test.go new file mode 100644 index 0000000..d328ed7 --- /dev/null +++ b/internal/dict/dict_serialization_test.go @@ -0,0 +1,84 @@ +package dict + +import ( + "os" + "reflect" + "testing" +) + +// TestLoadYamlUsingTempFile tests the loadYaml function. +func TestLoadYamlUsingTempFile(t *testing.T) { + // Step 1: Create a temporary file. + tmpFile, err := os.CreateTemp("", "example.*.yaml") + if err != nil { + t.Fatalf("Failed to create temp file: %v", err) + } + defer os.Remove(tmpFile.Name()) // Clean up after the test. + + // Step 2: Write some YAML content to this file. + yamlContent := ` +key1: value1 +key2: 2 +key3: + - elem1 + - elem2 +` + if _, err := tmpFile.Write([]byte(yamlContent)); err != nil { + t.Fatalf("Failed to write to temp file: %v", err) + } + if err := tmpFile.Close(); err != nil { + t.Fatalf("Failed to close temp file: %v", err) + } + + // Step 3: Use the loadYaml function to load this file into a Dict. + dict, err := loadYaml(tmpFile.Name()) + if err != nil { + t.Fatalf("loadYaml failed: %v", err) + } + + // Step 4: Verify that the Dict contains the expected data. + expectedDict := Dict{ + "key1": "value1", + "key2": 2, + "key3": []interface{}{"elem1", "elem2"}, + } + + if !reflect.DeepEqual(dict, expectedDict) { + t.Errorf("Expected dict to be %v, got %v", expectedDict, dict) + } +} + +// TestLoadYaml tests the loadYaml function. +func TestLoadYaml(t *testing.T) { + + dict, err := loadYaml("test_data/dict1.yaml") + if err != nil { + t.Fatalf("loadYaml() returned an error: %v", err) + } + + expectedDict := Dict{ + "key1": "value1", + "key2": 2, + "key3": []interface{}{"elem1", "elem2"}, + } + + if !reflect.DeepEqual(dict, expectedDict) { + t.Errorf("Expected dict to be %v, got %v", expectedDict, dict) + } +} + +func TestDumpJsonStrIndent(t *testing.T) { + d := Dict{"key": "value", "number": 1} + jsonStr, err := d.dumpJsonStrIndent("", " ") + if err != nil { + t.Fatalf("dumpJsonStrIndent() returned an error: %v", err) + } + + expected := `{ + "key": "value", + "number": 1 +}` + if jsonStr != expected { + t.Errorf("Expected %v, got %v", expected, jsonStr) + } +} diff --git a/internal/dict/dict_test.go b/internal/dict/dict_test.go new file mode 100644 index 0000000..093be63 --- /dev/null +++ b/internal/dict/dict_test.go @@ -0,0 +1,207 @@ +package dict + +import ( + "reflect" + "testing" +) + +func sampleDict() Dict { + return Dict{ + "name": "Test Project", + "version": 1.0, + "active": true, + "description": "This is a sample YAML file for testing the Dict package.", + "metadata": Dict{ + "author": "John Doe", + "license": "MIT", + "tags": []interface{}{"sample", "test", "yaml"}, + }, + "configuration": Dict{ + "threads": 4, + "verbose": true, + "features": []interface{}{"logging", "monitoring"}, + }, + "resources": []interface{}{ + Dict{ + "type": "database", + "name": "primary-db", + "properties": Dict{ + "host": "localhost", + "port": 5432, + "credentials": Dict{ + "username": "admin", + "password": "secret", + }, + }, + }, + Dict{ + "type": "cache", + "name": "redis-cache", + "properties": Dict{ + "host": "localhost", + "port": 6379, + "ttl": 3600, + }, + }, + }, + "nested": Dict{ + "level1": Dict{ + "level2": Dict{ + "level3": Dict{ + "key": "value", + "array": []interface{}{1, 2, 3, 4.5}, + "nestedArray": []interface{}{ + Dict{"key1": "val1"}, + Dict{ + "key2": "val2", + "subNested": Dict{ + "subKey1": "subVal1", + "subKey2": 2, + }, + }, + }, + }, + }, + }, + }, + "additionalNotes": "This is a multiline string.\nIt can contain new lines and spaces.\nIt's useful for longer descriptions or content.", + } +} + +func TestSampleDict(t *testing.T) { + originalDict, err := loadYaml("test_data/dict2.yaml") + if err != nil { + t.Fatalf("loadYaml() returned an error: %v", err) + } + + dict := sampleDict() + + if !reflect.DeepEqual(dict, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, dict) + } + +} + +func TestNew(t *testing.T) { + d := New() + if d == nil { + t.Error("New() should not return nil") + } + if len(d) != 0 { + t.Errorf("New() should return an empty dict, got %v", d) + } +} + +func TestIsDict(t *testing.T) { + d := Dict{ + "key1": "value1", + } + + r := IsDict(d) + if !r { + t.Errorf("Expected true, got %v", r) + } + + r = IsDict(12) + if r { + t.Errorf("Expected false, got %v", r) + } + + r = IsDict("Cool!") + if r { + t.Errorf("Expected false, got %v", r) + } + + var v1 interface{} + r = IsDict(v1) + if r { + t.Errorf("Expected false, got %v", r) + } + + var v2 []interface{} + r = IsDict(v2) + if r { + t.Errorf("Expected false, got %v", r) + } + + var v3 map[string]interface{} + r = IsDict(v3) + if r { + t.Errorf("Expected false, got %v", r) + } +} + +func TestCopy(t *testing.T) { + originalDict, err := loadYaml("test_data/dict2.yaml") + if err != nil { + t.Fatalf("loadYaml() returned an error: %v", err) + } + + newDict1 := Dict{} + Copy(&newDict1, originalDict) + if !reflect.DeepEqual(newDict1, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1) + } + + newDict2 := make(Dict) + Copy(&newDict2, originalDict) + if !reflect.DeepEqual(newDict2, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2) + } + + var newDict3 Dict + Copy(&newDict3, originalDict) + if !reflect.DeepEqual(newDict3, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3) + } +} + +func TestCopyFrom(t *testing.T) { + originalDict, err := loadYaml("test_data/dict2.yaml") + if err != nil { + t.Fatalf("loadYaml() returned an error: %v", err) + } + + newDict1 := Dict{} + newDict1.CopyFrom(originalDict) + if !reflect.DeepEqual(newDict1, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1) + } + + newDict2 := make(Dict) + newDict2.CopyFrom(originalDict) + if !reflect.DeepEqual(newDict2, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2) + } + + var newDict3 Dict + newDict3.CopyFrom(originalDict) + if !reflect.DeepEqual(newDict3, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3) + } +} + +func TestCopyTo(t *testing.T) { + originalDict, err := loadYaml("test_data/dict2.yaml") + if err != nil { + t.Fatalf("loadYaml() returned an error: %v", err) + } + + newDict1 := Dict{} + originalDict.CopyTo(&newDict1) + if !reflect.DeepEqual(newDict1, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict1) + } + + newDict2 := make(Dict) + originalDict.CopyTo(&newDict2) + if !reflect.DeepEqual(newDict2, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict2) + } + + var newDict3 Dict + originalDict.CopyTo(&newDict3) + if !reflect.DeepEqual(newDict3, originalDict) { + t.Errorf("Expected dict to be %v, got %v", originalDict, newDict3) + } +} diff --git a/internal/dict/test_data/dict1.yaml b/internal/dict/test_data/dict1.yaml new file mode 100644 index 0000000..6076ed8 --- /dev/null +++ b/internal/dict/test_data/dict1.yaml @@ -0,0 +1,6 @@ +key1: value1 +key2: 2 +key3: + - elem1 + - elem2 + diff --git a/internal/dict/test_data/dict2.yaml b/internal/dict/test_data/dict2.yaml new file mode 100644 index 0000000..8dc780a --- /dev/null +++ b/internal/dict/test_data/dict2.yaml @@ -0,0 +1,51 @@ +name: Test Project +version: 1.0 +active: true +description: This is a sample YAML file for testing the Dict package. + +metadata: + author: John Doe + license: MIT + tags: [sample, test, yaml] + +configuration: + threads: 4 + verbose: true + features: + - logging + - monitoring + +resources: + - type: database + name: primary-db + properties: + host: localhost + port: 5432 + credentials: + username: admin + password: secret + + - type: cache + name: redis-cache + properties: + host: localhost + port: 6379 + ttl: 3600 + +nested: + level1: + level2: + level3: + key: value + array: [1, 2, 3, 4.5] + nestedArray: + - key1: val1 + - key2: val2 + subNested: + subKey1: subVal1 + subKey2: 2 + +additionalNotes: |- + This is a multiline string. + It can contain new lines and spaces. + It's useful for longer descriptions or content. diff --git a/internal/dict/test_data/dict3.yaml b/internal/dict/test_data/dict3.yaml new file mode 100644 index 0000000..d5e3a2c --- /dev/null +++ b/internal/dict/test_data/dict3.yaml @@ -0,0 +1,24 @@ +nginx: + globals: + http_port: 80 + https_port: 443 + redirect_to_https: true + acme_challange: true + http_port: 8888 + sites: + globals: + domain: "example.com" + rate_limit: + zone: "mylimit" + burst: 20 + cdn: + subdomain: "cdn" + root: "/srv/public/cdn" + www: + subdomain: "www" + domain: "mywebsite.com" + redirect_to_https: false + http2: true + https_port: 8443 + rate_limit: + burst: 70 diff --git a/internal/dict/test_data/dict4.yaml b/internal/dict/test_data/dict4.yaml new file mode 100644 index 0000000..77335d2 --- /dev/null +++ b/internal/dict/test_data/dict4.yaml @@ -0,0 +1,32 @@ +--- +globals: + domain: "main.sample.org" + names: + - Jack + - John + - Jill +nginx: + globals: + http_port: 80 + https_port: 443 + redirect_to_https: true + acme_challange: true + http_port: 8888 + sites: + globals: + domain: "exmaple.com" + rate_limit: + zone: "mylimit" + burst: 20 + cdn: + subdomain: "cdn" + root: "/srv/public/cdn" + www: + subdomain: "www" + domain: "mywebsite.com" + redirect_to_https: false + http2: true + https_port: 8443 + rate_limit: + burst: 70 + diff --git a/internal/dict/test_data/dict5.yaml b/internal/dict/test_data/dict5.yaml new file mode 100644 index 0000000..1bcd920 --- /dev/null +++ b/internal/dict/test_data/dict5.yaml @@ -0,0 +1,5 @@ +key1: value1 +key2: value2 +key3: + key31: value31 + key32: value32 diff --git a/internal/dict/test_data/merge_cases.yaml b/internal/dict/test_data/merge_cases.yaml new file mode 100644 index 0000000..03ea3ec --- /dev/null +++ b/internal/dict/test_data/merge_cases.yaml @@ -0,0 +1,52 @@ +--- +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key3: value3 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + key3: value3 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key1: value9 + result: + key1: value9 + key2: + key21: value21 + key22: value22 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key2: value9 + result: + key1: value1 + key2: value9 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key2: + key22: value99 + result: + key1: value1 + key2: + key21: value21 + key22: value99 diff --git a/internal/dict/test_data/soft_merge_cases.yaml b/internal/dict/test_data/soft_merge_cases.yaml new file mode 100644 index 0000000..1d03774 --- /dev/null +++ b/internal/dict/test_data/soft_merge_cases.yaml @@ -0,0 +1,95 @@ +--- +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key3: value3 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + key3: value3 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key2: value9 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key1: value9 + key2: + key22: value99 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key1: value9 + key2: + key33: value33 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + key33: value33 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key1: value9 + key2: + key33: value33 + key3: value3 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + key33: value33 + key3: value3 + +- dict1: + key1: value1 + key2: + key21: value21 + key22: value22 + dict2: + key1: value9 + key2: + key22: value99 + key33: value33 + key3: value3 + result: + key1: value1 + key2: + key21: value21 + key22: value22 + key33: value33 + key3: value3 diff --git a/internal/dict/testutils_test.go b/internal/dict/testutils_test.go new file mode 100644 index 0000000..bb61515 --- /dev/null +++ b/internal/dict/testutils_test.go @@ -0,0 +1,27 @@ +package dict + +import ( + "os" + + "gopkg.in/yaml.v3" +) + +type dictDictToDictTestCase struct { + Dict1 Dict `yaml:"dict1"` + Dict2 Dict `yaml:"dict2"` + Result Dict `yaml:"result"` +} + +func loadDictDictToDictTestCases(fn string) []dictDictToDictTestCase { + content, err := os.ReadFile(fn) + if err != nil { + panic(err) + } + + var testCases []dictDictToDictTestCase + err = yaml.Unmarshal(content, &testCases) + if err != nil { + panic(err) + } + return testCases +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..f477bbf --- /dev/null +++ b/main.go @@ -0,0 +1,9 @@ +package main + +import ( + "fmt" +) + +func main() { + fmt.Println("hi") +}