implement '$not' regex

Author: tsetsoo

README.md

@@ -998,6 +998,8 @@ The same example with flags:
 However, keep in mind that Storers have to support regular expression and depending on the implementation of the storage handler the accepted syntax may vary.
 An error of `ErrNotImplemented` will be returned for those storage back-ends which do not support the `$regex` operator.
 
+The operator `$not` functions as an opposite operator to `$regex`
+
 The `$elemMatch` operator matches documents that contain an array field with at least one element that matches all the specified query criteria.
 ```go
 			"telephones": schema.Field{
@@ -1041,6 +1043,7 @@ The snippet above will return all documents, which `telephones` array field cont
 | `$gte`       | `{a: {$gte: 10}}`               | Fields value is greater than or equal to the specified number.
 | `$exists`    | `{a: {$exists: true}}`          | Match if the field is present (or not if set to `false`) in the item, event if `nil`.
 | `$regex`     | `{a: {$regex: "fo[o]{1}"}}`     | Match regular expression on a field's value.
+| `$not`       | `{a: {$not: "fo[o]{1}"}}`       | Opposite of `$regex`.
 | `$elemMatch` | `{a: {$elemMatch: {b: "foo"}}}` | Match array items against multiple query criteria.
 
 *Some storage handlers may not support all operators. Refer to the storage handler's documentation for more info.*

schema/query/predicate.go

@@ -22,6 +22,7 @@ const (
 	opGreaterOrEqual = "$gte"
 	opRegex          = "$regex"
 	opElemMatch      = "$elemMatch"
+	opNot            = "$not"
 )
 
 // Predicate defines an expression against a schema to perform a match on schema's data.
@@ -552,3 +553,24 @@ func (e ElemMatch) String() string {
 	}
 	return quoteField(e.Field) + ": {" + opElemMatch + ": {" + strings.Join(s, ", ") + "}}"
 }
+
+type Not struct {
+	Field string
+	Value *regexp.Regexp
+}
+
+// Match implements Expression interface.
+func (e Not) Match(payload map[string]interface{}) bool {
+	return !e.Value.MatchString(payload[e.Field].(string))
+}
+
+// Prepare implements Expression interface.
+func (e *Not) Prepare(validator schema.Validator) error {
+	_, err := prepareValue(e.Field, e.Value.String(), validator)
+	return err
+}
+
+// String implements Expression interface.
+func (e Not) String() string {
+	return quoteField(e.Field) + ": {" + opNot + ": \"" + e.Value.String() + "\"}"
+}

schema/query/predicate_parser.go

@@ -107,7 +107,7 @@ func (p *predicateParser) parseExpression() (Expression, error) {
 		or := Or(subExp)
 		return &or, nil
 	case opExists, opIn, opNotIn, opNotEqual, opRegex, opElemMatch,
-		opLowerThan, opLowerOrEqual, opGreaterThan, opGreaterOrEqual:
+		opLowerThan, opLowerOrEqual, opGreaterThan, opGreaterOrEqual, opNot:
 		p.pos = oldPos
 		return nil, fmt.Errorf("%s: invalid placement", label)
 	default:
@@ -235,13 +235,9 @@ func (p *predicateParser) parseCommand(field string) (Expression, error) {
 				return &GreaterOrEqual{Field: field, Value: value}, nil
 			}
 		case opRegex:
-			str, err := p.parseString()
+			re, err := p.parseRegex(label)
 			if err != nil {
-				return nil, fmt.Errorf("%s: %v", label, err)
-			}
-			re, err := regexp.Compile(str)
-			if err != nil {
-				return nil, fmt.Errorf("%s: invalid regex: %v", label, err)
+				return nil, err
 			}
 			p.eatWhitespaces()
 			if !p.expect('}') {
@@ -258,6 +254,16 @@ func (p *predicateParser) parseCommand(field string) (Expression, error) {
 				return nil, fmt.Errorf("%s: expected '}' got %q", label, p.peek())
 			}
 			return &ElemMatch{Field: field, Exps: exps}, nil
+		case opNot:
+			re, err := p.parseRegex(label)
+			if err != nil {
+				return nil, err
+			}
+			p.eatWhitespaces()
+			if !p.expect('}') {
+				return nil, fmt.Errorf("%s: expected '}' got %q", label, p.peek())
+			}
+			return &Not{Field: field, Value: re}, nil
 		}
 	}
 VALUE:
@@ -524,3 +530,15 @@ func (p *predicateParser) eatWhitespaces() {
 		break
 	}
 }
+
+func (p *predicateParser) parseRegex(label string) (*regexp.Regexp, error) {
+	str, err := p.parseString()
+	if err != nil {
+		return nil, fmt.Errorf("%s: %v", label, err)
+	}
+	re, err := regexp.Compile(str)
+	if err != nil {
+		return nil, fmt.Errorf("%s: invalid regex: %v", label, err)
+	}
+	return re, nil
+}

schema/query/predicate_parser_test.go

@@ -103,6 +103,11 @@ func TestParse(t *testing.T) {
 			Predicate{&Regex{Field: "foo", Value: regexp.MustCompile("regex.+awesome")}},
 			nil,
 		},
+		{
+			`{"foo": {"$not": "regex.+awesome"}}`,
+			Predicate{&Not{Field: "foo", Value: regexp.MustCompile("regex.+awesome")}},
+			nil,
+		},
 		{
 			`{"$and": [{"foo": "bar"}, {"foo": "baz"}]}`,
 			Predicate{&And{&Equal{Field: "foo", Value: "bar"}, &Equal{Field: "foo", Value: "baz"}}},
@@ -361,6 +366,11 @@ func TestParse(t *testing.T) {
 			Predicate{},
 			errors.New("char 1: $elemMatch: invalid placement"),
 		},
+		{
+			`{"$not": "someregexpression"}`,
+			Predicate{},
+			errors.New("char 1: $not: invalid placement"),
+		},
 	}
 	for i := range tests {
 		tt := tests[i]

schema/query/predicate_test.go

@@ -140,12 +140,24 @@ func TestMatch(t *testing.T) {
 			},
 			nil,
 		},
+		{
+			`{"foo": {"$not": "rege[x]{1}.+some"}}`, []test{
+				{map[string]interface{}{"foo": "regex-is-awesome"}, false},
+			},
+			nil,
+		},
 		{
 			`{"foo": {"$regex": "^(?i)my.+-rest.+$"}}`, []test{
 				{map[string]interface{}{"foo": "myAwesome-RESTApplication"}, true},
 			},
 			nil,
 		},
+		{
+			`{"foo": {"$not": "^(?i)my.+-rest.+$"}}`, []test{
+				{map[string]interface{}{"foo": "myAwesome-RESTApplication"}, false},
+			},
+			nil,
+		},
 		{
 			`{"$and": [{"foo": "bar"}, {"foo": "baz"}]}`, []test{
 				{map[string]interface{}{"foo": "bar"}, false},