feat(@angular-devkit/schematics): allow path templates to override some options

Like the interpolation and the pipe character. The default behaviour is kept.

We will need to use those to work around some limiations of the google3 file system which
does not accept "@".

Author: hansl

packages/angular_devkit/schematics/src/rules/template.ts

@@ -27,17 +27,24 @@ export class InvalidPipeException extends BaseException {
 }
 
 
-export const kPathTemplateComponentRE = /__(.+?)__/g;
-export const kPathTemplatePipeRE = /@([^@]+)/;
-
-
 export type PathTemplateValue = boolean | string | number | undefined;
 export type PathTemplatePipeFunction = (x: string) => PathTemplateValue;
-export type PathTemplateOptions = {
-  [key: string]: PathTemplateValue | PathTemplateOptions | PathTemplatePipeFunction,
+export type PathTemplateData = {
+  [key: string]: PathTemplateValue | PathTemplateData | PathTemplatePipeFunction,
 };
 
 
+export interface PathTemplateOptions {
+  // Interpolation start and end strings.
+  interpolationStart: string;
+  // Interpolation start and end strings.
+  interpolationEnd: string;
+
+  // Separator for pipes. Do not specify to remove pipe support.
+  pipeSeparator?: string;
+}
+
+
 export function applyContentTemplate<T>(options: T): FileOperator {
   return (entry: FileEntry) => {
     const {path, content} = entry;
@@ -58,57 +65,91 @@ export function contentTemplate<T>(options: T): Rule {
 }
 
 
-export function applyPathTemplate<T extends PathTemplateOptions>(options: T): FileOperator {
+export function applyPathTemplate<T extends PathTemplateData>(
+  data: T,
+  options: PathTemplateOptions = {
+    interpolationStart: '__',
+    interpolationEnd: '__',
+    pipeSeparator: '@',
+  },
+): FileOperator {
+  const is = options.interpolationStart;
+  const ie = options.interpolationEnd;
+  const isL = is.length;
+  const ieL = ie.length;
+
   return (entry: FileEntry) => {
-    let path = entry.path;
+    let path = entry.path as string;
     const content = entry.content;
     const original = path;
 
-    // Path template.
-    path = normalize(path.replace(kPathTemplateComponentRE, (_, match) => {
-      const [name, ...pipes] = match.split(kPathTemplatePipeRE);
-      let value = options[name];
+    let start = path.indexOf(is);
+    // + 1 to have at least a length 1 name. `____` is not valid.
+    let end = path.indexOf(ie, start + isL + 1);
 
-      if (typeof value == 'function') {
-        value = value.call(options, original);
-      }
+    while (start != -1 && end != -1) {
+      const match = path.substring(start + isL, end);
+      let replacement = data[match];
 
-      if (value === undefined) {
-        throw new OptionIsNotDefinedException(name);
-      }
+      if (!options.pipeSeparator) {
+        if (typeof replacement == 'function') {
+          replacement = replacement.call(data, original);
+        }
 
-      return pipes.reduce((acc: string, pipe: string) => {
-        if (!pipe) {
-          return acc;
+        if (replacement === undefined) {
+          throw new OptionIsNotDefinedException(match);
         }
-        if (!(pipe in options)) {
-          throw new UnknownPipeException(pipe);
+      } else {
+        const [name, ...pipes] = match.split(options.pipeSeparator);
+        replacement = data[name];
+
+        if (typeof replacement == 'function') {
+          replacement = replacement.call(data, original);
         }
-        if (typeof options[pipe] != 'function') {
-          throw new InvalidPipeException(pipe);
+
+        if (replacement === undefined) {
+          throw new OptionIsNotDefinedException(name);
         }
 
-        // Coerce to string.
-        return '' + (options[pipe] as PathTemplatePipeFunction)(acc);
-      }, '' + value);
-    }));
+        replacement = pipes.reduce((acc: string, pipe: string) => {
+          if (!pipe) {
+            return acc;
+          }
+          if (!(pipe in data)) {
+            throw new UnknownPipeException(pipe);
+          }
+          if (typeof data[pipe] != 'function') {
+            throw new InvalidPipeException(pipe);
+          }
+
+          // Coerce to string.
+          return '' + (data[pipe] as PathTemplatePipeFunction)(acc);
+        }, '' + replacement);
+      }
+
+      path = path.substring(0, start) + replacement + path.substring(end + ieL);
+
+      start = path.indexOf(options.interpolationStart);
+      // See above.
+      end = path.indexOf(options.interpolationEnd, start + isL + 1);
+    }
 
-    return { path, content };
+    return { path: normalize(path), content };
   };
 }
 
 
-export function pathTemplate<T extends PathTemplateOptions>(options: T): Rule {
+export function pathTemplate<T extends PathTemplateData>(options: T): Rule {
   return forEach(applyPathTemplate(options));
 }
 
 
 export function template<T>(options: T): Rule {
   return chain([
     contentTemplate(options),
-    // Force cast to PathTemplateOptions. We need the type for the actual pathTemplate() call,
+    // Force cast to PathTemplateData. We need the type for the actual pathTemplate() call,
     // but in this case we cannot do anything as contentTemplate are more permissive.
     // Since values are coerced to strings in PathTemplates it will be fine in the end.
-    pathTemplate(options as {} as PathTemplateOptions),
+    pathTemplate(options as {} as PathTemplateData),
   ]);
 }

packages/angular_devkit/schematics/src/rules/template_spec.ts

@@ -53,10 +53,26 @@ describe('applyPathTemplate', () => {
     expect(_applyPathTemplate('/a_b_c/d__e_f__g', { e_f: 1 })).toBe('/a_b_c/d1g');
   });
 
+  it('works with complex _________...', () => {
+    expect(_applyPathTemplate(
+      '/_____' + 'a' + '___a__' + '_/' + '__a___/__b___',
+      { _a: 0, a: 1, b: 2, _: '.' },
+    )).toBe('/.a0_/1_/2_');
+
+    expect(_applyPathTemplate(
+      '_____' + '_____' + '_____' + '___',
+      { _: '.' },
+    )).toBe('...___');
+  });
+
   it('works with functions', () => {
     let arg = '';
     expect(_applyPathTemplate('/a__c__b', {
-      c: (x: string) => (arg = x, 'hello'),
+      c: (x: string) => {
+        arg = x;
+
+        return 'hello';
+      },
     })).toBe('/ahellob');
     expect(arg).toBe('/a__c__b');
   });