feat(@angular-devkit/schematics): add custom schema formats

Author: filipesilva

packages/angular_devkit/schematics/src/formats/app-name.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { schema } from '@angular-devkit/core';
+import { htmlSelectorRe } from './html-selector';
+
+
+const unsupportedProjectNames = ['test', 'ember', 'ember-cli', 'vendor', 'app'];
+
+export const appNameFormat: schema.SchemaFormat = {
+  name: 'app-name',
+  formatter: {
+    async: false,
+    validate: (appName: string) => htmlSelectorRe.test(appName)
+      && unsupportedProjectNames.indexOf(appName) === -1,
+  },
+};

packages/angular_devkit/schematics/src/formats/app-name_spec.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { appNameFormat } from './app-name';
+import { formatValidator } from './format-validator';
+
+
+describe('Schematics app name format', () => {
+  it('accepts correct app name', done => {
+    const data = { appName: 'my-app' };
+    const dataSchema = {
+      properties: { appName: { type: 'string', format: 'app-name' } },
+    };
+
+    formatValidator(data, dataSchema, [appNameFormat])
+      .map(result => expect(result.success).toBe(true))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects app name starting with invalid characters', done => {
+    const data = { appName: 'my-app$' };
+    const dataSchema = {
+      properties: { appName: { type: 'string', format: 'app-name' } },
+    };
+
+    formatValidator(data, dataSchema, [appNameFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects app name starting with number', done => {
+    const data = { appName: '1app' };
+    const dataSchema = {
+      properties: { appName: { type: 'string', format: 'app-name' } },
+    };
+
+    formatValidator(data, dataSchema, [appNameFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects unsupported app names', done => {
+    const data = {
+      appName1: 'test',
+      appName2: 'ember',
+      appName3: 'ember-cli',
+      appName4: 'vendor',
+      appName5: 'app',
+    };
+    const dataSchema = {
+      properties: {
+        appName1: { type: 'string', format: 'app-name' },
+        appName2: { type: 'string', format: 'app-name' },
+        appName3: { type: 'string', format: 'app-name' },
+        appName4: { type: 'string', format: 'app-name' },
+        appName5: { type: 'string', format: 'app-name' },
+      },
+    };
+
+    formatValidator(data, dataSchema, [appNameFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+});

packages/angular_devkit/schematics/src/formats/format-validator.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { schema } from '@angular-devkit/core';
+import { Observable } from 'rxjs/Observable';
+import 'rxjs/add/operator/mergeMap';
+
+
+export function formatValidator(
+  data: Object,
+  dataSchema: Object,
+  formats: schema.SchemaFormat[],
+): Observable<schema.SchemaValidatorResult> {
+  const registry = new schema.CoreSchemaRegistry();
+
+  for (const format of formats) {
+    registry.addFormat(format);
+  }
+
+  return registry
+    .compile(dataSchema)
+    .mergeMap(validator => validator(data));
+}

packages/angular_devkit/schematics/src/formats/html-selector.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { schema } from '@angular-devkit/core';
+
+
+// Must start with a letter, and must contain only alphanumeric characters or dashes.
+// When adding a dash the segment after the dash must also start with a letter.
+export const htmlSelectorRe = /^[a-zA-Z][.0-9a-zA-Z]*(:?-[a-zA-Z][.0-9a-zA-Z]*)*$/;
+
+export const htmlSelectorFormat: schema.SchemaFormat = {
+  name: 'html-selector',
+  formatter: {
+    async: false,
+    validate: (selector: string) => htmlSelectorRe.test(selector),
+  },
+};

packages/angular_devkit/schematics/src/formats/html-selector_spec.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { formatValidator } from './format-validator';
+import { htmlSelectorFormat } from './html-selector';
+
+
+describe('Schematics HTML selector format', () => {
+  it('accepts correct selectors', done => {
+    const data = { selector: 'my-selector' };
+    const dataSchema = {
+      properties: { selector: { type: 'string', format: 'html-selector' } },
+    };
+
+    formatValidator(data, dataSchema, [htmlSelectorFormat])
+      .map(result => expect(result.success).toBe(true))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects selectors starting with invalid characters', done => {
+    const data = { selector: 'my-selector$' };
+    const dataSchema = {
+      properties: { selector: { type: 'string', format: 'html-selector' } },
+    };
+
+    formatValidator(data, dataSchema, [htmlSelectorFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects selectors starting with number', done => {
+    const data = { selector: '1selector' };
+    const dataSchema = {
+      properties: { selector: { type: 'string', format: 'html-selector' } },
+    };
+
+    formatValidator(data, dataSchema, [htmlSelectorFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects selectors with non-letter after dash', done => {
+    const data = { selector: 'my-1selector' };
+    const dataSchema = {
+      properties: { selector: { type: 'string', format: 'html-selector' } },
+    };
+
+    formatValidator(data, dataSchema, [htmlSelectorFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+});

packages/angular_devkit/schematics/src/formats/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export * from './app-name';
+export * from './html-selector';
+export * from './path';

packages/angular_devkit/schematics/src/formats/path.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { normalize, schema } from '@angular-devkit/core';
+
+
+export const pathFormat: schema.SchemaFormat = {
+  name: 'path',
+  formatter: {
+    async: false,
+    validate: (path: string) => {
+      // Check path is normalized already.
+      return path === normalize(path);
+      // TODO: check if path is valid (is that just checking if it's normalized?)
+      // TODO: check path is from root of schematics even if passed absolute
+      // TODO: error out if path is outside of host
+    },
+  },
+};

packages/angular_devkit/schematics/src/formats/path_spec.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { formatValidator } from './format-validator';
+import { pathFormat } from './path';
+
+
+describe('Schematics Path format', () => {
+  it('accepts correct Paths', done => {
+    const data = { path: 'a/b/c' };
+    const dataSchema = {
+      properties: { path: { type: 'string', format: 'path' } },
+    };
+
+    formatValidator(data, dataSchema, [pathFormat])
+      .map(result => expect(result.success).toBe(true))
+      .subscribe(done, done.fail);
+  });
+
+  it('rejects Paths that are not normalized', done => {
+    const data = { path: 'a/b/c/../' };
+    const dataSchema = {
+      properties: { path: { type: 'string', format: 'path' } },
+    };
+
+    formatValidator(data, dataSchema, [pathFormat])
+      .map(result => expect(result.success).toBe(false))
+      .subscribe(done, done.fail);
+  });
+});

packages/angular_devkit/schematics/src/index.ts

@@ -33,6 +33,8 @@ export {UpdateRecorder} from './tree/interface';
 export * from './engine/schematic';
 export * from './sink/dryrun';
 export {FileSystemSink} from './sink/filesystem';
+import * as formats from './formats';
+export { formats };
 
 
 export interface TreeConstructor {

packages/angular_devkit/schematics/testing/schematic-test-runner.ts

@@ -15,6 +15,7 @@ import {
   SchematicEngine,
   Tree,
   VirtualTree,
+  formats,
 } from '@angular-devkit/schematics';
 import {
   NodeModulesTestEngineHost,
@@ -43,8 +44,14 @@ export class SchematicTestRunner {
     this._engineHost.registerCollection(_collectionName, collectionPath);
     this._logger = new logging.Logger('test');
 
-    this._engineHost.registerOptionsTransform(
-      validateOptionsWithSchema(new schema.CoreSchemaRegistry()));
+    const schemaFormats = [
+      formats.appNameFormat,
+      formats.htmlSelectorFormat,
+      formats.pathFormat,
+    ];
+    const registry = new schema.CoreSchemaRegistry(schemaFormats);
+
+    this._engineHost.registerOptionsTransform(validateOptionsWithSchema(registry));
     this._collection = this._engine.createCollection(this._collectionName);
   }
 

packages/angular_devkit/schematics_cli/bin/schematics.ts

@@ -19,6 +19,7 @@ import {
   FileSystemTree,
   SchematicEngine,
   Tree,
+  formats,
 } from '@angular-devkit/schematics';
 import {
   FileSystemHost,
@@ -128,7 +129,13 @@ const engine = new SchematicEngine(engineHost);
 
 
 // Add support for schemaJson.
-engineHost.registerOptionsTransform(validateOptionsWithSchema(new schema.CoreSchemaRegistry()));
+const schemaFormats = [
+  formats.appNameFormat,
+  formats.htmlSelectorFormat,
+  formats.pathFormat,
+];
+const registry = new schema.CoreSchemaRegistry(schemaFormats);
+engineHost.registerOptionsTransform(validateOptionsWithSchema(registry));
 
 
 /**