1
1
import * as vscode from 'vscode' ;
2
2
import { ExtensionContext , window as Window } from 'vscode' ;
3
- import { EvaluationInfo , QueryInfo } from './queries' ;
4
- import * as helpers from './helpers' ;
5
- import * as messages from './messages' ;
3
+ import { CompletedQuery } from './query-results' ;
4
+ import { QueryWithResults } from './run-queries' ;
6
5
/**
7
6
* query-history.ts
8
7
* ------------
@@ -12,72 +11,32 @@ import * as messages from './messages';
12
11
* `TreeDataProvider` subclass below.
13
12
*/
14
13
15
- /**
16
- * One item in the user-displayed list of queries that have been run.
17
- */
18
- export class QueryHistoryItem {
19
- queryName : string ;
20
- time : string ;
21
- databaseName : string ;
22
- info : EvaluationInfo ;
23
-
24
- constructor ( info : EvaluationInfo ) {
25
- this . queryName = helpers . getQueryName ( info ) ;
26
- this . databaseName = info . database . name ;
27
- this . info = info ;
28
- this . time = new Date ( ) . toLocaleString ( ) ;
29
- }
30
-
31
- get statusString ( ) : string {
32
- switch ( this . info . result . resultType ) {
33
- case messages . QueryResultType . CANCELLATION :
34
- return `cancelled after ${ this . info . result . evaluationTime / 1000 } seconds` ;
35
- case messages . QueryResultType . OOM :
36
- return `out of memory` ;
37
- case messages . QueryResultType . SUCCESS :
38
- return `finished in ${ this . info . result . evaluationTime / 1000 } seconds` ;
39
- case messages . QueryResultType . TIMEOUT :
40
- return `timed out after ${ this . info . result . evaluationTime / 1000 } seconds` ;
41
- case messages . QueryResultType . OTHER_ERROR :
42
- default :
43
- return `failed` ;
44
- }
45
- }
46
-
47
- toString ( ) : string {
48
- const { databaseName, queryName, time } = this ;
49
- return `[${ time } ] ${ queryName } on ${ databaseName } - ${ this . statusString } ` ;
50
- }
51
- }
52
-
53
14
/**
54
15
* Tree data provider for the query history view.
55
16
*/
56
- class HistoryTreeDataProvider implements vscode . TreeDataProvider < QueryHistoryItem > {
17
+ class HistoryTreeDataProvider implements vscode . TreeDataProvider < CompletedQuery > {
57
18
58
19
/**
59
20
* XXX: This idiom for how to get a `.fire()`-able event emitter was
60
21
* cargo culted from another vscode extension. It seems rather
61
22
* involved and I hope there's something better that can be done
62
23
* instead.
63
24
*/
64
- private _onDidChangeTreeData : vscode . EventEmitter < QueryHistoryItem | undefined > = new vscode . EventEmitter < QueryHistoryItem | undefined > ( ) ;
65
- readonly onDidChangeTreeData : vscode . Event < QueryHistoryItem | undefined > = this . _onDidChangeTreeData . event ;
25
+ private _onDidChangeTreeData : vscode . EventEmitter < CompletedQuery | undefined > = new vscode . EventEmitter < CompletedQuery | undefined > ( ) ;
26
+ readonly onDidChangeTreeData : vscode . Event < CompletedQuery | undefined > = this . _onDidChangeTreeData . event ;
66
27
67
- private ctx : ExtensionContext ;
68
- private history : QueryHistoryItem [ ] = [ ] ;
28
+ private history : CompletedQuery [ ] = [ ] ;
69
29
70
30
/**
71
31
* When not undefined, must be reference-equal to an item in `this.databases`.
72
32
*/
73
- private current : QueryHistoryItem | undefined ;
33
+ private current : CompletedQuery | undefined ;
74
34
75
- constructor ( ctx : ExtensionContext ) {
76
- this . ctx = ctx ;
35
+ constructor ( ) {
77
36
this . history = [ ] ;
78
37
}
79
38
80
- getTreeItem ( element : QueryHistoryItem ) : vscode . TreeItem {
39
+ getTreeItem ( element : CompletedQuery ) : vscode . TreeItem {
81
40
const it = new vscode . TreeItem ( element . toString ( ) ) ;
82
41
83
42
it . command = {
@@ -89,7 +48,7 @@ class HistoryTreeDataProvider implements vscode.TreeDataProvider<QueryHistoryIte
89
48
return it ;
90
49
}
91
50
92
- getChildren ( element ?: QueryHistoryItem ) : vscode . ProviderResult < QueryHistoryItem [ ] > {
51
+ getChildren ( element ?: CompletedQuery ) : vscode . ProviderResult < CompletedQuery [ ] > {
93
52
if ( element == undefined ) {
94
53
return this . history ;
95
54
}
@@ -98,25 +57,25 @@ class HistoryTreeDataProvider implements vscode.TreeDataProvider<QueryHistoryIte
98
57
}
99
58
}
100
59
101
- getParent ( element : QueryHistoryItem ) : vscode . ProviderResult < QueryHistoryItem > {
60
+ getParent ( element : CompletedQuery ) : vscode . ProviderResult < CompletedQuery > {
102
61
return null ;
103
62
}
104
63
105
- getCurrent ( ) : QueryHistoryItem | undefined {
64
+ getCurrent ( ) : CompletedQuery | undefined {
106
65
return this . current ;
107
66
}
108
67
109
- push ( item : QueryHistoryItem ) : void {
68
+ push ( item : CompletedQuery ) : void {
110
69
this . current = item ;
111
70
this . history . push ( item ) ;
112
71
this . _onDidChangeTreeData . fire ( ) ;
113
72
}
114
73
115
- setCurrentItem ( item : QueryHistoryItem ) {
74
+ setCurrentItem ( item : CompletedQuery ) {
116
75
this . current = item ;
117
76
}
118
77
119
- remove ( item : QueryHistoryItem ) {
78
+ remove ( item : CompletedQuery ) {
120
79
if ( this . current === item )
121
80
this . current = undefined ;
122
81
const index = this . history . findIndex ( i => i === item ) ;
@@ -141,23 +100,24 @@ const DOUBLE_CLICK_TIME = 500;
141
100
export class QueryHistoryManager {
142
101
treeDataProvider : HistoryTreeDataProvider ;
143
102
ctx : ExtensionContext ;
144
- treeView : vscode . TreeView < QueryHistoryItem > ;
145
- selectedCallback : ( ( item : QueryHistoryItem ) => void ) | undefined ;
146
- lastItemClick : { time : Date , item : QueryHistoryItem } | undefined ;
103
+ treeView : vscode . TreeView < CompletedQuery > ;
104
+ selectedCallback : ( ( item : CompletedQuery ) => void ) | undefined ;
105
+ lastItemClick : { time : Date , item : CompletedQuery } | undefined ;
106
+
147
107
148
- async invokeCallbackOn ( queryHistoryItem : QueryHistoryItem ) {
108
+ async invokeCallbackOn ( queryHistoryItem : CompletedQuery ) {
149
109
if ( this . selectedCallback !== undefined ) {
150
110
const sc = this . selectedCallback ;
151
111
await sc ( queryHistoryItem ) ;
152
112
}
153
113
}
154
114
155
- async handleOpenQuery ( queryHistoryItem : QueryHistoryItem ) {
156
- const textDocument = await vscode . workspace . openTextDocument ( vscode . Uri . file ( queryHistoryItem . info . query . program . queryPath ) ) ;
115
+ async handleOpenQuery ( queryHistoryItem : CompletedQuery ) {
116
+ const textDocument = await vscode . workspace . openTextDocument ( vscode . Uri . file ( queryHistoryItem . query . program . queryPath ) ) ;
157
117
await vscode . window . showTextDocument ( textDocument , vscode . ViewColumn . One ) ;
158
118
}
159
119
160
- async handleRemoveHistoryItem ( queryHistoryItem : QueryHistoryItem ) {
120
+ async handleRemoveHistoryItem ( queryHistoryItem : CompletedQuery ) {
161
121
this . treeDataProvider . remove ( queryHistoryItem ) ;
162
122
const current = this . treeDataProvider . getCurrent ( ) ;
163
123
if ( current !== undefined ) {
@@ -166,7 +126,7 @@ export class QueryHistoryManager {
166
126
}
167
127
}
168
128
169
- async handleItemClicked ( queryHistoryItem : QueryHistoryItem ) {
129
+ async handleItemClicked ( queryHistoryItem : CompletedQuery ) {
170
130
this . treeDataProvider . setCurrentItem ( queryHistoryItem ) ;
171
131
172
132
const now = new Date ( ) ;
@@ -185,10 +145,10 @@ export class QueryHistoryManager {
185
145
}
186
146
}
187
147
188
- constructor ( ctx : ExtensionContext , selectedCallback ?: ( item : QueryHistoryItem ) => Promise < void > ) {
148
+ constructor ( ctx : ExtensionContext , selectedCallback ?: ( item : CompletedQuery ) => Promise < void > ) {
189
149
this . ctx = ctx ;
190
150
this . selectedCallback = selectedCallback ;
191
- const treeDataProvider = this . treeDataProvider = new HistoryTreeDataProvider ( ctx ) ;
151
+ const treeDataProvider = this . treeDataProvider = new HistoryTreeDataProvider ( ) ;
192
152
this . treeView = Window . createTreeView ( 'codeQLQueryHistory' , { treeDataProvider } ) ;
193
153
this . treeView . onDidChangeSelection ( async ev => {
194
154
if ( ev . selection . length == 0 ) {
@@ -204,8 +164,10 @@ export class QueryHistoryManager {
204
164
} ) ) ;
205
165
}
206
166
207
- push ( item : QueryHistoryItem ) {
167
+ addQuery ( info : QueryWithResults ) : CompletedQuery {
168
+ const item = new CompletedQuery ( info ) ;
208
169
this . treeDataProvider . push ( item ) ;
209
170
this . treeView . reveal ( item , { select : true } ) ;
171
+ return item ;
210
172
}
211
173
}
0 commit comments