detele everything

libs/pubsub/query/Makefile

@@ -1,11 +0,0 @@
-gen_query_parser:
-	@go get github.com/pointlander/peg
-	peg -inline -switch query.peg
-
-fuzzy_test:
-	@go get github.com/dvyukov/go-fuzz/go-fuzz
-	@go get github.com/dvyukov/go-fuzz/go-fuzz-build
-	go-fuzz-build github.com/tendermint/tendermint/libs/pubsub/query/fuzz_test
-	go-fuzz -bin=./fuzz_test-fuzz.zip -workdir=./fuzz_test/output
-
-.PHONY: gen_query_parser fuzzy_test

libs/pubsub/query/empty.go

@@ -1,16 +0,0 @@
-package query
-
-import "github.com/tendermint/tendermint/libs/pubsub"
-
-// Empty query matches any set of tags.
-type Empty struct {
-}
-
-// Matches always returns true.
-func (Empty) Matches(tags pubsub.TagMap) bool {
-	return true
-}
-
-func (Empty) String() string {
-	return "empty"
-}

libs/pubsub/query/empty_test.go

@@ -1,18 +0,0 @@
-package query_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/tendermint/tendermint/libs/pubsub"
-	"github.com/tendermint/tendermint/libs/pubsub/query"
-)
-
-func TestEmptyQueryMatchesAnything(t *testing.T) {
-	q := query.Empty{}
-	assert.True(t, q.Matches(pubsub.NewTagMap(map[string]string{})))
-	assert.True(t, q.Matches(pubsub.NewTagMap(map[string]string{"Asher": "Roth"})))
-	assert.True(t, q.Matches(pubsub.NewTagMap(map[string]string{"Route": "66"})))
-	assert.True(t, q.Matches(pubsub.NewTagMap(map[string]string{"Route": "66", "Billy": "Blue"})))
-}

libs/pubsub/query/fuzz_test/main.go

@@ -1,30 +0,0 @@
-package fuzz_test
-
-import (
-	"fmt"
-
-	"github.com/tendermint/tendermint/libs/pubsub/query"
-)
-
-func Fuzz(data []byte) int {
-	sdata := string(data)
-	q0, err := query.New(sdata)
-	if err != nil {
-		return 0
-	}
-
-	sdata1 := q0.String()
-	q1, err := query.New(sdata1)
-	if err != nil {
-		panic(err)
-	}
-
-	sdata2 := q1.String()
-	if sdata1 != sdata2 {
-		fmt.Printf("q0: %q\n", sdata1)
-		fmt.Printf("q1: %q\n", sdata2)
-		panic("query changed")
-	}
-
-	return 1
-}

libs/pubsub/query/parser_test.go

@@ -1,92 +0,0 @@
-package query_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/tendermint/tendermint/libs/pubsub/query"
-)
-
-// TODO: fuzzy testing?
-func TestParser(t *testing.T) {
-	cases := []struct {
-		query string
-		valid bool
-	}{
-		{"tm.events.type='NewBlock'", true},
-		{"tm.events.type = 'NewBlock'", true},
-		{"tm.events.name = ''", true},
-		{"tm.events.type='TIME'", true},
-		{"tm.events.type='DATE'", true},
-		{"tm.events.type='='", true},
-		{"tm.events.type='TIME", false},
-		{"tm.events.type=TIME'", false},
-		{"tm.events.type==", false},
-		{"tm.events.type=NewBlock", false},
-		{">==", false},
-		{"tm.events.type 'NewBlock' =", false},
-		{"tm.events.type>'NewBlock'", false},
-		{"", false},
-		{"=", false},
-		{"='NewBlock'", false},
-		{"tm.events.type=", false},
-
-		{"tm.events.typeNewBlock", false},
-		{"tm.events.type'NewBlock'", false},
-		{"'NewBlock'", false},
-		{"NewBlock", false},
-		{"", false},
-
-		{"tm.events.type='NewBlock' AND abci.account.name='Igor'", true},
-		{"tm.events.type='NewBlock' AND", false},
-		{"tm.events.type='NewBlock' AN", false},
-		{"tm.events.type='NewBlock' AN tm.events.type='NewBlockHeader'", false},
-		{"AND tm.events.type='NewBlock' ", false},
-
-		{"abci.account.name CONTAINS 'Igor'", true},
-
-		{"tx.date > DATE 2013-05-03", true},
-		{"tx.date < DATE 2013-05-03", true},
-		{"tx.date <= DATE 2013-05-03", true},
-		{"tx.date >= DATE 2013-05-03", true},
-		{"tx.date >= DAT 2013-05-03", false},
-		{"tx.date <= DATE2013-05-03", false},
-		{"tx.date <= DATE -05-03", false},
-		{"tx.date >= DATE 20130503", false},
-		{"tx.date >= DATE 2013+01-03", false},
-		// incorrect year, month, day
-		{"tx.date >= DATE 0013-01-03", false},
-		{"tx.date >= DATE 2013-31-03", false},
-		{"tx.date >= DATE 2013-01-83", false},
-
-		{"tx.date > TIME 2013-05-03T14:45:00+07:00", true},
-		{"tx.date < TIME 2013-05-03T14:45:00-02:00", true},
-		{"tx.date <= TIME 2013-05-03T14:45:00Z", true},
-		{"tx.date >= TIME 2013-05-03T14:45:00Z", true},
-		{"tx.date >= TIME2013-05-03T14:45:00Z", false},
-		{"tx.date = IME 2013-05-03T14:45:00Z", false},
-		{"tx.date = TIME 2013-05-:45:00Z", false},
-		{"tx.date >= TIME 2013-05-03T14:45:00", false},
-		{"tx.date >= TIME 0013-00-00T14:45:00Z", false},
-		{"tx.date >= TIME 2013+05=03T14:45:00Z", false},
-
-		{"account.balance=100", true},
-		{"account.balance >= 200", true},
-		{"account.balance >= -300", false},
-		{"account.balance >>= 400", false},
-		{"account.balance=33.22.1", false},
-
-		{"hash='136E18F7E4C348B780CF873A0BF43922E5BAFA63'", true},
-		{"hash=136E18F7E4C348B780CF873A0BF43922E5BAFA63", false},
-	}
-
-	for _, c := range cases {
-		_, err := query.New(c.query)
-		if c.valid {
-			assert.NoErrorf(t, err, "Query was '%s'", c.query)
-		} else {
-			assert.Errorf(t, err, "Query was '%s'", c.query)
-		}
-	}
-}

libs/pubsub/query/query.go

@@ -1,339 +0,0 @@
-// Package query provides a parser for a custom query format:
-//
-//		abci.invoice.number=22 AND abci.invoice.owner=Ivan
-//
-// See query.peg for the grammar, which is a https://en.wikipedia.org/wiki/Parsing_expression_grammar.
-// More: https://github.com/PhilippeSigaud/Pegged/wiki/PEG-Basics
-//
-// It has a support for numbers (integer and floating point), dates and times.
-package query
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/tendermint/tendermint/libs/pubsub"
-)
-
-// Query holds the query string and the query parser.
-type Query struct {
-	str    string
-	parser *QueryParser
-}
-
-// Condition represents a single condition within a query and consists of tag
-// (e.g. "tx.gas"), operator (e.g. "=") and operand (e.g. "7").
-type Condition struct {
-	Tag     string
-	Op      Operator
-	Operand interface{}
-}
-
-// New parses the given string and returns a query or error if the string is
-// invalid.
-func New(s string) (*Query, error) {
-	p := &QueryParser{Buffer: fmt.Sprintf(`"%s"`, s)}
-	p.Init()
-	if err := p.Parse(); err != nil {
-		return nil, err
-	}
-	return &Query{str: s, parser: p}, nil
-}
-
-// MustParse turns the given string into a query or panics; for tests or others
-// cases where you know the string is valid.
-func MustParse(s string) *Query {
-	q, err := New(s)
-	if err != nil {
-		panic(fmt.Sprintf("failed to parse %s: %v", s, err))
-	}
-	return q
-}
-
-// String returns the original string.
-func (q *Query) String() string {
-	return q.str
-}
-
-// Operator is an operator that defines some kind of relation between tag and
-// operand (equality, etc.).
-type Operator uint8
-
-const (
-	// "<="
-	OpLessEqual Operator = iota
-	// ">="
-	OpGreaterEqual
-	// "<"
-	OpLess
-	// ">"
-	OpGreater
-	// "="
-	OpEqual
-	// "CONTAINS"; used to check if a string contains a certain sub string.
-	OpContains
-)
-
-const (
-	// DateLayout defines a layout for all dates (`DATE date`)
-	DateLayout = "2006-01-02"
-	// TimeLayout defines a layout for all times (`TIME time`)
-	TimeLayout = time.RFC3339
-)
-
-// Conditions returns a list of conditions.
-func (q *Query) Conditions() []Condition {
-	conditions := make([]Condition, 0)
-
-	buffer, begin, end := q.parser.Buffer, 0, 0
-
-	var tag string
-	var op Operator
-
-	// tokens must be in the following order: tag ("tx.gas") -> operator ("=") -> operand ("7")
-	for _, token := range q.parser.Tokens() {
-		switch token.pegRule {
-
-		case rulePegText:
-			begin, end = int(token.begin), int(token.end)
-		case ruletag:
-			tag = buffer[begin:end]
-		case rulele:
-			op = OpLessEqual
-		case rulege:
-			op = OpGreaterEqual
-		case rulel:
-			op = OpLess
-		case ruleg:
-			op = OpGreater
-		case ruleequal:
-			op = OpEqual
-		case rulecontains:
-			op = OpContains
-		case rulevalue:
-			// strip single quotes from value (i.e. "'NewBlock'" -> "NewBlock")
-			valueWithoutSingleQuotes := buffer[begin+1 : end-1]
-			conditions = append(conditions, Condition{tag, op, valueWithoutSingleQuotes})
-		case rulenumber:
-			number := buffer[begin:end]
-			if strings.ContainsAny(number, ".") { // if it looks like a floating-point number
-				value, err := strconv.ParseFloat(number, 64)
-				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)", err, number))
-				}
-				conditions = append(conditions, Condition{tag, op, value})
-			} else {
-				value, err := strconv.ParseInt(number, 10, 64)
-				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)", err, number))
-				}
-				conditions = append(conditions, Condition{tag, op, value})
-			}
-		case ruletime:
-			value, err := time.Parse(TimeLayout, buffer[begin:end])
-			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)", err, buffer[begin:end]))
-			}
-			conditions = append(conditions, Condition{tag, op, value})
-		case ruledate:
-			value, err := time.Parse("2006-01-02", buffer[begin:end])
-			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)", err, buffer[begin:end]))
-			}
-			conditions = append(conditions, Condition{tag, op, value})
-		}
-	}
-
-	return conditions
-}
-
-// Matches returns true if the query matches the given set of tags, false otherwise.
-//
-// For example, query "name=John" matches tags = {"name": "John"}. More
-// examples could be found in parser_test.go and query_test.go.
-func (q *Query) Matches(tags pubsub.TagMap) bool {
-	if tags.Len() == 0 {
-		return false
-	}
-
-	buffer, begin, end := q.parser.Buffer, 0, 0
-
-	var tag string
-	var op Operator
-
-	// tokens must be in the following order: tag ("tx.gas") -> operator ("=") -> operand ("7")
-	for _, token := range q.parser.Tokens() {
-		switch token.pegRule {
-
-		case rulePegText:
-			begin, end = int(token.begin), int(token.end)
-		case ruletag:
-			tag = buffer[begin:end]
-		case rulele:
-			op = OpLessEqual
-		case rulege:
-			op = OpGreaterEqual
-		case rulel:
-			op = OpLess
-		case ruleg:
-			op = OpGreater
-		case ruleequal:
-			op = OpEqual
-		case rulecontains:
-			op = OpContains
-		case rulevalue:
-			// strip single quotes from value (i.e. "'NewBlock'" -> "NewBlock")
-			valueWithoutSingleQuotes := buffer[begin+1 : end-1]
-
-			// see if the triplet (tag, operator, operand) matches any tag
-			// "tx.gas", "=", "7", { "tx.gas": 7, "tx.ID": "4AE393495334" }
-			if !match(tag, op, reflect.ValueOf(valueWithoutSingleQuotes), tags) {
-				return false
-			}
-		case rulenumber:
-			number := buffer[begin:end]
-			if strings.ContainsAny(number, ".") { // if it looks like a floating-point number
-				value, err := strconv.ParseFloat(number, 64)
-				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)", err, number))
-				}
-				if !match(tag, op, reflect.ValueOf(value), tags) {
-					return false
-				}
-			} else {
-				value, err := strconv.ParseInt(number, 10, 64)
-				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)", err, number))
-				}
-				if !match(tag, op, reflect.ValueOf(value), tags) {
-					return false
-				}
-			}
-		case ruletime:
-			value, err := time.Parse(TimeLayout, buffer[begin:end])
-			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)", err, buffer[begin:end]))
-			}
-			if !match(tag, op, reflect.ValueOf(value), tags) {
-				return false
-			}
-		case ruledate:
-			value, err := time.Parse("2006-01-02", buffer[begin:end])
-			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)", err, buffer[begin:end]))
-			}
-			if !match(tag, op, reflect.ValueOf(value), tags) {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-// match returns true if the given triplet (tag, operator, operand) matches any tag.
-//
-// First, it looks up the tag in tags and if it finds one, tries to compare the
-// value from it to the operand using the operator.
-//
-// "tx.gas", "=", "7", { "tx.gas": 7, "tx.ID": "4AE393495334" }
-func match(tag string, op Operator, operand reflect.Value, tags pubsub.TagMap) bool {
-	// look up the tag from the query in tags
-	value, ok := tags.Get(tag)
-	if !ok {
-		return false
-	}
-	switch operand.Kind() {
-	case reflect.Struct: // time
-		operandAsTime := operand.Interface().(time.Time)
-		// try our best to convert value from tags to time.Time
-		var (
-			v   time.Time
-			err error
-		)
-		if strings.ContainsAny(value, "T") {
-			v, err = time.Parse(TimeLayout, value)
-		} else {
-			v, err = time.Parse(DateLayout, value)
-		}
-		if err != nil {
-			panic(fmt.Sprintf("Failed to convert value %v from tag to time.Time: %v", value, err))
-		}
-		switch op {
-		case OpLessEqual:
-			return v.Before(operandAsTime) || v.Equal(operandAsTime)
-		case OpGreaterEqual:
-			return v.Equal(operandAsTime) || v.After(operandAsTime)
-		case OpLess:
-			return v.Before(operandAsTime)
-		case OpGreater:
-			return v.After(operandAsTime)
-		case OpEqual:
-			return v.Equal(operandAsTime)
-		}
-	case reflect.Float64:
-		operandFloat64 := operand.Interface().(float64)
-		var v float64
-		// try our best to convert value from tags to float64
-		v, err := strconv.ParseFloat(value, 64)
-		if err != nil {
-			panic(fmt.Sprintf("Failed to convert value %v from tag to float64: %v", value, err))
-		}
-		switch op {
-		case OpLessEqual:
-			return v <= operandFloat64
-		case OpGreaterEqual:
-			return v >= operandFloat64
-		case OpLess:
-			return v < operandFloat64
-		case OpGreater:
-			return v > operandFloat64
-		case OpEqual:
-			return v == operandFloat64
-		}
-	case reflect.Int64:
-		operandInt := operand.Interface().(int64)
-		var v int64
-		// if value looks like float, we try to parse it as float
-		if strings.ContainsAny(value, ".") {
-			v1, err := strconv.ParseFloat(value, 64)
-			if err != nil {
-				panic(fmt.Sprintf("Failed to convert value %v from tag to float64: %v", value, err))
-			}
-			v = int64(v1)
-		} else {
-			var err error
-			// try our best to convert value from tags to int64
-			v, err = strconv.ParseInt(value, 10, 64)
-			if err != nil {
-				panic(fmt.Sprintf("Failed to convert value %v from tag to int64: %v", value, err))
-			}
-		}
-		switch op {
-		case OpLessEqual:
-			return v <= operandInt
-		case OpGreaterEqual:
-			return v >= operandInt
-		case OpLess:
-			return v < operandInt
-		case OpGreater:
-			return v > operandInt
-		case OpEqual:
-			return v == operandInt
-		}
-	case reflect.String:
-		switch op {
-		case OpEqual:
-			return value == operand.String()
-		case OpContains:
-			return strings.Contains(value, operand.String())
-		}
-	default:
-		panic(fmt.Sprintf("Unknown kind of operand %v", operand.Kind()))
-	}
-
-	return false
-}

libs/pubsub/query/query.peg

@@ -1,33 +0,0 @@
-package query
-
-type QueryParser Peg {
-}
-
-e <- '\"' condition ( ' '+ and ' '+ condition )* '\"' !.
-
-condition <- tag ' '* (le ' '* (number / time / date)
-                      / ge ' '* (number / time / date)
-                      / l ' '* (number / time / date)
-                      / g ' '* (number / time / date)
-                      / equal ' '* (number / time / date / value)
-                      / contains ' '* value
-                      )
-
-tag <- < (![ \t\n\r\\()"'=><] .)+ >
-value <- < '\'' (!["'] .)* '\''>
-number <- < ('0'
-           / [1-9] digit* ('.' digit*)?) >
-digit <- [0-9]
-time <- "TIME " < year '-' month '-' day 'T' digit digit ':' digit digit ':' digit digit (('-' / '+') digit digit ':' digit digit / 'Z') >
-date <- "DATE " < year '-' month '-' day >
-year <- ('1' / '2') digit digit digit
-month <- ('0' / '1') digit
-day <- ('0' / '1' / '2' / '3') digit
-and <- "AND"
-
-equal <- "="
-contains <- "CONTAINS"
-le <- "<="
-ge <- ">="
-l <- "<"
-g <- ">"

libs/pubsub/query/query_test.go

@@ -1,87 +0,0 @@
-package query_test
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/libs/pubsub"
-	"github.com/tendermint/tendermint/libs/pubsub/query"
-)
-
-func TestMatches(t *testing.T) {
-	var (
-		txDate = "2017-01-01"
-		txTime = "2018-05-03T14:45:00Z"
-	)
-
-	testCases := []struct {
-		s       string
-		tags    map[string]string
-		err     bool
-		matches bool
-	}{
-		{"tm.events.type='NewBlock'", map[string]string{"tm.events.type": "NewBlock"}, false, true},
-
-		{"tx.gas > 7", map[string]string{"tx.gas": "8"}, false, true},
-		{"tx.gas > 7 AND tx.gas < 9", map[string]string{"tx.gas": "8"}, false, true},
-		{"body.weight >= 3.5", map[string]string{"body.weight": "3.5"}, false, true},
-		{"account.balance < 1000.0", map[string]string{"account.balance": "900"}, false, true},
-		{"apples.kg <= 4", map[string]string{"apples.kg": "4.0"}, false, true},
-		{"body.weight >= 4.5", map[string]string{"body.weight": fmt.Sprintf("%v", float32(4.5))}, false, true},
-		{"oranges.kg < 4 AND watermellons.kg > 10", map[string]string{"oranges.kg": "3", "watermellons.kg": "12"}, false, true},
-		{"peaches.kg < 4", map[string]string{"peaches.kg": "5"}, false, false},
-
-		{"tx.date > DATE 2017-01-01", map[string]string{"tx.date": time.Now().Format(query.DateLayout)}, false, true},
-		{"tx.date = DATE 2017-01-01", map[string]string{"tx.date": txDate}, false, true},
-		{"tx.date = DATE 2018-01-01", map[string]string{"tx.date": txDate}, false, false},
-
-		{"tx.time >= TIME 2013-05-03T14:45:00Z", map[string]string{"tx.time": time.Now().Format(query.TimeLayout)}, false, true},
-		{"tx.time = TIME 2013-05-03T14:45:00Z", map[string]string{"tx.time": txTime}, false, false},
-
-		{"abci.owner.name CONTAINS 'Igor'", map[string]string{"abci.owner.name": "Igor,Ivan"}, false, true},
-		{"abci.owner.name CONTAINS 'Igor'", map[string]string{"abci.owner.name": "Pavel,Ivan"}, false, false},
-	}
-
-	for _, tc := range testCases {
-		q, err := query.New(tc.s)
-		if !tc.err {
-			require.Nil(t, err)
-		}
-
-		if tc.matches {
-			assert.True(t, q.Matches(pubsub.NewTagMap(tc.tags)), "Query '%s' should match %v", tc.s, tc.tags)
-		} else {
-			assert.False(t, q.Matches(pubsub.NewTagMap(tc.tags)), "Query '%s' should not match %v", tc.s, tc.tags)
-		}
-	}
-}
-
-func TestMustParse(t *testing.T) {
-	assert.Panics(t, func() { query.MustParse("=") })
-	assert.NotPanics(t, func() { query.MustParse("tm.events.type='NewBlock'") })
-}
-
-func TestConditions(t *testing.T) {
-	txTime, err := time.Parse(time.RFC3339, "2013-05-03T14:45:00Z")
-	require.NoError(t, err)
-
-	testCases := []struct {
-		s          string
-		conditions []query.Condition
-	}{
-		{s: "tm.events.type='NewBlock'", conditions: []query.Condition{query.Condition{Tag: "tm.events.type", Op: query.OpEqual, Operand: "NewBlock"}}},
-		{s: "tx.gas > 7 AND tx.gas < 9", conditions: []query.Condition{query.Condition{Tag: "tx.gas", Op: query.OpGreater, Operand: int64(7)}, query.Condition{Tag: "tx.gas", Op: query.OpLess, Operand: int64(9)}}},
-		{s: "tx.time >= TIME 2013-05-03T14:45:00Z", conditions: []query.Condition{query.Condition{Tag: "tx.time", Op: query.OpGreaterEqual, Operand: txTime}}},
-	}
-
-	for _, tc := range testCases {
-		q, err := query.New(tc.s)
-		require.Nil(t, err)
-
-		assert.Equal(t, tc.conditions, q.Conditions())
-	}
-}