refactor/cleanup: scully schematics (#177)

* refactor(scully): cleaned up schematic `scully`

- use existing utils to read and write `package.json` config parts
- split logic into smaller chainable functions
- provide aditional tests
- remove unused schema option `project`

* refactor(scully): use consistent id's and titles

* refactor(scully): use context.logger instead of console.log

* chore(scully): remove unused dependency chalk

* refactor(scully): replace all log with context.logger logs

* refactor(scully): outsource yaml converter

* style(scully): fix typo

* refactor(scully): use `post` schematic for initial post

avoid duplicat / mismatching code

* refactor(scully): use getFileContents utils function

* refactor(scully): cleanup markdown schematic including tests

* refactor(scully): use normalized paths

* fix(scully): use correct dasherized module path

* test(scully): add more tests for markdown schematic

* refactor(scully): camelize slug and use correct defaults

* fix(scully): remove unused title prop from schema

* refactor(scully): remove unused options from methods

* fix(scully): set correct defaults calling other schematic

* test(scully): update test for blog schematic

* test(scully): test blog schematic with specific routingScope

* test(scully): verify existing post won't be overridden

* test(scully): verify blog schematic is not called

...when disabling it via options

* fix(scully): set correct projectRoot src path

...and test it

* test(scully): test fail when no angular.json

* test(scully): fix error check in test

* test(scully): add test when appModule not exists

* feat(scully): remove blog promt for ng-add

* test(scully): fix test after merge

Author: d-koppenhagen

package.json

@@ -58,7 +58,6 @@
     "@types/request": "^2.48.4",
     "@types/yargs": "^13.0.3",
     "asciidoctor.js": "^1.5.9",
-    "chalk": "^2.4.2",
     "codelyzer": "^5.1.2",
     "conventional-changelog": "^2.0.3",
     "cz-conventional-changelog": "3.0.2",

schematics/scully/scullyio-init-0.0.16.tgz

@@ -8,6 +8,8 @@ export default function(options: Schema): Rule {
     const makrdownOptions: MarkownSchema = {
       name: 'blog',
       slug: 'slug',
+      sourceDir: 'blog',
+      route: 'blog',
     };
 
     if (options.routingScope) {

schematics/scully/src/add-blog/index.ts

@@ -23,16 +23,41 @@ describe('add-blog schematic', () => {
       appTree = await schematicRunner.runSchematicAsync('blog', defaultOptions, appTree).toPromise();
     });
 
-    it('should have run the markdown schematic', () => {
+    it('should have run the markdown schematic with default options', () => {
       expect(
         schematicRunner.tasks.some(
           task =>
             task.name === 'run-schematic' &&
             (task.options as any).name === 'create-markdown' &&
             (task.options as any).options.name === 'blog' &&
+            (task.options as any).options.sourceDir === 'blog' &&
+            (task.options as any).options.route === 'blog' &&
             (task.options as any).options.slug === 'slug'
         )
       ).toBe(true);
     });
   });
+
+  describe('when setting an explicit `routingScope`', () => {
+    beforeEach(async () => {
+      appTree = await schematicRunner
+        .runSchematicAsync('blog', {...defaultOptions, routingScope: 'Root'}, appTree)
+        .toPromise();
+    });
+
+    it('should have run the markdown schematic with defaults and `routingScope`', () => {
+      expect(
+        schematicRunner.tasks.some(
+          task =>
+            task.name === 'run-schematic' &&
+            (task.options as any).name === 'create-markdown' &&
+            (task.options as any).options.name === 'blog' &&
+            (task.options as any).options.sourceDir === 'blog' &&
+            (task.options as any).options.route === 'blog' &&
+            (task.options as any).options.slug === 'slug' &&
+            (task.options as any).options.routingScope === 'Root'
+        )
+      ).toBe(true);
+    });
+  });
 });

schematics/scully/src/add-blog/index_spec.ts

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "add-blog",
-  "title": "Scully add component schematic",
+  "id": "@scullyio/init:blog",
+  "title": "Scully: Add a complete blog schematic",
   "type": "object",
   "properties": {
     "routingScope": {

schematics/scully/src/add-blog/schema.json

@@ -1,9 +1,8 @@
 import {Rule, SchematicContext, SchematicsException, Tree} from '@angular-devkit/schematics';
 import {strings} from '@angular-devkit/core';
-import fs = require('fs');
-import yaml = require('js-yaml');
 
 import {Schema} from './schema';
+import {yamlToJson, jsonToJaml} from '../utils/utils';
 
 export default function(options: Schema): Rule {
   return (host: Tree, context: SchematicContext) => {
@@ -19,19 +18,10 @@ export default function(options: Schema): Rule {
     };
 
     if (options.metaDataFile) {
-      let metaDataContents = '';
-      try {
-        metaDataContents = fs.readFileSync(options.metaDataFile, 'utf8');
-      } catch (e) {
-        throw new SchematicsException(`File ${options.metaDataFile} not found`);
-      }
-
-      try {
-        // check if yaml is valid
-        metaData = yaml.safeLoad(metaDataContents);
+      const metaDataAsJson = yamlToJson(options.metaDataFile);
+      if (metaDataAsJson) {
+        metaData = metaDataAsJson;
         context.logger.info(`✅️ Meta Data File ${options.metaDataFile} successfully parsed`);
-      } catch (e) {
-        throw new SchematicsException(`${options.metaDataFile} contains no valid yaml`);
       }
     }
 
@@ -40,7 +30,7 @@ export default function(options: Schema): Rule {
 
     if (!host.exists(filename)) {
       const content = `---
-${yaml.safeDump(metaData)}---
+${jsonToJaml(metaData)}---
 
 # ${name}
 `;

schematics/scully/src/add-post/index.ts

@@ -72,4 +72,21 @@ describe('add-post', () => {
       expect(mdFileContent).toMatch(/language: en/g);
     });
   });
+
+  describe('when target file already exists', () => {
+    beforeEach(() => {
+      appTree.create(expectedFileName, 'foo');
+    });
+
+    it('should not touch existing file', async () => {
+      let error = '';
+      try {
+        await schematicRunner.runSchematicAsync('post', defaultOptions, appTree).toPromise();
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toMatch(/Error: foo-bar-baz exist/g);
+      expect(getFileContent(appTree, expectedFileName)).toEqual('foo');
+    });
+  });
 });

schematics/scully/src/add-post/index_spec.ts

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/schema",
-  "id": "Scully-ng-add-blog",
-  "title": "Scully ng-add-blog schematic",
+  "id": "@scullyio/init:post",
+  "title": "Scully: Add a blog post schematic",
   "type": "object",
   "properties": {
     "name": {

schematics/scully/src/add-post/schema.json

@@ -10,7 +10,7 @@
     },
     "scully": {
       "description": "Add scully to your angular app.",
-      "factory": "./scully/index#scully",
+      "factory": "./scully/index",
       "schema": "./scully/schema.json",
       "aliases": ["run"]
     },

schematics/scully/src/collection.json

@@ -1,85 +1,82 @@
 import {Rule, Tree, url, applyTemplates, move, chain, SchematicContext} from '@angular-devkit/schematics';
 import {strings, normalize} from '@angular-devkit/core';
-import {Schema as MyServiceSchema} from './schema';
+import {Schema} from './schema';
+import {Schema as PostSchema} from '../add-post/schema';
 import {
   addRouteToModule,
   addRouteToScullyConfig,
   applyWithOverwrite,
   getPrefix,
   getSrc,
+  getFileContents,
 } from '../utils/utils';
+import {RunSchematicTask} from '@angular-devkit/schematics/tasks';
 
 const SCULLY_CONF_FILE = '/scully.config.js';
 const ANGULAR_CONF_FILE = './angular.json';
 
-export default function(options: MyServiceSchema): Rule {
-  return (host: Tree, context: SchematicContext) => {
-    try {
-      const sourceDir = getSrc(host);
-      const name = options.name ? options.name : 'blog';
-      const nameDasherized = strings.dasherize(options.name);
-      const targetDirName = options.sourceDir
-        ? strings.dasherize(options.sourceDir) // use sourceDir when provided
-        : strings.dasherize(options.name); // fall back to name when not provided
-      const date = new Date();
-      // format yyyy-mm-dd
-      const fullDay = date.toISOString().substring(0, 10);
-      const path = `${targetDirName}/${fullDay}-${nameDasherized}.md`;
-      if (!host.exists(path)) {
-        host.create(
-          path,
-          `---
-title: This is the ${name}
-description: ${name} description
-publish: false
----
+export default (options: Schema): Rule => {
+  options.name = options.name || 'blog';
+  options.slug = options.slug || 'id';
+  options.sourceDir = options.sourceDir || options.name;
+  return chain([
+    addPost(options, options.sourceDir),
+    updateScullyConfig(options.sourceDir, options),
+    addModule(options),
+  ]);
+};
 
-# Page ${name} example
-`
-        );
-        context.logger.info(`✅ ${path} file created`);
-      }
+const addPost = (options: Schema, target: string) => (tree: Tree, context: SchematicContext) => {
+  const nameDasherized = strings.dasherize(options.name);
+  const targetDirName = strings.dasherize(target);
+  const date = new Date();
+  // format yyyy-mm-dd
+  const fullDay = date.toISOString().substring(0, 10);
+  const baseFileName = `${fullDay}-${nameDasherized}`;
+  if (!tree.exists(`${targetDirName}/${baseFileName}.md`)) {
+    const postOptions: PostSchema = {
+      name: baseFileName,
+      target: targetDirName,
+    };
+    context.addTask(new RunSchematicTask('post', postOptions), []);
+  }
+};
 
-      let scullyJs;
-      try {
-        scullyJs = host.read(SCULLY_CONF_FILE).toString();
-      } catch (e) {
-        // for test in schematics
-        scullyJs = `exports.config = {
-  projectRoot: "${getSrc(host)}/app",
-  routes: {
-  },
-};`;
-      }
-      const newScullyJs = addRouteToScullyConfig(scullyJs, {
-        name,
-        slug: options.slug,
-        type: 'contentFolder',
-        sourceDir,
-        route: options.route,
-      });
-      host.overwrite(SCULLY_CONF_FILE, newScullyJs);
-      context.logger.info(`✅️ Update ${SCULLY_CONF_FILE}`);
+const updateScullyConfig = (target: string, options: Schema) => (tree: Tree, context: SchematicContext) => {
+  const scullyJs = getFileContents(tree, SCULLY_CONF_FILE);
+  if (!scullyJs) {
+    context.logger.error(`No scully configuration file found ${SCULLY_CONF_FILE}`);
+  }
+  const newScullyJs = addRouteToScullyConfig(scullyJs, {
+    name: options.name,
+    slug: options.slug,
+    type: 'contentFolder',
+    sourceDir: target,
+    route: options.route,
+  });
 
-      const pathName = strings.dasherize(`${sourceDir}/app/${name}`);
-      let prefix = 'app';
-      if (host.exists(ANGULAR_CONF_FILE)) {
-        prefix = getPrefix(host.read(ANGULAR_CONF_FILE).toString());
-        addRouteToModule(host, options);
-      }
+  tree.overwrite(SCULLY_CONF_FILE, newScullyJs);
+  context.logger.info(`✅️ Update ${SCULLY_CONF_FILE}`);
+};
 
-      const templateSource = applyWithOverwrite(url('../files/markdown-module'), [
-        applyTemplates({
-          classify: strings.classify,
-          dasherize: strings.dasherize,
-          name: options.name,
-          slug: options.slug,
-          prefix,
-        }),
-        move(normalize(pathName)),
-      ]);
+const addModule = (options: Schema) => (tree: Tree, context: SchematicContext) => {
+  const sourceDir = getSrc(tree);
+  const pathName = strings.dasherize(`${sourceDir}/app/${options.name}`);
+  let prefix = 'app';
+  if (tree.exists(ANGULAR_CONF_FILE)) {
+    prefix = getPrefix(getFileContents(tree, ANGULAR_CONF_FILE));
+    addRouteToModule(tree, options);
+  }
 
-      return chain([templateSource]);
-    } catch (e) {}
-  };
-}
+  return applyWithOverwrite(url('../files/markdown-module'), [
+    applyTemplates({
+      classify: strings.classify,
+      dasherize: strings.dasherize,
+      camelize: strings.camelize,
+      name: options.name,
+      slug: options.slug,
+      prefix,
+    }),
+    move(normalize(pathName)),
+  ]);
+};