Move dict to the project's root directory

dict/dict.go

@@ -0,0 +1,63 @@
+package dict
+
+import (
+	"fmt"
+	"strings"
+)
+
+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 (d Dict) Print() {
+	pp, err := d.DumpJsonStrIndent("", "  ")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(pp)
+}
+
+func (d Dict) GetValue(path string) Dict {
+	var value Dict
+	current := make(Dict)
+	g := make(Dict)
+	current.CopyFrom(d)
+	keys := strings.Split(path, ".")
+	lastIndex := len(keys) - 1
+	for i, key := range keys {
+		if current.HasKey("globals") {
+			g.MergeWith(current["globals"].(Dict))
+			current.SoftMergeWith(g)
+		}
+		if !current.HasKey(key) {
+			value = nil
+			break
+		}
+		v := current[key]
+		if i == lastIndex {
+			if vv, ok := v.(Dict); ok {
+				vv.SoftMergeWith(g)
+				value = vv
+			} else {
+				value = Dict{"value": v}
+			}
+			break
+		}
+		if IsDict(v) {
+			current = v.(Dict)
+		}
+	}
+	return value
+}

dict/dict_copy_test.go

@@ -6,9 +6,9 @@ import (
 )
 
 func TestCopy(t *testing.T) {
-	originalDict, err := loadYaml("test_data/dict2.yaml")
+	originalDict, err := LoadYaml("test_data/dict2.yaml")
 	if err != nil {
-		t.Fatalf("loadYaml() returned an error: %v", err)
+		t.Fatalf("LoadYaml() returned an error: %v", err)
 	}
 
 	newDict1 := Dict{}
@@ -31,9 +31,9 @@ func TestCopy(t *testing.T) {
 }
 
 func TestCopyFrom(t *testing.T) {
-	originalDict, err := loadYaml("test_data/dict2.yaml")
+	originalDict, err := LoadYaml("test_data/dict2.yaml")
 	if err != nil {
-		t.Fatalf("loadYaml() returned an error: %v", err)
+		t.Fatalf("LoadYaml() returned an error: %v", err)
 	}
 
 	newDict1 := Dict{}
@@ -56,9 +56,9 @@ func TestCopyFrom(t *testing.T) {
 }
 
 func TestCopyTo(t *testing.T) {
-	originalDict, err := loadYaml("test_data/dict2.yaml")
+	originalDict, err := LoadYaml("test_data/dict2.yaml")
 	if err != nil {
-		t.Fatalf("loadYaml() returned an error: %v", err)
+		t.Fatalf("LoadYaml() returned an error: %v", err)
 	}
 
 	newDict1 := Dict{}

dict/dict_merge_test.go

@@ -6,7 +6,8 @@ import (
 )
 
 func TestSoftMerge(t *testing.T) {
-	testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml")
+	testCases := []dictDictToDictTestCase{}
+	loadYamlFile("test_data/soft_merge_cases.yaml", &testCases)
 	for _, testCase := range testCases {
 		SoftMerge(&testCase.Dict1, testCase.Dict2)
 		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
@@ -16,7 +17,8 @@ func TestSoftMerge(t *testing.T) {
 }
 
 func TestSoftMergeWith(t *testing.T) {
-	testCases := loadDictDictToDictTestCases("test_data/soft_merge_cases.yaml")
+	testCases := []dictDictToDictTestCase{}
+	loadYamlFile("test_data/soft_merge_cases.yaml", &testCases)
 	for _, testCase := range testCases {
 		testCase.Dict1.SoftMergeWith(testCase.Dict2)
 		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
@@ -26,7 +28,8 @@ func TestSoftMergeWith(t *testing.T) {
 }
 
 func TestMerge(t *testing.T) {
-	testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml")
+	testCases := []dictDictToDictTestCase{}
+	loadYamlFile("test_data/merge_cases.yaml", &testCases)
 	for _, testCase := range testCases {
 		Merge(&testCase.Dict1, testCase.Dict2)
 		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {
@@ -36,7 +39,8 @@ func TestMerge(t *testing.T) {
 }
 
 func TestMergeWith(t *testing.T) {
-	testCases := loadDictDictToDictTestCases("test_data/merge_cases.yaml")
+	testCases := []dictDictToDictTestCase{}
+	loadYamlFile("test_data/merge_cases.yaml", &testCases)
 	for _, testCase := range testCases {
 		testCase.Dict1.MergeWith(testCase.Dict2)
 		if !reflect.DeepEqual(testCase.Dict1, testCase.Result) {

dict/dict_serialization.go

@@ -7,7 +7,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func loadYaml(fn string) (Dict, error) {
+func LoadYaml(fn string) (Dict, error) {
 	content, err := os.ReadFile(fn)
 	if err != nil {
 		return nil, err
@@ -22,7 +22,7 @@ func loadYaml(fn string) (Dict, error) {
 
 }
 
-func loadYamlStr(yamlStr string) (Dict, error) {
+func LoadYamlStr(yamlStr string) (Dict, error) {
 	var data Dict
 	err := yaml.Unmarshal([]byte(yamlStr), &data)
 	if err != nil {
@@ -31,7 +31,7 @@ func loadYamlStr(yamlStr string) (Dict, error) {
 	return data, nil
 }
 
-func (d Dict) dumpYaml(fn string) error {
+func (d Dict) DumpYaml(fn string) error {
 	data, err := yaml.Marshal(d)
 	if err != nil {
 		return err
@@ -39,7 +39,7 @@ func (d Dict) dumpYaml(fn string) error {
 	return os.WriteFile(fn, data, 0644) // Write with user read/write, group read, and others read permissions
 }
 
-func (d Dict) dumpYamlStr() (string, error) {
+func (d Dict) DumpYamlStr() (string, error) {
 	data, err := yaml.Marshal(d)
 	if err != nil {
 		return "", err
@@ -48,7 +48,7 @@ func (d Dict) dumpYamlStr() (string, error) {
 }
 
 // loadJson loads the dictionary from a JSON file.
-func loadJson(fn string) (Dict, error) {
+func LoadJson(fn string) (Dict, error) {
 	var data Dict
 	content, err := os.ReadFile(fn)
 	if err != nil {
@@ -62,7 +62,7 @@ func loadJson(fn string) (Dict, error) {
 	return data, nil
 }
 
-func loadJsonStr(jsonStr string) (Dict, error) {
+func LoadJsonStr(jsonStr string) (Dict, error) {
 	var data Dict
 	err := json.Unmarshal([]byte(jsonStr), &data)
 	if err != nil {
@@ -72,7 +72,7 @@ func loadJsonStr(jsonStr string) (Dict, error) {
 }
 
 // dumpJson writes the dictionary to a JSON file.
-func (d Dict) dumpJson(fn string) error {
+func (d Dict) DumpJson(fn string) error {
 	data, err := json.Marshal(d)
 	if err != nil {
 		return err
@@ -81,7 +81,7 @@ func (d Dict) dumpJson(fn string) error {
 }
 
 // dumpJsonIndent writes the dictionary to a JSON file but applies indent first.
-func (d Dict) dumpJsonIndent(fn string, prefix, indent string) error {
+func (d Dict) DumpJsonIndent(fn string, prefix, indent string) error {
 	data, err := json.MarshalIndent(d, prefix, indent)
 	if err != nil {
 		return err
@@ -90,7 +90,7 @@ func (d Dict) dumpJsonIndent(fn string, prefix, indent string) error {
 }
 
 // dumpJsonStr returns the dictionary as a JSON string.
-func (d Dict) dumpJsonStr() (string, error) {
+func (d Dict) DumpJsonStr() (string, error) {
 	data, err := json.Marshal(d)
 	if err != nil {
 		return "", err
@@ -99,7 +99,7 @@ func (d Dict) dumpJsonStr() (string, error) {
 }
 
 // dumpJsonStr returns the dictionary as a JSON string.
-func (d Dict) dumpJsonStrIndent(prefix, indent string) (string, error) {
+func (d Dict) DumpJsonStrIndent(prefix, indent string) (string, error) {
 	data, err := json.MarshalIndent(d, prefix, indent)
 	if err != nil {
 		return "", err

dict/dict_serialization_test.go

@@ -31,7 +31,7 @@ key3:
 	}
 
 	// Step 3: Use the loadYaml function to load this file into a Dict.
-	dict, err := loadYaml(tmpFile.Name())
+	dict, err := LoadYaml(tmpFile.Name())
 	if err != nil {
 		t.Fatalf("loadYaml failed: %v", err)
 	}
@@ -51,7 +51,7 @@ key3:
 // TestLoadYaml tests the loadYaml function.
 func TestLoadYaml(t *testing.T) {
 
-	dict, err := loadYaml("test_data/dict1.yaml")
+	dict, err := LoadYaml("test_data/dict1.yaml")
 	if err != nil {
 		t.Fatalf("loadYaml() returned an error: %v", err)
 	}
@@ -69,7 +69,7 @@ func TestLoadYaml(t *testing.T) {
 
 func TestDumpJsonStrIndent(t *testing.T) {
 	d := Dict{"key": "value", "number": 1}
-	jsonStr, err := d.dumpJsonStrIndent("", "  ")
+	jsonStr, err := d.DumpJsonStrIndent("", "  ")
 	if err != nil {
 		t.Fatalf("dumpJsonStrIndent() returned an error: %v", err)
 	}

dict/dict_test.go

@@ -1,6 +1,7 @@
 package dict
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -52,3 +53,19 @@ func TestIsDict(t *testing.T) {
 		t.Errorf("Expected false, got %v", r)
 	}
 }
+
+func TestGeValue(t *testing.T) {
+	testCases := []dictStrToDictTestCase{}
+	loadYamlFile("test_data/getvalue_cases.yaml", &testCases)
+	for _, testCase := range testCases {
+		copy := make(Dict)
+		copy.CopyFrom(testCase.Arg1)
+		result := testCase.Arg1.GetValue(testCase.Arg2)
+		if !reflect.DeepEqual(testCase.Result, result) {
+			t.Errorf("Expected dict to be %v, got %v", testCase.Result, result)
+		}
+		if !reflect.DeepEqual(testCase.Arg1, copy) {
+			t.Errorf("Expected dict to be %v, got %v", copy, testCase.Arg1)
+		}
+	}
+}

dict/test_data/dict4.yaml

@@ -1,10 +1,6 @@
 ---
 globals:
-  domain: "main.sample.org"
+  domain: "main.sample.net"
-  names:
-    - Jack
-    - John
-    - Jill
 nginx:
   globals:
     http_port: 80

dict/test_data/getvalue_cases.yaml

@@ -0,0 +1,41 @@
+---
+- name: "test 1"
+  arg1:
+    globals:
+      domain: "main.sample.net"
+    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
+  arg2: "nginx.sites.www"
+  result:
+    subdomain: "www"
+    domain: "mywebsite.com"
+    redirect_to_https: false
+    http2: true
+    https_port: 8443
+    rate_limit: 
+      zone: "mylimit"
+      burst: 70
+    http_port: 80
+    acme_challange: true

dict/testutils_test.go

@@ -14,18 +14,23 @@ type dictDictToDictTestCase struct {
 	Result Dict `yaml:"result"`
 }
 
-func loadDictDictToDictTestCases(fn string) []dictDictToDictTestCase {
+type dictStrToDictTestCase struct {
+	Name   string `yaml:"name"`
+	Arg1   Dict   `yaml:"arg1"`
+	Arg2   string `yaml:"arg2"`
+	Result Dict   `yaml:"result"`
+}
+
+func loadYamlFile(fn string, out interface{}) {
 	content, err := os.ReadFile(fn)
 	if err != nil {
 		panic(err)
 	}
 
-	var testCases []dictDictToDictTestCase
+	err = yaml.Unmarshal(content, out)
-	err = yaml.Unmarshal(content, &testCases)
 	if err != nil {
 		panic(err)
 	}
-	return testCases
 }
 
 func sampleDict() Dict {
@@ -92,9 +97,9 @@ func sampleDict() Dict {
 }
 
 func TestSampleDict(t *testing.T) {
-	originalDict, err := loadYaml("test_data/dict2.yaml")
+	originalDict, err := LoadYaml("test_data/dict2.yaml")
 	if err != nil {
-		t.Fatalf("loadYaml() returned an error: %v", err)
+		t.Fatalf("LoadYaml() returned an error: %v", err)
 	}
 
 	dict := sampleDict()

go.mod

@@ -2,4 +2,4 @@ module git.behzadan.ir/reza/GoDict
 
 go 1.22.0
 
-require gopkg.in/yaml.v3 v3.0.1 // indirect
+require gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -1,3 +1,4 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 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=

internal/dict/dict.go

@@ -1,17 +0,0 @@
-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
-}

main.go

@@ -1,9 +1,19 @@
 package main
 
 import (
-	"fmt"
+	"git.behzadan.ir/reza/GoDict/dict"
 )
 
-func main() {
+func load(fn string) dict.Dict {
-	fmt.Println("hi")
+	d, err := dict.LoadYaml(fn)
+	if err != nil {
+		panic(err)
+	}
+	return d
+}
+
+func main() {
+	d := load("dict/test_data/dict4.yaml")
+	v := d.GetValue("nginx.sites.www")
+	v.Print()
 }