pkg/strings: add MinRunes and MaxRunes

Also adds respective conversions for the OpenAPI
encoding.

cue/builtins.go is generated using go generate

Change-Id: I3b709cb56bd59fbe08a0376d4b4760b9b21a2e3a
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/2625
Reviewed-by: Marcel van Lohuizen <[email protected]>

Author: mpvl

cue/builtin_test.go

@@ -164,6 +164,18 @@ func TestBuiltins(t *testing.T) {
 	}, {
 		test("strings", `strings.ToTitle("alpha")`),
 		`"Alpha"`,
+	}, {
+		test("strings", `strings.MaxRunes(3) & "foo"`),
+		`"foo"`,
+	}, {
+		test("strings", `strings.MaxRunes(3) & "quux"`),
+		`_|_(invalid value "quux" (does not satisfy strings.MaxRunes(3)))`,
+	}, {
+		test("strings", `strings.MinRunes(1) & "e"`),
+		`"e"`,
+	}, {
+		test("strings", `strings.MinRunes(0) & "e"`),
+		`_|_(invalid value "e" (does not satisfy strings.MinRunes(0)))`,
 	}, {
 		test("math/bits", `bits.And(0x10000000000000F0E, 0xF0F7)`), `6`,
 	}, {

cue/builtins.go

@@ -15,6 +15,7 @@
 package openapi
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"path"
@@ -612,8 +613,8 @@ func (b *builder) number(v cue.Value) {
 
 // string supports the following options:
 //
-// - maxLenght (Unicode codepoints)
-// - minLenght (Unicode codepoints)
+// - maxLength (Unicode codepoints)
+// - minLength (Unicode codepoints)
 // - pattern (a regexp)
 //
 // The regexp pattern is as follows, and is limited to be a  strict subset of RE2:
@@ -658,7 +659,7 @@ func (b *builder) string(v cue.Value) {
 			return
 		}
 		if op == cue.RegexMatchOp {
-			b.setFilter("schema", "pattern", s)
+			b.setFilter("Schema", "pattern", s)
 		} else {
 			b.setNot("pattern", s)
 		}
@@ -670,6 +671,22 @@ func (b *builder) string(v cue.Value) {
 	case cue.NoOp, cue.SelectorOp:
 		// TODO: determine formats from specific types.
 
+	case cue.CallOp:
+		name := fmt.Sprint(a[0])
+		field := ""
+		switch name {
+		case "strings.MinRunes":
+			field = "minLength"
+		case "strings.MaxRunes":
+			field = "maxLength"
+		default:
+			b.failf(v, "builtin %v not supported in OpenAPI", name)
+		}
+		if len(a) != 2 {
+			b.failf(v, "builtin %v may only be used with single argument", name)
+		}
+		b.setFilter("Schema", field, b.int(a[1]))
+
 	default:
 		b.failf(v, "unsupported op %v for string type", op)
 	}

encoding/openapi/build.go

@@ -50,6 +50,10 @@ func TestParseDefinitions(t *testing.T) {
 		"array.cue",
 		"array.json",
 		defaultConfig,
+	}, {
+		"strings.cue",
+		"strings.json",
+		defaultConfig,
 	}, {
 		"oneof.cue",
 		"oneof.json",
@@ -82,6 +86,9 @@ func TestParseDefinitions(t *testing.T) {
 			inst := cue.Build(load.Instances([]string{filename}, nil))[0]
 
 			b, err := Gen(inst, tc.config)
+			if err != nil {
+				t.Fatal(err)
+			}
 			var out = &bytes.Buffer{}
 			_ = json.Indent(out, b, "", "   ")
 

encoding/openapi/openapi_test.go

@@ -0,0 +1,9 @@
+import "strings"
+
+MyType: {
+	myString: strings.MinRunes(1) & strings.MaxRunes(5)
+
+	myPattern: =~"foo.*bar"
+
+	myAntiPattern: !~"foo.*bar"
+}

encoding/openapi/testdata/strings.cue

@@ -0,0 +1,34 @@
+{
+   "openapi": "3.0.0",
+   "info": {},
+   "components": {
+      "schemas": {
+         "MyType": {
+            "type": "object",
+            "required": [
+               "myString",
+               "myPattern",
+               "myAntiPattern"
+            ],
+            "properties": {
+               "myString": {
+                  "type": "string",
+                  "minLength": 1,
+                  "maxLength": 5
+               },
+               "myPattern": {
+                  "type": "string",
+                  "pattern": "foo.*bar"
+               },
+               "myAntiPattern": {
+                  "not": {
+                     "type": "string",
+                     "pattern": "foo.*bar"
+                  },
+                  "type": "string"
+               }
+            }
+         }
+      }
+   }
+}

encoding/openapi/testdata/strings.json

@@ -12,13 +12,42 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package strings implements simple functions to manipulate UTF-8 encoded
+// strings.package strings.
+//
+// Some of the functions in this package are specifically intended as field
+// constraints. For instance, MaxRunes as used in this CUE program
+//
+//    import "strings"
+//
+//    myString: strings.MaxRunes(5)
+//
+// specifies that the myString should be at most 5 code points.
 package strings
 
 import (
 	"strings"
 	"unicode"
 )
 
+// MinRunes reports whether the number of runes (Unicode codepoints) in a string
+// is at least a certain minimum. MinRunes can be used a a field constraint to
+// except all strings for which this property holds.
+func MinRunes(s string, max int) bool {
+	// TODO: CUE strings cannot be invalid UTF-8. In case this changes, we need
+	// to use the following conversion to count properly:
+	// s, _ = unicodeenc.UTF8.NewDecoder().String(s)
+	return len([]rune(s)) <= max
+}
+
+// MaxRunes reports whether the number of runes (Unicode codepoints) in a string
+// exceeds a certain maximum. MaxRunes can be used a a field constraint to
+// except all strings for which this property holds
+func MaxRunes(s string, max int) bool {
+	// See comment in MinRunes implementation.
+	return len([]rune(s)) <= max
+}
+
 // ToTitle returns a copy of the string s with all Unicode letters that begin
 // words mapped to their title case.
 func ToTitle(s string) string {