Merge pull request #301 from alexandernorth/fix/patterns-including-metacharacters

escape non-metacharacters (XML spec)

Author: hansthienpondt

pkg/utils/leaf_convert.go

@@ -273,6 +273,37 @@ func ConvertInt64(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue, e
 	return convertInt(value, lst.Range, ranges)
 }
 
+func XMLRegexConvert(s string) string {
+
+	cTest := func(r rune, prev rune) bool {
+		// if ^ is not following a [ or if $ we want to return true
+		return (r == '^' && prev != '[') || r == '$'
+	}
+
+	b := strings.Builder{}
+	b.Grow(len(s) + len(s)/4)
+	slashes := 0
+	prevR := rune(0)
+
+	for _, r := range s {
+		if r == '\\' {
+			slashes++
+			prevR = r
+			b.WriteRune(r)
+			continue
+		}
+
+		if cTest(r, prevR) && slashes%2 == 0 {
+			b.WriteRune('\\')
+		}
+
+		slashes = 0
+		prevR = r
+		b.WriteRune(r)
+	}
+	return b.String()
+}
+
 func ConvertString(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue, error) {
 	// check length of the string if the length property is set
 	// length will contain a range like string definition "5..60" or "7..10|40..45"
@@ -289,7 +320,14 @@ func ConvertString(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue,
 	// If the type has multiple "pattern" statements, the expressions are
 	// ANDed together, i.e., all such expressions have to match.
 	for _, sp := range lst.Patterns {
-		re, err := regexp.Compile(sp.Pattern)
+		// The set of metacharacters is not the same between XML schema and perl/python/go REs
+		// the set of metacharacters for XML is: .\?*+{}()[] (https://www.w3.org/TR/xmlschema-2/#dt-metac)
+		// the set of metacharacters defined in go is: \.+*?()|[]{}^$ (go/libexec/src/regexp/regexp.go:714)
+		// we need therefore to escape some values
+		// TODO check about '^'
+
+		escaped := XMLRegexConvert(sp.Pattern)
+		re, err := regexp.Compile(escaped)
 		if err != nil {
 			log.Errorf("unable to compile regex %q", sp.Pattern)
 		}

pkg/utils/leaf_convert_test.go

@@ -0,0 +1,63 @@
+package utils
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestXMLRegexConvert(t *testing.T) {
+
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "anchors become literals",
+			in:   `^\d+$`,
+			want: `\^\d+\$`,
+		},
+		{
+			name: "already-escaped anchors stay escaped",
+			in:   `foo\$bar`,
+			want: `foo\$bar`,
+		},
+		{
+			name: "caret in char class is left alone, dollar is escaped",
+			in:   `[^\w]+$`,
+			want: `[^\w]+\$`,
+		},
+		{
+			name: "caret later inside char class is escaped",
+			in:   `[a^b]`,
+			want: `[a\^b]`,
+		},
+		{
+			name: "caret escaped inside char class is escaped",
+			in:   `[\^]`,
+			want: `[\^]`,
+		},
+		{
+			name: "caret in char class multiple times, dollar is escaped",
+			in:   `[^a^b]`,
+			want: `[^a\^b]`,
+		},
+		{
+			name: "anchors preceded by a single back-slash stay escaped",
+			in:   `\^test\$`,
+			want: `\^test\$`,
+		},
+		{
+			name: "empty string",
+			in:   ``,
+			want: ``,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := XMLRegexConvert(tt.in); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("XMLRegexConvert() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}