+11 -21

query/parse.go

Reviewed

··· 188 188 case tokLang: 189 189 expr = &Language{Language: text} 190 190 191 191 + case tokSym: 192 192 + if text == "" { 193 193 + return nil, 0, fmt.Errorf("the sym: atom must have an argument") 194 194 + } 195 195 + expr = &Symbol{&Substring{Pattern: text}} 196 196 + 191 197 case tokParenClose: 192 198 // Caller must consume paren. 193 199 expr = nil ··· 320 326 } 321 327 qs = newQS 322 328 for _, q := range qs { 323 323 - if sq, ok := q.(*Substring); ok { 324 324 - switch setCase { 325 325 - case "yes": 326 326 - sq.CaseSensitive = true 327 327 - case "no": 328 328 - sq.CaseSensitive = false 329 329 - case "auto": 330 330 - sq.CaseSensitive = (sq.Pattern != string(toLower([]byte(sq.Pattern)))) 331 331 - } 332 332 - } 333 333 - 334 334 - if sq, ok := q.(*Regexp); ok && setCase != "" { 335 335 - switch setCase { 336 336 - 337 337 - case "yes": 338 338 - sq.CaseSensitive = true 339 339 - case "no": 340 340 - sq.CaseSensitive = false 341 341 - case "auto": 342 342 - sq.CaseSensitive = (sq.Regexp.String() != LowerRegexp(sq.Regexp).String()) 343 343 - } 329 329 + if sc, ok := q.(setCaser); ok { 330 330 + sc.setCase(setCase) 344 331 } 345 332 } 346 333 return qs, len(in) - len(b), nil ··· 374 361 tokOr = 10 375 362 tokContent = 11 376 363 tokLang = 12 364 364 + tokSym = 13 377 365 ) 378 366 379 367 var tokNames = map[int]string{ ··· 389 377 tokRepo: "Repo", 390 378 tokText: "Text", 391 379 tokLang: "Language", 380 380 + tokSym: "Symbol", 392 381 } 393 382 394 383 var prefixes = map[string]int{ ··· 403 392 "regex:": tokRegex, 404 393 "repo:": tokRepo, 405 394 "lang:": tokLang, 395 395 + "sym:": tokSym, 406 396 } 407 397 408 398 var reservedWords = map[string]int{

+3

query/parse_test.go

Reviewed

··· 84 84 {"content:abc", &Substring{Pattern: "abc", Content: true}}, 85 85 86 86 {"lang:c++", &Language{"c++"}}, 87 87 + {"sym:pqr", &Symbol{&Substring{Pattern: "pqr"}}}, 88 88 + {"sym:Pqr", &Symbol{&Substring{Pattern: "Pqr", CaseSensitive: true}}}, 87 89 88 90 // case 89 91 {"abc case:yes", &Substring{Pattern: "abc", CaseSensitive: true}}, ··· 95 97 {"\"a\\", nil}, 96 98 {"case:foo", nil}, 97 99 100 100 + {"sym:", nil}, 98 101 {"abc or", nil}, 99 102 {"or abc", nil}, 100 103 {"def or or abc", nil},

+38 -3

query/query.go

Reviewed

··· 37 37 CaseSensitive bool 38 38 } 39 39 40 40 - // SymbolSubstring finds a substring that is a symbol. 41 41 - type SymbolSubstring struct { 42 42 - Atom Substring 40 40 + // Symbol finds a string that is a symbol. 41 41 + type Symbol struct { 42 42 + Atom *Substring 43 43 + } 44 44 + 45 45 + func (s *Symbol) String() string { 46 46 + return fmt.Sprintf("sym:%s", s.Atom) 43 47 } 44 48 45 49 func (q *Regexp) String() string { ··· 115 119 s = "case_" + s 116 120 } 117 121 return s 122 122 + } 123 123 + 124 124 + type setCaser interface { 125 125 + setCase(string) 126 126 + } 127 127 + 128 128 + func (q *Substring) setCase(k string) { 129 129 + switch k { 130 130 + case "yes": 131 131 + q.CaseSensitive = true 132 132 + case "no": 133 133 + q.CaseSensitive = false 134 134 + case "auto": 135 135 + // TODO - unicode 136 136 + q.CaseSensitive = (q.Pattern != string(toLower([]byte(q.Pattern)))) 137 137 + } 138 138 + } 139 139 + 140 140 + func (q *Symbol) setCase(k string) { 141 141 + q.Atom.setCase(k) 142 142 + } 143 143 + 144 144 + func (q *Regexp) setCase(k string) { 145 145 + switch k { 146 146 + case "yes": 147 147 + q.CaseSensitive = true 148 148 + case "no": 149 149 + q.CaseSensitive = false 150 150 + case "auto": 151 151 + q.CaseSensitive = (q.Regexp.String() != LowerRegexp(q.Regexp).String()) 152 152 + } 118 153 } 119 154 120 155 // Or is matched when any of its children is matched.