encoding/gocode: add Go code generator
Also:
- add gocodec used by generator
- added ability to create temporary Runtime (for concurrency)
- removed index freezing
The latter was only for precondition checking of
internal code. At the same time, freezing could
lead to spurious races if Runtime is used
concurrently.
Note:
- gocodec is a separate package as it is useful
on its own and that way it can be used without
pulling all the dependencies of gocode.
Change-Id: Ib59b65084038b616c9fb725cbe152a56b8869416
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/2742
Reviewed-by: Marcel van Lohuizen <mpvl@golang.org>
diff --git a/encoding/gocode/gocodec/codec.go b/encoding/gocode/gocodec/codec.go
new file mode 100644
index 0000000..0037d2a
--- /dev/null
+++ b/encoding/gocode/gocodec/codec.go
@@ -0,0 +1,157 @@
+// Copyright 2019 CUE 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 codec converts Go to and from CUE and validates Go values based on
+// CUE constraints.
+//
+// CUE constraints can be used to validate Go types as well as fill out
+// missing struct fields that are implied from the constraints and the values
+// already defined by the struct value.
+package gocodec
+
+import (
+ "sync"
+
+ "cuelang.org/go/cue"
+ "cuelang.org/go/internal"
+)
+
+// Config has no options yet, but is defined for future extensibility.
+type Config struct {
+}
+
+// A Codec decodes and encodes CUE from and to Go values and validates and
+// completes Go values based on CUE templates.
+type Codec struct {
+ runtime *cue.Runtime
+ mutex sync.RWMutex
+}
+
+// New creates a new Codec for the given instance.
+//
+// It is safe to use the methods of Codec concurrently as long as the given
+// Runtime is not used elsewhere while using Codec. However, only the concurrent
+// use of Decode, Validate, and Complete is efficient.
+func New(r *cue.Runtime, c *Config) *Codec {
+ return &Codec{runtime: r}
+}
+
+// ExtractType extracts a CUE value from a Go type.
+//
+// The type represented by x is converted as the underlying type. Specific
+// values, such as map or slice elements or field values of structs are ignored.
+// If x is of type reflect.Type, the type represented by x is extracted.
+//
+// Fields of structs can be annoted using additional constrains using the 'cue'
+// field tag. The value of the tag is a CUE expression, which may contain
+// references to the JSON name of other fields in a struct.
+//
+// type Sum struct {
+// A int `cue:"c-b" json:"a,omitempty"`
+// B int `cue:"c-a" json:"b,omitempty"`
+// C int `cue:"a+b" json:"c,omitempty"`
+// }
+//
+func (c *Codec) ExtractType(x interface{}) (cue.Value, error) {
+ // ExtractType cannot introduce new fields on repeated calls. We could
+ // consider optimizing the lock usage based on this property.
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ return fromGoType(c.runtime, x)
+}
+
+// TODO: allow extracting constraints and type info separately?
+
+// Decode converts x to a CUE value.
+//
+// If x is of type reflect.Value it will convert the value represented by x.
+func (c *Codec) Decode(x interface{}) (cue.Value, error) {
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ // Depending on the type, can introduce new labels on repeated calls.
+ return fromGoValue(c.runtime, x, false)
+}
+
+// Encode converts v to a Go value.
+func (c *Codec) Encode(v cue.Value, x interface{}) error {
+ c.mutex.RLock()
+ defer c.mutex.RUnlock()
+
+ return v.Decode(x)
+}
+
+// Validate checks whether x satisfies the constraints defined by v.
+//
+// The given value must be created using the same Runtime with which c was
+// initialized.
+func (c *Codec) Validate(v cue.Value, x interface{}) error {
+ c.mutex.RLock()
+ defer c.mutex.RUnlock()
+
+ r := checkAndForkRuntime(c.runtime, v)
+ w, err := fromGoValue(r, x, false)
+ if err != nil {
+ return err
+ }
+ return w.Unify(v).Err()
+}
+
+// Complete sets previously undefined values in x that can be uniquely
+// determined form the constraints defined by v if validation passes, or returns
+// an error, without modifying anything, otherwise.
+//
+// Only undefined values are modified. A value is considered undefined if it is
+// pointer type and is nil or if it is a field with a zero value that has a json
+// tag with the omitempty flag.
+//
+// The given value must be created using the same Runtime with which c was
+// initialized.
+//
+// Complete does a JSON round trip. This means that data not preserved in such a
+// round trip, such as the location name of a time.Time, is lost after a
+// successful update.
+func (c *Codec) Complete(v cue.Value, x interface{}) error {
+ c.mutex.RLock()
+ defer c.mutex.RUnlock()
+
+ r := checkAndForkRuntime(c.runtime, v)
+ w, err := fromGoValue(r, x, true)
+ if err != nil {
+ return err
+ }
+
+ return w.Unify(v).Decode(x)
+}
+
+func fromGoValue(r *cue.Runtime, x interface{}, allowDefault bool) (cue.Value, error) {
+ v := internal.FromGoValue(r, x, allowDefault).(cue.Value)
+ if err := v.Err(); err != nil {
+ return v, err
+ }
+ return v, nil
+}
+
+func fromGoType(r *cue.Runtime, x interface{}) (cue.Value, error) {
+ v := internal.FromGoType(r, x).(cue.Value)
+ if err := v.Err(); err != nil {
+ return v, err
+ }
+ return v, nil
+}
+
+func checkAndForkRuntime(r *cue.Runtime, v cue.Value) *cue.Runtime {
+ return internal.CheckAndForkRuntime(r, v).(*cue.Runtime)
+}
diff --git a/encoding/gocode/gocodec/codec_test.go b/encoding/gocode/gocodec/codec_test.go
new file mode 100644
index 0000000..cb38865
--- /dev/null
+++ b/encoding/gocode/gocodec/codec_test.go
@@ -0,0 +1,286 @@
+// Copyright 2019 CUE 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 gocodec
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+
+ "cuelang.org/go/cue"
+ "github.com/google/go-cmp/cmp"
+)
+
+type Sum struct {
+ A int `cue:"C-B" json:",omitempty"`
+ B int `cue:"C-A" json:",omitempty"`
+ C int `cue:"A+B & >=5" json:",omitempty"`
+}
+
+func checkErr(t *testing.T, got error, want string) {
+ t.Helper()
+ if (got == nil) != (want == "") {
+ t.Errorf("error: got %v; want %v", got, want)
+ }
+}
+func TestValidate(t *testing.T) {
+ fail := "some error"
+ testCases := []struct {
+ name string
+ value interface{}
+ constraints string
+ err string
+ }{{
+ name: "*Sum: nil disallowed by constraint",
+ value: (*Sum)(nil),
+ constraints: "!=null",
+ err: fail,
+ }, {
+ name: "Sum",
+ value: Sum{A: 1, B: 4, C: 5},
+ }, {
+ name: "*Sum",
+ value: &Sum{A: 1, B: 4, C: 5},
+ }, {
+ name: "*Sum: incorrect sum",
+ value: &Sum{A: 1, B: 4, C: 6},
+ err: fail,
+ }, {
+ name: "*Sum: field C is too low",
+ value: &Sum{A: 1, B: 3, C: 4},
+ err: fail,
+ }, {
+ name: "*Sum: nil value",
+ value: (*Sum)(nil),
+ }, {
+ // Not a typical constraint, but it is possible.
+ name: "string list",
+ value: []string{"a", "b", "c"},
+ constraints: `[_, "b", ...]`,
+ }, {
+ // Not a typical constraint, but it is possible.
+ name: "string list incompatible lengths",
+ value: []string{"a", "b", "c"},
+ constraints: `4*[string]`,
+ err: fail,
+ }}
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ r := &cue.Runtime{}
+ codec := New(r, nil)
+
+ v, err := codec.ExtractType(tc.value)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if tc.constraints != "" {
+ inst, err := r.Compile(tc.name, tc.constraints)
+ if err != nil {
+ t.Fatal(err)
+ }
+ v = v.Unify(inst.Value())
+ fmt.Println("XXX", v)
+ fmt.Println("XXX", inst.Value())
+ fmt.Println("UUU", v)
+ }
+
+ err = codec.Validate(v, tc.value)
+ checkErr(t, err, tc.err)
+ })
+ }
+}
+
+func TestComplete(t *testing.T) {
+ type updated struct {
+ A []*int `cue:"[...int|*1]"` // arbitrary length slice with values 1
+ B []int `cue:"3*[int|*1]"` // slice of length 3, defaults to [1,1,1]
+
+ // TODO: better errors if the user forgets to quote.
+ M map[string]int `cue:",opt"`
+ }
+ type sump struct {
+ A *int `cue:"C-B"`
+ B *int `cue:"C-A"`
+ C *int `cue:"A+B"`
+ }
+ one := 1
+ two := 2
+ fail := "some error"
+ _ = fail
+ _ = one
+ testCases := []struct {
+ name string
+ value interface{}
+ result interface{}
+ constraints string
+ err string
+ }{{
+ name: "*Sum",
+ value: &Sum{A: 1, B: 4, C: 5},
+ result: &Sum{A: 1, B: 4, C: 5},
+ }, {
+ name: "*Sum",
+ value: &Sum{A: 1, B: 4},
+ result: &Sum{A: 1, B: 4, C: 5},
+ }, {
+ name: "*sump",
+ value: &sump{A: &one, B: &one},
+ result: &sump{A: &one, B: &one, C: &two},
+ }, {
+ name: "*Sum: backwards",
+ value: &Sum{B: 4, C: 8},
+ result: &Sum{A: 4, B: 4, C: 8},
+ }, {
+ name: "*Sum: sum too low",
+ value: &Sum{A: 1, B: 3},
+ result: &Sum{A: 1, B: 3}, // Value should not be updated
+ err: fail,
+ }, {
+ name: "*Sum: sum underspecified",
+ value: &Sum{A: 1},
+ result: &Sum{A: 1}, // Value should not be updated
+ err: fail,
+ }, {
+ name: "Sum: cannot modify",
+ value: Sum{A: 3, B: 4, C: 7},
+ result: Sum{A: 3, B: 4, C: 7},
+ err: fail,
+ }, {
+ name: "*Sum: cannot update nil value",
+ value: (*Sum)(nil),
+ result: (*Sum)(nil),
+ err: fail,
+ }, {
+ name: "cannot modify slice",
+ value: []string{"a", "b", "c"},
+ result: []string{"a", "b", "c"},
+ err: fail,
+ }, {
+ name: "composite values update",
+ // allocate a slice with uninitialized values and let Update fill
+ // out default values.
+ value: &updated{A: make([]*int, 3)},
+ result: &updated{
+ A: []*int{&one, &one, &one},
+ B: []int{1, 1, 1},
+ M: map[string]int(nil),
+ },
+ }, {
+ name: "composite values update with unsatisfied map constraints",
+ value: &updated{},
+ result: &updated{},
+
+ constraints: ` { M: {foo: bar, bar: foo} } `,
+ err: fail, // incomplete values
+ }, {
+ name: "composite values update with map constraints",
+ value: &updated{M: map[string]int{"foo": 1}},
+ constraints: ` { M: {foo: bar, bar: foo} } `,
+ result: &updated{
+ // TODO: would be better if this is nil, but will not matter for
+ // JSON output: if omitempty is false, an empty list will be
+ // printed regardless, and if it is true, it will be omitted
+ // regardless.
+ A: []*int{},
+ B: []int{1, 1, 1},
+ M: map[string]int{"bar": 1, "foo": 1},
+ },
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ r := &cue.Runtime{}
+ codec := New(r, nil)
+
+ v, err := codec.ExtractType(tc.value)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if tc.constraints != "" {
+ inst, err := r.Compile(tc.name, tc.constraints)
+ if err != nil {
+ t.Fatal(err)
+ }
+ v = v.Unify(inst.Value())
+ }
+
+ err = codec.Complete(v, tc.value)
+ checkErr(t, err, tc.err)
+ if !reflect.DeepEqual(tc.value, tc.result) {
+ t.Errorf("value:\n got: %#v;\nwant: %#v", tc.value, tc.result)
+ }
+ })
+ }
+}
+
+func TestEncode(t *testing.T) {
+ testCases := []struct {
+ in string
+ dst interface{}
+ want interface{}
+ }{{
+ in: "4",
+ dst: new(int),
+ want: 4,
+ }}
+ r := &cue.Runtime{}
+ c := New(r, nil)
+
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ inst, err := r.Compile("test", tc.in)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ err = c.Encode(inst.Value(), tc.dst)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ got := reflect.ValueOf(tc.dst).Elem().Interface()
+ if !cmp.Equal(got, tc.want) {
+ t.Error(cmp.Diff(got, tc.want))
+ }
+ })
+ }
+}
+
+func TestDecode(t *testing.T) {
+ testCases := []struct {
+ in interface{}
+ want string
+ }{{
+ in: "str",
+ want: `"str"`,
+ }}
+ c := New(&cue.Runtime{}, nil)
+
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ v, err := c.Decode(tc.in)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ got := fmt.Sprint(v)
+ if got != tc.want {
+ t.Errorf("got %v; want %v", got, tc.want)
+ }
+ })
+ }
+}
