ember-cli 7.4.0-alpha.1 → 7.4.0

package/packages/blueprint-model/utilities/markdown-color.js

@@ -1,208 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-
-const { default: chalk } = require('chalk');
-const SilentError = require('silent-error');
-const merge = require('lodash/merge');
-
-let colors = ['red', 'green', 'blue', 'cyan', 'magenta', 'yellow', 'black', 'white', 'grey', 'gray'];
-let backgroundColors = ['bgRed', 'bgGreen', 'bgBlue', 'bgCyan', 'bgMagenta', 'bgYellow', 'bgWhite', 'bgBlack'];
-
-/*
-  Parses markdown and applies coloring to output by matching defined tokens and
-  applying styling. Default outputs chalk.js coloring for terminal output.
-  Options:
-    tokens: pass additional tokens in the following format:
-    {
-      name:{
-        token: '(Reserved)', // example of token
-        pattern: /(Reserved)/g, // regexp pattern
-        render(string) { return string + '!'} // function that takes and returns a string
-      }
-    }
-
-    markdownOptions: object containing options to pass (or override) to markdown-it-terminal upon
-      instantiation. See https://github.com/trabus/markdown-it-terminal/blob/master/index.js#L8
-
-    renderStyles: pass an object to render color styles, default is chalk.js
-
-  @class MarkdownColor
-  @constructor
-  @param {Object} [options]
-*/
-class MarkdownColor {
-  constructor(options) {
-    let optionTokens = (options && options.tokens) || {};
-    let renderStyles = (options && options.renderStyles) || chalk;
-    let tokens = this.generateTokens(renderStyles);
-    let markdownOptions = (options && options.markdownOptions) || {};
-    const markdown = require('markdown-it');
-    const terminal = require('markdown-it-terminal');
-    this.options = options || {};
-    this.markdown = markdown().use(terminal, markdownOptions);
-    this.tokens = merge(tokens, optionTokens);
-  }
-
-  /*
-    Lookup markdown file and render contents
-    @method renderFile
-    @param {String} [filePath]
-    @param {Object} [options]
-  */
-  renderFile(filePath, options) {
-    let file;
-    try {
-      file = fs.readFileSync(filePath, 'utf-8');
-    } catch (e) {
-      throw new SilentError(`The file '${filePath}' doesn't exist. Please check your filePath`);
-    }
-
-    return this.render(file, options);
-  }
-
-  /*
-    Parse markdown and output as string
-    @method render
-    @param {String} [string]
-    @param {Object} [options]
-    @return {String}
-  */
-  render(string, options) {
-    let indent = (options && options.indent) || '';
-    let input = this.markdown.render(string);
-    let styles = Object.keys(this.tokens);
-
-    input = input.replace(/^/gm, indent);
-    styles.reverse().map((style) => {
-      input = input.replace(this.tokens[style].pattern, this.tokens[style].render);
-    });
-    input = input.replace(/~\^(.*)~\^/g, escapeToken);
-    return input;
-  }
-
-  /*
-    Generate default style tokens
-    @method generateTokens
-    @return {Object}
-  */
-  generateTokens(renderer) {
-    let defaultTokens = {
-      // ember-cli styles
-      option: {
-        name: 'option',
-        token: '--option',
-        pattern: /((--\w*\b)|(<options>))/g,
-        render: this.renderStylesFactory(renderer, 'cyan'),
-      },
-      default: {
-        name: 'default',
-        token: '(Default: default)',
-        pattern: /(\(Default:\s.*\))/g,
-        render: this.renderStylesFactory(renderer, 'cyan'),
-      },
-      required: {
-        name: 'required',
-        token: '(Required)',
-        pattern: /(\(Required\))/g,
-        render: this.renderStylesFactory(renderer, 'cyan'),
-      },
-    };
-    let colorTokens = unshiftValue(colors.concat(backgroundColors).map(getToken.bind(this)), {}).reduce(setToken);
-    return merge(colorTokens, defaultTokens);
-  }
-
-  /*
-    Looks up multiple styles to apply to the rendered output
-    @method renderStylesFactory
-    @param {Object} [renderer] should match chalk.js format
-    @param {String, Array} [styleNames]
-    @return {Function} Function that will wrap the input string with styling
-  */
-  renderStylesFactory(renderer, styleNames) {
-    let styles;
-
-    if (Array.isArray(styleNames)) {
-      styles = styleNames.map(checkStyleName.bind(null, renderer));
-    } else {
-      styles = [checkStyleName(renderer, styleNames)];
-    }
-
-    return function (match, pattern) {
-      return styles.reverse().reduce((previous, current) => renderer[current](previous), pattern);
-    };
-  }
-}
-
-module.exports = MarkdownColor;
-
-/*
-  Check to see if style exists on the renderer
-  @param {Object} [renderer] should match chalk.js format
-  @param {String} [name]
-*/
-function checkStyleName(renderer, name) {
-  if (typeof renderer[name] === 'function') {
-    return name;
-  } else {
-    throw new SilentError(`The style '${name}' is not supported by the markdown renderer.`);
-  }
-}
-
-/*
-  @param {String} [name]
-  @param {Object} [options]
-  @return {RegExp} Returns lookup pattern
-*/
-function getColorTokenRegex(name, options) {
-  options = options || {};
-  let start = options.start || '(?:<';
-  let end = options.end || '>)';
-  let close = options.close || '(?:</';
-  let middle = options.middle || '(.*?)';
-  let tag = start + name + end;
-  let closeTag = close + name + end;
-  let pattern = tag + middle + closeTag;
-  return new RegExp(pattern, 'g');
-}
-
-/*
-  @param {String} [name]
-  @param {Object} [options]
-  @return {Object} Returns token object
-*/
-function getToken(name, options) {
-  let renderer = (options && options.renderer) || chalk;
-  return {
-    name,
-    token: `<${name}></${name}>`,
-    pattern: getColorTokenRegex(name),
-    render: this.renderStylesFactory(renderer, name),
-  };
-}
-
-function setToken(result, color) {
-  result[color.name] = color;
-  return result;
-}
-
-function escapeToken(match, pattern) {
-  let output = pattern.replace(/~/g, '');
-  return `<${output}>`;
-}
-
-function unshiftValue(array, value) {
-  array.unshift(value);
-  return array;
-}
-
-/*
-Formatting colors for ember-cli help
-
-white: ember serve
-yellow: <arg-option, >
-cyan: --port, --important-option
-cyan: (Default: something), (Default: 4200)
-white: Description 1, Description 2
-cyan: (Required)
-*/

package/packages/blueprint-model/utilities/open-editor.js

@@ -1,44 +0,0 @@
-'use strict';
-
-const spawn = require('child_process').spawn;
-
-function openEditor(file) {
-  if (!openEditor.canEdit()) {
-    throw new Error('EDITOR environment variable is not set');
-  }
-
-  if (!file) {
-    throw new Error('No `file` option provided');
-  }
-
-  let editorArgs = openEditor._env().EDITOR.split(' ');
-  let editor = editorArgs.shift();
-  const args = [file].concat(editorArgs);
-  let editProcess = openEditor._spawn(editor, args, { stdio: 'inherit' });
-
-  return new Promise((resolve, reject) => {
-    editProcess.on('close', (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(`Spawn('${editor}', [${args.join(',')}]) exited with a non zero error status code: '${code}'`)
-        );
-      }
-    });
-  });
-}
-
-openEditor.canEdit = function () {
-  return openEditor._env().EDITOR !== undefined;
-};
-
-openEditor._env = function () {
-  return process.env;
-};
-
-openEditor._spawn = function () {
-  return spawn.apply(this, arguments);
-};
-
-module.exports = openEditor;

package/packages/blueprint-model/utilities/prepend-emoji.js

@@ -1,12 +0,0 @@
-'use strict';
-
-function supportEmoji() {
-  const hasEmojiTurnedOff = process.argv.indexOf('--no-emoji') > -1;
-  return process.stdout.isTTY && process.platform !== 'win32' && !hasEmojiTurnedOff;
-}
-
-const areEmojiSupported = supportEmoji();
-
-module.exports = function prependEmoji(emoji, msg) {
-  return areEmojiSupported ? `${emoji}  ${msg}` : msg;
-};

package/packages/blueprint-model/utilities/print-command.js

@@ -1,102 +0,0 @@
-'use strict';
-
-const { default: chalk } = require('chalk');
-const EOL = require('os').EOL;
-
-module.exports = function (initialMargin, shouldDescriptionBeGrey) {
-  initialMargin = initialMargin || '';
-
-  let output = '';
-
-  let options = this.anonymousOptions;
-
-  // <anonymous-option-1> ...
-  if (options.length) {
-    output += ` ${chalk.yellow(
-      options
-        .map((option) => {
-          // blueprints we insert brackets, commands already have them
-          if (option.indexOf('<') === 0) {
-            return option;
-          } else {
-            return `<${option}>`;
-          }
-        })
-        .join(' ')
-    )}`;
-  }
-
-  options = this.availableOptions;
-
-  // <options...>
-  if (options.length) {
-    output += ` ${chalk.cyan('<options...>')}`;
-  }
-
-  // Description
-  let description = this.description;
-  if (description) {
-    if (shouldDescriptionBeGrey) {
-      description = chalk.grey(description);
-    }
-    output += `${EOL + initialMargin}  ${description}`;
-  }
-
-  // aliases: a b c
-  if (this.aliases && this.aliases.length) {
-    output += `${EOL + initialMargin}  ${chalk.grey(`aliases: ${this.aliases.filter((a) => a).join(', ')}`)}`;
-  }
-
-  // --available-option (Required) (Default: value)
-  // ...
-  options.forEach((option) => {
-    output += `${EOL + initialMargin}  ${chalk.cyan(`--${option.name}`)}`;
-
-    if (option.values) {
-      output += chalk.cyan(`=${option.values.join('|')}`);
-    }
-
-    if (option.type) {
-      let types = Array.isArray(option.type) ? option.type.map(formatType).join(', ') : formatType(option.type);
-
-      output += ` ${chalk.cyan(`(${types})`)}`;
-    }
-
-    if (option.required) {
-      output += ` ${chalk.cyan('(Required)')}`;
-    }
-
-    if (option.default !== undefined) {
-      output += ` ${chalk.cyan(`(Default: ${formatValue(option.default)})`)}`;
-    }
-
-    if (option.description) {
-      output += ` ${option.description}`;
-    }
-
-    if (option.aliases && option.aliases.length) {
-      output += `${EOL + initialMargin}    ${chalk.grey(
-        `aliases: ${option.aliases
-          .map((a) => {
-            if (typeof a === 'string') {
-              return (a.length > 4 ? '--' : '-') + a + (option.type === Boolean ? '' : ' <value>');
-            } else {
-              let key = Object.keys(a)[0];
-              return `${(key.length > 4 ? '--' : '-') + key} (--${option.name}=${formatValue(a[key])})`;
-            }
-          })
-          .join(', ')}`
-      )}`;
-    }
-  });
-
-  return output;
-};
-
-function formatType(type) {
-  return typeof type === 'string' ? formatValue(type) : type.name;
-}
-
-function formatValue(val) {
-  return val === '' ? '""' : val;
-}

package/packages/blueprint-model/utilities/process-template.js

@@ -1,10 +0,0 @@
-'use strict';
-
-module.exports = function processTemplate(content, context) {
-  let options = {
-    evaluate: /<%([\s\S]+?)%>/g,
-    interpolate: /<%=([\s\S]+?)%>/g,
-    escape: /<%-([\s\S]+?)%>/g,
-  };
-  return require('lodash/template')(content, options)(context);
-};

package/packages/blueprint-model/utilities/sequence.js

@@ -1,42 +0,0 @@
-'use strict';
-
-/*
- *
- * given an array of functions, that may or may not return promises sequence
- * will invoke them sequentially. If a promise is encountered sequence will
- * wait until it fulfills before moving to the next entry.
- *
- * ```js
- * var tasks = [
- *   function() { return Promise.resolve(1); },
- *   2,
- *   function() { return timeout(1000).then(function() { return 3; } },
- * ];
- *
- * sequence(tasks).then(function(results) {
- *   results === [
- *     1,
- *     2,
- *     3
- *   ]
- * });
- * ```
- *
- * @method sequence
- * @param tasks
- * @return Promise<Array>
- *
- */
-module.exports = async function sequence(tasks) {
-  let length = tasks.length;
-  let results = [];
-
-  for (let i = 0; i < length; ++i) {
-    let task = tasks[i];
-    let prevResult = results[i - 1];
-
-    results.push(typeof task === 'function' ? await task(prevResult) : await task);
-  }
-
-  return results;
-};

package/packages/blueprint-model/utilities/walk-up-path.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-let regex = /^[./]$/;
-
-function walkUp(thePath) {
-  let paths = [];
-
-  let currentPath = thePath;
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    currentPath = path.dirname(currentPath);
-    if (regex.test(currentPath)) {
-      break;
-    }
-    paths.push(currentPath);
-  }
-
-  return paths;
-}
-
-module.exports = walkUp;