UNPKG

40 kBJavaScriptView Raw
1"use strict";
2var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
3 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
4 return new (P || (P = Promise))(function (resolve, reject) {
5 function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
6 function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
7 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
8 step((generator = generator.apply(thisArg, _arguments || [])).next());
9 });
10};
11Object.defineProperty(exports, "__esModule", { value: true });
12const convert_1 = require("../convert");
13const Utils = require("../utils");
14const languageclient_1 = require("../languageclient");
15const atom_1 = require("atom");
16/** Public: Adapts the documentSymbolProvider of the language server to the Outline View supplied by Atom IDE UI. */
17class OutlineViewAdapter {
18 constructor() {
19 this._cancellationTokens = new WeakMap();
20 }
21 /**
22 * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities
23 * matrix containing a documentSymbolProvider.
24 *
25 * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
26 * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.
27 */
28 static canAdapt(serverCapabilities) {
29 return serverCapabilities.documentSymbolProvider === true;
30 }
31 /**
32 * Public: Obtain the Outline for document via the {LanguageClientConnection} as identified by the {TextEditor}.
33 *
34 * @param connection A {LanguageClientConnection} to the language server that will be queried for the outline.
35 * @param editor The Atom {TextEditor} containing the text the Outline should represent.
36 * @returns A {Promise} containing the {Outline} of this document.
37 */
38 getOutline(connection, editor) {
39 return __awaiter(this, void 0, void 0, function* () {
40 const results = yield Utils.doWithCancellationToken(connection, this._cancellationTokens, (cancellationToken) => connection.documentSymbol({ textDocument: convert_1.default.editorToTextDocumentIdentifier(editor) }, cancellationToken));
41 if (results === null || results.length === 0) {
42 return {
43 outlineTrees: [],
44 };
45 }
46 if (results[0].selectionRange !== undefined) {
47 // If the server is giving back the newer DocumentSymbol format.
48 return {
49 outlineTrees: OutlineViewAdapter.createHierarchicalOutlineTrees(results),
50 };
51 }
52 else {
53 // If the server is giving back the original SymbolInformation format.
54 return {
55 outlineTrees: OutlineViewAdapter.createOutlineTrees(results),
56 };
57 }
58 });
59 }
60 /**
61 * Public: Create an {Array} of {OutlineTree}s from the Array of {DocumentSymbol} recieved from the language server.
62 * This includes converting all the children nodes in the entire hierarchy.
63 *
64 * @param symbols An {Array} of {DocumentSymbol}s received from the language server that should be converted to an
65 * {Array} of {OutlineTree}.
66 * @returns An {Array} of {OutlineTree} containing the given symbols that the Outline View can display.
67 */
68 static createHierarchicalOutlineTrees(symbols) {
69 // Sort all the incoming symbols
70 symbols.sort((a, b) => {
71 if (a.range.start.line !== b.range.start.line) {
72 return a.range.start.line - b.range.start.line;
73 }
74 if (a.range.start.character !== b.range.start.character) {
75 return a.range.start.character - b.range.start.character;
76 }
77 if (a.range.end.line !== b.range.end.line) {
78 return a.range.end.line - b.range.end.line;
79 }
80 return a.range.end.character - b.range.end.character;
81 });
82 return symbols.map((symbol) => {
83 const tree = OutlineViewAdapter.hierarchicalSymbolToOutline(symbol);
84 if (symbol.children != null) {
85 tree.children = OutlineViewAdapter.createHierarchicalOutlineTrees(symbol.children);
86 }
87 return tree;
88 });
89 }
90 /**
91 * Public: Create an {Array} of {OutlineTree}s from the Array of {SymbolInformation} recieved from the language
92 * server. This includes determining the appropriate child and parent relationships for the hierarchy.
93 *
94 * @param symbols An {Array} of {SymbolInformation}s received from the language server that should be converted to an
95 * {OutlineTree}.
96 * @returns An {OutlineTree} containing the given symbols that the Outline View can display.
97 */
98 static createOutlineTrees(symbols) {
99 symbols.sort((a, b) => {
100 if (a.location.range.start.line === b.location.range.start.line) {
101 return a.location.range.start.character - b.location.range.start.character;
102 }
103 else {
104 return a.location.range.start.line - b.location.range.start.line;
105 }
106 });
107 // Temporarily keep containerName through the conversion process
108 // Also filter out symbols without a name - it's part of the spec but some don't include it
109 const allItems = symbols
110 .filter((symbol) => symbol.name)
111 .map((symbol) => ({
112 containerName: symbol.containerName,
113 outline: OutlineViewAdapter.symbolToOutline(symbol),
114 }));
115 // Create a map of containers by name with all items that have that name
116 const containers = allItems.reduce((map, item) => {
117 const name = item.outline.representativeName;
118 if (name != null) {
119 const container = map.get(name);
120 if (container == null) {
121 map.set(name, [item.outline]);
122 }
123 else {
124 container.push(item.outline);
125 }
126 }
127 return map;
128 }, new Map());
129 const roots = [];
130 // Put each item within its parent and extract out the roots
131 for (const item of allItems) {
132 const containerName = item.containerName;
133 const child = item.outline;
134 if (containerName == null || containerName === "") {
135 roots.push(item.outline);
136 }
137 else {
138 const possibleParents = containers.get(containerName);
139 let closestParent = OutlineViewAdapter._getClosestParent(possibleParents, child);
140 if (closestParent == null) {
141 closestParent = {
142 plainText: containerName,
143 representativeName: containerName,
144 startPosition: new atom_1.Point(0, 0),
145 children: [child],
146 };
147 roots.push(closestParent);
148 if (possibleParents == null) {
149 containers.set(containerName, [closestParent]);
150 }
151 else {
152 possibleParents.push(closestParent);
153 }
154 }
155 else {
156 closestParent.children.push(child);
157 }
158 }
159 }
160 return roots;
161 }
162 static _getClosestParent(candidates, child) {
163 if (candidates == null || candidates.length === 0) {
164 return null;
165 }
166 let parent;
167 for (const candidate of candidates) {
168 if (candidate !== child &&
169 candidate.startPosition.isLessThanOrEqual(child.startPosition) &&
170 (candidate.endPosition === undefined ||
171 (child.endPosition && candidate.endPosition.isGreaterThanOrEqual(child.endPosition)))) {
172 if (parent === undefined ||
173 parent.startPosition.isLessThanOrEqual(candidate.startPosition) ||
174 (parent.endPosition != null &&
175 candidate.endPosition &&
176 parent.endPosition.isGreaterThanOrEqual(candidate.endPosition))) {
177 parent = candidate;
178 }
179 }
180 }
181 return parent || null;
182 }
183 /**
184 * Public: Convert an individual {DocumentSymbol} from the language server to an {OutlineTree} for use by the Outline
185 * View. It does NOT recursively process the given symbol's children (if any).
186 *
187 * @param symbol The {DocumentSymbol} to convert to an {OutlineTree}.
188 * @returns The {OutlineTree} corresponding to the given {DocumentSymbol}.
189 */
190 static hierarchicalSymbolToOutline(symbol) {
191 const icon = OutlineViewAdapter.symbolKindToEntityKind(symbol.kind);
192 return {
193 tokenizedText: [
194 {
195 kind: OutlineViewAdapter.symbolKindToTokenKind(symbol.kind),
196 value: symbol.name,
197 },
198 ],
199 icon: icon != null ? icon : undefined,
200 representativeName: symbol.name,
201 startPosition: convert_1.default.positionToPoint(symbol.selectionRange.start),
202 endPosition: convert_1.default.positionToPoint(symbol.selectionRange.end),
203 children: [],
204 };
205 }
206 /**
207 * Public: Convert an individual {SymbolInformation} from the language server to an {OutlineTree} for use by the Outline View.
208 *
209 * @param symbol The {SymbolInformation} to convert to an {OutlineTree}.
210 * @returns The {OutlineTree} equivalent to the given {SymbolInformation}.
211 */
212 static symbolToOutline(symbol) {
213 const icon = OutlineViewAdapter.symbolKindToEntityKind(symbol.kind);
214 return {
215 tokenizedText: [
216 {
217 kind: OutlineViewAdapter.symbolKindToTokenKind(symbol.kind),
218 value: symbol.name,
219 },
220 ],
221 icon: icon != null ? icon : undefined,
222 representativeName: symbol.name,
223 startPosition: convert_1.default.positionToPoint(symbol.location.range.start),
224 endPosition: convert_1.default.positionToPoint(symbol.location.range.end),
225 children: [],
226 };
227 }
228 /**
229 * Public: Convert a symbol kind into an outline entity kind used to determine the styling such as the appropriate
230 * icon in the Outline View.
231 *
232 * @param symbol The numeric symbol kind received from the language server.
233 * @returns A string representing the equivalent OutlineView entity kind.
234 */
235 static symbolKindToEntityKind(symbol) {
236 switch (symbol) {
237 case languageclient_1.SymbolKind.Array:
238 return "type-array";
239 case languageclient_1.SymbolKind.Boolean:
240 return "type-boolean";
241 case languageclient_1.SymbolKind.Class:
242 return "type-class";
243 case languageclient_1.SymbolKind.Constant:
244 return "type-constant";
245 case languageclient_1.SymbolKind.Constructor:
246 return "type-constructor";
247 case languageclient_1.SymbolKind.Enum:
248 return "type-enum";
249 case languageclient_1.SymbolKind.Field:
250 return "type-field";
251 case languageclient_1.SymbolKind.File:
252 return "type-file";
253 case languageclient_1.SymbolKind.Function:
254 return "type-function";
255 case languageclient_1.SymbolKind.Interface:
256 return "type-interface";
257 case languageclient_1.SymbolKind.Method:
258 return "type-method";
259 case languageclient_1.SymbolKind.Module:
260 return "type-module";
261 case languageclient_1.SymbolKind.Namespace:
262 return "type-namespace";
263 case languageclient_1.SymbolKind.Number:
264 return "type-number";
265 case languageclient_1.SymbolKind.Package:
266 return "type-package";
267 case languageclient_1.SymbolKind.Property:
268 return "type-property";
269 case languageclient_1.SymbolKind.String:
270 return "type-string";
271 case languageclient_1.SymbolKind.Variable:
272 return "type-variable";
273 case languageclient_1.SymbolKind.Struct:
274 return "type-class";
275 case languageclient_1.SymbolKind.EnumMember:
276 return "type-constant";
277 default:
278 return null;
279 }
280 }
281 /**
282 * Public: Convert a symbol kind to the appropriate token kind used to syntax highlight the symbol name in the Outline View.
283 *
284 * @param symbol The numeric symbol kind received from the language server.
285 * @returns A string representing the equivalent syntax token kind.
286 */
287 static symbolKindToTokenKind(symbol) {
288 switch (symbol) {
289 case languageclient_1.SymbolKind.Class:
290 return "type";
291 case languageclient_1.SymbolKind.Constructor:
292 return "constructor";
293 case languageclient_1.SymbolKind.Method:
294 case languageclient_1.SymbolKind.Function:
295 return "method";
296 case languageclient_1.SymbolKind.String:
297 return "string";
298 default:
299 return "plain";
300 }
301 }
302}
303exports.default = OutlineViewAdapter;
304//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"outline-view-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/outline-view-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as atomIde from \"atom-ide-base\"\nimport Convert from \"../convert\"\nimport * as Utils from \"../utils\"\nimport { CancellationTokenSource } from \"vscode-jsonrpc\"\nimport {\n  LanguageClientConnection,\n  SymbolKind,\n  ServerCapabilities,\n  SymbolInformation,\n  DocumentSymbol,\n} from \"../languageclient\"\nimport { Point, TextEditor } from \"atom\"\n\n/** Public: Adapts the documentSymbolProvider of the language server to the Outline View supplied by Atom IDE UI. */\nexport default class OutlineViewAdapter {\n  private _cancellationTokens: WeakMap<LanguageClientConnection, CancellationTokenSource> = new WeakMap()\n\n  /**\n   * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities\n   * matrix containing a documentSymbolProvider.\n   *\n   * @param serverCapabilities The {ServerCapabilities} of the language server to consider.\n   * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.\n   */\n  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {\n    return serverCapabilities.documentSymbolProvider === true\n  }\n\n  /**\n   * Public: Obtain the Outline for document via the {LanguageClientConnection} as identified by the {TextEditor}.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will be queried for the outline.\n   * @param editor The Atom {TextEditor} containing the text the Outline should represent.\n   * @returns A {Promise} containing the {Outline} of this document.\n   */\n  public async getOutline(connection: LanguageClientConnection, editor: TextEditor): Promise<atomIde.Outline | null> {\n    const results = await Utils.doWithCancellationToken(connection, this._cancellationTokens, (cancellationToken) =>\n      connection.documentSymbol({ textDocument: Convert.editorToTextDocumentIdentifier(editor) }, cancellationToken)\n    )\n\n    if (results === null || results.length === 0) {\n      return {\n        outlineTrees: [],\n      }\n    }\n\n    if ((results[0] as DocumentSymbol).selectionRange !== undefined) {\n      // If the server is giving back the newer DocumentSymbol format.\n      return {\n        outlineTrees: OutlineViewAdapter.createHierarchicalOutlineTrees(results as DocumentSymbol[]),\n      }\n    } else {\n      // If the server is giving back the original SymbolInformation format.\n      return {\n        outlineTrees: OutlineViewAdapter.createOutlineTrees(results as SymbolInformation[]),\n      }\n    }\n  }\n\n  /**\n   * Public: Create an {Array} of {OutlineTree}s from the Array of {DocumentSymbol} recieved from the language server.\n   * This includes converting all the children nodes in the entire hierarchy.\n   *\n   * @param symbols An {Array} of {DocumentSymbol}s received from the language server that should be converted to an\n   *   {Array} of {OutlineTree}.\n   * @returns An {Array} of {OutlineTree} containing the given symbols that the Outline View can display.\n   */\n  public static createHierarchicalOutlineTrees(symbols: DocumentSymbol[]): atomIde.OutlineTree[] {\n    // Sort all the incoming symbols\n    symbols.sort((a, b) => {\n      if (a.range.start.line !== b.range.start.line) {\n        return a.range.start.line - b.range.start.line\n      }\n\n      if (a.range.start.character !== b.range.start.character) {\n        return a.range.start.character - b.range.start.character\n      }\n\n      if (a.range.end.line !== b.range.end.line) {\n        return a.range.end.line - b.range.end.line\n      }\n\n      return a.range.end.character - b.range.end.character\n    })\n\n    return symbols.map((symbol) => {\n      const tree = OutlineViewAdapter.hierarchicalSymbolToOutline(symbol)\n\n      if (symbol.children != null) {\n        tree.children = OutlineViewAdapter.createHierarchicalOutlineTrees(symbol.children)\n      }\n\n      return tree\n    })\n  }\n\n  /**\n   * Public: Create an {Array} of {OutlineTree}s from the Array of {SymbolInformation} recieved from the language\n   * server. This includes determining the appropriate child and parent relationships for the hierarchy.\n   *\n   * @param symbols An {Array} of {SymbolInformation}s received from the language server that should be converted to an\n   *   {OutlineTree}.\n   * @returns An {OutlineTree} containing the given symbols that the Outline View can display.\n   */\n  public static createOutlineTrees(symbols: SymbolInformation[]): atomIde.OutlineTree[] {\n    symbols.sort((a, b) => {\n      if (a.location.range.start.line === b.location.range.start.line) {\n        return a.location.range.start.character - b.location.range.start.character\n      } else {\n        return a.location.range.start.line - b.location.range.start.line\n      }\n    })\n\n    // Temporarily keep containerName through the conversion process\n    // Also filter out symbols without a name - it's part of the spec but some don't include it\n    const allItems = symbols\n      .filter((symbol) => symbol.name)\n      .map((symbol) => ({\n        containerName: symbol.containerName,\n        outline: OutlineViewAdapter.symbolToOutline(symbol),\n      }))\n\n    // Create a map of containers by name with all items that have that name\n    const containers = allItems.reduce((map, item) => {\n      const name = item.outline.representativeName\n      if (name != null) {\n        const container = map.get(name)\n        if (container == null) {\n          map.set(name, [item.outline])\n        } else {\n          container.push(item.outline)\n        }\n      }\n      return map\n    }, new Map())\n\n    const roots: atomIde.OutlineTree[] = []\n\n    // Put each item within its parent and extract out the roots\n    for (const item of allItems) {\n      const containerName = item.containerName\n      const child = item.outline\n      if (containerName == null || containerName === \"\") {\n        roots.push(item.outline)\n      } else {\n        const possibleParents = containers.get(containerName)\n        let closestParent = OutlineViewAdapter._getClosestParent(possibleParents, child)\n        if (closestParent == null) {\n          closestParent = {\n            plainText: containerName,\n            representativeName: containerName,\n            startPosition: new Point(0, 0),\n            children: [child],\n          }\n          roots.push(closestParent)\n          if (possibleParents == null) {\n            containers.set(containerName, [closestParent])\n          } else {\n            possibleParents.push(closestParent)\n          }\n        } else {\n          closestParent.children.push(child)\n        }\n      }\n    }\n\n    return roots\n  }\n\n  private static _getClosestParent(\n    candidates: atomIde.OutlineTree[] | null,\n    child: atomIde.OutlineTree\n  ): atomIde.OutlineTree | null {\n    if (candidates == null || candidates.length === 0) {\n      return null\n    }\n\n    let parent: atomIde.OutlineTree | undefined\n    for (const candidate of candidates) {\n      if (\n        candidate !== child &&\n        candidate.startPosition.isLessThanOrEqual(child.startPosition) &&\n        (candidate.endPosition === undefined ||\n          (child.endPosition && candidate.endPosition.isGreaterThanOrEqual(child.endPosition)))\n      ) {\n        if (\n          parent === undefined ||\n          parent.startPosition.isLessThanOrEqual(candidate.startPosition) ||\n          (parent.endPosition != null &&\n            candidate.endPosition &&\n            parent.endPosition.isGreaterThanOrEqual(candidate.endPosition))\n        ) {\n          parent = candidate\n        }\n      }\n    }\n\n    return parent || null\n  }\n\n  /**\n   * Public: Convert an individual {DocumentSymbol} from the language server to an {OutlineTree} for use by the Outline\n   * View. It does NOT recursively process the given symbol's children (if any).\n   *\n   * @param symbol The {DocumentSymbol} to convert to an {OutlineTree}.\n   * @returns The {OutlineTree} corresponding to the given {DocumentSymbol}.\n   */\n  public static hierarchicalSymbolToOutline(symbol: DocumentSymbol): atomIde.OutlineTree {\n    const icon = OutlineViewAdapter.symbolKindToEntityKind(symbol.kind)\n\n    return {\n      tokenizedText: [\n        {\n          kind: OutlineViewAdapter.symbolKindToTokenKind(symbol.kind),\n          value: symbol.name,\n        },\n      ],\n      icon: icon != null ? icon : undefined,\n      representativeName: symbol.name,\n      startPosition: Convert.positionToPoint(symbol.selectionRange.start),\n      endPosition: Convert.positionToPoint(symbol.selectionRange.end),\n      children: [],\n    }\n  }\n\n  /**\n   * Public: Convert an individual {SymbolInformation} from the language server to an {OutlineTree} for use by the Outline View.\n   *\n   * @param symbol The {SymbolInformation} to convert to an {OutlineTree}.\n   * @returns The {OutlineTree} equivalent to the given {SymbolInformation}.\n   */\n  public static symbolToOutline(symbol: SymbolInformation): atomIde.OutlineTree {\n    const icon = OutlineViewAdapter.symbolKindToEntityKind(symbol.kind)\n    return {\n      tokenizedText: [\n        {\n          kind: OutlineViewAdapter.symbolKindToTokenKind(symbol.kind),\n          value: symbol.name,\n        },\n      ],\n      icon: icon != null ? icon : undefined,\n      representativeName: symbol.name,\n      startPosition: Convert.positionToPoint(symbol.location.range.start),\n      endPosition: Convert.positionToPoint(symbol.location.range.end),\n      children: [],\n    }\n  }\n\n  /**\n   * Public: Convert a symbol kind into an outline entity kind used to determine the styling such as the appropriate\n   * icon in the Outline View.\n   *\n   * @param symbol The numeric symbol kind received from the language server.\n   * @returns A string representing the equivalent OutlineView entity kind.\n   */\n  public static symbolKindToEntityKind(symbol: number): string | null {\n    switch (symbol) {\n      case SymbolKind.Array:\n        return \"type-array\"\n      case SymbolKind.Boolean:\n        return \"type-boolean\"\n      case SymbolKind.Class:\n        return \"type-class\"\n      case SymbolKind.Constant:\n        return \"type-constant\"\n      case SymbolKind.Constructor:\n        return \"type-constructor\"\n      case SymbolKind.Enum:\n        return \"type-enum\"\n      case SymbolKind.Field:\n        return \"type-field\"\n      case SymbolKind.File:\n        return \"type-file\"\n      case SymbolKind.Function:\n        return \"type-function\"\n      case SymbolKind.Interface:\n        return \"type-interface\"\n      case SymbolKind.Method:\n        return \"type-method\"\n      case SymbolKind.Module:\n        return \"type-module\"\n      case SymbolKind.Namespace:\n        return \"type-namespace\"\n      case SymbolKind.Number:\n        return \"type-number\"\n      case SymbolKind.Package:\n        return \"type-package\"\n      case SymbolKind.Property:\n        return \"type-property\"\n      case SymbolKind.String:\n        return \"type-string\"\n      case SymbolKind.Variable:\n        return \"type-variable\"\n      case SymbolKind.Struct:\n        return \"type-class\"\n      case SymbolKind.EnumMember:\n        return \"type-constant\"\n      default:\n        return null\n    }\n  }\n\n  /**\n   * Public: Convert a symbol kind to the appropriate token kind used to syntax highlight the symbol name in the Outline View.\n   *\n   * @param symbol The numeric symbol kind received from the language server.\n   * @returns A string representing the equivalent syntax token kind.\n   */\n  public static symbolKindToTokenKind(symbol: number): atomIde.TokenKind {\n    switch (symbol) {\n      case SymbolKind.Class:\n        return \"type\"\n      case SymbolKind.Constructor:\n        return \"constructor\"\n      case SymbolKind.Method:\n      case SymbolKind.Function:\n        return \"method\"\n      case SymbolKind.String:\n        return \"string\"\n      default:\n        return \"plain\"\n    }\n  }\n}\n"]}
\No newline at end of file