diff --git a/package.json b/package.json index 83c607a..55aa370 100644 --- a/package.json +++ b/package.json @@ -82,6 +82,11 @@ "default": true, "description": "Put each xmlns attribute on a new line when formatting XML." }, + "xmlTools.xmlFormatterImplementation": { + "type": "string", + "default": "classic", + "description": "Supported XML Formatters: classic" + }, "xmlTools.xqueryExecutionArguments": { "type": "array", "default": ["-xquery", "$(script)", "-in", "$(input)", "-out", "$(input.output.xml"], diff --git a/src/extension.ts b/src/extension.ts index 15d78b0..720c780 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -1,29 +1,27 @@ -"use strict"; -// The module 'vscode' contains the VS Code extensibility API -// Import the module and reference it with the alias vscode in your code below -import * as vscode from "vscode"; +import { workspace } from "vscode"; +import { ExtensionContext, WorkspaceConfiguration } from "vscode"; -// this method is called when your extension is activated -// your extension is activated the very first time the command is executed -export function activate(context: vscode.ExtensionContext) { +const onActivateHandlers: OnActivateHandler[] = []; +const onDeactivateHandlers: OnDeactivateHandler[] = []; - // Use the console to output diagnostic information (console.log) and errors (console.error) - // This line of code will only be executed once when your extension is activated - console.log("Congratulations, your extension \"xml\" is now active!"); +export function activate(context: ExtensionContext) { + const workspaceConfiguration = workspace.getConfiguration("xmlTools"); - // The command has been defined in the package.json file - // Now provide the implementation of the command with registerCommand - // The commandId parameter must match the command field in package.json - const disposable = vscode.commands.registerCommand("extension.sayHello", () => { - // The code you place here will be executed every time your command is executed - - // Display a message box to the user - vscode.window.showInformationMessage("Hello World!"); - }); - - context.subscriptions.push(disposable); + onActivateHandlers.forEach(x => x(context, workspaceConfiguration)); } -// this method is called when your extension is deactivated export function deactivate() { + onDeactivateHandlers.forEach(x => x()); } + +export function onActivate(handler: OnActivateHandler): void { + onActivateHandlers.push(handler); +} + +export function onDeactivate(handler: OnDeactivateHandler): void { + onDeactivateHandlers.push(handler); +} + +export type OnActivateHandler = (context: ExtensionContext, config: WorkspaceConfiguration) => void; + +export type OnDeactivateHandler = () => void; diff --git a/src/formatting/formatters/classic-xml-formatter.ts b/src/formatting/formatters/classic-xml-formatter.ts new file mode 100644 index 0000000..12a10c9 --- /dev/null +++ b/src/formatting/formatters/classic-xml-formatter.ts @@ -0,0 +1,123 @@ +import { XmlFormatter } from "../xml-formatter"; +import { XmlFormattingOptions } from "../xml-formatting-options"; + +export class ClassicXmlFormatter implements XmlFormatter { + + formatXml(xml: string, options: XmlFormattingOptions): string { + xml = this.minifyXml(xml, options); + xml = xml.replace(/ -1) { + output += this._getIndent(options, level, parts[i]); + inComment = true; + + // end /) > -1 || parts[i].search(/\]>/) > -1 || parts[i].search(/!DOCTYPE/) > -1) { + inComment = false; + } + } else if (parts[i].search(/-->/) > -1 || parts[i].search(/\]>/) > -1) { + output += parts[i]; + inComment = false; + } else if (/^<(\w|:)/.test(parts[i - 1]) && /^<\/(\w|:)/.test(parts[i]) + && /^<[\w:\-\.\,\/]+/.exec(parts[i - 1])[0] === /^<\/[\w:\-\.\,]+/.exec(parts[i])[0].replace("/", "")) { + + output += parts[i]; + if (!inComment) { level--; } + } else if (parts[i].search(/<(\w|:)/) > -1 && parts[i].search(/<\//) === -1 && parts[i].search(/\/>/) === -1) { + output = (!inComment) ? output += this._getIndent(options, level++, parts[i]) : output += parts[i]; + } else if (parts[i].search(/<(\w|:)/) > -1 && parts[i].search(/<\//) > -1) { + output = (!inComment) ? output += this._getIndent(options, level, parts[i]) : output += parts[i]; + } else if (parts[i].search(/<\//) > -1) { + output = (!inComment) ? output += this._getIndent(options, --level, parts[i]) : output += parts[i]; + } else if (parts[i].search(/\/>/) > -1 && (!options.splitXmlnsOnFormat || parts[i].search(/xmlns(:|=)/) === -1)) { + output = (!inComment) ? output += this._getIndent(options, level, parts[i]) : output += parts[i]; + } else if (parts[i].search(/\/>/) > -1 && parts[i].search(/xmlns(:|=)/) > -1 && options.splitXmlnsOnFormat) { + output = (!inComment) ? output += this._getIndent(options, level--, parts[i]) : output += parts[i]; + } else if (parts[i].search(/<\?/) > -1) { + output += this._getIndent(options, level, parts[i]); + } else if (options.splitXmlnsOnFormat && (parts[i].search(/xmlns\:/) > -1 || parts[i].search(/xmlns\=/) > -1)) { + output += this._getIndent(options, level, parts[i]); + } else { + output += parts[i]; + } + } + + // remove leading newline + if (output[0] === options.newLine) { + output = output.slice(1); + } else if (output.substring(0, 1) === options.newLine) { + output = output.slice(2); + } + + return output; + } + + minifyXml(xml: string, options: XmlFormattingOptions): string { + xml = this._stripLineBreaks(options, xml); // all line breaks outside of CDATA elements + xml = (options.removeCommentsOnMinify) ? xml.replace(/\/g, "") : xml; + xml = xml.replace(/>\s{0,}<"); // insignificant whitespace between tags + xml = xml.replace(/"\s+(?=[^\s]+=)/g, "\" "); // spaces between attributes + xml = xml.replace(/"\s+(?=>)/g, "\""); // spaces between the last attribute and tag close (>) + xml = xml.replace(/"\s+(?=\/>)/g, "\" "); // spaces between the last attribute and tag close (/>) + xml = xml.replace(/[^ <>="]\s+[^ <>="]+=/g, (match: string) => { // spaces between the node name and the first attribute + return match.replace(/\s+/g, " "); + }); + + return xml; + } + + private _getIndent(options: XmlFormattingOptions, level: number, trailingValue?: string): string { + trailingValue = trailingValue || ""; + + const indentPattern = (options.editorOptions.preferSpaces) ? " ".repeat(options.editorOptions.tabSize) : "\t"; + + return `${options.newLine}${indentPattern.repeat(level)}${trailingValue}`; + } + + private _stripLineBreaks(options: XmlFormattingOptions, xml: string): string { + let output = ""; + const inTag = false; + const inTagName = false; + let inCdata = false; + const inAttribute = false; + + for (let i = 0; i < xml.length; i++) { + const char: string = xml.charAt(i); + const prev: string = xml.charAt(i - 1); + const next: string = xml.charAt(i + 1); + + if (char === "!" && (xml.substr(i, 8) === "![CDATA[" || xml.substr(i, 3) === "!--")) { + inCdata = true; + } else if (char === "]" && (xml.substr(i, 3) === "]]>")) { + inCdata = false; + } else if (char === "-" && (xml.substr(i, 3) === "-->")) { + inCdata = false; + } else if (char.search(/[\r\n]/g) > -1 && !inCdata) { + if (/\r/.test(char) && /\S|\r|\n/.test(prev) && /\S|\r|\n/.test(xml.charAt(i + options.newLine.length))) { + output += char; + } else if (/\n/.test(char) && /\S|\r|\n/.test(xml.charAt(i - options.newLine.length)) && /\S|\r|\n/.test(next)) { + output += char; + } + + continue; + } + + output += char; + } + + return output; + } +} diff --git a/src/formatting/xml-formatter.ts b/src/formatting/xml-formatter.ts new file mode 100644 index 0000000..2ad9111 --- /dev/null +++ b/src/formatting/xml-formatter.ts @@ -0,0 +1,6 @@ +import { XmlFormattingOptions } from "./xml-formatting-options"; + +export interface XmlFormatter { + formatXml(xml: string, options: XmlFormattingOptions): string; + minifyXml(xml: string, options: XmlFormattingOptions): string; +} diff --git a/src/formatting/xml-formatting-edit-provider.ts b/src/formatting/xml-formatting-edit-provider.ts new file mode 100644 index 0000000..a82c1b0 --- /dev/null +++ b/src/formatting/xml-formatting-edit-provider.ts @@ -0,0 +1,66 @@ +import { commands, languages } from "vscode"; +import { + CancellationToken, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider, ExtensionContext, + FormattingOptions, ProviderResult, Range, TextDocument, TextEdit, TextEditor, WorkspaceConfiguration +} from "vscode"; + +import * as extension from "../extension"; +import { XmlFormatter } from "./xml-formatter"; + +import { ClassicXmlFormatter } from "./formatters/classic-xml-formatter"; + +extension.onActivate((context: ExtensionContext, config: WorkspaceConfiguration) => { + const xmlFormatterImplementationSetting = config.get("xmlFormatterImplementation"); + let xmlFormatterImplementation: XmlFormatter; + + switch (xmlFormatterImplementationSetting) { + case "classic": + default: xmlFormatterImplementation = new ClassicXmlFormatter(); break; + } + + // tslint:disable-next-line:no-use-before-declare + const xmlFormattingEditProvider = new XmlFormattingEditProvider(config, xmlFormatterImplementation); + + const formatAsXmlCommand = commands.registerTextEditorCommand("xmlTools.formatAsXml", (textEditor) => { + // TODO: implement command + }); + + const minifyXmlCommand = commands.registerTextEditorCommand("xmlTools.minifyXml", (textEditor: TextEditor) => { + // TODO: implement command + }); + + context.subscriptions.push( + formatAsXmlCommand, + minifyXmlCommand, + languages.registerDocumentFormattingEditProvider("xml", xmlFormattingEditProvider), + languages.registerDocumentRangeFormattingEditProvider("xml", xmlFormattingEditProvider) + ); +}); + +export class XmlFormattingEditProvider implements DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider { + + constructor( + public workspaceConfiguration: WorkspaceConfiguration, + public xmlFormatter: XmlFormatter + ) { } + + provideDocumentFormattingEdits(document: TextDocument, options: FormattingOptions, token: CancellationToken): ProviderResult { + const lastLine = document.lineAt(document.lineCount - 1); + const documentRange = new Range(document.positionAt(0), lastLine.range.end); + + return this.provideDocumentRangeFormattingEdits(document, documentRange, options, token); + } + + provideDocumentRangeFormattingEdits(document: TextDocument, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult { + let xml = document.getText(range); + + xml = this.xmlFormatter.formatXml(xml, { + editorOptions: options, + newLine: document.eol.toString(), + removeCommentsOnMinify: this.workspaceConfiguration.get("removeCommentsOnMinify"), + splitXmlnsOnFormat: this.workspaceConfiguration.get("splitXmlnsOnFormat") + }); + + return [ TextEdit.replace(range, xml) ]; + } +} diff --git a/src/formatting/xml-formatting-options.ts b/src/formatting/xml-formatting-options.ts new file mode 100644 index 0000000..439bdba --- /dev/null +++ b/src/formatting/xml-formatting-options.ts @@ -0,0 +1,8 @@ +import { FormattingOptions } from "vscode"; + +export interface XmlFormattingOptions { + editorOptions: FormattingOptions; + newLine: string; + removeCommentsOnMinify: boolean; + splitXmlnsOnFormat: boolean; +} diff --git a/src/test/extension.test.ts b/src/test/extension.test.ts index 35bf33f..d4c8a71 100644 --- a/src/test/extension.test.ts +++ b/src/test/extension.test.ts @@ -13,10 +13,5 @@ import * as myExtension from "../extension"; // Defines a Mocha test suite to group tests of similar kind together suite("Extension Tests", () => { - - // Defines a Mocha unit test - test("Something 1", () => { - assert.equal(-1, [1, 2, 3].indexOf(5)); - assert.equal(-1, [1, 2, 3].indexOf(0)); - }); + // TODO: implement tests }); diff --git a/tsconfig.json b/tsconfig.json index 8a1d847..c3e70b8 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -7,7 +7,9 @@ "es6" ], "sourceMap": true, - "rootDir": "src" + "rootDir": "src", + "strict": true, + "strictNullChecks": false }, "exclude": [ "node_modules", diff --git a/tslint.json b/tslint.json index 1b54217..34d7b7b 100644 --- a/tslint.json +++ b/tslint.json @@ -28,7 +28,7 @@ "label-position": true, "max-line-length": [ true, - 140 + 165 ], "member-access": false, "member-ordering": [