create links for values of format: uri-reference

Author: twelvelabs

src/jsonLanguageService.ts

@@ -26,7 +26,7 @@ import {
 	Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic,
 	TextEdit, FormattingOptions, DocumentSymbol, DefinitionLink, MatchingSchema, JSONLanguageStatus, SortOptions
 } from './jsonLanguageTypes';
-import { findLinks } from './services/jsonLinks';
+import { JSONLinks } from './services/jsonLinks';
 import { DocumentLink } from 'vscode-languageserver-types';
 
 export type JSONDocument = {
@@ -67,6 +67,7 @@ export function getLanguageService(params: LanguageServiceParams): LanguageServi
 
 	const jsonCompletion = new JSONCompletion(jsonSchemaService, params.contributions, promise, params.clientCapabilities);
 	const jsonHover = new JSONHover(jsonSchemaService, params.contributions, promise);
+	const jsonLinks = new JSONLinks(jsonSchemaService);
 	const jsonDocumentSymbols = new JSONDocumentSymbols(jsonSchemaService);
 	const jsonValidation = new JSONValidation(jsonSchemaService, promise);
 
@@ -92,7 +93,7 @@ export function getLanguageService(params: LanguageServiceParams): LanguageServi
 		getFoldingRanges,
 		getSelectionRanges,
 		findDefinition: () => Promise.resolve([]),
-		findLinks,
+		findLinks: jsonLinks.findLinks.bind(jsonLinks),
 		format: (document: TextDocument, range: Range, options: FormattingOptions) => format(document, options, range),
 		sort: (document: TextDocument, options: FormattingOptions) => sort(document, options)
 	};

src/services/jsonLinks.ts

@@ -6,24 +6,71 @@
 import { DocumentLink } from 'vscode-languageserver-types';
 import { TextDocument, ASTNode, PropertyASTNode, Range, Thenable } from '../jsonLanguageTypes';
 import { JSONDocument } from '../parser/jsonParser';
+import { IJSONSchemaService } from './jsonSchemaService';
+import { URI } from 'vscode-uri';
+import { existsSync as fileExistsSync } from 'fs';
+import { resolve as resolvePath } from 'path';
 
-export function findLinks(document: TextDocument, doc: JSONDocument): Thenable<DocumentLink[]> {
-	const links: DocumentLink[] = [];
+export class JSONLinks {
+	private schemaService: IJSONSchemaService;
+
+	constructor(schemaService: IJSONSchemaService) {
+		this.schemaService = schemaService;
+	}
+
+	public findLinks(document: TextDocument, doc: JSONDocument): Thenable<DocumentLink[]> {
+		return findLinks(document, doc, this.schemaService);
+	}
+}
+
+export function findLinks(document: TextDocument, doc: JSONDocument, schemaService?: IJSONSchemaService): Thenable<DocumentLink[]> {
+	const promises: Thenable<DocumentLink[]>[] = [];
+
+	const refLinks: DocumentLink[] = [];
 	doc.visit(node => {
-		if (node.type === "property" && node.keyNode.value === "$ref" && node.valueNode?.type === 'string') {
+		if (node.type === "property" && node.valueNode?.type === 'string' && node.keyNode.value === "$ref") {
 			const path = node.valueNode.value;
 			const targetNode = findTargetNode(doc, path);
 			if (targetNode) {
 				const targetPos = document.positionAt(targetNode.offset);
-				links.push({
+				refLinks.push({
 					target: `${document.uri}#${targetPos.line + 1},${targetPos.character + 1}`,
 					range: createRange(document, node.valueNode)
 				});
 			}
 		}
+		if (node.type === "property" && node.valueNode?.type === 'string' && schemaService) {
+			const pathNode = node.valueNode;
+			const pathLinks: DocumentLink[] = [];
+			const promise = schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
+				if (schema) {
+					const matchingSchemas = doc.getMatchingSchemas(schema.schema, pathNode.offset);
+					matchingSchemas.forEach((s) => {
+						if (s.node === pathNode && !s.inverted && s.schema) {
+							if (s.schema.format === 'uri-reference') {
+								const path = resolvePath(pathNode.value);
+								const uri = URI.file(path);
+								if (fileExistsSync(path)) {
+									pathLinks.push({
+										target: uri.toString(),
+										range: createRange(document, pathNode)
+									});
+								}
+							}
+						}
+					});
+				}
+				return pathLinks;
+			});
+			promises.push(promise);
+		}
 		return true;
 	});
-	return Promise.resolve(links);
+
+	promises.push(Promise.resolve(refLinks));
+	return Promise.all(promises).then(values => {
+		return values.flat();
+	});
 }
 
 function createRange(document: TextDocument, node: ASTNode): Range {

src/test/fixtures/uri-reference.txt

@@ -5,7 +5,15 @@
 
 import * as assert from 'assert';
 
-import { getLanguageService, Range, TextDocument, ClientCapabilities } from '../jsonLanguageService';
+import {
+	ClientCapabilities,
+	DocumentLink,
+	getLanguageService,
+	JSONSchema,
+	Range,
+	TextDocument,
+} from '../jsonLanguageService';
+import { resolve as resolvePath } from 'path';
 
 suite('JSON Find Links', () => {
 	const testFindLinksFor = function (value: string, expected: {offset: number, length: number, target: number} | null): PromiseLike<void> {
@@ -26,6 +34,20 @@ suite('JSON Find Links', () => {
 		});
 	};
 
+	let requestService = function (uri: string): Promise<string> {
+		return Promise.reject<string>('Resource not found');
+	};
+
+	function testFindLinksWithSchema(document: TextDocument, schema: JSONSchema): PromiseLike<DocumentLink[]> {
+		const schemaUri = "http://myschemastore/test1";
+
+		const ls = getLanguageService({ clientCapabilities: ClientCapabilities.LATEST });
+		ls.configure({ schemas: [{ fileMatch: ["*.json"], uri: schemaUri, schema }] });
+		const jsonDoc = ls.parseJSONDocument(document);
+
+		return ls.findLinks(document, jsonDoc);
+	}
+
 	test('FindDefinition invalid ref', async function () {
 		await testFindLinksFor('{}', null);
 		await testFindLinksFor('{"name": "John"}', null);
@@ -52,4 +74,38 @@ suite('JSON Find Links', () => {
 		await testFindLinksFor(doc('#/ '), {target: 81, offset: 102, length: 3});
 		await testFindLinksFor(doc('#/m~0n'), {target: 90, offset: 102, length: 6});
 	});
+
+	test('URI reference link', async function () {
+		const relativePath = './src/test/fixtures/uri-reference.txt';
+		const content = `{"stringProp": "string-value", "uriProp": "${relativePath}", "uriPropNotFound": "./does/not/exist.txt"}`;
+		const document = TextDocument.create('test://test.json', 'json', 0, content);
+		const schema: JSONSchema = {
+			type: 'object',
+			properties: {
+				'stringProp': {
+					type: 'string',
+				},
+				'uriProp': {
+					type: 'string',
+					format: 'uri-reference'
+				},
+				'uriPropNotFound': {
+					type: 'string',
+					format: 'uri-reference'
+				}
+			}
+		};
+		await testFindLinksWithSchema(document, schema).then((links) => {
+			assert.notDeepEqual(links, []);
+
+			const absPath = resolvePath(relativePath);
+			assert.equal(links[0].target, `file://${absPath}`);
+
+			const startOffset = content.indexOf(relativePath);
+			const endOffset = startOffset + relativePath.length;
+			const range = Range.create(document.positionAt(startOffset), document.positionAt(endOffset));
+			assert.deepEqual(links[0].range, range);
+		});
+	});
+
 });