- (feat) add concept of post processors

- (feat) add 'key as default value' post processor (closes #109)
- (chore) move clean functionality to a post processor
- (chore) move sort functionality to a post processor
- (refactor) get rid of leading underscore on protected properties/methods

tests/parsers/abstract-template.parser.spec.ts

@@ -5,11 +5,11 @@ import { AbstractTemplateParser } from '../../src/parsers/abstract-template.pars
 class TestTemplateParser extends AbstractTemplateParser {
 
 	public isAngularComponent(filePath: string): boolean {
-		return this._isAngularComponent(filePath);
+		return super.isAngularComponent(filePath);
 	}
 
 	public extractInlineTemplate(contents: string): string {
-		return this._extractInlineTemplate(contents);
+		return super.extractInlineTemplate(contents);
 	}
 
 }

tests/parsers/directive.parser.spec.ts

@@ -5,7 +5,7 @@ import { DirectiveParser } from '../../src/parsers/directive.parser';
 class TestDirectiveParser extends DirectiveParser {
 
 	public normalizeTemplateAttributes(template: string): string {
-		return this._normalizeTemplateAttributes(template);
+		return super.normalizeTemplateAttributes(template);
 	}
 
 }

tests/parsers/service.parser.spec.ts

@@ -4,10 +4,6 @@ import { ServiceParser } from '../../src/parsers/service.parser';
 
 class TestServiceParser extends ServiceParser {
 
-	/*public getInstancePropertyName(): string {
-		return this._getInstancePropertyName();
-	}*/
-
 }
 
 describe('ServiceParser', () => {
@@ -20,20 +16,6 @@ describe('ServiceParser', () => {
 		parser = new TestServiceParser();
 	});
 
-	/*it('should extract variable used for TranslateService', () => {
-		const contents = `
-			@Component({ })
-			export class AppComponent {
-				public constructor(
-					_serviceA: ServiceA,
-					public _serviceB: ServiceB,
-					protected _translateService: TranslateService
-			) { }
-		`;
-		const name = parser.getInstancePropertyName();
-		expect(name).to.equal('_translateService');
-	});*/
-
 	it('should extract strings in TranslateService\'s get() method', () => {
 		const contents = `
 			@Component({ })

tests/post-processors/key-as-default-value.post-processor.spec.ts

@@ -0,0 +1,31 @@
+import { expect } from 'chai';
+
+import { PostProcessorInterface } from '../../src/post-processors/post-processor.interface';
+import { KeyAsDefaultValuePostProcessor } from '../../src/post-processors/key-as-default-value.post-processor';
+import { TranslationCollection } from '../../src/utils/translation.collection';
+
+describe('KeyAsDefaultValuePostProcessor', () => {
+
+	let processor: PostProcessorInterface;
+
+	beforeEach(() => {
+		processor = new KeyAsDefaultValuePostProcessor();
+	});
+
+	it('should use key as default value', () => {
+		const collection = new TranslationCollection({
+			'I have no value': '',
+			'I am already translated': 'Jeg er allerede oversat',
+			'Use this key as value as well': ''
+		});
+		const extracted = new TranslationCollection();
+		const existing = new TranslationCollection();
+
+		expect(processor.process(collection, extracted, existing).values).to.deep.equal({
+			'I have no value': 'I have no value',
+			'I am already translated': 'Jeg er allerede oversat',
+			'Use this key as value as well': 'Use this key as value as well'
+		});
+	});
+
+});

tests/post-processors/purge-obsolete-keys.post-processor.spec.ts

@@ -0,0 +1,36 @@
+import { expect } from 'chai';
+
+import { PostProcessorInterface } from '../../src/post-processors/post-processor.interface';
+import { PurgeObsoleteKeysPostProcessor } from '../../src/post-processors/purge-obsolete-keys.post-processor';
+import { TranslationCollection } from '../../src/utils/translation.collection';
+
+describe('KeyAsDefaultValuePostProcessor', () => {
+
+	let processor: PostProcessorInterface;
+
+	beforeEach(() => {
+		processor = new PurgeObsoleteKeysPostProcessor();
+	});
+
+	it('should purge obsolete keys', () => {
+		const collection = new TranslationCollection({
+			'I am completely new': '',
+			'I already exist': '',
+			'I already exist but was not present in extract': ''
+		});
+		const extracted = new TranslationCollection({
+			'I am completely new': '',
+			'I already exist': ''
+		});
+		const existing = new TranslationCollection({
+			'I already exist': '',
+			'I already exist but was not present in extract': ''
+		});
+
+		expect(processor.process(collection, extracted, existing).values).to.deep.equal({
+			'I am completely new': '',
+			'I already exist': ''
+		});
+	});
+
+});

tests/post-processors/sort-by-key.post-processor.spec.ts

@@ -0,0 +1,33 @@
+import { expect } from 'chai';
+
+import { PostProcessorInterface } from '../../src/post-processors/post-processor.interface';
+import { SortByKeyPostProcessor } from '../../src/post-processors/sort-by-key.post-processor';
+import { TranslationCollection } from '../../src/utils/translation.collection';
+
+describe('SortByKeyPostProcessor', () => {
+
+	let processor: PostProcessorInterface;
+
+	beforeEach(() => {
+		processor = new SortByKeyPostProcessor();
+	});
+
+	it('should sort keys alphanumerically', () => {
+		const collection = new TranslationCollection({
+			'z': 'last value',
+			'a': 'a value',
+			'9': 'a numeric key',
+			'b': 'another value'
+		});
+		const extracted = new TranslationCollection();
+		const existing = new TranslationCollection();
+
+		expect(processor.process(collection, extracted, existing).values).to.deep.equal({
+			'9': 'a numeric key',
+			'a': 'a value',
+			'b': 'another value',
+			'z': 'last value'
+		});
+	});
+
+});

tests/utils/translation.collection.spec.ts

@@ -69,7 +69,7 @@ describe('StringCollection', () => {
 
 	it('should intersect with passed collection', () => {
 		collection = collection.addKeys(['red', 'green', 'blue']);
-		const newCollection = new TranslationCollection( { red: '', blue: '' });
+		const newCollection = new TranslationCollection( { red: '', blue: '' });
 		expect(collection.intersect(newCollection).values).to.deep.equal({ red: '', blue: '' });
 	});
 
@@ -79,10 +79,16 @@ describe('StringCollection', () => {
 		expect(collection.intersect(newCollection).values).to.deep.equal({ red: 'rød', blue: 'blå' });
 	});
 
-	it('should sort translations in alphabetical order', () => {
+	it('should sort keys alphabetically', () => {
 		collection = new TranslationCollection({ red: 'rød', green: 'grøn', blue: 'blå' });
 		collection = collection.sort();
 		expect(collection.keys()).deep.equal(['blue', 'green', 'red']);
 	});
 
+	it('should map values', () => {
+		collection = new TranslationCollection({ red: 'rød', green: 'grøn', blue: 'blå' });
+		collection = collection.map((key, val) => 'mapped value');
+		expect(collection.values).to.deep.equal({ red: 'mapped value', green: 'mapped value', blue: 'mapped value' });
+	});
+
 });