Add tests and update a bunch of imports

Author: lumaxis

src/extension.ts

@@ -1,9 +1,10 @@
 import * as vscode from 'vscode';
+import { ExtensionContext } from 'vscode';
 import { generateSnippet } from './lib/textHelpers';
 
-export function activate(context: vscode.ExtensionContext) {
+export function activate(context: ExtensionContext) {
 	let disposable = vscode.commands.registerTextEditorCommand('snippet-copy.copyWithoutLeadingIndentation', async (editor) => {
-		const snippet = generateSnippet(editor);
+		const snippet = generateSnippet(editor.document, editor.selections);
 
 		await vscode.env.clipboard.writeText(snippet);
 	});

src/lib/documentHelpers.ts

@@ -1,4 +1,4 @@
-import { TextDocument, EndOfLine, TextLine, Range } from "vscode";
+import { EndOfLine, Range, TextDocument, TextLine } from "vscode";
 
 export function linesForIndexes(document: TextDocument, lineIndexes: number[]): TextLine[] {
 	return lineIndexes.map((lineIndex) => {
@@ -26,7 +26,11 @@ export function contentOfLinesWithAdjustedIndentation(document: TextDocument, li
 	return contentOfLinesWithAdjustedIndentation.join(eolCharacter);
 }
 
-export function adjustedRangeWithMinimumIndentation(range: Range, minimumIndentation: number) {
+export function adjustedRangeWithMinimumIndentation(range: Range, minimumIndentation: number): Range {
+	if (range.start.character !== 0) {
+		console.warn('Adjusting range: Range does not start at character 0, this is not expected.');
+	}
+
 	const adjustedRange = new Range(range.start.line, range.start.character + minimumIndentation, range.end.line, range.end.character);
 	return adjustedRange;
 }

src/lib/textHelpers.ts

@@ -1,12 +1,10 @@
-import { TextDocument, Selection, TextEditor } from "vscode";
+import { Selection, TextDocument } from "vscode";
+import { contentOfLinesWithAdjustedIndentation, endOfLineCharacter, minimumIndentationForLineIndexes } from "./documentHelpers";
 import { lineIndexesForSelection } from "./selectionHelpers";
-import { endOfLineCharacter, minimumIndentationForLineIndexes, contentOfLinesWithAdjustedIndentation } from "./documentHelpers";
-
-export function generateSnippet(editor: TextEditor): string {
-	const document = editor.document;
 
+export function generateSnippet(document: TextDocument, selections: Selection[]): string {
 	let texts: string[] = [];
-	editor.selections.forEach(selection => {
+	selections.forEach(selection => {
 		texts.push(generateCopyableText(document, selection));
 	});
 

src/test/fixtures/javascript-example.js

@@ -1,5 +1,11 @@
-function doSomething(aValue) {
-  if (aValue) {
-    console.log(`Doing something with ${aValue}!`);
+class MyThing {
+  doSomething(aValue) {
+    if (aValue) {
+      console.log(`Doing something with ${aValue}!`);
+    }
+  }
+
+  doSomethingElse() {
+    throw new Error('Nope!');
   }
 }

src/test/suite/lib/documentHelpers.test.ts

@@ -1,44 +1,50 @@
 import * as assert from 'assert';
 import * as path from 'path';
 import * as vscode from 'vscode';
+import { Range, TextDocument } from 'vscode';
+import { adjustedRangeWithMinimumIndentation, contentOfLinesWithAdjustedIndentation, endOfLineCharacter, linesForIndexes, minimumIndentationForLineIndexes } from '../../../lib/documentHelpers';
 
-import { minimumIndentationForLineIndexes, contentOfLinesWithAdjustedIndentation } from '../../../lib/documentHelpers';
 
 const fixturesPath = '/../../../../src/test/fixtures/';
 const uri = vscode.Uri.file(
 	path.join(__dirname + fixturesPath + 'javascript-example.js')
 );
 
 describe('Document Helpers', function () {
-	context('minimumIndentationLevelForLineIndexes', async () => {
-		let document: vscode.TextDocument;
+	let document: TextDocument;
+
+	before(async () => {
+		document = await vscode.workspace.openTextDocument(uri);
+	});
 
-		before(async () => {
-			document = await vscode.workspace.openTextDocument(uri);
+	context('linesForIndexes', () => {
+		it('returns the correct lines', () => {
+			const lines = linesForIndexes(document, [0, 1]);
+			assert.equal(lines.length, 2);
+			assert.equal(lines[0].lineNumber, 0);
+			assert.equal(lines[0].text, 'class MyThing {');
+			assert.equal(lines[1].lineNumber, 1);
+			assert.equal(lines[1].text, '  doSomething(aValue) {');
 		});
+	});
 
+	context('minimumIndentationLevelForLineIndexes', async () => {
 		it('calculates the correct minimum indentation level for a single line', () => {
-			assert.equal(4, minimumIndentationForLineIndexes(document, [2]));
+			assert.equal(minimumIndentationForLineIndexes(document, [3]), 6);
 		});
 
 		it('calculates the correct minimum indentation level for multiple lines', () => {
-			assert.equal(2, minimumIndentationForLineIndexes(document, [1, 2, 3]));
+			assert.equal(minimumIndentationForLineIndexes(document, [1, 2, 3]), 2);
 		});
 	});
 
 	context('contentOfLinesWithAdjustedIndentation', async () => {
-		let document: vscode.TextDocument;
-
-		before(async () => {
-			document = await vscode.workspace.openTextDocument(uri);
-		});
-
 		it('returns multiline text with the indentation adjusted correctly', () => {
-			assert.equal('if (aValue) {\n  console.log(`Doing something with ${aValue}!`);\n}', contentOfLinesWithAdjustedIndentation(document, [1, 2, 3], 2));
+			assert.equal(contentOfLinesWithAdjustedIndentation(document, [2, 3, 4], 4), 'if (aValue) {\n  console.log(`Doing something with ${aValue}!`);\n}');
 		});
 
 		it('returns single line text with the indentation adjusted correctly', () => {
-			assert.equal('console.log(`Doing something with ${aValue}!`);', contentOfLinesWithAdjustedIndentation(document, [2], 4));
+			assert.equal(contentOfLinesWithAdjustedIndentation(document, [3], 6), 'console.log(`Doing something with ${aValue}!`);');
 		});
 
 		it('returns text with CRLF characters if file is using them', async () => {
@@ -47,7 +53,30 @@ describe('Document Helpers', function () {
 			);
 			let crlfDocument = await vscode.workspace.openTextDocument(uri);
 
-			assert.equal('def polish\r\n  puts "Polishing"\r\nend', contentOfLinesWithAdjustedIndentation(crlfDocument, [1, 2, 3], 2));
+			assert.equal(contentOfLinesWithAdjustedIndentation(crlfDocument, [1, 2, 3], 2), 'def polish\r\n  puts "Polishing"\r\nend');
+		});
+	});
+
+	context('adjustedRangeWithMinimumIndentation', () => {
+		it('adjusts the range', () => {
+			const adjustedRange = adjustedRangeWithMinimumIndentation(new Range(2, 0, 2, 17), 4);
+			assert.equal(adjustedRange.start.line, 2);
+			assert.equal(adjustedRange.start.character, 4);
+			assert.equal(adjustedRange.end.line, 2);
+			assert.equal(adjustedRange.end.character, 17);
+		});
+	});
+
+	context('endOfLineCharacter', () => {
+		it('correctly returns LF', async () => {
+			assert.equal(endOfLineCharacter(document), '\n');
+		});
+
+		it('correctly returns CRLF', async () => {
+			const uri = vscode.Uri.file(
+				path.join(__dirname + fixturesPath + 'crlf-ruby-example.rb')
+			);
+			assert.equal(endOfLineCharacter(await vscode.workspace.openTextDocument(uri)), '\r\n');
 		});
 	});
 });

src/test/suite/lib/selectionHelpers.test.ts

@@ -1,24 +1,24 @@
 import * as assert from 'assert';
-import * as vscode from 'vscode';
-
+import { Selection } from 'vscode';
 import { lineIndexesForSelection } from '../../../lib/selectionHelpers';
 
+
 describe('Selection Helpers', function () {
 	context('calculateSelectionLineIndexes', () => {
 		it('calculates the correct line indexes from an empty selection', () => {
-			assert.deepEqual([0], lineIndexesForSelection(new vscode.Selection(0, 0, 0, 0)));
+			assert.deepEqual([0], lineIndexesForSelection(new Selection(0, 0, 0, 0)));
 		});
 
 		it('calculates the correct line indexes from a single line selection', () => {
-			assert.deepEqual([1], lineIndexesForSelection(new vscode.Selection(1, 2, 1, 15)));
+			assert.deepEqual([1], lineIndexesForSelection(new Selection(1, 2, 1, 15)));
 		});
 
 		it('calculates the correct line indexes from a multiline selection', () => {
-			assert.deepEqual([1, 2, 3], lineIndexesForSelection(new vscode.Selection(1, 2, 3, 3)));
+			assert.deepEqual([1, 2, 3], lineIndexesForSelection(new Selection(1, 2, 3, 3)));
 		});
 
 		it('calculates the correct line indexes from an reversed selection ', () => {
-			assert.deepEqual([1, 2, 3], lineIndexesForSelection(new vscode.Selection(3, 0, 1, 0)));
+			assert.deepEqual([1, 2, 3], lineIndexesForSelection(new Selection(3, 0, 1, 0)));
 		});
 	});
 });

src/test/suite/lib/textHelpers.test.ts

@@ -1,28 +1,64 @@
 import * as assert from 'assert';
 import * as path from 'path';
 import * as vscode from 'vscode';
-
-import { generateCopyableText } from '../../../lib/textHelpers';
+import { Position, Selection, TextDocument } from 'vscode';
+import { generateCopyableText, generateSnippet } from '../../../lib/textHelpers';
 
 const fixturesPath = '/../../../../src/test/fixtures/';
 const uri = vscode.Uri.file(
 	path.join(__dirname + fixturesPath + 'javascript-example.js')
 );
 
+interface TestSelection {
+	selection: Selection;
+	content: string;
+}
+
 describe('Text Helpers', () => {
-	let document: vscode.TextDocument;
+	const testSelection1: TestSelection = {
+		content: 'if (aValue) {\n  console.log(`Doing something with ${aValue}!`);\n}',
+		selection: new Selection(2, 4, 4, 5)
+	};
+	const testSelection2: TestSelection = {
+		content: 'doSomethingElse() {\n  throw new Error(\'Nope!\');\n}',
+		selection: new Selection(7, 2, 9, 3)
+	};
+	let document: TextDocument;
 
 	before(async () => {
 		document = await vscode.workspace.openTextDocument(uri);
 	});
 
+	context('generateSnippet', () => {
+		it('generates the correct snippet for a single selection', () => {
+			assert.deepEqual(testSelection1.content, generateSnippet(document, [testSelection1.selection]));
+		});
+
+		it('generates the correct snippet for multiple selections', () => {
+			assert.deepEqual(testSelection1.content + '\n' + testSelection2.content,
+				generateSnippet(document, [testSelection1.selection, testSelection2.selection])
+			);
+		});
+
+		it('generates the correct snippet for multiple selections where one ends on the beginning of a newline', () => {
+			assert.deepEqual(testSelection1.content + '\n' + testSelection2.content,
+				generateSnippet(document, [
+					new Selection(testSelection1.selection.start, new Position(5, 0)),
+					testSelection2.selection
+				])
+			);
+		});
+	});
+
 	context('generateCopyableText', () => {
 		it('generates the correct text', () => {
-			assert.deepEqual('if (aValue) {\n  console.log(`Doing something with ${aValue}!`);\n}', generateCopyableText(document, new vscode.Selection(1, 2, 3, 3)));
+			assert.deepEqual(testSelection1.content, generateCopyableText(document, testSelection1.selection));
 		});
 
 		it('generates the correct text when the cursor is on a newline', () => {
-			assert.deepEqual('if (aValue) {\n  console.log(`Doing something with ${aValue}!`);\n}', generateCopyableText(document, new vscode.Selection(1, 2, 4, 0)));
+			assert.deepEqual(testSelection1.content,
+				generateCopyableText(document, new Selection(testSelection1.selection.start, new Position(5, 0)))
+			);
 		});
 	});
 });