diff options
Diffstat (limited to 'query')
| -rw-r--r-- | query/lexer.go | 71 | ||||
| -rw-r--r-- | query/lexer_test.go | 45 | ||||
| -rw-r--r-- | query/parser.go | 99 | ||||
| -rw-r--r-- | query/parser_test.go | 97 | ||||
| -rw-r--r-- | query/query.go | 49 |
5 files changed, 361 insertions, 0 deletions
diff --git a/query/lexer.go b/query/lexer.go new file mode 100644 index 00000000..ec05f44e --- /dev/null +++ b/query/lexer.go @@ -0,0 +1,71 @@ +package query + +import ( + "fmt" + "strings" + "unicode" +) + +type token struct { + qualifier string + value string +} + +// TODO: this lexer implementation behave badly with unmatched quotes. +// A hand written one would be better instead of relying on strings.FieldsFunc() + +// tokenize parse and break a input into tokens ready to be +// interpreted later by a parser to get the semantic. +func tokenize(query string) ([]token, error) { + fields := splitQuery(query) + + var tokens []token + for _, field := range fields { + split := strings.Split(field, ":") + if len(split) != 2 { + return nil, fmt.Errorf("can't tokenize \"%s\"", field) + } + + if len(split[0]) == 0 { + return nil, fmt.Errorf("can't tokenize \"%s\": empty qualifier", field) + } + if len(split[1]) == 0 { + return nil, fmt.Errorf("empty value for qualifier \"%s\"", split[0]) + } + + tokens = append(tokens, token{ + qualifier: split[0], + value: removeQuote(split[1]), + }) + } + return tokens, nil +} + +func splitQuery(query string) []string { + lastQuote := rune(0) + f := func(c rune) bool { + switch { + case c == lastQuote: + lastQuote = rune(0) + return false + case lastQuote != rune(0): + return false + case unicode.In(c, unicode.Quotation_Mark): + lastQuote = c + return false + default: + return unicode.IsSpace(c) + } + } + + return strings.FieldsFunc(query, f) +} + +func removeQuote(field string) string { + if len(field) >= 2 { + if field[0] == '"' && field[len(field)-1] == '"' { + return field[1 : len(field)-1] + } + } + return field +} diff --git a/query/lexer_test.go b/query/lexer_test.go new file mode 100644 index 00000000..922e3fc9 --- /dev/null +++ b/query/lexer_test.go @@ -0,0 +1,45 @@ +package query + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestTokenize(t *testing.T) { + var tests = []struct { + input string + tokens []token + }{ + {"gibberish", nil}, + {"status:", nil}, + {":value", nil}, + + {"status:open", []token{{"status", "open"}}}, + {"status:closed", []token{{"status", "closed"}}}, + + {"author:rene", []token{{"author", "rene"}}}, + {`author:"René Descartes"`, []token{{"author", "René Descartes"}}}, + + { + `status:open status:closed author:rene author:"René Descartes"`, + []token{ + {"status", "open"}, + {"status", "closed"}, + {"author", "rene"}, + {"author", "René Descartes"}, + }, + }, + } + + for _, tc := range tests { + tokens, err := tokenize(tc.input) + if tc.tokens == nil { + assert.Error(t, err) + assert.Nil(t, tokens) + } else { + assert.NoError(t, err) + assert.Equal(t, tc.tokens, tokens) + } + } +} diff --git a/query/parser.go b/query/parser.go new file mode 100644 index 00000000..a379f750 --- /dev/null +++ b/query/parser.go @@ -0,0 +1,99 @@ +package query + +import ( + "fmt" + + "github.com/MichaelMure/git-bug/bug" +) + +// Parse parse a query DSL +// +// Ex: "status:open author:descartes sort:edit-asc" +// +// Supported filter qualifiers and syntax are described in docs/queries.md +func Parse(query string) (*Query, error) { + tokens, err := tokenize(query) + if err != nil { + return nil, err + } + + q := &Query{ + OrderBy: OrderByCreation, + OrderDirection: OrderDescending, + } + sortingDone := false + + for _, t := range tokens { + switch t.qualifier { + case "status", "state": + status, err := bug.StatusFromString(t.value) + if err != nil { + return nil, err + } + q.Status = append(q.Status, status) + case "author": + q.Author = append(q.Author, t.value) + case "actor": + q.Actor = append(q.Actor, t.value) + case "participant": + q.Participant = append(q.Participant, t.value) + case "label": + q.Label = append(q.Label, t.value) + case "title": + q.Title = append(q.Title, t.value) + case "no": + switch t.value { + case "label": + q.NoLabel = true + default: + return nil, fmt.Errorf("unknown \"no\" filter \"%s\"", t.value) + } + case "sort": + if sortingDone { + return nil, fmt.Errorf("multiple sorting") + } + err = parseSorting(q, t.value) + if err != nil { + return nil, err + } + sortingDone = true + + default: + return nil, fmt.Errorf("unknown qualifier \"%s\"", t.qualifier) + } + } + return q, nil +} + +func parseSorting(q *Query, value string) error { + switch value { + // default ASC + case "id-desc": + q.OrderBy = OrderById + q.OrderDirection = OrderDescending + case "id", "id-asc": + q.OrderBy = OrderById + q.OrderDirection = OrderAscending + + // default DESC + case "creation", "creation-desc": + q.OrderBy = OrderByCreation + q.OrderDirection = OrderDescending + case "creation-asc": + q.OrderBy = OrderByCreation + q.OrderDirection = OrderAscending + + // default DESC + case "edit", "edit-desc": + q.OrderBy = OrderByEdit + q.OrderDirection = OrderDescending + case "edit-asc": + q.OrderBy = OrderByEdit + q.OrderDirection = OrderAscending + + default: + return fmt.Errorf("unknown sorting %s", value) + } + + return nil +} diff --git a/query/parser_test.go b/query/parser_test.go new file mode 100644 index 00000000..6a509adb --- /dev/null +++ b/query/parser_test.go @@ -0,0 +1,97 @@ +package query + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/MichaelMure/git-bug/bug" +) + +func TestParse(t *testing.T) { + var tests = []struct { + input string + output *Query + }{ + {"gibberish", nil}, + {"status:", nil}, + {":value", nil}, + + {"status:open", &Query{ + Filters: Filters{Status: []bug.Status{bug.OpenStatus}}, + }}, + {"status:closed", &Query{ + Filters: Filters{Status: []bug.Status{bug.ClosedStatus}}, + }}, + {"status:unknown", nil}, + + {"author:rene", &Query{ + Filters: Filters{Author: []string{"rene"}}, + }}, + {`author:"René Descartes"`, &Query{ + Filters: Filters{Author: []string{"René Descartes"}}, + }}, + + {"actor:bernhard", &Query{ + Filters: Filters{Actor: []string{"bernhard"}}, + }}, + {"participant:leonhard", &Query{ + Filters: Filters{Participant: []string{"leonhard"}}, + }}, + + {"label:hello", &Query{ + Filters: Filters{Label: []string{"hello"}}, + }}, + {`label:"Good first issue"`, &Query{ + Filters: Filters{Label: []string{"Good first issue"}}, + }}, + + {"title:titleOne", &Query{ + Filters: Filters{Title: []string{"titleOne"}}, + }}, + {`title:"Bug titleTwo"`, &Query{ + Filters: Filters{Title: []string{"Bug titleTwo"}}, + }}, + + {"no:label", &Query{ + Filters: Filters{NoLabel: true}, + }}, + + {"sort:edit", &Query{ + OrderBy: OrderByEdit, + }}, + {"sort:unknown", nil}, + + {`status:open author:"René Descartes" participant:leonhard label:hello label:"Good first issue" sort:edit-desc`, + &Query{ + Filters: Filters{ + Status: []bug.Status{bug.OpenStatus}, + Author: []string{"René Descartes"}, + Participant: []string{"leonhard"}, + Label: []string{"hello", "Good first issue"}, + }, + OrderBy: OrderByEdit, + OrderDirection: OrderDescending, + }, + }, + } + + for _, tc := range tests { + t.Run(tc.input, func(t *testing.T) { + query, err := Parse(tc.input) + if tc.output == nil { + assert.Error(t, err) + assert.Nil(t, query) + } else { + assert.NoError(t, err) + if tc.output.OrderBy != 0 { + assert.Equal(t, tc.output.OrderBy, query.OrderBy) + } + if tc.output.OrderDirection != 0 { + assert.Equal(t, tc.output.OrderDirection, query.OrderDirection) + } + assert.Equal(t, tc.output.Filters, query.Filters) + } + }) + } +} diff --git a/query/query.go b/query/query.go new file mode 100644 index 00000000..a499ad38 --- /dev/null +++ b/query/query.go @@ -0,0 +1,49 @@ +package query + +import "github.com/MichaelMure/git-bug/bug" + +// Query is the intermediary representation of a Bug's query. It is either +// produced by parsing a query string (ex: "status:open author:rene") or created +// manually. This query doesn't do anything by itself and need to be interpreted +// for the specific domain of application. +type Query struct { + Filters + OrderBy + OrderDirection +} + +// NewQuery return an identity query with the default sorting (creation-desc). +func NewQuery() *Query { + return &Query{ + OrderBy: OrderByCreation, + OrderDirection: OrderDescending, + } +} + +// Filters is a collection of Filter that implement a complex filter +type Filters struct { + Status []bug.Status + Author []string + Actor []string + Participant []string + Label []string + Title []string + NoLabel bool +} + +type OrderBy int + +const ( + _ OrderBy = iota + OrderById + OrderByCreation + OrderByEdit +) + +type OrderDirection int + +const ( + _ OrderDirection = iota + OrderAscending + OrderDescending +) |