Implement tag-based filters for issues and pulls #1065

+7

appview/indexer/bleve/query.go

··· 13 13 return q 14 14 } 15 15 16 16 + func MatchPhraseQuery(field, phrase, analyzer string) query.Query { 17 17 + q := bleve.NewMatchPhraseQuery(phrase) 18 18 + q.FieldVal = field 19 19 + q.Analyzer = analyzer 20 20 + return q 21 21 + } 22 22 + 16 23 func BoolFieldQuery(field string, val bool) query.Query { 17 24 q := bleve.NewBoolFieldQuery(val) 18 25 q.FieldVal = field

+83 -25

appview/indexer/issues/indexer.go

··· 29 29 issueIndexerDocType = "issueIndexerDocType" 30 30 31 31 unicodeNormalizeName = "uicodeNormalize" 32 32 + 33 33 + // Bump this when the index mapping changes to trigger a rebuild. 34 34 + issueIndexerVersion = 2 32 35 ) 33 36 34 37 type Indexer struct { ··· 84 87 85 88 docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping) 86 89 docMapping.AddFieldMappingsAt("is_open", boolFieldMapping) 90 90 + docMapping.AddFieldMappingsAt("author_did", keywordFieldMapping) 91 91 + docMapping.AddFieldMappingsAt("labels", keywordFieldMapping) 87 92 88 93 err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{ 89 94 "type": unicodenorm.Name, ··· 116 121 return false, errors.New("indexer is already initialized") 117 122 } 118 123 119 119 - indexer, err := openIndexer(ctx, ix.path) 124 124 + indexer, err := openIndexer(ctx, ix.path, issueIndexerVersion) 120 125 if err != nil { 121 126 return false, err 122 127 } ··· 133 138 if err != nil { 134 139 return false, err 135 140 } 141 141 + indexer.SetInternal([]byte("mapping_version"), []byte{byte(issueIndexerVersion)}) 136 142 137 143 ix.indexer = indexer 138 144 139 145 return false, nil 140 146 } 141 147 142 142 - func openIndexer(ctx context.Context, path string) (bleve.Index, error) { 148 148 + func openIndexer(ctx context.Context, path string, version int) (bleve.Index, error) { 143 149 l := tlog.FromContext(ctx) 144 150 indexer, err := bleve.Open(path) 145 151 if err != nil { ··· 149 155 } 150 156 return nil, nil 151 157 } 158 158 + 159 159 + storedVersion, _ := indexer.GetInternal([]byte("mapping_version")) 160 160 + if storedVersion == nil || int(storedVersion[0]) != version { 161 161 + l.Info("Indexer mapping version changed, deleting and rebuilding") 162 162 + indexer.Close() 163 163 + return nil, os.RemoveAll(path) 164 164 + } 165 165 + 152 166 return indexer, nil 153 167 } 154 168 ··· 168 182 return err 169 183 } 170 184 171 171 - // issueData data stored and will be indexed 172 185 type issueData struct { 173 173 - ID int64 `json:"id"` 174 174 - RepoAt string `json:"repo_at"` 175 175 - IssueID int `json:"issue_id"` 176 176 - Title string `json:"title"` 177 177 - Body string `json:"body"` 186 186 + ID int64 `json:"id"` 187 187 + RepoAt string `json:"repo_at"` 188 188 + IssueID int `json:"issue_id"` 189 189 + Title string `json:"title"` 190 190 + Body string `json:"body"` 191 191 + IsOpen bool `json:"is_open"` 192 192 + AuthorDid string `json:"author_did"` 193 193 + Labels []string `json:"labels"` 178 194 179 179 - IsOpen bool `json:"is_open"` 180 195 Comments []IssueCommentData `json:"comments"` 181 196 } 182 197 183 198 func makeIssueData(issue *models.Issue) *issueData { 184 199 return &issueData{ 185 185 - ID: issue.Id, 186 186 - RepoAt: issue.RepoAt.String(), 187 187 - IssueID: issue.IssueId, 188 188 - Title: issue.Title, 189 189 - Body: issue.Body, 190 190 - IsOpen: issue.Open, 200 200 + ID: issue.Id, 201 201 + RepoAt: issue.RepoAt.String(), 202 202 + IssueID: issue.IssueId, 203 203 + Title: issue.Title, 204 204 + Body: issue.Body, 205 205 + IsOpen: issue.Open, 206 206 + AuthorDid: issue.Did, 207 207 + Labels: issue.Labels.LabelNames(), 191 208 } 192 209 } 193 210 ··· 222 239 return ix.indexer.Delete(base36.Encode(issueId)) 223 240 } 224 241 225 225 - // Search searches for issues 226 242 func (ix *Indexer) Search(ctx context.Context, opts models.IssueSearchOptions) (*SearchResult, error) { 227 227 - var queries []query.Query 243 243 + var musts []query.Query 244 244 + var mustNots []query.Query 228 245 229 229 - if opts.Keyword != "" { 230 230 - queries = append(queries, bleve.NewDisjunctionQuery( 231 231 - bleveutil.MatchAndQuery("title", opts.Keyword, issueIndexerAnalyzer, 0), 232 232 - bleveutil.MatchAndQuery("body", opts.Keyword, issueIndexerAnalyzer, 0), 246 246 + for _, keyword := range opts.Keywords { 247 247 + musts = append(musts, bleve.NewDisjunctionQuery( 248 248 + bleveutil.MatchAndQuery("title", keyword, issueIndexerAnalyzer, 0), 249 249 + bleveutil.MatchAndQuery("body", keyword, issueIndexerAnalyzer, 0), 250 250 + )) 251 251 + } 252 252 + 253 253 + for _, phrase := range opts.Phrases { 254 254 + musts = append(musts, bleve.NewDisjunctionQuery( 255 255 + bleveutil.MatchPhraseQuery("title", phrase, issueIndexerAnalyzer), 256 256 + bleveutil.MatchPhraseQuery("body", phrase, issueIndexerAnalyzer), 257 257 + )) 258 258 + } 259 259 + 260 260 + for _, keyword := range opts.NegatedKeywords { 261 261 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 262 262 + bleveutil.MatchAndQuery("title", keyword, issueIndexerAnalyzer, 0), 263 263 + bleveutil.MatchAndQuery("body", keyword, issueIndexerAnalyzer, 0), 233 264 )) 234 265 } 235 235 - queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 236 236 - queries = append(queries, bleveutil.BoolFieldQuery("is_open", opts.IsOpen)) 237 237 - // TODO: append more queries 238 266 239 239 - var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...) 267 267 + for _, phrase := range opts.NegatedPhrases { 268 268 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 269 269 + bleveutil.MatchPhraseQuery("title", phrase, issueIndexerAnalyzer), 270 270 + bleveutil.MatchPhraseQuery("body", phrase, issueIndexerAnalyzer), 271 271 + )) 272 272 + } 273 273 + 274 274 + musts = append(musts, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 275 275 + if opts.IsOpen != nil { 276 276 + musts = append(musts, bleveutil.BoolFieldQuery("is_open", *opts.IsOpen)) 277 277 + } 278 278 + 279 279 + if opts.AuthorDid != "" { 280 280 + musts = append(musts, bleveutil.KeywordFieldQuery("author_did", opts.AuthorDid)) 281 281 + } 282 282 + 283 283 + for _, label := range opts.Labels { 284 284 + musts = append(musts, bleveutil.KeywordFieldQuery("labels", label)) 285 285 + } 286 286 + 287 287 + if opts.NegatedAuthorDid != "" { 288 288 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("author_did", opts.NegatedAuthorDid)) 289 289 + } 290 290 + 291 291 + for _, label := range opts.NegatedLabels { 292 292 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("labels", label)) 293 293 + } 294 294 + 295 295 + indexerQuery := bleve.NewBooleanQuery() 296 296 + indexerQuery.AddMust(musts...) 297 297 + indexerQuery.AddMustNot(mustNots...) 240 298 searchReq := bleve.NewSearchRequestOptions(indexerQuery, opts.Page.Limit, opts.Page.Offset, false) 241 299 res, err := ix.indexer.SearchInContext(ctx, searchReq) 242 300 if err != nil {

+264

appview/indexer/issues/indexer_test.go

··· 1 1 + package issues_indexer 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "os" 6 6 + "testing" 7 7 + 8 8 + "github.com/blevesearch/bleve/v2" 9 9 + "github.com/stretchr/testify/assert" 10 10 + "github.com/stretchr/testify/require" 11 11 + "tangled.org/core/appview/models" 12 12 + "tangled.org/core/appview/pagination" 13 13 + "tangled.org/core/appview/searchquery" 14 14 + ) 15 15 + 16 16 + func setupTestIndexer(t *testing.T) (*Indexer, func()) { 17 17 + t.Helper() 18 18 + 19 19 + tmpDir, err := os.MkdirTemp("", "issue_indexer_test") 20 20 + require.NoError(t, err) 21 21 + 22 22 + ix := NewIndexer(tmpDir) 23 23 + 24 24 + mapping, err := generateIssueIndexMapping() 25 25 + require.NoError(t, err) 26 26 + 27 27 + indexer, err := bleve.New(tmpDir, mapping) 28 28 + require.NoError(t, err) 29 29 + ix.indexer = indexer 30 30 + 31 31 + cleanup := func() { 32 32 + ix.indexer.Close() 33 33 + os.RemoveAll(tmpDir) 34 34 + } 35 35 + 36 36 + return ix, cleanup 37 37 + } 38 38 + 39 39 + func boolPtr(b bool) *bool { return &b } 40 40 + 41 41 + func makeLabelState(labels ...string) models.LabelState { 42 42 + state := models.NewLabelState() 43 43 + for _, label := range labels { 44 44 + state.Inner()[label] = make(map[string]struct{}) 45 45 + state.SetName(label, label) 46 46 + } 47 47 + return state 48 48 + } 49 49 + 50 50 + func TestSearchFilters(t *testing.T) { 51 51 + ix, cleanup := setupTestIndexer(t) 52 52 + defer cleanup() 53 53 + 54 54 + ctx := context.Background() 55 55 + 56 56 + err := ix.Index(ctx, 57 57 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 58 58 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob", Labels: makeLabelState("feature")}, 59 59 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login timeout", Body: "Login takes too long", Open: false, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 60 60 + ) 61 61 + require.NoError(t, err) 62 62 + 63 63 + opts := func() models.IssueSearchOptions { 64 64 + return models.IssueSearchOptions{ 65 65 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 66 66 + IsOpen: boolPtr(true), 67 67 + Page: pagination.Page{Limit: 10}, 68 68 + } 69 69 + } 70 70 + 71 71 + // Keyword in title 72 72 + o := opts() 73 73 + o.Keywords = []string{"bug"} 74 74 + result, err := ix.Search(ctx, o) 75 75 + require.NoError(t, err) 76 76 + assert.Equal(t, uint64(1), result.Total) 77 77 + assert.Contains(t, result.Hits, int64(1)) 78 78 + 79 79 + // Keyword in body 80 80 + o = opts() 81 81 + o.Keywords = []string{"theme"} 82 82 + result, err = ix.Search(ctx, o) 83 83 + require.NoError(t, err) 84 84 + assert.Equal(t, uint64(1), result.Total) 85 85 + assert.Contains(t, result.Hits, int64(2)) 86 86 + 87 87 + // Phrase match 88 88 + o = opts() 89 89 + o.Phrases = []string{"login bug"} 90 90 + result, err = ix.Search(ctx, o) 91 91 + require.NoError(t, err) 92 92 + assert.Equal(t, uint64(1), result.Total) 93 93 + assert.Contains(t, result.Hits, int64(1)) 94 94 + 95 95 + // Author filter 96 96 + o = opts() 97 97 + o.AuthorDid = "did:plc:alice" 98 98 + result, err = ix.Search(ctx, o) 99 99 + require.NoError(t, err) 100 100 + assert.Equal(t, uint64(1), result.Total) 101 101 + assert.Contains(t, result.Hits, int64(1)) 102 102 + 103 103 + // Label filter 104 104 + o = opts() 105 105 + o.Labels = []string{"bug"} 106 106 + result, err = ix.Search(ctx, o) 107 107 + require.NoError(t, err) 108 108 + assert.Equal(t, uint64(1), result.Total) 109 109 + assert.Contains(t, result.Hits, int64(1)) 110 110 + 111 111 + // State filter (closed) 112 112 + o = opts() 113 113 + o.IsOpen = boolPtr(false) 114 114 + o.Labels = []string{"bug"} 115 115 + result, err = ix.Search(ctx, o) 116 116 + require.NoError(t, err) 117 117 + assert.Equal(t, uint64(1), result.Total) 118 118 + assert.Contains(t, result.Hits, int64(3)) 119 119 + 120 120 + // Combined: keyword + author + label 121 121 + o = opts() 122 122 + o.Keywords = []string{"login"} 123 123 + o.AuthorDid = "did:plc:alice" 124 124 + o.Labels = []string{"bug"} 125 125 + result, err = ix.Search(ctx, o) 126 126 + require.NoError(t, err) 127 127 + assert.Equal(t, uint64(1), result.Total) 128 128 + assert.Contains(t, result.Hits, int64(1)) 129 129 + } 130 130 + 131 131 + func TestSearchLabelAND(t *testing.T) { 132 132 + ix, cleanup := setupTestIndexer(t) 133 133 + defer cleanup() 134 134 + 135 135 + ctx := context.Background() 136 136 + 137 137 + err := ix.Index(ctx, 138 138 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue 1", Body: "Body", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 139 139 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue 2", Body: "Body", Open: true, Did: "did:plc:bob", Labels: makeLabelState("bug", "urgent")}, 140 140 + ) 141 141 + require.NoError(t, err) 142 142 + 143 143 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 144 144 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 145 145 + IsOpen: boolPtr(true), 146 146 + Labels: []string{"bug", "urgent"}, 147 147 + Page: pagination.Page{Limit: 10}, 148 148 + }) 149 149 + require.NoError(t, err) 150 150 + assert.Equal(t, uint64(1), result.Total) 151 151 + assert.Contains(t, result.Hits, int64(2)) 152 152 + } 153 153 + 154 154 + func TestSearchNegation(t *testing.T) { 155 155 + ix, cleanup := setupTestIndexer(t) 156 156 + defer cleanup() 157 157 + 158 158 + ctx := context.Background() 159 159 + 160 160 + err := ix.Index(ctx, 161 161 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 162 162 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob", Labels: makeLabelState("feature")}, 163 163 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix timeout bug", Body: "Timeout on save", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug", "urgent")}, 164 164 + ) 165 165 + require.NoError(t, err) 166 166 + 167 167 + opts := func() models.IssueSearchOptions { 168 168 + return models.IssueSearchOptions{ 169 169 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 170 170 + IsOpen: boolPtr(true), 171 171 + Page: pagination.Page{Limit: 10}, 172 172 + } 173 173 + } 174 174 + 175 175 + // Negated label: exclude "bug", should only return issue 2 176 176 + o := opts() 177 177 + o.NegatedLabels = []string{"bug"} 178 178 + result, err := ix.Search(ctx, o) 179 179 + require.NoError(t, err) 180 180 + assert.Equal(t, uint64(1), result.Total) 181 181 + assert.Contains(t, result.Hits, int64(2)) 182 182 + 183 183 + // Negated keyword: exclude "login", should return issues 2 and 3 184 184 + o = opts() 185 185 + o.NegatedKeywords = []string{"login"} 186 186 + result, err = ix.Search(ctx, o) 187 187 + require.NoError(t, err) 188 188 + assert.Equal(t, uint64(2), result.Total) 189 189 + assert.Contains(t, result.Hits, int64(2)) 190 190 + assert.Contains(t, result.Hits, int64(3)) 191 191 + 192 192 + // Positive label + negated label: bug but not urgent 193 193 + o = opts() 194 194 + o.Labels = []string{"bug"} 195 195 + o.NegatedLabels = []string{"urgent"} 196 196 + result, err = ix.Search(ctx, o) 197 197 + require.NoError(t, err) 198 198 + assert.Equal(t, uint64(1), result.Total) 199 199 + assert.Contains(t, result.Hits, int64(1)) 200 200 + 201 201 + // Negated phrase 202 202 + o = opts() 203 203 + o.NegatedPhrases = []string{"dark theme"} 204 204 + result, err = ix.Search(ctx, o) 205 205 + require.NoError(t, err) 206 206 + assert.Equal(t, uint64(2), result.Total) 207 207 + assert.NotContains(t, result.Hits, int64(2)) 208 208 + } 209 209 + 210 210 + func TestSearchNegatedPhraseParsed(t *testing.T) { 211 211 + ix, cleanup := setupTestIndexer(t) 212 212 + defer cleanup() 213 213 + 214 214 + ctx := context.Background() 215 215 + 216 216 + err := ix.Index(ctx, 217 217 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice"}, 218 218 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob"}, 219 219 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix timeout bug", Body: "Timeout on save", Open: true, Did: "did:plc:alice"}, 220 220 + ) 221 221 + require.NoError(t, err) 222 222 + 223 223 + // Parse a query with a negated quoted phrase, as the handler would 224 224 + query := searchquery.Parse(`-"dark theme"`) 225 225 + var negatedPhrases []string 226 226 + for _, item := range query.Items() { 227 227 + if item.Kind == searchquery.KindQuoted && item.Negated { 228 228 + negatedPhrases = append(negatedPhrases, item.Value) 229 229 + } 230 230 + } 231 231 + require.Equal(t, []string{"dark theme"}, negatedPhrases) 232 232 + 233 233 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 234 234 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 235 235 + IsOpen: boolPtr(true), 236 236 + NegatedPhrases: negatedPhrases, 237 237 + Page: pagination.Page{Limit: 10}, 238 238 + }) 239 239 + require.NoError(t, err) 240 240 + assert.Equal(t, uint64(2), result.Total) 241 241 + assert.NotContains(t, result.Hits, int64(2)) 242 242 + } 243 243 + 244 244 + func TestSearchNoResults(t *testing.T) { 245 245 + ix, cleanup := setupTestIndexer(t) 246 246 + defer cleanup() 247 247 + 248 248 + ctx := context.Background() 249 249 + 250 250 + err := ix.Index(ctx, 251 251 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue", Body: "Body", Open: true, Did: "did:plc:alice"}, 252 252 + ) 253 253 + require.NoError(t, err) 254 254 + 255 255 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 256 256 + Keywords: []string{"nonexistent"}, 257 257 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 258 258 + IsOpen: boolPtr(true), 259 259 + Page: pagination.Page{Limit: 10}, 260 260 + }) 261 261 + require.NoError(t, err) 262 262 + assert.Equal(t, uint64(0), result.Total) 263 263 + assert.Empty(t, result.Hits) 264 264 + }

+18

appview/indexer/notifier.go

··· 38 38 } 39 39 } 40 40 41 41 + func (ix *Indexer) NewIssueLabelOp(ctx context.Context, issue *models.Issue) { 42 42 + l := log.FromContext(ctx).With("notifier", "indexer", "issue", issue) 43 43 + l.Debug("reindexing issue after label change") 44 44 + err := ix.Issues.Index(ctx, *issue) 45 45 + if err != nil { 46 46 + l.Error("failed to index an issue", "err", err) 47 47 + } 48 48 + } 49 49 + 50 50 + func (ix *Indexer) NewPullLabelOp(ctx context.Context, pull *models.Pull) { 51 51 + l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull) 52 52 + l.Debug("reindexing pull after label change") 53 53 + err := ix.Pulls.Index(ctx, pull) 54 54 + if err != nil { 55 55 + l.Error("failed to index a pr", "err", err) 56 56 + } 57 57 + } 58 58 + 41 59 func (ix *Indexer) NewPull(ctx context.Context, pull *models.Pull) { 42 60 l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull) 43 61 l.Debug("indexing new pr")

+83 -24

appview/indexer/pulls/indexer.go

··· 28 28 pullIndexerDocType = "pullIndexerDocType" 29 29 30 30 unicodeNormalizeName = "uicodeNormalize" 31 31 + 32 32 + // Bump this when the index mapping changes to trigger a rebuild. 33 33 + pullIndexerVersion = 2 31 34 ) 32 35 33 36 type Indexer struct { ··· 79 82 80 83 docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping) 81 84 docMapping.AddFieldMappingsAt("state", keywordFieldMapping) 85 85 + docMapping.AddFieldMappingsAt("author_did", keywordFieldMapping) 86 86 + docMapping.AddFieldMappingsAt("labels", keywordFieldMapping) 82 87 83 88 err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{ 84 89 "type": unicodenorm.Name, ··· 111 116 return false, errors.New("indexer is already initialized") 112 117 } 113 118 114 114 - indexer, err := openIndexer(ctx, ix.path) 119 119 + indexer, err := openIndexer(ctx, ix.path, pullIndexerVersion) 115 120 if err != nil { 116 121 return false, err 117 122 } ··· 128 133 if err != nil { 129 134 return false, err 130 135 } 136 136 + indexer.SetInternal([]byte("mapping_version"), []byte{byte(pullIndexerVersion)}) 131 137 132 138 ix.indexer = indexer 133 139 134 140 return false, nil 135 141 } 136 142 137 137 - func openIndexer(ctx context.Context, path string) (bleve.Index, error) { 143 143 + func openIndexer(ctx context.Context, path string, version int) (bleve.Index, error) { 138 144 l := tlog.FromContext(ctx) 139 145 indexer, err := bleve.Open(path) 140 146 if err != nil { ··· 144 150 } 145 151 return nil, nil 146 152 } 153 153 + 154 154 + storedVersion, _ := indexer.GetInternal([]byte("mapping_version")) 155 155 + if storedVersion == nil || int(storedVersion[0]) != version { 156 156 + l.Info("Indexer mapping version changed, deleting and rebuilding") 157 157 + indexer.Close() 158 158 + return nil, os.RemoveAll(path) 159 159 + } 160 160 + 147 161 return indexer, nil 148 162 } 149 163 ··· 163 177 return err 164 178 } 165 179 166 166 - // pullData data stored and will be indexed 167 180 type pullData struct { 168 168 - ID int64 `json:"id"` 169 169 - RepoAt string `json:"repo_at"` 170 170 - PullID int `json:"pull_id"` 171 171 - Title string `json:"title"` 172 172 - Body string `json:"body"` 173 173 - State string `json:"state"` 181 181 + ID int64 `json:"id"` 182 182 + RepoAt string `json:"repo_at"` 183 183 + PullID int `json:"pull_id"` 184 184 + Title string `json:"title"` 185 185 + Body string `json:"body"` 186 186 + State string `json:"state"` 187 187 + AuthorDid string `json:"author_did"` 188 188 + Labels []string `json:"labels"` 174 189 175 190 Comments []pullCommentData `json:"comments"` 176 191 } 177 192 178 193 func makePullData(pull *models.Pull) *pullData { 179 194 return &pullData{ 180 180 - ID: int64(pull.ID), 181 181 - RepoAt: pull.RepoAt.String(), 182 182 - PullID: pull.PullId, 183 183 - Title: pull.Title, 184 184 - Body: pull.Body, 185 185 - State: pull.State.String(), 195 195 + ID: int64(pull.ID), 196 196 + RepoAt: pull.RepoAt.String(), 197 197 + PullID: pull.PullId, 198 198 + Title: pull.Title, 199 199 + Body: pull.Body, 200 200 + State: pull.State.String(), 201 201 + AuthorDid: pull.OwnerDid, 202 202 + Labels: pull.Labels.LabelNames(), 186 203 } 187 204 } 188 205 ··· 217 234 return ix.indexer.Delete(base36.Encode(pullID)) 218 235 } 219 236 220 220 - // Search searches for pulls 221 237 func (ix *Indexer) Search(ctx context.Context, opts models.PullSearchOptions) (*searchResult, error) { 222 222 - var queries []query.Query 238 238 + var musts []query.Query 239 239 + var mustNots []query.Query 223 240 224 241 // TODO(boltless): remove this after implementing pulls page pagination 225 242 limit := opts.Page.Limit ··· 227 244 limit = 500 228 245 } 229 246 230 230 - if opts.Keyword != "" { 231 231 - queries = append(queries, bleve.NewDisjunctionQuery( 232 232 - bleveutil.MatchAndQuery("title", opts.Keyword, pullIndexerAnalyzer, 0), 233 233 - bleveutil.MatchAndQuery("body", opts.Keyword, pullIndexerAnalyzer, 0), 247 247 + for _, keyword := range opts.Keywords { 248 248 + musts = append(musts, bleve.NewDisjunctionQuery( 249 249 + bleveutil.MatchAndQuery("title", keyword, pullIndexerAnalyzer, 0), 250 250 + bleveutil.MatchAndQuery("body", keyword, pullIndexerAnalyzer, 0), 251 251 + )) 252 252 + } 253 253 + 254 254 + for _, phrase := range opts.Phrases { 255 255 + musts = append(musts, bleve.NewDisjunctionQuery( 256 256 + bleveutil.MatchPhraseQuery("title", phrase, pullIndexerAnalyzer), 257 257 + bleveutil.MatchPhraseQuery("body", phrase, pullIndexerAnalyzer), 258 258 + )) 259 259 + } 260 260 + 261 261 + for _, keyword := range opts.NegatedKeywords { 262 262 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 263 263 + bleveutil.MatchAndQuery("title", keyword, pullIndexerAnalyzer, 0), 264 264 + bleveutil.MatchAndQuery("body", keyword, pullIndexerAnalyzer, 0), 265 265 + )) 266 266 + } 267 267 + 268 268 + for _, phrase := range opts.NegatedPhrases { 269 269 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 270 270 + bleveutil.MatchPhraseQuery("title", phrase, pullIndexerAnalyzer), 271 271 + bleveutil.MatchPhraseQuery("body", phrase, pullIndexerAnalyzer), 234 272 )) 235 273 } 236 236 - queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 237 237 - queries = append(queries, bleveutil.KeywordFieldQuery("state", opts.State.String())) 274 274 + 275 275 + musts = append(musts, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 276 276 + if opts.State != nil { 277 277 + musts = append(musts, bleveutil.KeywordFieldQuery("state", opts.State.String())) 278 278 + } 279 279 + 280 280 + if opts.AuthorDid != "" { 281 281 + musts = append(musts, bleveutil.KeywordFieldQuery("author_did", opts.AuthorDid)) 282 282 + } 238 283 239 239 - var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...) 284 284 + for _, label := range opts.Labels { 285 285 + musts = append(musts, bleveutil.KeywordFieldQuery("labels", label)) 286 286 + } 287 287 + 288 288 + if opts.NegatedAuthorDid != "" { 289 289 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("author_did", opts.NegatedAuthorDid)) 290 290 + } 291 291 + 292 292 + for _, label := range opts.NegatedLabels { 293 293 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("labels", label)) 294 294 + } 295 295 + 296 296 + indexerQuery := bleve.NewBooleanQuery() 297 297 + indexerQuery.AddMust(musts...) 298 298 + indexerQuery.AddMustNot(mustNots...) 240 299 searchReq := bleve.NewSearchRequestOptions(indexerQuery, limit, opts.Page.Offset, false) 241 300 res, err := ix.indexer.SearchInContext(ctx, searchReq) 242 301 if err != nil {

+135 -56

appview/issues/issues.go

··· 27 27 "tangled.org/core/appview/pages/repoinfo" 28 28 "tangled.org/core/appview/pagination" 29 29 "tangled.org/core/appview/reporesolver" 30 30 + "tangled.org/core/appview/searchquery" 30 31 "tangled.org/core/appview/validator" 31 32 "tangled.org/core/idresolver" 32 33 "tangled.org/core/orm" ··· 793 794 l := rp.logger.With("handler", "RepoIssues") 794 795 795 796 params := r.URL.Query() 796 796 - state := params.Get("state") 797 797 - isOpen := true 798 798 - switch state { 799 799 - case "open": 800 800 - isOpen = true 801 801 - case "closed": 802 802 - isOpen = false 803 803 - default: 804 804 - isOpen = true 805 805 - } 806 806 - 807 797 page := pagination.FromContext(r.Context()) 808 798 809 799 user := rp.oauth.GetMultiAccountUser(r) ··· 813 803 return 814 804 } 815 805 806 806 + query := searchquery.Parse(params.Get("q")) 807 807 + 808 808 + var isOpen *bool 809 809 + if urlState := params.Get("state"); urlState != "" { 810 810 + switch urlState { 811 811 + case "open": 812 812 + isOpen = ptrBool(true) 813 813 + case "closed": 814 814 + isOpen = ptrBool(false) 815 815 + } 816 816 + query.Set("state", urlState) 817 817 + } else if queryState := query.Get("state"); queryState != nil { 818 818 + switch *queryState { 819 819 + case "open": 820 820 + isOpen = ptrBool(true) 821 821 + case "closed": 822 822 + isOpen = ptrBool(false) 823 823 + } 824 824 + } else if _, hasQ := params["q"]; !hasQ { 825 825 + // no q param at all -- default to open 826 826 + isOpen = ptrBool(true) 827 827 + query.Set("state", "open") 828 828 + } 829 829 + 830 830 + var authorDid string 831 831 + if authorHandle := query.Get("author"); authorHandle != nil { 832 832 + identity, err := rp.idResolver.ResolveIdent(r.Context(), *authorHandle) 833 833 + if err != nil { 834 834 + l.Debug("failed to resolve author handle", "handle", *authorHandle, "err", err) 835 835 + } else { 836 836 + authorDid = identity.DID.String() 837 837 + } 838 838 + } 839 839 + 840 840 + var negatedAuthorDid string 841 841 + if negatedAuthors := query.GetAllNegated("author"); len(negatedAuthors) > 0 { 842 842 + identity, err := rp.idResolver.ResolveIdent(r.Context(), negatedAuthors[0]) 843 843 + if err != nil { 844 844 + l.Debug("failed to resolve negated author handle", "handle", negatedAuthors[0], "err", err) 845 845 + } else { 846 846 + negatedAuthorDid = identity.DID.String() 847 847 + } 848 848 + } 849 849 + 850 850 + labels := query.GetAll("label") 851 851 + negatedLabels := query.GetAllNegated("label") 852 852 + 853 853 + var keywords, negatedKeywords []string 854 854 + var phrases, negatedPhrases []string 855 855 + for _, item := range query.Items() { 856 856 + switch item.Kind { 857 857 + case searchquery.KindKeyword: 858 858 + if item.Negated { 859 859 + negatedKeywords = append(negatedKeywords, item.Value) 860 860 + } else { 861 861 + keywords = append(keywords, item.Value) 862 862 + } 863 863 + case searchquery.KindQuoted: 864 864 + if item.Negated { 865 865 + negatedPhrases = append(negatedPhrases, item.Value) 866 866 + } else { 867 867 + phrases = append(phrases, item.Value) 868 868 + } 869 869 + } 870 870 + } 871 871 + 872 872 + searchOpts := models.IssueSearchOptions{ 873 873 + Keywords: keywords, 874 874 + Phrases: phrases, 875 875 + RepoAt: f.RepoAt().String(), 876 876 + IsOpen: isOpen, 877 877 + AuthorDid: authorDid, 878 878 + Labels: labels, 879 879 + NegatedKeywords: negatedKeywords, 880 880 + NegatedPhrases: negatedPhrases, 881 881 + NegatedLabels: negatedLabels, 882 882 + NegatedAuthorDid: negatedAuthorDid, 883 883 + Page: page, 884 884 + } 885 885 + 816 886 totalIssues := 0 817 817 - if isOpen { 887 887 + if isOpen == nil { 888 888 + totalIssues = f.RepoStats.IssueCount.Open + f.RepoStats.IssueCount.Closed 889 889 + } else if *isOpen { 818 890 totalIssues = f.RepoStats.IssueCount.Open 819 891 } else { 820 892 totalIssues = f.RepoStats.IssueCount.Closed 821 893 } 822 894 823 823 - keyword := params.Get("q") 824 824 - 825 895 repoInfo := rp.repoResolver.GetRepoInfo(r, user) 826 896 827 897 var issues []models.Issue 828 828 - searchOpts := models.IssueSearchOptions{ 829 829 - Keyword: keyword, 830 830 - RepoAt: f.RepoAt().String(), 831 831 - IsOpen: isOpen, 832 832 - Page: page, 833 833 - } 834 834 - if keyword != "" { 898 898 + 899 899 + if searchOpts.HasSearchFilters() { 835 900 res, err := rp.indexer.Search(r.Context(), searchOpts) 836 901 if err != nil { 837 902 l.Error("failed to search for issues", "err", err) ··· 840 905 l.Debug("searched issues with indexer", "count", len(res.Hits)) 841 906 totalIssues = int(res.Total) 842 907 843 843 - // count matching issues in the opposite state to display correct counts 844 844 - countRes, err := rp.indexer.Search(r.Context(), models.IssueSearchOptions{ 845 845 - Keyword: keyword, RepoAt: f.RepoAt().String(), IsOpen: !isOpen, 846 846 - Page: pagination.Page{Limit: 1}, 847 847 - }) 848 848 - if err == nil { 849 849 - if isOpen { 850 850 - repoInfo.Stats.IssueCount.Open = int(res.Total) 851 851 - repoInfo.Stats.IssueCount.Closed = int(countRes.Total) 852 852 - } else { 853 853 - repoInfo.Stats.IssueCount.Closed = int(res.Total) 854 854 - repoInfo.Stats.IssueCount.Open = int(countRes.Total) 855 855 - } 908 908 + // update tab counts to reflect filtered results 909 909 + countOpts := searchOpts 910 910 + countOpts.Page = pagination.Page{Limit: 1} 911 911 + countOpts.IsOpen = ptrBool(true) 912 912 + if openRes, err := rp.indexer.Search(r.Context(), countOpts); err == nil { 913 913 + repoInfo.Stats.IssueCount.Open = int(openRes.Total) 914 914 + } 915 915 + countOpts.IsOpen = ptrBool(false) 916 916 + if closedRes, err := rp.indexer.Search(r.Context(), countOpts); err == nil { 917 917 + repoInfo.Stats.IssueCount.Closed = int(closedRes.Total) 856 918 } 857 919 858 858 - issues, err = db.GetIssues( 859 859 - rp.db, 860 860 - orm.FilterIn("id", res.Hits), 861 861 - ) 862 862 - if err != nil { 863 863 - l.Error("failed to get issues", "err", err) 864 864 - rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") 865 865 - return 920 920 + if len(res.Hits) > 0 { 921 921 + issues, err = db.GetIssues( 922 922 + rp.db, 923 923 + orm.FilterIn("id", res.Hits), 924 924 + ) 925 925 + if err != nil { 926 926 + l.Error("failed to get issues", "err", err) 927 927 + rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") 928 928 + return 929 929 + } 866 930 } 867 867 - 868 931 } else { 869 869 - openInt := 0 870 870 - if isOpen { 871 871 - openInt = 1 932 932 + filters := []orm.Filter{ 933 933 + orm.FilterEq("repo_at", f.RepoAt()), 934 934 + } 935 935 + if isOpen != nil { 936 936 + openInt := 0 937 937 + if *isOpen { 938 938 + openInt = 1 939 939 + } 940 940 + filters = append(filters, orm.FilterEq("open", openInt)) 872 941 } 873 942 issues, err = db.GetIssuesPaginated( 874 943 rp.db, 875 944 page, 876 876 - orm.FilterEq("repo_at", f.RepoAt()), 877 877 - orm.FilterEq("open", openInt), 945 945 + filters..., 878 946 ) 879 947 if err != nil { 880 948 l.Error("failed to get issues", "err", err) ··· 899 967 defs[l.AtUri().String()] = &l 900 968 } 901 969 970 970 + filterState := "" 971 971 + if isOpen != nil { 972 972 + if *isOpen { 973 973 + filterState = "open" 974 974 + } else { 975 975 + filterState = "closed" 976 976 + } 977 977 + } 978 978 + 902 979 rp.pages.RepoIssues(w, pages.RepoIssuesParams{ 903 903 - LoggedInUser: rp.oauth.GetMultiAccountUser(r), 904 904 - RepoInfo: repoInfo, 905 905 - Issues: issues, 906 906 - IssueCount: totalIssues, 907 907 - LabelDefs: defs, 908 908 - FilteringByOpen: isOpen, 909 909 - FilterQuery: keyword, 910 910 - Page: page, 980 980 + LoggedInUser: rp.oauth.GetMultiAccountUser(r), 981 981 + RepoInfo: repoInfo, 982 982 + Issues: issues, 983 983 + IssueCount: totalIssues, 984 984 + LabelDefs: defs, 985 985 + FilterState: filterState, 986 986 + FilterQuery: query.String(), 987 987 + Page: page, 911 988 }) 912 989 } 990 990 + 991 991 + func ptrBool(b bool) *bool { return &b } 913 992 914 993 func (rp *Issues) NewIssue(w http.ResponseWriter, r *http.Request) { 915 994 l := rp.logger.With("handler", "NewIssue")

+18

appview/labels/labels.go

··· 13 13 "tangled.org/core/appview/db" 14 14 "tangled.org/core/appview/middleware" 15 15 "tangled.org/core/appview/models" 16 16 + "tangled.org/core/appview/notify" 16 17 "tangled.org/core/appview/oauth" 17 18 "tangled.org/core/appview/pages" 18 19 "tangled.org/core/appview/validator" ··· 34 35 logger *slog.Logger 35 36 validator *validator.Validator 36 37 enforcer *rbac.Enforcer 38 38 + notifier notify.Notifier 37 39 } 38 40 39 41 func New( ··· 42 44 db *db.DB, 43 45 validator *validator.Validator, 44 46 enforcer *rbac.Enforcer, 47 47 + notifier notify.Notifier, 45 48 logger *slog.Logger, 46 49 ) *Labels { 47 50 return &Labels{ ··· 51 54 logger: logger, 52 55 validator: validator, 53 56 enforcer: enforcer, 57 57 + notifier: notifier, 54 58 } 55 59 } 56 60 ··· 244 248 245 249 // clear aturi when everything is successful 246 250 atUri = "" 251 251 + 252 252 + subject := syntax.ATURI(subjectUri) 253 253 + if subject.Collection() == tangled.RepoIssueNSID { 254 254 + issues, err := db.GetIssues(l.db, orm.FilterEq("at_uri", subjectUri)) 255 255 + if err == nil && len(issues) == 1 { 256 256 + l.notifier.NewIssueLabelOp(r.Context(), &issues[0]) 257 257 + } 258 258 + } 259 259 + if subject.Collection() == tangled.RepoPullNSID { 260 260 + pulls, err := db.GetPulls(l.db, orm.FilterEq("at_uri", subjectUri)) 261 261 + if err == nil && len(pulls) == 1 { 262 262 + l.notifier.NewPullLabelOp(r.Context(), pulls[0]) 263 263 + } 264 264 + } 247 265 248 266 l.pages.HxRefresh(w) 249 267 }

+21

appview/models/label.go

··· 291 291 292 292 type LabelState struct { 293 293 inner map[string]set 294 294 + names map[string]string 294 295 } 295 296 296 297 func NewLabelState() LabelState { 297 298 return LabelState{ 298 299 inner: make(map[string]set), 300 300 + names: make(map[string]string), 299 301 } 300 302 } 301 303 304 304 + func (s LabelState) LabelNames() []string { 305 305 + var result []string 306 306 + for key, valset := range s.inner { 307 307 + if valset == nil { 308 308 + continue 309 309 + } 310 310 + if name, ok := s.names[key]; ok { 311 311 + result = append(result, name) 312 312 + } 313 313 + } 314 314 + return result 315 315 + } 316 316 + 302 317 func (s LabelState) Inner() map[string]set { 303 318 return s.inner 319 319 + } 320 320 + 321 321 + func (s LabelState) SetName(key, name string) { 322 322 + s.names[key] = name 304 323 } 305 324 306 325 func (s LabelState) ContainsLabel(l string) bool { ··· 347 366 // this def was deleted, but an op exists, so we just skip over the op 348 367 return nil 349 368 } 369 369 + 370 370 + state.names[op.OperandKey] = def.Name 350 371 351 372 switch op.Operation { 352 373 case LabelOperationAdd:

+35 -17

appview/models/search.go

··· 3 3 import "tangled.org/core/appview/pagination" 4 4 5 5 type IssueSearchOptions struct { 6 6 - Keyword string 7 7 - RepoAt string 8 8 - IsOpen bool 6 6 + Keywords []string 7 7 + Phrases []string 8 8 + RepoAt string 9 9 + IsOpen *bool 10 10 + AuthorDid string 11 11 + Labels []string 12 12 + 13 13 + NegatedKeywords []string 14 14 + NegatedPhrases []string 15 15 + NegatedLabels []string 16 16 + NegatedAuthorDid string 9 17 10 18 Page pagination.Page 11 19 } 12 20 21 21 + func (o *IssueSearchOptions) HasSearchFilters() bool { 22 22 + return len(o.Keywords) > 0 || len(o.Phrases) > 0 || 23 23 + o.AuthorDid != "" || o.NegatedAuthorDid != "" || 24 24 + len(o.Labels) > 0 || len(o.NegatedLabels) > 0 || 25 25 + len(o.NegatedKeywords) > 0 || len(o.NegatedPhrases) > 0 26 26 + } 27 27 + 13 28 type PullSearchOptions struct { 14 14 - Keyword string 15 15 - RepoAt string 16 16 - State PullState 29 29 + Keywords []string 30 30 + Phrases []string 31 31 + RepoAt string 32 32 + State *PullState 33 33 + AuthorDid string 34 34 + Labels []string 35 35 + 36 36 + NegatedKeywords []string 37 37 + NegatedPhrases []string 38 38 + NegatedLabels []string 39 39 + NegatedAuthorDid string 17 40 18 41 Page pagination.Page 19 42 } 20 43 21 21 - // func (so *SearchOptions) ToFilters() []filter { 22 22 - // var filters []filter 23 23 - // if so.IsOpen != nil { 24 24 - // openValue := 0 25 25 - // if *so.IsOpen { 26 26 - // openValue = 1 27 27 - // } 28 28 - // filters = append(filters, FilterEq("open", openValue)) 29 29 - // } 30 30 - // return filters 31 31 - // } 44 44 + func (o *PullSearchOptions) HasSearchFilters() bool { 45 45 + return len(o.Keywords) > 0 || len(o.Phrases) > 0 || 46 46 + o.AuthorDid != "" || o.NegatedAuthorDid != "" || 47 47 + len(o.Labels) > 0 || len(o.NegatedLabels) > 0 || 48 48 + len(o.NegatedKeywords) > 0 || len(o.NegatedPhrases) > 0 49 49 + }

+4 -1

appview/notify/db/db.go

··· 206 206 // no-op for now 207 207 } 208 208 209 209 + func (n *databaseNotifier) NewIssueLabelOp(ctx context.Context, issue *models.Issue) {} 210 210 + func (n *databaseNotifier) NewPullLabelOp(ctx context.Context, pull *models.Pull) {} 211 211 + 209 212 func (n *databaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) { 210 213 actorDid := syntax.DID(follow.UserDid) 211 214 recipients := sets.Singleton(syntax.DID(follow.SubjectDid)) ··· 375 378 recipients.Insert(syntax.DID(p)) 376 379 } 377 380 378 378 - entityType := "pull" 381 381 + entityType := "issue" 379 382 entityId := issue.AtUri().String() 380 383 repoId := &issue.Repo.Id 381 384 issueId := &issue.Id

+10

appview/notify/logging_notifier.go

··· 59 59 l.inner.DeleteIssue(ctx, issue) 60 60 } 61 61 62 62 + func (l *loggingNotifier) NewIssueLabelOp(ctx context.Context, issue *models.Issue) { 63 63 + ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewIssueLabelOp")) 64 64 + l.inner.NewIssueLabelOp(ctx, issue) 65 65 + } 66 66 + 67 67 + func (l *loggingNotifier) NewPullLabelOp(ctx context.Context, pull *models.Pull) { 68 68 + ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewPullLabelOp")) 69 69 + l.inner.NewPullLabelOp(ctx, pull) 70 70 + } 71 71 + 62 72 func (l *loggingNotifier) NewFollow(ctx context.Context, follow *models.Follow) { 63 73 ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewFollow")) 64 74 l.inner.NewFollow(ctx, follow)

+8

appview/notify/merged_notifier.go

··· 58 58 m.fanout(func(n Notifier) { n.DeleteIssue(ctx, issue) }) 59 59 } 60 60 61 61 + func (m *mergedNotifier) NewIssueLabelOp(ctx context.Context, issue *models.Issue) { 62 62 + m.fanout(func(n Notifier) { n.NewIssueLabelOp(ctx, issue) }) 63 63 + } 64 64 + 65 65 + func (m *mergedNotifier) NewPullLabelOp(ctx context.Context, pull *models.Pull) { 66 66 + m.fanout(func(n Notifier) { n.NewPullLabelOp(ctx, pull) }) 67 67 + } 68 68 + 61 69 func (m *mergedNotifier) NewFollow(ctx context.Context, follow *models.Follow) { 62 70 m.fanout(func(n Notifier) { n.NewFollow(ctx, follow) }) 63 71 }

+6

appview/notify/notifier.go

··· 25 25 NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) 26 26 NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) 27 27 28 28 + NewIssueLabelOp(ctx context.Context, issue *models.Issue) 29 29 + NewPullLabelOp(ctx context.Context, pull *models.Pull) 30 30 + 28 31 UpdateProfile(ctx context.Context, profile *models.Profile) 29 32 30 33 NewString(ctx context.Context, s *models.String) ··· 47 50 } 48 51 func (m *BaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {} 49 52 func (m *BaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue) {} 53 53 + 54 54 + func (m *BaseNotifier) NewIssueLabelOp(ctx context.Context, issue *models.Issue) {} 55 55 + func (m *BaseNotifier) NewPullLabelOp(ctx context.Context, pull *models.Pull) {} 50 56 51 57 func (m *BaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) {} 52 58 func (m *BaseNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {}

+10 -10

appview/pages/pages.go

··· 965 965 } 966 966 967 967 type RepoIssuesParams struct { 968 968 - LoggedInUser *oauth.MultiAccountUser 969 969 - RepoInfo repoinfo.RepoInfo 970 970 - Active string 971 971 - Issues []models.Issue 972 972 - IssueCount int 973 973 - LabelDefs map[string]*models.LabelDefinition 974 974 - Page pagination.Page 975 975 - FilteringByOpen bool 976 976 - FilterQuery string 968 968 + LoggedInUser *oauth.MultiAccountUser 969 969 + RepoInfo repoinfo.RepoInfo 970 970 + Active string 971 971 + Issues []models.Issue 972 972 + IssueCount int 973 973 + LabelDefs map[string]*models.LabelDefinition 974 974 + Page pagination.Page 975 975 + FilterState string 976 976 + FilterQuery string 977 977 } 978 978 979 979 func (p *Pages) RepoIssues(w io.Writer, params RepoIssuesParams) error { ··· 1103 1103 RepoInfo repoinfo.RepoInfo 1104 1104 Pulls []*models.Pull 1105 1105 Active string 1106 1106 - FilteringBy models.PullState 1106 1106 + FilterState string 1107 1107 FilterQuery string 1108 1108 Stacks map[string]models.Stack 1109 1109 Pipelines map[string]models.Pipeline

+23 -1

appview/pages/templates/fragments/tabSelector.html

··· 3 3 {{ $all := .Values }} 4 4 {{ $active := .Active }} 5 5 {{ $include := .Include }} 6 6 + {{ $form := .Form }} 6 7 <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden"> 7 8 {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }} 8 9 {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }} 9 10 {{ range $index, $value := $all }} 10 11 {{ $isActive := eq $value.Key $active }} 12 12 + {{ if $form }} 13 13 + <button type="submit" 14 14 + form="{{ $form }}" 15 15 + name="{{ $name }}" value="{{ $value.Key }}" 16 16 + hx-get="?{{ $name }}={{ $value.Key }}" 17 17 + hx-include="{{ $include }}" 18 18 + hx-push-url="true" 19 19 + hx-target="body" 20 20 + hx-on:htmx:config-request="if(!event.detail.parameters.q) delete event.detail.parameters.q" 21 21 + class="p-2 whitespace-nowrap flex justify-center items-center gap-2 text-sm w-full hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}"> 22 22 + {{ if $value.Icon }} 23 23 + {{ i $value.Icon "size-4" }} 24 24 + {{ end }} 25 25 + 26 26 + {{ with $value.Meta }} 27 27 + {{ . }} 28 28 + {{ end }} 29 29 + 30 30 + {{ $value.Value }} 31 31 + </button> 32 32 + {{ else }} 11 33 <a href="?{{ $name }}={{ $value.Key }}" 12 34 {{ if $include }} 13 35 hx-get="?{{ $name }}={{ $value.Key }}" ··· 27 49 28 50 {{ $value.Value }} 29 51 </a> 52 52 + {{ end }} 30 53 {{ end }} 31 54 </div> 32 55 {{ end }} 33 33 -

+10 -18

appview/pages/templates/repo/issues/issues.html

··· 8 8 {{ end }} 9 9 10 10 {{ define "repoContent" }} 11 11 - {{ $active := "closed" }} 12 12 - {{ if .FilteringByOpen }} 13 13 - {{ $active = "open" }} 14 14 - {{ end }} 11 11 + {{ $active := .FilterState }} 15 12 16 16 - {{ $open := 13 13 + {{ $open := 17 14 (dict 18 15 "Key" "open" 19 16 "Value" "open" 20 17 "Icon" "circle-dot" 21 18 "Meta" (string .RepoInfo.Stats.IssueCount.Open)) }} 22 22 - {{ $closed := 19 19 + {{ $closed := 23 20 (dict 24 21 "Key" "closed" 25 22 "Value" "closed" ··· 28 25 {{ $values := list $open $closed }} 29 26 30 27 <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2"> 31 31 - <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 32 32 - <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}"> 28 28 + <form id="search-form" class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 33 29 <div class="flex-1 flex relative"> 34 30 <input 35 31 id="search-q" ··· 40 36 placeholder="search issues..." 41 37 > 42 38 <a 43 43 - href="?state={{ if .FilteringByOpen }}open{{ else }}closed{{ end }}" 39 39 + {{ if $active }}href="?q=state:{{ $active }}"{{ else }}href="?"{{ end }} 44 40 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block" 45 41 > 46 42 {{ i "x" "w-4 h-4" }} ··· 54 50 </button> 55 51 </form> 56 52 <div class="sm:row-start-1"> 57 57 - {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }} 53 53 + {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q" "Form" "search-form") }} 58 54 </div> 59 55 <a 60 56 href="/{{ .RepoInfo.FullName }}/issues/new" ··· 72 68 {{ template "repo/issues/fragments/issueListing" (dict "Issues" .Issues "RepoPrefix" .RepoInfo.FullName "LabelDefs" .LabelDefs) }} 73 69 </div> 74 70 {{if gt .IssueCount .Page.Limit }} 75 75 - {{ $state := "closed" }} 76 76 - {{ if .FilteringByOpen }} 77 77 - {{ $state = "open" }} 78 78 - {{ end }} 79 79 - {{ template "fragments/pagination" (dict 80 80 - "Page" .Page 81 81 - "TotalCount" .IssueCount 71 71 + {{ template "fragments/pagination" (dict 72 72 + "Page" .Page 73 73 + "TotalCount" .IssueCount 82 74 "BasePath" (printf "/%s/issues" .RepoInfo.FullName) 83 83 - "QueryParams" (queryParams "state" $state "q" .FilterQuery) 75 75 + "QueryParams" (queryParams "q" .FilterQuery) 84 76 ) }} 85 77 {{ end }} 86 78 {{ end }}

+11 -17

appview/pages/templates/repo/pulls/pulls.html

··· 8 8 {{ end }} 9 9 10 10 {{ define "repoContent" }} 11 11 - {{ $active := "closed" }} 12 12 - {{ if .FilteringBy.IsOpen }} 13 13 - {{ $active = "open" }} 14 14 - {{ else if .FilteringBy.IsMerged }} 15 15 - {{ $active = "merged" }} 16 16 - {{ end }} 17 17 - {{ $open := 11 11 + {{ $active := .FilterState }} 12 12 + {{ $open := 18 13 (dict 19 14 "Key" "open" 20 15 "Value" "open" 21 16 "Icon" "git-pull-request" 22 17 "Meta" (string .RepoInfo.Stats.PullCount.Open)) }} 23 23 - {{ $merged := 18 18 + {{ $merged := 24 19 (dict 25 20 "Key" "merged" 26 21 "Value" "merged" 27 22 "Icon" "git-merge" 28 23 "Meta" (string .RepoInfo.Stats.PullCount.Merged)) }} 29 29 - {{ $closed := 24 24 + {{ $closed := 30 25 (dict 31 26 "Key" "closed" 32 27 "Value" "closed" ··· 34 29 "Meta" (string .RepoInfo.Stats.PullCount.Closed)) }} 35 30 {{ $values := list $open $merged $closed }} 36 31 <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2"> 37 37 - <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 38 38 - <input type="hidden" name="state" value="{{ .FilteringBy.String }}"> 32 32 + <form id="search-form" class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 39 33 <div class="flex-1 flex relative"> 40 34 <input 41 35 id="search-q" ··· 46 40 placeholder="search pulls..." 47 41 > 48 42 <a 49 49 - href="?state={{ .FilteringBy.String }}" 43 43 + {{ if $active }}href="?q=state:{{ $active }}"{{ else }}href="?"{{ end }} 50 44 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block" 51 45 > 52 46 {{ i "x" "w-4 h-4" }} ··· 60 54 </button> 61 55 </form> 62 56 <div class="sm:row-start-1"> 63 63 - {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }} 57 57 + {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q" "Form" "search-form") }} 64 58 </div> 65 59 <a 66 60 href="/{{ .RepoInfo.FullName }}/pulls/new" ··· 162 156 {{ end }} 163 157 </div> 164 158 {{if gt .PullCount .Page.Limit }} 165 165 - {{ template "fragments/pagination" (dict 166 166 - "Page" .Page 167 167 - "TotalCount" .PullCount 159 159 + {{ template "fragments/pagination" (dict 160 160 + "Page" .Page 161 161 + "TotalCount" .PullCount 168 162 "BasePath" (printf "/%s/pulls" .RepoInfo.FullName) 169 169 - "QueryParams" (queryParams "state" .FilteringBy.String "q" .FilterQuery) 163 163 + "QueryParams" (queryParams "q" .FilterQuery) 170 164 ) }} 171 165 {{ end }} 172 166 {{ end }}

+147 -40

appview/pulls/pulls.go

··· 31 31 "tangled.org/core/appview/pages/repoinfo" 32 32 "tangled.org/core/appview/pagination" 33 33 "tangled.org/core/appview/reporesolver" 34 34 + "tangled.org/core/appview/searchquery" 34 35 "tangled.org/core/appview/validator" 35 36 "tangled.org/core/appview/xrpcclient" 36 37 "tangled.org/core/idresolver" ··· 524 525 525 526 user := s.oauth.GetMultiAccountUser(r) 526 527 params := r.URL.Query() 527 527 - 528 528 - state := models.PullOpen 529 529 - switch params.Get("state") { 530 530 - case "closed": 531 531 - state = models.PullClosed 532 532 - case "merged": 533 533 - state = models.PullMerged 534 534 - } 535 535 - 536 528 page := pagination.FromContext(r.Context()) 537 529 538 530 f, err := s.repoResolver.Resolve(r) ··· 541 533 return 542 534 } 543 535 544 544 - var totalPulls int 545 545 - switch state { 546 546 - case models.PullOpen: 547 547 - totalPulls = f.RepoStats.PullCount.Open 548 548 - case models.PullMerged: 549 549 - totalPulls = f.RepoStats.PullCount.Merged 550 550 - case models.PullClosed: 551 551 - totalPulls = f.RepoStats.PullCount.Closed 536 536 + query := searchquery.Parse(params.Get("q")) 537 537 + 538 538 + var state *models.PullState 539 539 + if urlState := params.Get("state"); urlState != "" { 540 540 + switch urlState { 541 541 + case "open": 542 542 + state = ptrPullState(models.PullOpen) 543 543 + case "closed": 544 544 + state = ptrPullState(models.PullClosed) 545 545 + case "merged": 546 546 + state = ptrPullState(models.PullMerged) 547 547 + } 548 548 + query.Set("state", urlState) 549 549 + } else if queryState := query.Get("state"); queryState != nil { 550 550 + switch *queryState { 551 551 + case "open": 552 552 + state = ptrPullState(models.PullOpen) 553 553 + case "closed": 554 554 + state = ptrPullState(models.PullClosed) 555 555 + case "merged": 556 556 + state = ptrPullState(models.PullMerged) 557 557 + } 558 558 + } else if _, hasQ := params["q"]; !hasQ { 559 559 + state = ptrPullState(models.PullOpen) 560 560 + query.Set("state", "open") 552 561 } 553 562 554 554 - keyword := params.Get("q") 563 563 + var authorDid string 564 564 + if authorHandle := query.Get("author"); authorHandle != nil { 565 565 + identity, err := s.idResolver.ResolveIdent(r.Context(), *authorHandle) 566 566 + if err != nil { 567 567 + l.Debug("failed to resolve author handle", "handle", *authorHandle, "err", err) 568 568 + } else { 569 569 + authorDid = identity.DID.String() 570 570 + } 571 571 + } 555 572 556 556 - var pulls []*models.Pull 573 573 + var negatedAuthorDid string 574 574 + if negatedAuthors := query.GetAllNegated("author"); len(negatedAuthors) > 0 { 575 575 + identity, err := s.idResolver.ResolveIdent(r.Context(), negatedAuthors[0]) 576 576 + if err != nil { 577 577 + l.Debug("failed to resolve negated author handle", "handle", negatedAuthors[0], "err", err) 578 578 + } else { 579 579 + negatedAuthorDid = identity.DID.String() 580 580 + } 581 581 + } 582 582 + 583 583 + labels := query.GetAll("label") 584 584 + negatedLabels := query.GetAllNegated("label") 585 585 + 586 586 + var keywords, negatedKeywords []string 587 587 + var phrases, negatedPhrases []string 588 588 + for _, item := range query.Items() { 589 589 + switch item.Kind { 590 590 + case searchquery.KindKeyword: 591 591 + if item.Negated { 592 592 + negatedKeywords = append(negatedKeywords, item.Value) 593 593 + } else { 594 594 + keywords = append(keywords, item.Value) 595 595 + } 596 596 + case searchquery.KindQuoted: 597 597 + if item.Negated { 598 598 + negatedPhrases = append(negatedPhrases, item.Value) 599 599 + } else { 600 600 + phrases = append(phrases, item.Value) 601 601 + } 602 602 + } 603 603 + } 604 604 + 557 605 searchOpts := models.PullSearchOptions{ 558 558 - Keyword: keyword, 559 559 - RepoAt: f.RepoAt().String(), 560 560 - State: state, 561 561 - Page: page, 606 606 + Keywords: keywords, 607 607 + Phrases: phrases, 608 608 + RepoAt: f.RepoAt().String(), 609 609 + State: state, 610 610 + AuthorDid: authorDid, 611 611 + Labels: labels, 612 612 + NegatedKeywords: negatedKeywords, 613 613 + NegatedPhrases: negatedPhrases, 614 614 + NegatedLabels: negatedLabels, 615 615 + NegatedAuthorDid: negatedAuthorDid, 616 616 + Page: page, 562 617 } 563 563 - l.Debug("searching with", "searchOpts", searchOpts) 564 564 - if keyword != "" { 618 618 + 619 619 + var totalPulls int 620 620 + if state == nil { 621 621 + totalPulls = f.RepoStats.PullCount.Open + f.RepoStats.PullCount.Merged + f.RepoStats.PullCount.Closed 622 622 + } else { 623 623 + switch *state { 624 624 + case models.PullOpen: 625 625 + totalPulls = f.RepoStats.PullCount.Open 626 626 + case models.PullMerged: 627 627 + totalPulls = f.RepoStats.PullCount.Merged 628 628 + case models.PullClosed: 629 629 + totalPulls = f.RepoStats.PullCount.Closed 630 630 + } 631 631 + } 632 632 + 633 633 + repoInfo := s.repoResolver.GetRepoInfo(r, user) 634 634 + 635 635 + var pulls []*models.Pull 636 636 + 637 637 + if searchOpts.HasSearchFilters() { 565 638 res, err := s.indexer.Search(r.Context(), searchOpts) 566 639 if err != nil { 567 640 l.Error("failed to search for pulls", "err", err) ··· 570 643 totalPulls = int(res.Total) 571 644 l.Debug("searched pulls with indexer", "count", len(res.Hits)) 572 645 573 573 - pulls, err = db.GetPulls( 574 574 - s.db, 575 575 - orm.FilterIn("id", res.Hits), 576 576 - ) 577 577 - if err != nil { 578 578 - log.Println("failed to get pulls", err) 579 579 - s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 580 580 - return 646 646 + // update tab counts to reflect filtered results 647 647 + countOpts := searchOpts 648 648 + countOpts.Page = pagination.Page{Limit: 1} 649 649 + for _, ps := range []models.PullState{models.PullOpen, models.PullMerged, models.PullClosed} { 650 650 + ps := ps 651 651 + countOpts.State = &ps 652 652 + countRes, err := s.indexer.Search(r.Context(), countOpts) 653 653 + if err != nil { 654 654 + continue 655 655 + } 656 656 + switch ps { 657 657 + case models.PullOpen: 658 658 + repoInfo.Stats.PullCount.Open = int(countRes.Total) 659 659 + case models.PullMerged: 660 660 + repoInfo.Stats.PullCount.Merged = int(countRes.Total) 661 661 + case models.PullClosed: 662 662 + repoInfo.Stats.PullCount.Closed = int(countRes.Total) 663 663 + } 664 664 + } 665 665 + 666 666 + if len(res.Hits) > 0 { 667 667 + pulls, err = db.GetPulls( 668 668 + s.db, 669 669 + orm.FilterIn("id", res.Hits), 670 670 + ) 671 671 + if err != nil { 672 672 + l.Error("failed to get pulls", "err", err) 673 673 + s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 674 674 + return 675 675 + } 581 676 } 582 677 } else { 678 678 + filters := []orm.Filter{ 679 679 + orm.FilterEq("repo_at", f.RepoAt()), 680 680 + } 681 681 + if state != nil { 682 682 + filters = append(filters, orm.FilterEq("state", *state)) 683 683 + } 583 684 pulls, err = db.GetPullsPaginated( 584 685 s.db, 585 686 page, 586 586 - orm.FilterEq("repo_at", f.RepoAt()), 587 587 - orm.FilterEq("state", searchOpts.State), 687 687 + filters..., 588 688 ) 589 689 if err != nil { 590 590 - log.Println("failed to get pulls", err) 690 690 + l.Error("failed to get pulls", "err", err) 591 691 s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 592 692 return 593 693 } ··· 656 756 orm.FilterContains("scope", tangled.RepoPullNSID), 657 757 ) 658 758 if err != nil { 659 659 - log.Println("failed to fetch labels", err) 759 759 + l.Error("failed to fetch labels", "err", err) 660 760 s.pages.Error503(w) 661 761 return 662 762 } ··· 664 764 defs := make(map[string]*models.LabelDefinition) 665 765 for _, l := range labelDefs { 666 766 defs[l.AtUri().String()] = &l 767 767 + } 768 768 + 769 769 + filterState := "" 770 770 + if state != nil { 771 771 + filterState = state.String() 667 772 } 668 773 669 774 s.pages.RepoPulls(w, pages.RepoPullsParams{ 670 775 LoggedInUser: s.oauth.GetMultiAccountUser(r), 671 671 - RepoInfo: s.repoResolver.GetRepoInfo(r, user), 776 776 + RepoInfo: repoInfo, 672 777 Pulls: pulls, 673 778 LabelDefs: defs, 674 674 - FilteringBy: state, 675 675 - FilterQuery: keyword, 779 779 + FilterState: filterState, 780 780 + FilterQuery: query.String(), 676 781 Stacks: stacks, 677 782 Pipelines: m, 678 783 Page: page, ··· 2450 2555 w.Close() 2451 2556 return &b 2452 2557 } 2558 2558 + 2559 2559 + func ptrPullState(s models.PullState) *models.PullState { return &s }

+204

appview/searchquery/searchquery.go

··· 1 1 + package searchquery 2 2 + 3 3 + import ( 4 4 + "strings" 5 5 + "unicode" 6 6 + ) 7 7 + 8 8 + type ItemKind int 9 9 + 10 10 + const ( 11 11 + KindKeyword ItemKind = iota 12 12 + KindQuoted 13 13 + KindTagValue 14 14 + ) 15 15 + 16 16 + type Item struct { 17 17 + Kind ItemKind 18 18 + Negated bool 19 19 + Raw string 20 20 + Key string 21 21 + Value string 22 22 + } 23 23 + 24 24 + type Query struct { 25 25 + items []Item 26 26 + } 27 27 + 28 28 + func Parse(input string) *Query { 29 29 + q := &Query{} 30 30 + runes := []rune(strings.TrimSpace(input)) 31 31 + if len(runes) == 0 { 32 32 + return q 33 33 + } 34 34 + 35 35 + i := 0 36 36 + for i < len(runes) { 37 37 + for i < len(runes) && unicode.IsSpace(runes[i]) { 38 38 + i++ 39 39 + } 40 40 + if i >= len(runes) { 41 41 + break 42 42 + } 43 43 + 44 44 + negated := false 45 45 + if runes[i] == '-' && i+1 < len(runes) && runes[i+1] == '"' { 46 46 + negated = true 47 47 + i++ // skip '-' 48 48 + } 49 49 + 50 50 + if runes[i] == '"' { 51 51 + start := i 52 52 + if negated { 53 53 + start-- // include the '-' in Raw 54 54 + } 55 55 + i++ // skip opening quote 56 56 + inner := i 57 57 + for i < len(runes) && runes[i] != '"' { 58 58 + if runes[i] == '\\' && i+1 < len(runes) { 59 59 + i++ 60 60 + } 61 61 + i++ 62 62 + } 63 63 + value := unescapeQuoted(runes[inner:i]) 64 64 + if i < len(runes) { 65 65 + i++ // skip closing quote 66 66 + } 67 67 + q.items = append(q.items, Item{ 68 68 + Kind: KindQuoted, 69 69 + Negated: negated, 70 70 + Raw: string(runes[start:i]), 71 71 + Value: value, 72 72 + }) 73 73 + continue 74 74 + } 75 75 + 76 76 + start := i 77 77 + for i < len(runes) && !unicode.IsSpace(runes[i]) && runes[i] != '"' { 78 78 + i++ 79 79 + } 80 80 + token := string(runes[start:i]) 81 81 + 82 82 + negated = false 83 83 + subject := token 84 84 + if len(subject) > 1 && subject[0] == '-' { 85 85 + negated = true 86 86 + subject = subject[1:] 87 87 + } 88 88 + 89 89 + colonIdx := strings.Index(subject, ":") 90 90 + if colonIdx > 0 { 91 91 + key := subject[:colonIdx] 92 92 + value := subject[colonIdx+1:] 93 93 + q.items = append(q.items, Item{ 94 94 + Kind: KindTagValue, 95 95 + Negated: negated, 96 96 + Raw: token, 97 97 + Key: key, 98 98 + Value: value, 99 99 + }) 100 100 + } else { 101 101 + q.items = append(q.items, Item{ 102 102 + Kind: KindKeyword, 103 103 + Negated: negated, 104 104 + Raw: token, 105 105 + Value: subject, 106 106 + }) 107 107 + } 108 108 + } 109 109 + 110 110 + return q 111 111 + } 112 112 + 113 113 + func unescapeQuoted(runes []rune) string { 114 114 + var b strings.Builder 115 115 + for i := 0; i < len(runes); i++ { 116 116 + if runes[i] == '\\' && i+1 < len(runes) { 117 117 + i++ 118 118 + } 119 119 + b.WriteRune(runes[i]) 120 120 + } 121 121 + return b.String() 122 122 + } 123 123 + 124 124 + func (q *Query) Items() []Item { 125 125 + return q.items 126 126 + } 127 127 + 128 128 + func (q *Query) Get(key string) *string { 129 129 + for i, item := range q.items { 130 130 + if item.Kind == KindTagValue && !item.Negated && item.Key == key { 131 131 + return &q.items[i].Value 132 132 + } 133 133 + } 134 134 + return nil 135 135 + } 136 136 + 137 137 + func (q *Query) GetAll(key string) []string { 138 138 + var result []string 139 139 + for _, item := range q.items { 140 140 + if item.Kind == KindTagValue && !item.Negated && item.Key == key { 141 141 + result = append(result, item.Value) 142 142 + } 143 143 + } 144 144 + return result 145 145 + } 146 146 + 147 147 + func (q *Query) GetAllNegated(key string) []string { 148 148 + var result []string 149 149 + for _, item := range q.items { 150 150 + if item.Kind == KindTagValue && item.Negated && item.Key == key { 151 151 + result = append(result, item.Value) 152 152 + } 153 153 + } 154 154 + return result 155 155 + } 156 156 + 157 157 + func (q *Query) Has(key string) bool { 158 158 + return q.Get(key) != nil 159 159 + } 160 160 + 161 161 + func (q *Query) Set(key, value string) { 162 162 + raw := key + ":" + value 163 163 + found := false 164 164 + newItems := make([]Item, 0, len(q.items)) 165 165 + 166 166 + for _, item := range q.items { 167 167 + if item.Kind == KindTagValue && !item.Negated && item.Key == key { 168 168 + if !found { 169 169 + newItems = append(newItems, Item{ 170 170 + Kind: KindTagValue, 171 171 + Raw: raw, 172 172 + Key: key, 173 173 + Value: value, 174 174 + }) 175 175 + found = true 176 176 + } 177 177 + } else { 178 178 + newItems = append(newItems, item) 179 179 + } 180 180 + } 181 181 + 182 182 + if !found { 183 183 + newItems = append(newItems, Item{ 184 184 + Kind: KindTagValue, 185 185 + Raw: raw, 186 186 + Key: key, 187 187 + Value: value, 188 188 + }) 189 189 + } 190 190 + 191 191 + q.items = newItems 192 192 + } 193 193 + 194 194 + func (q *Query) String() string { 195 195 + if len(q.items) == 0 { 196 196 + return "" 197 197 + } 198 198 + 199 199 + parts := make([]string, len(q.items)) 200 200 + for i, item := range q.items { 201 201 + parts[i] = item.Raw 202 202 + } 203 203 + return strings.Join(parts, " ") 204 204 + }

+206

appview/searchquery/searchquery_test.go

··· 1 1 + package searchquery 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + 6 6 + "github.com/stretchr/testify/assert" 7 7 + ) 8 8 + 9 9 + func TestParseMixed(t *testing.T) { 10 10 + q := Parse(`state:open bug "critical issue" label:good-first-issue fix`) 11 11 + items := q.Items() 12 12 + assert.Equal(t, 5, len(items)) 13 13 + 14 14 + assert.Equal(t, KindTagValue, items[0].Kind) 15 15 + assert.Equal(t, "state", items[0].Key) 16 16 + assert.Equal(t, "open", items[0].Value) 17 17 + 18 18 + assert.Equal(t, KindKeyword, items[1].Kind) 19 19 + assert.Equal(t, "bug", items[1].Raw) 20 20 + 21 21 + assert.Equal(t, KindQuoted, items[2].Kind) 22 22 + assert.Equal(t, `"critical issue"`, items[2].Raw) 23 23 + 24 24 + assert.Equal(t, KindTagValue, items[3].Kind) 25 25 + assert.Equal(t, "label", items[3].Key) 26 26 + assert.Equal(t, "good-first-issue", items[3].Value) 27 27 + 28 28 + assert.Equal(t, KindKeyword, items[4].Kind) 29 29 + 30 30 + assert.Equal(t, `state:open bug "critical issue" label:good-first-issue fix`, q.String()) 31 31 + } 32 32 + 33 33 + func TestGetSetLifecycle(t *testing.T) { 34 34 + q := Parse("label:bug state:open keyword label:feature label:urgent") 35 35 + 36 36 + // Get returns first match 37 37 + val := q.Get("state") 38 38 + assert.NotNil(t, val) 39 39 + assert.Equal(t, "open", *val) 40 40 + 41 41 + // Get returns nil for missing key 42 42 + assert.Nil(t, q.Get("author")) 43 43 + 44 44 + // Has 45 45 + assert.True(t, q.Has("state")) 46 46 + assert.False(t, q.Has("author")) 47 47 + 48 48 + // GetAll 49 49 + assert.Equal(t, []string{"bug", "feature", "urgent"}, q.GetAll("label")) 50 50 + assert.Equal(t, 0, len(q.GetAll("missing"))) 51 51 + 52 52 + // Set updates existing, preserving position 53 53 + q.Set("state", "closed") 54 54 + assert.Equal(t, "label:bug state:closed keyword label:feature label:urgent", q.String()) 55 55 + 56 56 + // Set deduplicates 57 57 + q.Set("label", "single") 58 58 + assert.Equal(t, "label:single state:closed keyword", q.String()) 59 59 + 60 60 + // Set appends new tag 61 61 + q.Set("author", "bob") 62 62 + assert.Equal(t, "label:single state:closed keyword author:bob", q.String()) 63 63 + } 64 64 + 65 65 + func TestParseEmpty(t *testing.T) { 66 66 + q := Parse(" ") 67 67 + assert.Equal(t, 0, len(q.Items())) 68 68 + assert.Equal(t, "", q.String()) 69 69 + } 70 70 + 71 71 + func TestParseUnclosedQuote(t *testing.T) { 72 72 + q := Parse(`"hello world`) 73 73 + items := q.Items() 74 74 + assert.Equal(t, 1, len(items)) 75 75 + assert.Equal(t, KindQuoted, items[0].Kind) 76 76 + assert.Equal(t, `"hello world`, items[0].Raw) 77 77 + assert.Equal(t, "hello world", items[0].Value) 78 78 + } 79 79 + 80 80 + func TestParseLeadingColon(t *testing.T) { 81 81 + q := Parse(":value") 82 82 + items := q.Items() 83 83 + assert.Equal(t, 1, len(items)) 84 84 + assert.Equal(t, KindKeyword, items[0].Kind) 85 85 + assert.Equal(t, ":value", items[0].Raw) 86 86 + } 87 87 + 88 88 + func TestParseColonInValue(t *testing.T) { 89 89 + q := Parse("key:value:with:colons") 90 90 + items := q.Items() 91 91 + assert.Equal(t, 1, len(items)) 92 92 + assert.Equal(t, "key", items[0].Key) 93 93 + assert.Equal(t, "value:with:colons", items[0].Value) 94 94 + } 95 95 + 96 96 + func TestParseEmptyValue(t *testing.T) { 97 97 + q := Parse("state:") 98 98 + items := q.Items() 99 99 + assert.Equal(t, 1, len(items)) 100 100 + assert.Equal(t, KindTagValue, items[0].Kind) 101 101 + assert.Equal(t, "state", items[0].Key) 102 102 + assert.Equal(t, "", items[0].Value) 103 103 + } 104 104 + 105 105 + func TestQuotedKeyValueIsNotTag(t *testing.T) { 106 106 + q := Parse(`"state:open"`) 107 107 + items := q.Items() 108 108 + assert.Equal(t, 1, len(items)) 109 109 + assert.Equal(t, KindQuoted, items[0].Kind) 110 110 + assert.Equal(t, "state:open", items[0].Value) 111 111 + assert.False(t, q.Has("state")) 112 112 + } 113 113 + 114 114 + func TestConsecutiveQuotes(t *testing.T) { 115 115 + q := Parse(`"one""two"`) 116 116 + items := q.Items() 117 117 + assert.Equal(t, 2, len(items)) 118 118 + assert.Equal(t, `"one"`, items[0].Raw) 119 119 + assert.Equal(t, `"two"`, items[1].Raw) 120 120 + } 121 121 + 122 122 + func TestEscapedQuotes(t *testing.T) { 123 123 + q := Parse(`"hello \"world\""`) 124 124 + items := q.Items() 125 125 + assert.Equal(t, 1, len(items)) 126 126 + assert.Equal(t, KindQuoted, items[0].Kind) 127 127 + assert.Equal(t, `"hello \"world\""`, items[0].Raw) 128 128 + assert.Equal(t, `hello "world"`, items[0].Value) 129 129 + } 130 130 + 131 131 + func TestEscapedBackslash(t *testing.T) { 132 132 + q := Parse(`"hello\\"`) 133 133 + items := q.Items() 134 134 + assert.Equal(t, 1, len(items)) 135 135 + assert.Equal(t, KindQuoted, items[0].Kind) 136 136 + assert.Equal(t, `hello\`, items[0].Value) 137 137 + } 138 138 + 139 139 + func TestNegatedTag(t *testing.T) { 140 140 + q := Parse("state:open -label:bug keyword -label:wontfix") 141 141 + items := q.Items() 142 142 + assert.Equal(t, 4, len(items)) 143 143 + 144 144 + assert.False(t, items[0].Negated) 145 145 + assert.Equal(t, "state", items[0].Key) 146 146 + 147 147 + assert.True(t, items[1].Negated) 148 148 + assert.Equal(t, KindTagValue, items[1].Kind) 149 149 + assert.Equal(t, "label", items[1].Key) 150 150 + assert.Equal(t, "bug", items[1].Value) 151 151 + assert.Equal(t, "-label:bug", items[1].Raw) 152 152 + 153 153 + assert.True(t, items[3].Negated) 154 154 + assert.Equal(t, "wontfix", items[3].Value) 155 155 + 156 156 + // Get/GetAll/Has skip negated tags 157 157 + assert.False(t, q.Has("label")) 158 158 + assert.Equal(t, 0, len(q.GetAll("label"))) 159 159 + 160 160 + // Set doesn't touch negated tags 161 161 + q.Set("label", "feature") 162 162 + assert.Equal(t, "state:open -label:bug keyword -label:wontfix label:feature", q.String()) 163 163 + } 164 164 + 165 165 + func TestNegatedBareWordIsKeyword(t *testing.T) { 166 166 + q := Parse("-keyword") 167 167 + items := q.Items() 168 168 + assert.Equal(t, 1, len(items)) 169 169 + assert.Equal(t, KindKeyword, items[0].Kind) 170 170 + assert.Equal(t, "-keyword", items[0].Raw) 171 171 + } 172 172 + 173 173 + func TestNegatedQuotedPhrase(t *testing.T) { 174 174 + q := Parse(`-"critical bug" state:open`) 175 175 + items := q.Items() 176 176 + assert.Equal(t, 2, len(items)) 177 177 + 178 178 + assert.Equal(t, KindQuoted, items[0].Kind) 179 179 + assert.True(t, items[0].Negated) 180 180 + assert.Equal(t, `-"critical bug"`, items[0].Raw) 181 181 + assert.Equal(t, "critical bug", items[0].Value) 182 182 + 183 183 + assert.Equal(t, KindTagValue, items[1].Kind) 184 184 + assert.Equal(t, "state", items[1].Key) 185 185 + } 186 186 + 187 187 + func TestNegatedQuotedPhraseAmongOthers(t *testing.T) { 188 188 + q := Parse(`"good phrase" -"bad phrase" keyword`) 189 189 + items := q.Items() 190 190 + assert.Equal(t, 3, len(items)) 191 191 + 192 192 + assert.Equal(t, KindQuoted, items[0].Kind) 193 193 + assert.False(t, items[0].Negated) 194 194 + assert.Equal(t, "good phrase", items[0].Value) 195 195 + 196 196 + assert.Equal(t, KindQuoted, items[1].Kind) 197 197 + assert.True(t, items[1].Negated) 198 198 + assert.Equal(t, "bad phrase", items[1].Value) 199 199 + 200 200 + assert.Equal(t, KindKeyword, items[2].Kind) 201 201 + } 202 202 + 203 203 + func TestWhitespaceNormalization(t *testing.T) { 204 204 + q := Parse(" state:open keyword ") 205 205 + assert.Equal(t, "state:open keyword", q.String()) 206 206 + }

+1

appview/state/router.go

··· 340 340 s.db, 341 341 s.validator, 342 342 s.enforcer, 343 343 + s.notifier, 343 344 log.SubLogger(s.logger, "labels"), 344 345 ) 345 346 return ls.Router()