refactor(config): NgConfig

jkuri · jkuri · commit 16738165fdfc · 2016-08-03T07:08:00.000+02:00
diff --git a/addon/ng2/commands/set.ts b/addon/ng2/commands/set.ts
@@ -1,6 +1,6 @@
 import * as Command from 'ember-cli/lib/models/command';
 import {CliConfig} from '../models/config';
-
+import * as chalk from 'chalk';
 
 const SetCommand = Command.extend({
   name: 'set',
@@ -12,9 +12,24 @@ const SetCommand = Command.extend({
   ],
 
   run: function (commandOptions, rawArgs): Promise<void> {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
+      if (rawArgs.length < 2) {
+        this.ui.writeLine(`
+        ${chalk.red.bold('Error: not enough parameters provided.')}
+        'Examples:'
+        ${chalk.yellow('ng set project.name "My awesome project"')}
+        ${chalk.yellow('ng set defaults.styleExt sass')}
+        ${chalk.yellow('ng set apps[0].mobile true')}
+        ${chalk.yellow('ng set "apps[0].styles[\'src/styles.css\'].autoImported" = false')}
+        ${chalk.yellow('ng set "apps[0].styles[\'src/app.sass\']" = "{ output: \'app.css\', autoImported: true }"')}
+        `);
+        reject();
+      }
+
       const config = new CliConfig();
-      config.set(rawArgs[0], rawArgs[1], commandOptions.force);
+      const value = rawArgs[1] === '=' ? rawArgs[2] : rawArgs[1];
+
+      config.set(rawArgs[0], value, commandOptions.force);
       config.save();
       resolve();
     });
diff --git a/addon/ng2/models/config.ts b/addon/ng2/models/config.ts
@@ -1,5 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as jp from 'jsonpath';
+import * as chalk from 'chalk';
 
 const schemaPath = path.resolve(process.env.CLI_ROOT, 'lib/config/schema.json');
 const schema = require(schemaPath);
@@ -29,7 +31,7 @@ export class CliConfig {
     if (path) {
       try {
         fs.accessSync(path);
-        this._config = require(path);
+        this._config = JSON.parse(fs.readFileSync(path, 'utf8'));
       } catch (e) {
         throw new Error(`Config file does not exits.`);
       }
@@ -46,116 +48,104 @@ export class CliConfig {
     fs.writeFileSync(path, JSON.stringify(this._config, null, 2), { encoding: 'utf-8' });
   }
 
-  set(jsonPath: string, value: any, force: boolean = false): boolean {
-    let method: any = null;
-    let splittedPath = jsonPath.split('.');
-    if (ARRAY_METHODS.indexOf(splittedPath[splittedPath.length - 1]) != -1) {
-      method = splittedPath[splittedPath.length - 1];
-      splittedPath.splice(splittedPath.length - 1, 1);
-      jsonPath = splittedPath.join('.');
-    }
+  checkValidSchemaPath(jsonPath: Object): boolean {
+    const parsed = jp.parse(jsonPath);
+    const invalidMsg = `${jsonPath} does not match schema.`;
+    let propertiesPath;
 
-    let { parent, name, remaining } = this._findParent(jsonPath);
-    let properties: any;
-    let additionalProperties: boolean;
+    parsed.forEach((p, i) => {
+      let type = p.expression.type;
+      let value = p.expression.value;
 
-    const checkPath = jsonPath.split('.').reduce((o, i) => {
-      if (!o || !o.properties) {
-        throw new Error(`Invalid config path.`);
+      if (i === parsed.length - 1) {
+        return;
       }
-      properties = o.properties;
-      additionalProperties = o.additionalProperties;
 
-      return o.properties[i];
-    }, schema);
-    const configPath = jsonPath.split('.').reduce((o, i) => o[i], this._config);
+      if (!i) {
+        propertiesPath = `properties.${value}`;
+      } else {
+        if (type === 'numeric_literal') {
+          let prop = propertiesPath.split('.').reduce((prev, curr) => prev[curr], schema);
+          if (prop.type !== 'array') {
+            throw new Error(invalidMsg);
+          } else {
+            propertiesPath += `.items`;
+          }
+        } else {
+          propertiesPath += `.properties.${value}`;
+        }
+      }
+    });
 
-    if (!properties[name] && !additionalProperties) {
-      throw new Error(`${name} is not a known property.`);
+    if (!propertiesPath.split('.').reduce((prev, curr) => prev[curr], schema)) {
+      throw new Error(invalidMsg);
     }
+  }
 
-    if (method) {
-      if (Array.isArray(configPath) && checkPath.type === 'array') {
-        [][method].call(configPath, value);
-        return true;
-      } else {
-        throw new Error(`Trying to use array method on non-array property type.`);
+  set(jsonPath: string, value: any, force: boolean = false): boolean {
+    this._validatePath(jsonPath);
+    this.checkValidSchemaPath(jsonPath);
+
+    if (value.slice(0, 1) === '{' && value.slice(-1) === '}') {
+      try {
+        value = JSON.parse(value.replace(/\'/g, '\"'));
+      } catch (e) {
+        throw new Error(`Invalid JSON value ${value}`);
       }
     }
 
-    if (typeof checkPath.type === 'string' && isNaN(value)) {
-      parent[name] = value;
-      return true;
+    if (typeof value === 'object') {
+      if (prop.type !== 'object') {
+                
+      }
     }
 
-    if (typeof checkPath.type === 'number' && !isNaN(value)) {
-      parent[name] = value;
-      return true;
+    let prop = jsonPath.split('.').reduce((prev, curr) => prev[curr], this._config);
+
+    if (ARRAY_METHODS.indexOf(path.extname(jsonPath).replace('.', '')) !== -1) {
+      let method = path.extname(jsonPath);
+      let parentPath = jsonPath.replace(path.extname(jsonPath), '');
+
+      if (typeof jp.query(this._config, `$.${parentPath}`)[0] === 'string') {
+        throw new Error(`Cannot use array method on non-array type.`);
+      } else {
+        [][method].call(parent, value);
+      }
     }
 
-    if (typeof value != checkPath.type) {
-      throw new Error(`Invalid value type. Trying to set ${typeof value} to ${path.type}`);
+    if (!prop) {
+      throw new Error(`Property does not exists.`);
     }
+
+    jp.value(this._config, `$.${jsonPath}`, value);
   }
 
   get(jsonPath: string): any {
-    let { parent, name, remaining } = this._findParent(jsonPath);
-    if (remaining || !(name in parent)) {
+    let results = jp.query(this._config, `$.${jsonPath}`);
+    if (!results.length) {
+      let ext = path.extname(jsonPath);
+      results = jp.query(this._config, `$..${ext}`);
+      if (results.length) {
+        console.log(chalk.yellow(`
+          We could not find value on the path you were requested.
+          Did you mean: ${results[0]}?`
+        ));
+      }
+
       return null;
     } else {
-      return parent[name];
+      return results[0];
     }
   }
 
   private _validatePath(jsonPath: string) {
-    if (!jsonPath.match(/^(?:[-_\w\d]+(?:\[\d+\])*\.)*(?:[-_\w\d]+(?:\[\d+\])*)$/)) {
+    try {
+      jp.parse(jsonPath);
+    } catch (e) {
       throw `Invalid JSON path: "${jsonPath}"`;
     }
   }
 
-  private _findParent(jsonPath: string): { parent: any, name: string | number, remaining?: string } {
-    this._validatePath(jsonPath);
-
-    let parent: any = null;
-    let current: any = this._config;
-
-    const splitPath = jsonPath.split('.');
-    let name: string | number = '';
-
-    while (splitPath.length > 0) {
-      const m = splitPath.shift().match(/^(.*?)(?:\[(\d+)\])*$/);
-
-      name = m[1];
-      const index: string = m[2];
-      parent = current;
-      current = current[name];
-
-      if (current === null || current === undefined) {
-        return {
-          parent,
-          name,
-          remaining: (!isNaN(index) ? `[${index}]` : '') + splitPath.join('.')
-        };
-      }
-
-      if (!isNaN(index)) {
-        name = index;
-        parent = current;
-        current = current[index];
-
-        if (current === null || current === undefined) {
-          return {
-            parent,
-            name,
-            remaining: splitPath.join('.')
-          };
-        }
-      }
-    }
-
-    return { parent, name };
-  }
-
   private static _configFilePath(projectPath?: string): string {
     // Find the configuration, either where specified, in the angular-cli project
     // (if it's in node_modules) or from the current process.
@@ -166,6 +156,6 @@ export class CliConfig {
 
   public static fromProject(): any {
     const configPath = CliConfig._configFilePath();
-    return configPath ? require(configPath) : {};
+    return configPath ? JSON.parse(fs.readFileSync(configPath, 'utf8')) : {};
   }
 }
diff --git a/angular-cli.json b/angular-cli.json
@@ -0,0 +1,32 @@
+{
+  "project": {
+    "name": "Angular CLI global config"
+  },
+  "apps": [
+    {
+      "main": "src/main.ts",
+      "tsconfig": "src/tsconfig.json",
+      "mobile": false,
+      "styles": {}
+    }
+  ],
+  "addons": [],
+  "packages": [],
+  "e2e": {
+    "protractor": {
+      "config": "config/protractor.conf.js"
+    }
+  },
+  "test": {
+    "karma": {
+      "config": "config/karma.conf.js"
+    }
+  },
+  "defaults": {
+    "prefix": "app",
+    "sourceDir": "src",
+    "styleExt": "css",
+    "prefixInterfaces": false,
+    "lazyRoutePrefix": "+"
+  }
+}
diff --git a/lib/config/schema.json b/lib/config/schema.json
@@ -24,7 +24,19 @@
         "properties": {
           "main": "string",
           "tsconfig": "string",
-          "mobile": "boolean"
+          "mobile": "boolean",
+          "styles": {
+            "type": "object",
+            "properties": {
+              "output": {
+                "type": "string"
+              },
+              "autoImported": {
+                "type": "boolean"
+              }
+            },
+            "additionalProperties": false
+          }
         },
         "additionalProperties": false
       },
diff --git a/package.json b/package.json
@@ -55,6 +55,7 @@
     "html-webpack-plugin": "^2.19.0",
     "istanbul-instrumenter-loader": "^0.2.0",
     "json-loader": "^0.5.4",
+    "jsonpath": "^0.2.6",
     "karma-sourcemap-loader": "^0.3.7",
     "karma-webpack": "^1.7.0",
     "leek": "0.0.21",
diff --git a/tests/models/config.spec.ts b/tests/models/config.spec.ts
@@ -1,17 +1,17 @@
 import {CliConfig} from '../../addon/ng2/models/config';
 import * as fs from 'fs';
 import * as path from 'path';
+import { expect } from 'chai';
 
-const expect = require('chai').expect;
-const config = path.resolve(process.cwd(), 'addon/ng2/blueprints/ng2/files/angular-cli.json');
-const configCopy = path.resolve(process.cwd(), 'angular-cli.json');
+const config = path.resolve(process.cwd(), 'angular-cli.json');
+const configCopy = path.resolve(process.cwd(), 'angular-cli-tmp.json');
 
 function getContents() {
-  return require(configCopy);
+  return JSON.parse(fs.readFileSync(configCopy, 'utf8'));
 }
 
 // TODO: revisit this test to make non-valid-JSON-friendly.
-describe.skip('Config Tests', () => {
+describe('Config Tests', () => {
   before(() => {
     process.chdir(process.cwd());
   });
@@ -41,7 +41,7 @@ describe.skip('Config Tests', () => {
   it('Updates property of type `string` successfully', () => {
     let c = new CliConfig(configCopy);
     c.set('project.name', 'new-project-name');
-    c.save();
+    c.save(configCopy);
 
     let contents = getContents();
 
@@ -55,7 +55,7 @@ describe.skip('Config Tests', () => {
 
     let fn = () => {
       c.set('project.foo', 'bar');
-      c.save();
+      c.save(configCopy);
     }
 
     expect(fn).to.throw(Error);
@@ -66,7 +66,7 @@ describe.skip('Config Tests', () => {
 
     let fn = () => {
       c.set('project.name.push', 'new-project-name');
-      c.save();
+      c.save(configCopy);
     }
 
     expect(fn).to.throw(Error);
