refactor(@schematics/angular): Parameterize findModule

This commit modifies `findModule` to accept custom regular expressions
so that a different filename convention for Angular modules is allowed.

Author: Keen Yee Liau

packages/schematics/angular/utility/find-module.ts

@@ -15,8 +15,12 @@ export interface ModuleOptions {
   flat?: boolean;
   path?: string;
   skipImport?: boolean;
+  moduleExt?: string;
+  routingModuleExt?: string;
 }
 
+const MODULE_EXT = '.module.ts';
+const ROUTING_MODULE_EXT = '-routing.module.ts';
 
 /**
  * Find the module referred by a set of options passed to the schematics.
@@ -26,44 +30,46 @@ export function findModuleFromOptions(host: Tree, options: ModuleOptions): Path
     return undefined;
   }
 
+  const moduleExt = options.moduleExt || MODULE_EXT;
+  const routingModuleExt = options.routingModuleExt || ROUTING_MODULE_EXT;
+
   if (!options.module) {
     const pathToCheck = (options.path || '')
       + (options.flat ? '' : '/' + strings.dasherize(options.name));
 
-    return normalize(findModule(host, pathToCheck));
+    return normalize(findModule(host, pathToCheck, moduleExt, routingModuleExt));
   } else {
     const modulePath = normalize(
       '/' + (options.path) + '/' + options.module);
     const moduleBaseName = normalize(modulePath).split('/').pop();
 
-    if (host.exists(modulePath)) {
-      return normalize(modulePath);
-    } else if (host.exists(modulePath + '.ts')) {
-      return normalize(modulePath + '.ts');
-    } else if (host.exists(modulePath + '.module.ts')) {
-      return normalize(modulePath + '.module.ts');
-    } else if (host.exists(modulePath + '/' + moduleBaseName + '.module.ts')) {
-      return normalize(modulePath + '/' + moduleBaseName + '.module.ts');
-    } else {
-      throw new Error('Specified module does not exist');
+    const candidates = [
+      modulePath,
+      `${modulePath}.ts`,
+      `${modulePath}${moduleExt}`,
+      `${modulePath}/${moduleBaseName}${moduleExt}`,
+    ];
+    for (const c of candidates) {
+      if (host.exists(c)) {
+        return normalize(c);
+      }
     }
+    throw new Error(`Specified module '${options.module}' does not exist.`);
   }
 }
 
 /**
  * Function to find the "closest" module to a generated file's path.
  */
-export function findModule(host: Tree, generateDir: string): Path {
-  let dir: DirEntry | null = host.getDir('/' + generateDir);
-
-  const moduleRe = /\.module\.ts$/;
-  const routingModuleRe = /-routing\.module\.ts/;
+export function findModule(host: Tree, generateDir: string,
+                           moduleExt = MODULE_EXT, routingModuleExt = ROUTING_MODULE_EXT): Path {
 
+  let dir: DirEntry | null = host.getDir('/' + generateDir);
   let foundRoutingModule = false;
 
   while (dir) {
-    const allMatches = dir.subfiles.filter(p => moduleRe.test(p));
-    const filteredMatches = allMatches.filter(p => !routingModuleRe.test(p));
+    const allMatches = dir.subfiles.filter(p => p.endsWith(moduleExt));
+    const filteredMatches = allMatches.filter(p => !p.endsWith(routingModuleExt));
 
     foundRoutingModule = foundRoutingModule || allMatches.length !== filteredMatches.length;
 
@@ -78,7 +84,7 @@ export function findModule(host: Tree, generateDir: string): Path {
   }
 
   const errorMsg = foundRoutingModule ? 'Could not find a non Routing NgModule.'
-    + '\nModules with suffix \'-routing.module\' are strictly reserved for routing.'
+    + `\nModules with suffix '${routingModuleExt}' are strictly reserved for routing.`
     + '\nUse the skip-import option to skip importing in NgModule.'
     : 'Could not find an NgModule. Use the skip-import option to skip importing in NgModule.';
 

packages/schematics/angular/utility/find-module_spec.ts

@@ -74,6 +74,25 @@ describe('find-module', () => {
         expect(err.message).toMatch(/Could not find an NgModule/);
       }
     });
+
+    it('should accept custom ext for module', () => {
+      const host = new EmptyTree();
+      const modulePath = '/foo/src/app/app_module.ts';
+      host.create(modulePath, 'app module');
+      // Should find module if given a custom ext
+      const foundModule = findModule(host, 'foo/src/app/bar', '_module.ts');
+      expect(foundModule).toBe(modulePath);
+      // Should not find module if using default ext
+      expect(() => findModule(host, 'foo/src/app/bar'))
+        .toThrowError(/Could not find an NgModule/);
+    });
+
+    it('should not find module if ext is invalid', () => {
+      expect(() => findModule(host, 'foo/src/app/bar', '-module.ts'))
+        .toThrowError(/Could not find an NgModule/);
+      expect(() => findModule(host, 'foo/src/app/bar', '_module.ts'))
+        .toThrowError(/Could not find an NgModule/);
+    });
   });
 
   describe('findModuleFromOptions', () => {
@@ -100,5 +119,40 @@ describe('find-module', () => {
       const modPath = findModuleFromOptions(tree, options);
       expect(modPath).toEqual('/projects/my-proj/src/admin/foo.module.ts' as Path);
     });
+
+    it('should find a module using custom ext', () => {
+      tree.create('/projects/my-proj/src/app_module.ts', '');
+      options.module = 'app';
+      options.path = '/projects/my-proj/src';
+      options.moduleExt = '_module.ts';
+      // Should find module using custom moduleExt
+      const modPath = findModuleFromOptions(tree, options);
+      expect(modPath).toBe('/projects/my-proj/src/app_module.ts' as Path);
+      // Should not find module if using invalid ext
+      options.moduleExt = '-module.ts';
+      expect(() => findModuleFromOptions(tree, options)).toThrowError(
+        /Specified module 'app' does not exist/);
+      // Should not find module if using default ext
+      options.moduleExt = undefined;   // use default ext
+      expect(() => findModuleFromOptions(tree, options)).toThrowError(
+        /Specified module 'app' does not exist/);
+    });
+
+    it('should ignore custom ext if module or ${module}.ts exists', () => {
+      tree.create('/projects/my-proj/src/app.module.ts', '');
+      options.path = '/projects/my-proj/src';
+      options.moduleExt = '_module.ts';
+      let modPath;
+
+      // moduleExt ignored because exact path is found
+      options.module = 'app.module.ts';
+      modPath = findModuleFromOptions(tree, options);
+      expect(modPath).toBe('/projects/my-proj/src/app.module.ts' as Path);
+
+      // moduleExt ignored because module + .ts is found
+      options.module = 'app.module';
+      modPath = findModuleFromOptions(tree, options);
+      expect(modPath).toBe('/projects/my-proj/src/app.module.ts' as Path);
+    });
   });
 });