Bump version

- fix template parser regexp (Closes #15)

.gitignore

@@ -10,8 +10,8 @@ npm-debug.log*
 dist
 
 # Extracted strings
-template.json
-template.pot
+strings.json
+strings.pot
 
 # Dependency directory
 node_modules

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biesbjerg/ngx-translate-extract",
-  "version": "2.2.1",
+  "version": "2.3.1",
   "description": "Extract strings from projects using ngx-translate",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -47,24 +47,24 @@
   },
   "config": {},
   "devDependencies": {
-    "@types/chai": "3.4.35",
+    "@types/chai": "3.5.2",
     "@types/glob": "5.0.30",
-    "@types/mocha": "2.2.40",
+    "@types/mocha": "2.2.41",
     "@types/cheerio": "0.22.1",
     "@types/chalk": "0.4.31",
     "@types/flat": "0.0.28",
     "@types/yargs": "6.6.0",
     "@types/mkdirp": "0.3.29",
     "chai": "3.5.0",
-    "mocha": "3.2.0",
-    "ts-node": "3.0.2",
-    "tslint": "4.5.1",
-    "tslint-eslint-rules": "3.5.1",
-    "typescript": "2.2.2"
+    "mocha": "3.3.0",
+    "ts-node": "3.0.4",
+    "tslint": "5.2.0",
+    "tslint-eslint-rules": "4.0.0",
+    "typescript": "2.3.2"
   },
   "dependencies": {
     "chalk": "1.1.3",
-    "yargs": "7.0.2",
+    "yargs": "8.0.1",
     "cheerio": "0.22.0",
     "fs": "0.0.1-security",
     "gettext-parser": "1.2.2",

src/compilers/json.compiler.ts

@@ -1,6 +1,8 @@
 import { CompilerInterface } from './compiler.interface';
 import { TranslationCollection } from '../utils/translation.collection';
 
+import * as flat from 'flat';
+
 export class JsonCompiler implements CompilerInterface {
 
 	public indentation: string = '\t';
@@ -18,7 +20,15 @@ export class JsonCompiler implements CompilerInterface {
 	}
 
 	public parse(contents: string): TranslationCollection {
-		return new TranslationCollection(JSON.parse(contents));
+		let values: any = JSON.parse(contents);
+		if (this._isNamespacedJsonFormat(values)) {
+			values = flat.flatten(values);
+		}
+		return new TranslationCollection(values);
+	}
+
+	protected _isNamespacedJsonFormat(values: any): boolean {
+		return Object.keys(values).some(key => typeof values[key] === 'object');
 	}
 
 }

src/parsers/abstract-ast.parser.ts

@@ -35,11 +35,7 @@ export abstract class AbstractAstParser {
 	/**
 	 * Find all child nodes of a kind
 	 */
-	protected _findNodes(node: ts.Node, kind: ts.SyntaxKind, onlyOne: boolean = false): ts.Node[] {
-		if (node.kind === kind && onlyOne) {
-			return [node];
-		}
-
+	protected _findNodes(node: ts.Node, kind: ts.SyntaxKind): ts.Node[] {
 		const childrenNodes: ts.Node[] = node.getChildren(this._sourceFile);
 		const initialValue: ts.Node[] = node.kind === kind ? [node] : [];
 

src/parsers/pipe.parser.ts

@@ -15,10 +15,10 @@ export class PipeParser extends AbstractTemplateParser implements ParserInterfac
 	protected _parseTemplate(template: string): TranslationCollection {
 		let collection: TranslationCollection = new TranslationCollection();
 
-		const regExp: RegExp = /(['"`])([^>\1\r\n]*?)\1\s*\|\s*translate/g;
+		const regExp: RegExp = /(['"`])((?:(?!\1).|\\\1)+)\1\s*\|\s*translate/g;
 		let matches: RegExpExecArray;
 		while (matches = regExp.exec(template)) {
-			collection = collection.add(matches[2]);
+			collection = collection.add(matches[2].replace('\\\'', '\''));
 		}
 
 		return collection;

src/parsers/service.parser.ts

@@ -8,26 +8,29 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 
 	protected _sourceFile: ts.SourceFile;
 
-	protected _instancePropertyName: any;
-	protected _serviceClassName: string = 'TranslateService';
-	protected _serviceMethodNames: string[] = ['get', 'instant'];
-
 	public extract(contents: string, path?: string): TranslationCollection {
 		let collection: TranslationCollection = new TranslationCollection();
 
 		this._sourceFile = this._createSourceFile(path, contents);
-
-		this._instancePropertyName = this._getInstancePropertyName();
-		if (!this._instancePropertyName) {
-			return collection;
-		}
-
-		const callNodes = this._findCallNodes();
-		callNodes.forEach(callNode => {
-			const keys: string[] = this._getCallArgStrings(callNode);
-			if (keys && keys.length) {
-				collection = collection.addKeys(keys);
+		const classNodes = this._findClassNodes(this._sourceFile);
+		classNodes.forEach(classNode => {
+			const constructorNode = this._findConstructorNode(classNode);
+			if (!constructorNode) {
+				return;
 			}
+
+			const propertyName: string = this._findTranslateServicePropertyName(constructorNode);
+			if (!propertyName) {
+				return;
+			}
+
+			const callNodes = this._findCallNodes(classNode, propertyName);
+			callNodes.forEach(callNode => {
+				const keys: string[] = this._getCallArgStrings(callNode);
+				if (keys && keys.length) {
+					collection = collection.addKeys(keys);
+				}
+			});
 		});
 
 		return collection;
@@ -35,10 +38,9 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 
 	/**
 	 * Detect what the TranslateService instance property
-	 * is called by inspecting constructor params
+	 * is called by inspecting constructor arguments
 	 */
-	protected _getInstancePropertyName(): string {
-		const constructorNode = this._findConstructorNode();
+	protected _findTranslateServicePropertyName(constructorNode: ts.ConstructorDeclaration): string {
 		if (!constructorNode) {
 			return null;
 		}
@@ -49,13 +51,18 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 				return false;
 			}
 
+			// Parameter has no type
+			if (!parameter.type) {
+				return false;
+			}
+
 			// Make sure className is of the correct type
 			const parameterType: ts.Identifier = (parameter.type as ts.TypeReferenceNode).typeName as ts.Identifier;
 			if (!parameterType) {
 				return false;
 			}
 			const className: string = parameterType.text;
-			if (className !== this._serviceClassName) {
+			if (className !== 'TranslateService') {
 				return false;
 			}
 
@@ -68,23 +75,26 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 	}
 
 	/**
-	 * Find first constructor
+	 * Find class nodes
 	 */
-	protected _findConstructorNode(): ts.ConstructorDeclaration {
-		const constructors = this._findNodes(this._sourceFile, ts.SyntaxKind.Constructor, true) as ts.ConstructorDeclaration[];
-		if (constructors.length) {
-			return constructors[0];
+	protected _findClassNodes(node: ts.Node): ts.ClassDeclaration[] {
+		return this._findNodes(node, ts.SyntaxKind.ClassDeclaration) as ts.ClassDeclaration[];
+	}
+
+	/**
+	 * Find constructor
+	 */
+	protected _findConstructorNode(node: ts.ClassDeclaration): ts.ConstructorDeclaration {
+		const constructorNodes = this._findNodes(node, ts.SyntaxKind.Constructor) as ts.ConstructorDeclaration[];
+		if (constructorNodes) {
+			return constructorNodes[0];
 		}
 	}
 
 	/**
 	 * Find all calls to TranslateService methods
 	 */
-	protected _findCallNodes(node?: ts.Node): ts.CallExpression[] {
-		if (!node) {
-			node = this._sourceFile;
-		}
-
+	protected _findCallNodes(node: ts.Node, propertyIdentifier: string): ts.CallExpression[] {
 		let callNodes = this._findNodes(node, ts.SyntaxKind.CallExpression) as ts.CallExpression[];
 		callNodes = callNodes
 			.filter(callNode => {
@@ -100,7 +110,7 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 				if (!propAccess.getFirstToken() || propAccess.getFirstToken().kind !== ts.SyntaxKind.ThisKeyword) {
 					return false;
 				}
-				if (propAccess.name.text !== this._instancePropertyName) {
+				if (propAccess.name.text !== propertyIdentifier) {
 					return false;
 				}
 
@@ -108,7 +118,7 @@ export class ServiceParser extends AbstractAstParser implements ParserInterface
 				if (!methodAccess || methodAccess.kind !== ts.SyntaxKind.PropertyAccessExpression) {
 					return false;
 				}
-				if (!methodAccess.name || this._serviceMethodNames.indexOf(methodAccess.name.text) === -1) {
+				if (!methodAccess.name || (methodAccess.name.text !== 'get' && methodAccess.name.text !== 'instant')) {
 					return false;
 				}
 

src/utils/translation.collection.ts

@@ -1,6 +1,6 @@
 export interface TranslationType {
 	[key: string]: string
-};
+}
 
 export class TranslationCollection {
 

tests/parsers/pipe.parser.spec.ts

@@ -18,6 +18,12 @@ describe('PipeParser', () => {
 		expect(keys).to.deep.equal(['SomeKey_NotWorking']);
 	});
 
+	it('should extract string using pipe, but between quotes only', () => {
+		const contents = `<input class="form-control" type="text" placeholder="{{'user.settings.form.phone.placeholder' | translate}}" [formControl]="settingsForm.controls['phone']">`;
+		const keys = parser.extract(contents, templateFilename).keys();
+		expect(keys).to.deep.equal(['user.settings.form.phone.placeholder']);
+	});
+
 	it('should extract interpolated strings using translate pipe', () => {
 		const contents = `Hello {{ 'World' | translate }}`;
 		const keys = parser.extract(contents, templateFilename).keys();
@@ -25,7 +31,7 @@ describe('PipeParser', () => {
 	});
 
 	it('should extract strings with escaped quotes', () => {
-		const contents = `Hello {{ 'World\'s largest potato' | translate }}`;
+		const contents = `Hello {{ 'World\\'s largest potato' | translate }}`;
 		const keys = parser.extract(contents, templateFilename).keys();
 		expect(keys).to.deep.equal([`World's largest potato`]);
 	});

tests/parsers/service.parser.spec.ts

@@ -151,4 +151,51 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['You are expected at {{time}}']);
 	});
 
+	it('should not crash when constructor parameter has no type', () => {
+		const contents = `
+			@Component({ })
+			export class AppComponent {
+				public constructor(protected _translateService) { }
+				public test() {
+					this._translateService.instant('Hello World');
+				}
+		`;
+		const keys = parser.extract(contents, componentFilename).keys();
+		expect(keys).to.deep.equal([]);
+	});
+
+	it('should extract strings from all classes in the file', () => {
+		const contents = `
+			import { Injectable } from '@angular/core';
+			import { TranslateService } from '@ngx-translate/core';
+			export class Stuff {
+				thing: string;
+				translate: any;
+				constructor(thing: string) {
+					this.translate.get('Not me');
+					this.thing = thing;
+				}
+			}
+			@Injectable()
+			export class MyComponent {
+				constructor(public translate: TranslateService) {
+					this.translate.instant("Extract me!");
+				}
+			}
+			export class OtherClass {
+				constructor(thing: string, _translate: TranslateService) {
+					this._translate.get("Do not extract me");
+				}
+			}
+			@Injectable()
+			export class AuthService {
+				constructor(public translate: TranslateService) {
+					this.translate.instant("Hello!");
+				}
+			}
+		`;
+		const keys = parser.extract(contents, componentFilename).keys();
+		expect(keys).to.deep.equal(['Extract me!', 'Hello!']);
+	});
+
 });