Merge pull request #273 from jpbetz/json-tags

Add JSON Tag parse utility

Author: k8s-ci-robot

v2/parser/tags/json.go

@@ -0,0 +1,100 @@
+/*
+Copyright 2021 The Kubernetes 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.
+*/
+
+// This is based on the highly efficient approach from https://golang.org/src/encoding/json/encode.go
+
+package tags
+
+import (
+	"reflect"
+	"strings"
+
+	"k8s.io/gengo/v2/types"
+)
+
+// JSON represents a go json field tag.
+type JSON struct {
+	Name      string
+	Omit      bool
+	Inline    bool
+	Omitempty bool
+}
+
+func (t JSON) String() string {
+	var tag string
+	if !t.Inline {
+		tag += t.Name
+	}
+	if t.Omitempty {
+		tag += ",omitempty"
+	}
+	if t.Inline {
+		tag += ",inline"
+	}
+	return tag
+}
+
+func LookupJSON(m types.Member) (JSON, bool) {
+	tag := reflect.StructTag(m.Tags).Get("json")
+	if tag == "-" {
+		return JSON{Omit: true}, true
+	}
+	name, opts := parse(tag)
+	inline := opts.Contains("inline")
+	omitempty := opts.Contains("omitempty")
+	if !inline && name == "" {
+		name = m.Name
+	}
+	return JSON{
+		Name:      name,
+		Omit:      false,
+		Inline:    inline,
+		Omitempty: omitempty,
+	}, true
+}
+
+type options string
+
+// parse splits a struct field's json tag into its Name and
+// comma-separated options.
+func parse(tag string) (string, options) {
+	if idx := strings.Index(tag, ","); idx != -1 {
+		return tag[:idx], options(tag[idx+1:])
+	}
+	return tag, ""
+}
+
+// Contains reports whether a comma-separated listAlias of options
+// contains a particular substr flag. substr must be surrounded by a
+// string boundary or commas.
+func (o options) Contains(optionName string) bool {
+	if len(o) == 0 {
+		return false
+	}
+	s := string(o)
+	for s != "" {
+		var next string
+		i := strings.Index(s, ",")
+		if i >= 0 {
+			s, next = s[:i], s[i+1:]
+		}
+		if s == optionName {
+			return true
+		}
+		s = next
+	}
+	return false
+}

v2/parser/tags/json_test.go

@@ -0,0 +1,93 @@
+/*
+Copyright 2024 The Kubernetes 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 tags
+
+import (
+	"testing"
+
+	"k8s.io/gengo/v2/parser"
+	"k8s.io/gengo/v2/types"
+)
+
+func TestJSON(t *testing.T) {
+	p := parser.New()
+	u := types.Universe{}
+	// Proper packages with deps.
+	pkgs, err := p.LoadPackagesTo(&u, "./testdata/tags")
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	member := func(typeName, memberName string) types.Member {
+		typ := pkgs[0].Type(typeName)
+		for _, m := range typ.Members {
+			if m.Name == memberName {
+				return m
+			}
+		}
+		t.Fatalf("member %s not found", memberName)
+		return types.Member{}
+	}
+
+	tests := []struct {
+		name     string
+		member   types.Member
+		expected JSON
+	}{
+		{
+			name:     "name",
+			member:   member("T1", "A"),
+			expected: JSON{Name: "a"},
+		},
+		{
+			name:     "omitempty",
+			member:   member("T1", "B"),
+			expected: JSON{Name: "b", Omitempty: true},
+		},
+		{
+			name:     "inline",
+			member:   member("T1", "C"),
+			expected: JSON{Name: "", Inline: true},
+		},
+		{
+			name:     "omit",
+			member:   member("T1", "D"),
+			expected: JSON{Name: "", Omit: true},
+		},
+		{
+			name:     "empty",
+			member:   member("T1", "E"),
+			expected: JSON{Name: "E"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tags, ok := LookupJSON(tt.member)
+			if !ok {
+				t.Errorf("failed to lookup tags")
+			}
+			if tags != tt.expected {
+				t.Errorf("expected %#+v, got %#+v", tt.expected, tags)
+			}
+		})
+	}
+}
+
+type t1 struct {
+	Name string `json:"name"`
+}

v2/parser/tags/testdata/tags/file.go

@@ -0,0 +1,9 @@
+package tags
+
+type T1 struct {
+	A string `json:"a"`
+	B string `json:"b,omitempty"`
+	C string `json:",inline"`
+	D string `json:"-"`
+	E string `json:""`
+}