@hubspot/cli 4.1.8-beta.1 → 4.1.8-beta.3

package/lib/interpolation.js

@@ -0,0 +1,137 @@
+const helpers = require('./interpolationHelpers');
+const delimiters = {
+  interpolation: {
+    start: '{{',
+    end: '}}',
+  },
+  helpers: {
+    start: '#',
+    end: '/',
+  },
+};
+
+const isHelperIdentifier = identifier => {
+  return (
+    identifier.startsWith(delimiters.helpers.start) ||
+    identifier.startsWith(delimiters.helpers.end)
+  );
+};
+
+const generateReplaceFn = (matchedText, startIndex, replacementString) => {
+  return currentStringValue =>
+    `${currentStringValue.slice(0, startIndex)}${replacementString ||
+      ''}${currentStringValue.slice(startIndex + matchedText.length)}`;
+};
+
+/**
+ * Interpolate a string with data
+ * @param {string} stringValue - The string to interpolate
+ * @param {object} interpolationData - The data to interpolate with
+ * @returns {string} - The interpolated string
+ * @example
+ * interpolation('Hello {{name}}', { name: 'World' })
+ * // 'Hello World'
+ */
+const interpolation = (stringValue, interpolationData) => {
+  const interpolationIdentifierRegEx = new RegExp(
+    `${delimiters.interpolation.start}(.*?)${delimiters.interpolation.end}`,
+    'g'
+  );
+  const replaceQueue = [];
+  let match;
+
+  // while & reduce necessary because RegExp.exec is stateful and only runs
+  // from beginning to end of string
+  while ((match = interpolationIdentifierRegEx.exec(stringValue)) != null) {
+    const { 0: matchedText, 1: rawIdentifier, index } = match;
+    const identifier = rawIdentifier.trim();
+
+    if (identifier && !isHelperIdentifier(identifier)) {
+      replaceQueue.unshift(
+        generateReplaceFn(matchedText, index, interpolationData[identifier])
+      );
+    }
+  }
+
+  const compiledString = replaceQueue.reduce(
+    (currentValue, replaceFn) => replaceFn(currentValue),
+    stringValue
+  );
+
+  return compiledString;
+};
+
+/**
+ * Compile a string using a specified helper function
+ * @param {string} stringValue - The string to modify
+ * @param {object} helperIdentifier - Helper name
+ * @param {function} helperFn - Helper function to call on string
+ * @returns {string} - The modified string
+ * @example
+ * compileHelper('White {{#yellow}}yellow{{/yellow}}', 'yellow', (string) => { chalk.reset.yellow(string) }))))
+ * // 'White yellow' (with 'yellow' colored yellow)
+ */
+const compileHelper = (stringValue, helperIdentifier, helperFn) => {
+  const helperIdentifierRegEx = new RegExp(
+    `${delimiters.interpolation.start}(${delimiters.helpers.start}${helperIdentifier})${delimiters.interpolation.end}(.*?)${delimiters.interpolation.start}(${delimiters.helpers.end}${helperIdentifier})${delimiters.interpolation.end}`,
+    'g'
+  );
+  const replaceQueue = [];
+  let match;
+
+  // while & reduce necessary because RegExp.exec is stateful and only runs
+  // from beginning to end of string
+  while ((match = helperIdentifierRegEx.exec(stringValue)) != null) {
+    const {
+      0: matchedText,
+      1: rawHelperIdentifierStart,
+      2: innerText,
+      index,
+    } = match;
+    const identifier = rawHelperIdentifierStart
+      .replace(delimiters.helpers.start, '')
+      .trim();
+
+    if (identifier && helperFn) {
+      replaceQueue.unshift(
+        generateReplaceFn(matchedText, index, helperFn(innerText))
+      );
+    }
+  }
+
+  const compiledString = replaceQueue.reduce(
+    (currentValue, replaceFn) => replaceFn(currentValue),
+    stringValue
+  );
+
+  return compiledString;
+};
+
+const compileHelpers = stringValue => {
+  return Object.keys(helpers).reduce((currentStringValue, helperIdentifier) => {
+    return compileHelper(
+      currentStringValue,
+      helperIdentifier,
+      helpers[helperIdentifier]
+    );
+  }, stringValue);
+};
+
+/**
+ * Interpolate a string with data and compile helpers on the string
+ * @param {string} stringValue - The string to interpolate
+ * @param {object} interpolationData - The data to interpolate with
+ * @returns {string} - The interpolated and helper-compiled string
+ * @example
+ * interpolateAndCompile('Some {{#bold}}{{text}}{{/bold}} text', { text: 'awesomely bold' })
+ * // 'Some awsomely bold text' (with the words 'awesomely bold' in bold)
+ */
+const interpolate = (stringValue, interpolationData) => {
+  const interpolatedString = interpolation(stringValue, interpolationData);
+  const helperCompiledString = compileHelpers(interpolatedString);
+  return helperCompiledString;
+};
+
+module.exports = {
+  interpolate,
+};

package/lib/interpolationHelpers.js

@@ -0,0 +1,23 @@
+const chalk = require('chalk');
+
+/**
+ * These helper methods are used to modify text output within the CLI. They
+ * should all take in a string value and output a modified string value.
+ */
+module.exports = {
+  bold: function(stringValue) {
+    return chalk.bold(stringValue);
+  },
+  yellow: function(stringValue) {
+    return chalk.reset.yellow(stringValue);
+  },
+  green: function(stringValue) {
+    return chalk.reset.green(stringValue);
+  },
+  red: function(stringValue) {
+    return chalk.reset.red(stringValue);
+  },
+  cyan: function(stringValue) {
+    return chalk.cyan(stringValue);
+  },
+};

package/lib/lang.js

@@ -0,0 +1,95 @@
+const util = require('util');
+const path = require('path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { interpolate } = require('./interpolation');
+
+const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+
+let locale;
+let languageObj;
+
+const loadLanguageFromYaml = () => {
+  if (languageObj) return;
+
+  try {
+    const nodeLocale = Intl.DateTimeFormat()
+      .resolvedOptions()
+      .locale.split('-')[0];
+    const languageFilePath = path.join(
+      __dirname,
+      `../lang/${nodeLocale}.lyaml`
+    );
+    const languageFileExists = fs.existsSync(languageFilePath);
+
+    // Fall back to using the default language file
+    locale = languageFileExists ? nodeLocale : 'en';
+    languageObj = yaml.load(
+      fs.readFileSync(path.join(__dirname, `../lang/${locale}.lyaml`), 'utf8')
+    );
+
+    logger.debug(
+      'Loaded language data: ',
+      util.inspect(languageObj, true, 999, true)
+    );
+  } catch (e) {
+    logger.error('Error loading language data: ', e);
+  }
+};
+
+const getTextValue = lookupDotNotation => {
+  const lookupProps = [locale, ...lookupDotNotation.split('.')];
+  const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join(
+    '.'
+  )}`;
+  let textValue = languageObj;
+  let previouslyCheckedProp = lookupProps[0];
+
+  try {
+    lookupProps.forEach(prop => {
+      textValue = textValue[prop];
+      previouslyCheckedProp = prop;
+    });
+  } catch (e) {
+    logger.error(
+      `Unable to access language property: ${lookupProps.join(
+        '.'
+      )}. Failed to access prop "${previouslyCheckedProp}".`
+    );
+    return missingTextData;
+  }
+
+  if (!textValue) {
+    return missingTextData;
+  }
+
+  return textValue;
+};
+
+const i18n = (lookupDotNotation, options = {}) => {
+  if (!languageObj) {
+    loadLanguageFromYaml();
+  }
+
+  if (typeof lookupDotNotation !== 'string') {
+    throw new Error(
+      `i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`
+    );
+  }
+
+  const textValue = getTextValue(lookupDotNotation);
+  const shouldInterpolate = !textValue.startsWith(MISSING_LANGUAGE_DATA_PREFIX);
+
+  return shouldInterpolate ? interpolate(textValue, options) : textValue;
+};
+
+const setLangData = (newLocale, newLangObj) => {
+  locale = newLocale;
+  languageObj = newLangObj;
+};
+
+module.exports = {
+  i18n,
+  setLangData,
+};

package/lib/marketplace-validate.js

@@ -6,7 +6,7 @@ const {
   getValidationStatus,
   getValidationResults,
 } = require('@hubspot/cli-lib/api/marketplaceValidation');
-const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { i18n } = require('./lang');
 const { EXIT_CODES } = require('./enums/exitCodes');
 
 const SLEEP_TIME = 2000;