fork of https://github.com/sourcegraph/zoekt
Replace Repo with RepoRegex implementation (#213)
repo keyword now takes in regular expressions. This is a more powerful syntax to use.
An API only syntax.RepoRegex implementation existed, this aligns the syntax.Repo with it.
author
Yevhenii Huselietov
committer
GitHub
date
(Jan 10, 2022, 8:59 AM +0200)
commit
2195b41e
2195b41ec871cf0d88603ebaf519850eb91a23f6
parent
4a99786b
4a99786b9310db9bf37919b9e65401fd259ab34b
+84
-46
+4
-3
build/e2e_test.go
+4
-3
build/e2e_test.go
···
22
22
"os"
23
23
"path/filepath"
24
24
"reflect"
25
+
"regexp"
25
26
"runtime"
26
27
"strings"
27
28
"testing"
···
281
282
}
282
283
283
284
ctx := context.Background()
284
-
repos, err := ss.List(ctx, &query.Repo{Pattern: "repo"}, nil)
285
+
repos, err := ss.List(ctx, &query.Repo{Regexp: regexp.MustCompile("repo")}, nil)
285
286
if err != nil {
286
287
t.Fatalf("List: %v", err)
287
288
}
···
317
318
time.Sleep(100 * time.Millisecond)
318
319
319
320
ctx = context.Background()
320
-
if repos, err = ss.List(ctx, &query.Repo{Pattern: "repo"}, nil); err != nil {
321
+
if repos, err = ss.List(ctx, &query.Repo{Regexp: regexp.MustCompile("repo")}, nil); err != nil {
321
322
t.Fatalf("List: %v", err)
322
323
} else if len(repos.Repos) != 2 {
323
324
t.Errorf("List(repo): got %v, want 2 repos", repos.Repos)
···
333
334
time.Sleep(100 * time.Millisecond)
334
335
335
336
ctx = context.Background()
336
-
if repos, err = ss.List(ctx, &query.Repo{Pattern: "repo"}, nil); err != nil {
337
+
if repos, err = ss.List(ctx, &query.Repo{Regexp: regexp.MustCompile("repo")}, nil); err != nil {
337
338
t.Fatalf("List: %v", err)
338
339
} else if len(repos.Repos) != 1 {
339
340
var ss []string
+1
-1
eval.go
+1
-1
eval.go
···
67
67
switch r := q.(type) {
68
68
case *query.Repo:
69
69
return d.simplifyMultiRepo(q, func(repo *Repository) bool {
70
-
return strings.Contains(repo.Name, r.Pattern)
70
+
return r.Regexp.MatchString(repo.Name)
71
71
})
72
72
case *query.RepoRegexp:
73
73
return d.simplifyMultiRepo(q, func(repo *Repository) bool {
+34
-18
eval_test.go
+34
-18
eval_test.go
···
214
214
}
215
215
216
216
func TestSimplifyRepo(t *testing.T) {
217
-
d := compoundReposShard(t, "foo", "fool")
218
-
all := &query.Repo{"foo"}
219
-
some := &query.Repo{"fool"}
220
-
none := &query.Repo{"bar"}
221
-
222
-
got := d.simplify(all)
223
-
if d := cmp.Diff(&query.Const{Value: true}, got); d != "" {
224
-
t.Fatalf("-want, +got:\n%s", d)
225
-
}
226
-
227
-
got = d.simplify(some)
228
-
if d := cmp.Diff(some, got); d != "" {
229
-
t.Fatalf("-want, +got:\n%s", d)
217
+
re := func(pat string) *query.Repo {
218
+
t.Helper()
219
+
re, err := regexp.Compile(pat)
220
+
if err != nil {
221
+
t.Fatal(err)
222
+
}
223
+
return &query.Repo{
224
+
Regexp: re,
225
+
}
230
226
}
227
+
d := compoundReposShard(t, "foo", "fool")
228
+
cases := []struct {
229
+
name string
230
+
q query.Q
231
+
want query.Q
232
+
}{{
233
+
name: "all",
234
+
q: re("f.*"),
235
+
want: &query.Const{Value: true},
236
+
}, {
237
+
name: "some",
238
+
q: re("foo."),
239
+
want: re("foo."),
240
+
}, {
241
+
name: "none",
242
+
q: re("banana"),
243
+
want: &query.Const{Value: false},
244
+
}}
231
245
232
-
got = d.simplify(none)
233
-
if d := cmp.Diff(&query.Const{Value: false}, got); d != "" {
234
-
t.Fatalf("-want, +got:\n%s", d)
246
+
for _, tc := range cases {
247
+
got := d.simplify(tc.q)
248
+
if d := cmp.Diff(tc.want.String(), got.String()); d != "" {
249
+
t.Errorf("%s: -want, +got:\n%s", tc.name, d)
250
+
}
235
251
}
236
252
}
237
253
···
277
293
d := compoundReposShard(t, "foo", "bar")
278
294
279
295
some := &query.RepoBranches{Set: map[string][]string{"bar": {"branch1"}}}
280
-
none := &query.Repo{"banana"}
296
+
none := &query.Repo{Regexp: regexp.MustCompile("banana")}
281
297
282
298
got := d.simplify(some)
283
299
if d := cmp.Diff(some, got); d != "" {
···
298
314
{Branch: "branch1", Repos: roaring.BitmapOf(hash("bar"))},
299
315
},
300
316
}
301
-
none := &query.Repo{"banana"}
317
+
none := &query.Repo{Regexp: regexp.MustCompile("banana")}
302
318
303
319
got := d.simplify(some)
304
320
tr := cmp.Transformer("", func(b *roaring.Bitmap) []uint32 { return b.ToArray() })
+4
-3
gitindex/tree_test.go
+4
-3
gitindex/tree_test.go
···
24
24
"os/exec"
25
25
"path/filepath"
26
26
"reflect"
27
+
"regexp"
27
28
"sort"
28
29
"testing"
29
30
"time"
···
373
374
}
374
375
defer searcher.Close()
375
376
376
-
if rlist, err := searcher.List(context.Background(), &query.Repo{Pattern: ""}, nil); err != nil {
377
+
if rlist, err := searcher.List(context.Background(), &query.Repo{Regexp: regexp.MustCompile("repo")}, nil); err != nil {
377
378
t.Fatalf("List(): %v", err)
378
379
} else if len(rlist.Repos) != 1 {
379
380
t.Errorf("got %v, want 1 result", rlist.Repos)
···
468
469
}
469
470
defer searcher.Close()
470
471
471
-
if rlist, err := searcher.List(context.Background(), &query.Repo{Pattern: ""}, nil); err != nil {
472
+
if rlist, err := searcher.List(context.Background(), &query.Repo{Regexp: regexp.MustCompile("repo")}, nil); err != nil {
472
473
t.Fatalf("List(): %v", err)
473
474
} else if len(rlist.Repos) != 1 {
474
475
t.Errorf("got %v, want 1 result", rlist.Repos)
···
518
519
}
519
520
defer searcher.Close()
520
521
521
-
rlist, err := searcher.List(context.Background(), &query.Repo{Pattern: ""}, nil)
522
+
rlist, err := searcher.List(context.Background(), &query.Repo{Regexp: regexp.MustCompile("repo")}, nil)
522
523
if err != nil {
523
524
t.Fatalf("List(): %v", err)
524
525
}
+13
-12
index_test.go
+13
-12
index_test.go
···
20
20
"fmt"
21
21
"os"
22
22
"reflect"
23
+
"regexp"
23
24
"regexp/syntax"
24
25
"strings"
25
26
"testing"
···
153
154
t.Fatalf("Search: %v", err)
154
155
}
155
156
156
-
if _, err := searcher.List(context.Background(), &query.Repo{}, nil); err != nil {
157
+
if _, err := searcher.List(context.Background(), &query.Repo{Regexp: regexp.MustCompile("")}, nil); err != nil {
157
158
t.Fatalf("List: %v", err)
158
159
}
159
160
···
770
771
sres := searchForTest(t, b,
771
772
query.NewAnd(
772
773
&query.Substring{Pattern: "needle"},
773
-
&query.Repo{Pattern: "foo"},
774
+
&query.Repo{Regexp: regexp.MustCompile("foo")},
774
775
))
775
776
776
777
if len(sres.Files) != 0 {
···
784
785
sres = searchForTest(t, b,
785
786
query.NewAnd(
786
787
&query.Substring{Pattern: "needle"},
787
-
&query.Repo{Pattern: "bla"},
788
+
&query.Repo{Regexp: regexp.MustCompile("bla")},
788
789
))
789
790
if len(sres.Files) != 1 {
790
791
t.Fatalf("got %v, want 1 match", sres.Files)
···
1001
1002
sres := searchForTest(t, b,
1002
1003
query.NewAnd(
1003
1004
&query.Substring{Pattern: "needle"},
1004
-
&query.Not{Child: &query.Repo{Pattern: "bla"}},
1005
+
&query.Not{Child: &query.Repo{Regexp: regexp.MustCompile("bla")}},
1005
1006
))
1006
1007
1007
1008
if len(sres.Files) != 0 {
···
1031
1032
{Minimal: true},
1032
1033
} {
1033
1034
t.Run(fmt.Sprint(opts), func(t *testing.T) {
1034
-
q := &query.Repo{Pattern: "epo"}
1035
+
q := &query.Repo{Regexp: regexp.MustCompile("epo")}
1035
1036
1036
1037
res, err := searcher.List(context.Background(), q, opts)
1037
1038
if err != nil {
···
1072
1073
t.Fatalf("mismatch (-want +got):\n%s", diff)
1073
1074
}
1074
1075
1075
-
q = &query.Repo{Pattern: "bla"}
1076
+
q = &query.Repo{Regexp: regexp.MustCompile("bla")}
1076
1077
res, err = searcher.List(context.Background(), q, nil)
1077
1078
if err != nil {
1078
1079
t.Fatalf("List(%v): %v", q, err)
···
1099
1100
1100
1101
searcher := searcherForTest(t, b)
1101
1102
1102
-
q := &query.Repo{Pattern: "epo"}
1103
+
q := &query.Repo{Regexp: regexp.MustCompile("epo")}
1103
1104
res, err := searcher.List(context.Background(), q, &ListOptions{Minimal: true})
1104
1105
if err != nil {
1105
1106
t.Fatalf("List(%v): %v", q, err)
···
1127
1128
t.Fatalf("mismatch (-want +got):\n%s", diff)
1128
1129
}
1129
1130
1130
-
q = &query.Repo{Pattern: "bla"}
1131
+
q = &query.Repo{Regexp: regexp.MustCompile("bla")}
1131
1132
res, err = searcher.List(context.Background(), q, &ListOptions{Minimal: true})
1132
1133
if err != nil {
1133
1134
t.Fatalf("List(%v): %v", q, err)
···
1444
1445
if sres := searchForTest(t, b,
1445
1446
query.NewAnd(
1446
1447
&query.Substring{Pattern: "needle"},
1447
-
&query.Repo{Pattern: "reponame"},
1448
+
&query.Repo{Regexp: regexp.MustCompile("reponame")},
1448
1449
), SearchOptions{
1449
1450
EstimateDocCount: true,
1450
1451
}); sres.Stats.ShardFilesConsidered != 2 {
···
1453
1454
if sres := searchForTest(t, b,
1454
1455
query.NewAnd(
1455
1456
&query.Substring{Pattern: "needle"},
1456
-
&query.Repo{Pattern: "nomatch"},
1457
+
&query.Repo{Regexp: regexp.MustCompile("nomatch")},
1457
1458
), SearchOptions{
1458
1459
EstimateDocCount: true,
1459
1460
}); sres.Stats.ShardFilesConsidered != 0 {
···
1557
1558
t.Errorf("parse: %v", err)
1558
1559
}
1559
1560
finalQ := query.NewAnd(q,
1560
-
query.NewOr(query.NewAnd(&query.Repo{Pattern: "name"},
1561
+
query.NewOr(query.NewAnd(&query.Repo{Regexp: regexp.MustCompile("name")},
1561
1562
query.NewOr(&query.Branch{Pattern: "master"}))))
1562
1563
1563
1564
b := testIndexBuilder(t, &Repository{
···
1684
1685
1685
1686
q := query.NewAnd(
1686
1687
&query.Not{Child: &query.Substring{Pattern: "xyz"}},
1687
-
&query.Repo{Pattern: "reponame"})
1688
+
&query.Repo{Regexp: regexp.MustCompile("reponame")})
1688
1689
res := searchForTest(t, b, q)
1689
1690
if len(res.Files) != 2 {
1690
1691
t.Fatalf("got %v, want 2 results in f3", res.Files)
+1
-1
matchtree.go
+1
-1
matchtree.go
+2
-1
matchtree_test.go
+2
-1
matchtree_test.go
···
16
16
17
17
import (
18
18
"reflect"
19
+
"regexp"
19
20
"testing"
20
21
21
22
"github.com/RoaringBitmap/roaring"
···
256
257
fileBranchMasks: []uint64{1, 1, 1, 1, 1},
257
258
repos: []uint16{0, 0, 1, 0, 1},
258
259
}
259
-
mt, err := d.newMatchTree(&query.Repo{"ar"})
260
+
mt, err := d.newMatchTree(&query.Repo{Regexp: regexp.MustCompile("ar")})
260
261
if err != nil {
261
262
t.Fatal(err)
262
263
}
+8
-1
query/parse.go
+8
-1
query/parse.go
···
18
18
"bytes"
19
19
"fmt"
20
20
"log"
21
+
"regexp"
21
22
"regexp/syntax"
22
23
23
24
"github.com/go-enry/go-enry/v2"
···
117
118
}
118
119
expr = &caseQ{text}
119
120
case tokRepo:
120
-
expr = &Repo{Pattern: text}
121
+
r, err := regexp.Compile(text)
122
+
123
+
if err != nil {
124
+
return nil, 0, err
125
+
}
126
+
127
+
expr = &Repo{r}
121
128
case tokBranch:
122
129
expr = &Branch{Pattern: text}
123
130
case tokText, tokRegex:
+3
-1
query/parse_test.go
+3
-1
query/parse_test.go
···
17
17
import (
18
18
"log"
19
19
"reflect"
20
+
"regexp"
20
21
"regexp/syntax"
21
22
"testing"
22
23
)
···
73
74
{"regex:abc[p-q]", &Regexp{Regexp: mustParseRE("abc[p-q]")}},
74
75
{"aBc[p-q]", &Regexp{Regexp: mustParseRE("aBc[p-q]"), CaseSensitive: true}},
75
76
{"aBc[p-q] case:auto", &Regexp{Regexp: mustParseRE("aBc[p-q]"), CaseSensitive: true}},
76
-
{"repo:go", &Repo{"go"}},
77
+
{"repo:go", &Repo{regexp.MustCompile("go")}},
78
+
{"repo:.*", &Repo{Regexp: regexp.MustCompile(".*")}},
77
79
78
80
{"file:\"\"", &Const{true}},
79
81
{"abc.*def", &Regexp{Regexp: mustParseRE("abc.*def")}},
+2
-2
query/query.go
+2
-2
query/query.go
···
169
169
}
170
170
171
171
type Repo struct {
172
-
Pattern string
172
+
Regexp *regexp.Regexp
173
173
}
174
174
175
175
func (q *Repo) String() string {
176
-
return fmt.Sprintf("repo:%s", q.Pattern)
176
+
return fmt.Sprintf("repo:%s", q.Regexp.String())
177
177
}
178
178
179
179
// RepoRegexp is a Sourcegraph addition which searches documents where the
+2
-1
query/query_test.go
+2
-1
query/query_test.go
···
17
17
import (
18
18
"log"
19
19
"reflect"
20
+
"regexp"
20
21
"testing"
21
22
)
22
23
···
84
85
}
85
86
86
87
func TestMap(t *testing.T) {
87
-
in := NewAnd(&Substring{Pattern: "bla"}, &Not{&Repo{"foo"}})
88
+
in := NewAnd(&Substring{Pattern: "bla"}, &Not{&Repo{Regexp: regexp.MustCompile("foo")}})
88
89
out := NewAnd(&Substring{Pattern: "bla"}, &Not{&Const{false}})
89
90
90
91
f := func(q Q) Q {
+2
-1
shards/shards_test.go
+2
-1
shards/shards_test.go
···
23
23
"math"
24
24
"os"
25
25
"reflect"
26
+
"regexp"
26
27
"runtime"
27
28
"sort"
28
29
"strconv"
···
457
458
t.Run(tc.name, func(t *testing.T) {
458
459
t.Parallel()
459
460
460
-
q := &query.Repo{Pattern: "epo"}
461
+
q := &query.Repo{Regexp: regexp.MustCompile("repo")}
461
462
462
463
res, err := ss.List(context.Background(), q, tc.opts)
463
464
if err != nil {
+8
-1
web/server.go
+8
-1
web/server.go
···
550
550
if err != nil {
551
551
return err
552
552
}
553
+
554
+
repoRe, err := regexp.Compile("^"+regexp.QuoteMeta(repoStr)+"$")
555
+
556
+
if err != nil {
557
+
return err
558
+
}
559
+
553
560
qs := []query.Q{
554
561
&query.Regexp{Regexp: re, FileName: true, CaseSensitive: true},
555
-
&query.Repo{Pattern: repoStr},
562
+
&query.Repo{Regexp: repoRe},
556
563
}
557
564
558
565
if branchStr := qvals.Get("b"); branchStr != "" {