clone

vendor/github.com/asdine/storm/v3/q/compare.go

@@ -0,0 +1,122 @@
+package q
+
+import (
+	"go/constant"
+	"go/token"
+	"reflect"
+	"strconv"
+)
+
+func compare(a, b interface{}, tok token.Token) bool {
+	vala := reflect.ValueOf(a)
+	valb := reflect.ValueOf(b)
+
+	ak := vala.Kind()
+	bk := valb.Kind()
+	switch {
+	// comparing nil values
+	case (ak == reflect.Ptr || ak == reflect.Slice || ak == reflect.Interface || ak == reflect.Invalid) &&
+		(bk == reflect.Ptr || ak == reflect.Slice || bk == reflect.Interface || bk == reflect.Invalid) &&
+		(!vala.IsValid() || vala.IsNil()) && (!valb.IsValid() || valb.IsNil()):
+		return true
+	case ak >= reflect.Int && ak <= reflect.Int64:
+		if bk >= reflect.Int && bk <= reflect.Int64 {
+			return constant.Compare(constant.MakeInt64(vala.Int()), tok, constant.MakeInt64(valb.Int()))
+		}
+
+		if bk >= reflect.Uint && bk <= reflect.Uint64 {
+			return constant.Compare(constant.MakeInt64(vala.Int()), tok, constant.MakeInt64(int64(valb.Uint())))
+		}
+
+		if bk == reflect.Float32 || bk == reflect.Float64 {
+			return constant.Compare(constant.MakeFloat64(float64(vala.Int())), tok, constant.MakeFloat64(valb.Float()))
+		}
+
+		if bk == reflect.String {
+			bla, err := strconv.ParseFloat(valb.String(), 64)
+			if err != nil {
+				return false
+			}
+
+			return constant.Compare(constant.MakeFloat64(float64(vala.Int())), tok, constant.MakeFloat64(bla))
+		}
+	case ak >= reflect.Uint && ak <= reflect.Uint64:
+		if bk >= reflect.Uint && bk <= reflect.Uint64 {
+			return constant.Compare(constant.MakeUint64(vala.Uint()), tok, constant.MakeUint64(valb.Uint()))
+		}
+
+		if bk >= reflect.Int && bk <= reflect.Int64 {
+			return constant.Compare(constant.MakeUint64(vala.Uint()), tok, constant.MakeUint64(uint64(valb.Int())))
+		}
+
+		if bk == reflect.Float32 || bk == reflect.Float64 {
+			return constant.Compare(constant.MakeFloat64(float64(vala.Uint())), tok, constant.MakeFloat64(valb.Float()))
+		}
+
+		if bk == reflect.String {
+			bla, err := strconv.ParseFloat(valb.String(), 64)
+			if err != nil {
+				return false
+			}
+
+			return constant.Compare(constant.MakeFloat64(float64(vala.Uint())), tok, constant.MakeFloat64(bla))
+		}
+	case ak == reflect.Float32 || ak == reflect.Float64:
+		if bk == reflect.Float32 || bk == reflect.Float64 {
+			return constant.Compare(constant.MakeFloat64(vala.Float()), tok, constant.MakeFloat64(valb.Float()))
+		}
+
+		if bk >= reflect.Int && bk <= reflect.Int64 {
+			return constant.Compare(constant.MakeFloat64(vala.Float()), tok, constant.MakeFloat64(float64(valb.Int())))
+		}
+
+		if bk >= reflect.Uint && bk <= reflect.Uint64 {
+			return constant.Compare(constant.MakeFloat64(vala.Float()), tok, constant.MakeFloat64(float64(valb.Uint())))
+		}
+
+		if bk == reflect.String {
+			bla, err := strconv.ParseFloat(valb.String(), 64)
+			if err != nil {
+				return false
+			}
+
+			return constant.Compare(constant.MakeFloat64(vala.Float()), tok, constant.MakeFloat64(bla))
+		}
+	case ak == reflect.String:
+		if bk == reflect.String {
+			return constant.Compare(constant.MakeString(vala.String()), tok, constant.MakeString(valb.String()))
+		}
+	}
+
+	typea, typeb := reflect.TypeOf(a), reflect.TypeOf(b)
+
+	if typea != nil && (typea.String() == "time.Time" || typea.String() == "*time.Time") &&
+		typeb != nil && (typeb.String() == "time.Time" || typeb.String() == "*time.Time") {
+
+		if typea.String() == "*time.Time" && vala.IsNil() {
+			return true
+		}
+
+		if typeb.String() == "*time.Time" {
+			if valb.IsNil() {
+				return true
+			}
+			valb = valb.Elem()
+		}
+
+		var x, y int64
+		x = 1
+		if vala.MethodByName("Equal").Call([]reflect.Value{valb})[0].Bool() {
+			y = 1
+		} else if vala.MethodByName("Before").Call([]reflect.Value{valb})[0].Bool() {
+			y = 2
+		}
+		return constant.Compare(constant.MakeInt64(x), tok, constant.MakeInt64(y))
+	}
+
+	if tok == token.EQL {
+		return reflect.DeepEqual(a, b)
+	}
+
+	return false
+}

vendor/github.com/asdine/storm/v3/q/fieldmatcher.go

@@ -0,0 +1,67 @@
+package q
+
+import (
+	"errors"
+	"go/token"
+	"reflect"
+)
+
+// ErrUnknownField is returned when an unknown field is passed.
+var ErrUnknownField = errors.New("unknown field")
+
+type fieldMatcherDelegate struct {
+	FieldMatcher
+	Field string
+}
+
+// NewFieldMatcher creates a Matcher for a given field.
+func NewFieldMatcher(field string, fm FieldMatcher) Matcher {
+	return fieldMatcherDelegate{Field: field, FieldMatcher: fm}
+}
+
+// FieldMatcher can be used in NewFieldMatcher as a simple way to create the
+// most common Matcher: A Matcher that evaluates one field's value.
+// For more complex scenarios, implement the Matcher interface directly.
+type FieldMatcher interface {
+	MatchField(v interface{}) (bool, error)
+}
+
+func (r fieldMatcherDelegate) Match(i interface{}) (bool, error) {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	return r.MatchValue(&v)
+}
+
+func (r fieldMatcherDelegate) MatchValue(v *reflect.Value) (bool, error) {
+	field := v.FieldByName(r.Field)
+	if !field.IsValid() {
+		return false, ErrUnknownField
+	}
+	return r.MatchField(field.Interface())
+}
+
+// NewField2FieldMatcher creates a Matcher for a given field1 and field2.
+func NewField2FieldMatcher(field1, field2 string, tok token.Token) Matcher {
+	return field2fieldMatcherDelegate{Field1: field1, Field2: field2, Tok: tok}
+}
+
+type field2fieldMatcherDelegate struct {
+	Field1, Field2 string
+	Tok            token.Token
+}
+
+func (r field2fieldMatcherDelegate) Match(i interface{}) (bool, error) {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	return r.MatchValue(&v)
+}
+
+func (r field2fieldMatcherDelegate) MatchValue(v *reflect.Value) (bool, error) {
+	field1 := v.FieldByName(r.Field1)
+	if !field1.IsValid() {
+		return false, ErrUnknownField
+	}
+	field2 := v.FieldByName(r.Field2)
+	if !field2.IsValid() {
+		return false, ErrUnknownField
+	}
+	return compare(field1.Interface(), field2.Interface(), r.Tok), nil
+}

vendor/github.com/asdine/storm/v3/q/regexp.go

@@ -0,0 +1,51 @@
+package q
+
+import (
+	"fmt"
+	"regexp"
+	"sync"
+)
+
+// Re creates a regexp matcher. It checks if the given field matches the given regexp.
+// Note that this only supports fields of type string or []byte.
+func Re(field string, re string) Matcher {
+	regexpCache.RLock()
+	if r, ok := regexpCache.m[re]; ok {
+		regexpCache.RUnlock()
+		return NewFieldMatcher(field, &regexpMatcher{r: r})
+	}
+	regexpCache.RUnlock()
+
+	regexpCache.Lock()
+	r, err := regexp.Compile(re)
+	if err == nil {
+		regexpCache.m[re] = r
+	}
+	regexpCache.Unlock()
+
+	return NewFieldMatcher(field, &regexpMatcher{r: r, err: err})
+}
+
+var regexpCache = struct {
+	sync.RWMutex
+	m map[string]*regexp.Regexp
+}{m: make(map[string]*regexp.Regexp)}
+
+type regexpMatcher struct {
+	r   *regexp.Regexp
+	err error
+}
+
+func (r *regexpMatcher) MatchField(v interface{}) (bool, error) {
+	if r.err != nil {
+		return false, r.err
+	}
+	switch fieldValue := v.(type) {
+	case string:
+		return r.r.MatchString(fieldValue), nil
+	case []byte:
+		return r.r.Match(fieldValue), nil
+	default:
+		return false, fmt.Errorf("Only string and []byte supported for regexp matcher, got %T", fieldValue)
+	}
+}

vendor/github.com/asdine/storm/v3/q/tree.go

@@ -0,0 +1,247 @@
+// Package q contains a list of Matchers used to compare struct fields with values
+package q
+
+import (
+	"go/token"
+	"reflect"
+)
+
+// A Matcher is used to test against a record to see if it matches.
+type Matcher interface {
+	// Match is used to test the criteria against a structure.
+	Match(interface{}) (bool, error)
+}
+
+// A ValueMatcher is used to test against a reflect.Value.
+type ValueMatcher interface {
+	// MatchValue tests if the given reflect.Value matches.
+	// It is useful when the reflect.Value of an object already exists.
+	MatchValue(*reflect.Value) (bool, error)
+}
+
+type cmp struct {
+	value interface{}
+	token token.Token
+}
+
+func (c *cmp) MatchField(v interface{}) (bool, error) {
+	return compare(v, c.value, c.token), nil
+}
+
+type trueMatcher struct{}
+
+func (*trueMatcher) Match(i interface{}) (bool, error) {
+	return true, nil
+}
+
+func (*trueMatcher) MatchValue(v *reflect.Value) (bool, error) {
+	return true, nil
+}
+
+type or struct {
+	children []Matcher
+}
+
+func (c *or) Match(i interface{}) (bool, error) {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	return c.MatchValue(&v)
+}
+
+func (c *or) MatchValue(v *reflect.Value) (bool, error) {
+	for _, matcher := range c.children {
+		if vm, ok := matcher.(ValueMatcher); ok {
+			ok, err := vm.MatchValue(v)
+			if err != nil {
+				return false, err
+			}
+			if ok {
+				return true, nil
+			}
+			continue
+		}
+
+		ok, err := matcher.Match(v.Interface())
+		if err != nil {
+			return false, err
+		}
+		if ok {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+type and struct {
+	children []Matcher
+}
+
+func (c *and) Match(i interface{}) (bool, error) {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	return c.MatchValue(&v)
+}
+
+func (c *and) MatchValue(v *reflect.Value) (bool, error) {
+	for _, matcher := range c.children {
+		if vm, ok := matcher.(ValueMatcher); ok {
+			ok, err := vm.MatchValue(v)
+			if err != nil {
+				return false, err
+			}
+			if !ok {
+				return false, nil
+			}
+			continue
+		}
+
+		ok, err := matcher.Match(v.Interface())
+		if err != nil {
+			return false, err
+		}
+		if !ok {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
+type strictEq struct {
+	field string
+	value interface{}
+}
+
+func (s *strictEq) MatchField(v interface{}) (bool, error) {
+	return reflect.DeepEqual(v, s.value), nil
+}
+
+type in struct {
+	list interface{}
+}
+
+func (i *in) MatchField(v interface{}) (bool, error) {
+	ref := reflect.ValueOf(i.list)
+	if ref.Kind() != reflect.Slice {
+		return false, nil
+	}
+
+	c := cmp{
+		token: token.EQL,
+	}
+
+	for i := 0; i < ref.Len(); i++ {
+		c.value = ref.Index(i).Interface()
+		ok, err := c.MatchField(v)
+		if err != nil {
+			return false, err
+		}
+		if ok {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+type not struct {
+	children []Matcher
+}
+
+func (n *not) Match(i interface{}) (bool, error) {
+	v := reflect.Indirect(reflect.ValueOf(i))
+	return n.MatchValue(&v)
+}
+
+func (n *not) MatchValue(v *reflect.Value) (bool, error) {
+	var err error
+
+	for _, matcher := range n.children {
+		vm, ok := matcher.(ValueMatcher)
+		if ok {
+			ok, err = vm.MatchValue(v)
+		} else {
+			ok, err = matcher.Match(v.Interface())
+		}
+		if err != nil {
+			return false, err
+		}
+		if ok {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
+// Eq matcher, checks if the given field is equal to the given value
+func Eq(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &cmp{value: v, token: token.EQL})
+}
+
+// EqF matcher, checks if the given field is equal to the given field
+func EqF(field1, field2 string) Matcher {
+	return NewField2FieldMatcher(field1, field2, token.EQL)
+}
+
+// StrictEq matcher, checks if the given field is deeply equal to the given value
+func StrictEq(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &strictEq{value: v})
+}
+
+// Gt matcher, checks if the given field is greater than the given value
+func Gt(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &cmp{value: v, token: token.GTR})
+}
+
+// GtF matcher, checks if the given field is greater than the given field
+func GtF(field1, field2 string) Matcher {
+	return NewField2FieldMatcher(field1, field2, token.GTR)
+}
+
+// Gte matcher, checks if the given field is greater than or equal to the given value
+func Gte(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &cmp{value: v, token: token.GEQ})
+}
+
+// GteF matcher, checks if the given field is greater than or equal to the given field
+func GteF(field1, field2 string) Matcher {
+	return NewField2FieldMatcher(field1, field2, token.GEQ)
+}
+
+// Lt matcher, checks if the given field is lesser than the given value
+func Lt(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &cmp{value: v, token: token.LSS})
+}
+
+// LtF matcher, checks if the given field is lesser than the given field
+func LtF(field1, field2 string) Matcher {
+	return NewField2FieldMatcher(field1, field2, token.LSS)
+}
+
+// Lte matcher, checks if the given field is lesser than or equal to the given value
+func Lte(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &cmp{value: v, token: token.LEQ})
+}
+
+// LteF matcher, checks if the given field is lesser than or equal to the given field
+func LteF(field1, field2 string) Matcher {
+	return NewField2FieldMatcher(field1, field2, token.LEQ)
+}
+
+// In matcher, checks if the given field matches one of the value of the given slice.
+// v must be a slice.
+func In(field string, v interface{}) Matcher {
+	return NewFieldMatcher(field, &in{list: v})
+}
+
+// True matcher, always returns true
+func True() Matcher { return &trueMatcher{} }
+
+// Or matcher, checks if at least one of the given matchers matches the record
+func Or(matchers ...Matcher) Matcher { return &or{children: matchers} }
+
+// And matcher, checks if all of the given matchers matches the record
+func And(matchers ...Matcher) Matcher { return &and{children: matchers} }
+
+// Not matcher, checks if all of the given matchers return false
+func Not(matchers ...Matcher) Matcher { return &not{children: matchers} }