Added ComparativeStrings to support =~ and =! operators on string values

Author: mariusor

decode.go

@@ -152,6 +152,12 @@ func (d *decoder) coerce(query string, target reflect.Kind, field reflect.Value)
 			if err == nil {
 				field.Set(reflect.ValueOf(t))
 			}
+		case ComparativeString:
+			s := ComparativeString{}
+			err = s.Parse(query)
+			if err == nil {
+				field.Set(reflect.ValueOf(s))
+			}
 		default:
 			d.value(field)
 		}

fields.go

@@ -7,29 +7,54 @@ import (
 	"time"
 )
 
+const (
+	operatorEquals    = "="
+	operatorGreater   = ">"
+	operatorGreaterEq = ">="
+	operatorLesser    = "<"
+	operatorLesserEq  = "<="
+	operatorLike      = "~"
+	operatorDifferent = "!"
+)
+
 // parseOperator parses a leading logical operator out of the provided string
 func parseOperator(s string) string {
 	switch s[0] {
-	case 60: // "<"
+	case operatorLesser[0]: // "<"
+		if 1 == len(s) {
+			return operatorLesser
+		}
 		switch s[1] {
-		case 61: // "="
-			return "<="
+		case operatorEquals[0]: // "="
+			return operatorLesserEq
 		default:
-			return "<"
+			return operatorLesser
+		}
+	case operatorGreater[0]: // ">"
+		if 1 == len(s) {
+			return operatorGreater
 		}
-	case 62: // ">"
 		switch s[1] {
-		case 61: // "="
-			return ">="
+		case operatorEquals[0]: // "="
+			return operatorGreaterEq
 		default:
-			return ">"
+			return operatorGreater
 		}
+	case operatorLike[0]: // "~"
+		return operatorLike
+	case operatorDifferent[0]: // "!"
+		return operatorDifferent
 	default:
 		// no operator found, default to "="
-		return "="
+		return operatorEquals
 	}
 }
 
+type ComparativeString struct {
+	Operator string
+	Str      string
+}
+
 // ComparativeTime is a field that can be used for specifying a query parameter
 // which includes a conditional operator and a timestamp
 type ComparativeTime struct {
@@ -70,3 +95,38 @@ func (c *ComparativeTime) Parse(query string) error {
 func (c ComparativeTime) String() string {
 	return fmt.Sprintf("%s%s", c.Operator, c.Time.Format(time.RFC3339))
 }
+
+// Parse is used to parse a query string into a ComparativeString instance
+func (c *ComparativeString) Parse(query string) error {
+	if len(query) <= 2 {
+		return errors.New("qstring: Invalid Query")
+	}
+
+	c.Operator = parseOperator(query)
+
+	if c.Operator != operatorDifferent && c.Operator != operatorLike && c.Operator != operatorEquals {
+		return errors.New(fmt.Sprintf("qstring: Invalid operator for %T", c))
+	}
+	if c.Operator == operatorEquals {
+		c.Operator = ""
+	}
+
+	// if no operator was provided and we defaulted to an equality operator
+	if !strings.HasPrefix(query, c.Operator) {
+		query = fmt.Sprintf("=%s", query)
+	}
+
+	var err error
+	c.Str = query[len(c.Operator):]
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// String returns this ComparativeString instance in the form of the query
+// parameter that it came in on
+func (c ComparativeString) String() string {
+	return fmt.Sprintf("%s%s", c.Operator, c.Str)
+}

fields_test.go

@@ -1,6 +1,7 @@
 package qstring
 
 import (
+	"fmt"
 	"net/url"
 	"strings"
 	"testing"
@@ -108,3 +109,88 @@ func TestComparativeTimeMarshalString(t *testing.T) {
 		}
 	}
 }
+
+func TestComparativeStringUnmarshal(t *testing.T) {
+	type Query struct {
+		Equals    ComparativeString
+		Similar   ComparativeString
+		Different ComparativeString
+	}
+
+	val1 := "stringValue1"
+	equalsVal := fmt.Sprintf("%s", val1)
+	val2 := "stringValue2"
+	similarVal := fmt.Sprintf("~%s", val2)
+	val3 := "stringValue3"
+	diffVal := fmt.Sprintf("!%s", val3)
+
+	query := url.Values{
+		"equals":    []string{equalsVal},
+		"different": []string{diffVal},
+		"similar":   []string{similarVal},
+	}
+
+	params := &Query{}
+	err := Unmarshal(query, params)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	equals := params.Equals.String()
+	if equals != equalsVal {
+		t.Errorf("Expected equals val of %s, got %s instead.", equalsVal, equals)
+	}
+	similar := params.Similar.String()
+	if similar != similarVal {
+		t.Errorf("Expected similar val of %s, got %s instead.", similarVal, similar)
+	}
+	diff := params.Different.String()
+	if diff != diffVal {
+		t.Errorf("Expected different val of %s, got %s instead.", diffVal, diff)
+	}
+}
+
+func TestComparativeStringMarshalString(t *testing.T) {
+	type Query struct {
+		Equals    ComparativeString
+		Similar   ComparativeString
+		Different ComparativeString
+	}
+
+	val1 := "stringValue1"
+	equalsVal := fmt.Sprintf("%s", val1)
+	equals := &ComparativeString{}
+	equals.Parse(equalsVal)
+
+	val2 := "stringValue2"
+	similarVal := fmt.Sprintf("~%s", val2)
+	similar := &ComparativeString{}
+	similar.Parse(similarVal)
+
+	val3 := "stringValue3"
+	diffVal := fmt.Sprintf("!%s", val3)
+	different := &ComparativeString{}
+	different.Parse(diffVal)
+
+	q := &Query{*equals, *similar, *different}
+	result, err := MarshalString(q)
+	if err != nil {
+		t.Fatalf("Unable to marshal comparative timestamp: %s", err.Error())
+	}
+
+	var unescaped string
+	unescaped, err = url.QueryUnescape(result)
+	if err != nil {
+		t.Fatalf("Unable to unescape query string %q: %q", result, err.Error())
+	}
+	expected := []string{
+		fmt.Sprintf("different=!%s", val3),
+		fmt.Sprintf("equals=%s", val1),
+		fmt.Sprintf("similar=~%s", val2),
+	}
+	for _, ts := range expected {
+		if !strings.Contains(unescaped, ts) {
+			t.Errorf("Expected query string %s to contain %s", unescaped, ts)
+		}
+	}
+}