ghost 4.19.1 → 4.20.3

package/core/frontend/services/theme-engine/i18n/i18n.js

@@ -1,73 +1,312 @@
 const errors = require('@tryghost/errors');
-const i18n = require('../../../../shared/i18n');
+const fs = require('fs-extra');
+const path = require('path');
+const MessageFormat = require('intl-messageformat');
+const jp = require('jsonpath');
+const isString = require('lodash/isString');
+const isObject = require('lodash/isObject');
+const isEqual = require('lodash/isEqual');
+const isNil = require('lodash/isNil');
+const merge = require('lodash/merge');
+const get = require('lodash/get');
 
-class ThemeI18n extends i18n.I18n {
+class I18n {
     /**
      * @param {objec} [options]
-     * @param {string} basePath - the base path for the translation directory (e.g. where themes live)
+     * @param {string} basePath - the base path to the translations directory
      * @param {string} [locale] - a locale string
+     * @param {{dot|fulltext}} [stringMode] - which mode our translation keys use
+     * @param {{object}} [logging] - logging method
      */
     constructor(options = {}) {
-        super(options);
-        // We don't care what gets passed in, themes use fulltext mode
-        this._stringMode = 'fulltext';
+        this._basePath = options.basePath || __dirname;
+        this._locale = options.locale || this.defaultLocale();
+        this._stringMode = options.stringMode || 'dot';
+        this._logging = options.logging || console;
+
+        this._strings = null;
+    }
+
+    /**
+     * BasePath getter & setter used for testing
+     */
+    set basePath(basePath) {
+        this._basePath = basePath;
+    }
+
+    /**
+         * Need to call init after this
+         */
+    get basePath() {
+        return this._basePath;
+    }
+
+    /**
+     * English is our default locale
+     */
+    defaultLocale() {
+        return 'en';
+    }
+
+    supportedLocales() {
+        return [this.defaultLocale()];
+    }
+
+    /**
+     * Exporting the current locale (e.g. "en") to make it available for other files as well,
+     * such as core/frontend/helpers/date.js and core/frontend/helpers/lang.js
+     */
+    locale() {
+        return this._locale;
+    }
+
+    /**
+     * Helper method to find and compile the given data context with a proper string resource.
+     *
+     * @param {string} translationPath Path within the JSON language file to desired string (ie: "errors.init.jsNotBuilt")
+     * @param {object} [bindings]
+     * @returns {string}
+     */
+    t(translationPath, bindings) {
+        let string;
+        let msg;
+
+        string = this._findString(translationPath);
+
+        // If the path returns an array (as in the case with anything that has multiple paragraphs such as emails), then
+        // loop through them and return an array of translated/formatted strings. Otherwise, just return the normal
+        // translated/formatted string.
+        if (Array.isArray(string)) {
+            msg = [];
+            string.forEach(function (s) {
+                msg.push(this._formatMessage(s, bindings));
+            });
+        } else {
+            msg = this._formatMessage(string, bindings);
+        }
+
+        return msg;
+    }
+
+    /**
+     * Setup i18n support:
+     *  - Load proper language file into memory
+     */
+    init() {
+        this._strings = this._loadStrings();
+
+        this._initializeIntl();
+    }
+
+    /**
+     * Attempt to load strings from a file
+     *
+     * @param {sting} [locale]
+     * @returns {object} strings
+     */
+    _loadStrings(locale) {
+        locale = locale || this.locale();
+
+        try {
+            return this._readTranslationsFile(locale);
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                this._handleMissingFileError(locale, err);
+
+                if (locale !== this.defaultLocale()) {
+                    this._handleFallbackToDefault();
+                    return this._loadStrings(this.defaultLocale());
+                }
+            } else if (err instanceof SyntaxError) {
+                this._handleInvalidFileError(locale, err);
+            } else {
+                throw err;
+            }
+
+            // At this point we've done all we can and strings must be an object
+            return {};
+        }
     }
 
     /**
-     * Setup i18n support for themes:
-     *  - Load correct language file into memory
+     * Do the lookup within the JSON file using jsonpath
      *
-     * @param {object} options
-     * @param {String} options.activeTheme - name of the currently loaded theme
-     * @param {String} options.locale - name of the currently loaded locale
+     * @param {String} msgPath
+     */
+    _getCandidateString(msgPath) {
+        // Our default string mode is "dot" for dot-notation, e.g. $.something.like.this used in the backend
+        // Both jsonpath's dot-notation and bracket-notation start with '$' E.g.: $.store.book.title or $['store']['book']['title']
+        // While bracket-notation allows any Unicode characters in keys (i.e. for themes / fulltext mode) E.g. $['Read more']
+        // dot-notation allows only word characters in keys for backend messages (that is \w or [A-Za-z0-9_] in RegExp)
+        let jsonPath = `$.${msgPath}`;
+        let fallback = null;
+
+        if (this._stringMode === 'fulltext') {
+            jsonPath = jp.stringify(['$', msgPath]);
+            // In fulltext mode we can use the passed string as a fallback
+            fallback = msgPath;
+        }
+
+        try {
+            return jp.value(this._strings, jsonPath) || fallback;
+        } catch (err) {
+            this._handleInvalidKeyError(msgPath, err);
+        }
+    }
+
+    /**
+     * Parse JSON file for matching locale, returns string giving path.
      *
+     * @param {string} msgPath Path with in the JSON language file to desired string (ie: "errors.init.jsNotBuilt")
+     * @returns {string}
      */
-    init({activeTheme, locale} = {}) {
-        // This function is called during theme initialization, and when switching language or theme.
-        this._locale = locale || this._locale;
-        this._activetheme = activeTheme || this._activetheme;
+    _findString(msgPath, opts) {
+        const options = merge({log: true}, opts || {});
+        let candidateString;
+        let matchingString;
+
+        // no path? no string
+        if (msgPath.length === 0 || !isString(msgPath)) {
+            this._handleEmptyKeyError();
+            return '';
+        }
+
+        // If not in memory, load translations for core
+        if (isNil(this._strings)) {
+            this._handleUninitialisedError(msgPath);
+        }
+
+        candidateString = this._getCandidateString(msgPath);
+
+        matchingString = candidateString || {};
 
-        super.init();
+        if (isObject(matchingString) || isEqual(matchingString, {})) {
+            if (options.log) {
+                this._handleMissingKeyError(msgPath);
+            }
+
+            matchingString = this._fallbackError();
+        }
+
+        return matchingString;
     }
 
     _translationFileDirs() {
-        return [this.basePath, this._activetheme, 'locales'];
+        return [this.basePath];
+    }
+
+    // If we are passed a locale, use that, else use this.locale
+    _translationFileName(locale) {
+        return `${locale || this.locale()}.json`;
+    }
+
+    /**
+     * Read the translations file
+     * Error handling to be done by consumer
+     *
+     * @param  {string} locale
+     */
+    _readTranslationsFile(locale) {
+        const filePath = path.join(...this._translationFileDirs(), this._translationFileName(locale));
+        const content = fs.readFileSync(filePath);
+        return JSON.parse(content);
+    }
+
+    /**
+     * Format the string using the correct locale and applying any bindings
+     * @param {String} string
+     * @param {Object} bindings
+     */
+    _formatMessage(string, bindings) {
+        let currentLocale = this.locale();
+        let msg = new MessageFormat(string, currentLocale);
+
+        try {
+            msg = msg.format(bindings);
+        } catch (err) {
+            this._handleFormatError(err);
+
+            // fallback
+            msg = new MessageFormat(this._fallbackError(), currentLocale);
+            msg = msg.format();
+        }
+
+        return msg;
+    }
+
+    /**
+     * [Private] Setup i18n support:
+     *  - Polyfill node.js if it does not have Intl support or support for a particular locale
+     */
+    _initializeIntl() {
+        let hasBuiltInLocaleData;
+        let IntlPolyfill;
+
+        if (global.Intl) {
+            // Determine if the built-in `Intl` has the locale data we need.
+            hasBuiltInLocaleData = this.supportedLocales().every(function (locale) {
+                return Intl.NumberFormat.supportedLocalesOf(locale)[0] === locale &&
+                    Intl.DateTimeFormat.supportedLocalesOf(locale)[0] === locale;
+            });
+            if (!hasBuiltInLocaleData) {
+                // `Intl` exists, but it doesn't have the data we need, so load the
+                // polyfill and replace the constructors with need with the polyfill's.
+                IntlPolyfill = require('intl');
+                Intl.NumberFormat = IntlPolyfill.NumberFormat;
+                Intl.DateTimeFormat = IntlPolyfill.DateTimeFormat;
+            }
+        } else {
+            // No `Intl`, so use and load the polyfill.
+            global.Intl = require('intl');
+        }
     }
 
     _handleUninitialisedError(key) {
-        throw new errors.IncorrectUsageError({message: `Theme translation was used before it was initialised with key ${key}`});
+        this._logging.warn(`i18n was used before it was initialised with key ${key}`);
+        this.init();
+    }
+
+    _handleFormatError(err) {
+        this._logging.error(err.message);
     }
 
     _handleFallbackToDefault() {
-        this._logging.warn(`Theme translations falling back to locales/${this.defaultLocale()}.json.`);
+        this._logging.warn(`i18n is falling back to ${this.defaultLocale()}.json.`);
     }
 
     _handleMissingFileError(locale) {
-        if (locale !== this.defaultLocale()) {
-            this._logging.warn(`Theme translations file locales/${locale}.json not found.`);
-        }
+        this._logging.warn(`i18n was unable to find ${locale}.json.`);
     }
     _handleInvalidFileError(locale, err) {
         this._logging.error(new errors.IncorrectUsageError({
             err,
-            message: `Theme translations unable to parse locales/${locale}.json. Please check that it is valid JSON.`
+            message: `i18n was unable to parse ${locale}.json. Please check that it is valid JSON.`
         }));
     }
 
     _handleEmptyKeyError() {
-        this._logging.warn('Theme translations {{t}} helper called without a translation key.');
+        this._logging.warn('i18n.t() was called without a key');
     }
 
-    _handleMissingKeyError() {
-        // This case cannot be reached in themes as we use the key as the fallback
+    _handleMissingKeyError(key) {
+        this._logging.error(new errors.IncorrectUsageError({
+            message: `i18n.t() was called with a key that could not be found: ${key}`
+        }));
     }
 
     _handleInvalidKeyError(key, err) {
         throw new errors.IncorrectUsageError({
             err,
-            message: `Theme translations {{t}} helper called with an invalid translation key: ${key}`
+            message: `i18n.t() called with an invalid key: ${key}`
         });
     }
+
+    /**
+     * A really basic error for if everything goes wrong
+     */
+    _fallbackError() {
+        return get(this._strings, 'errors.errors.anErrorOccurred', 'An error occurred');
+    }
 }
 
-module.exports = ThemeI18n;
+module.exports = I18n;

package/core/frontend/services/theme-engine/i18n/index.js

@@ -1,7 +1,7 @@
 const config = require('../../../../shared/config');
 const logging = require('@tryghost/logging');
 
-const ThemeI18n = require('./i18n');
+const ThemeI18n = require('./theme-i18n');
 
 module.exports = new ThemeI18n({logging, basePath: config.getContentPath('themes')});
 module.exports.ThemeI18n = ThemeI18n;

package/core/frontend/services/theme-engine/i18n/theme-i18n.js

@@ -0,0 +1,73 @@
+const errors = require('@tryghost/errors');
+const I18n = require('./i18n');
+
+class ThemeI18n extends I18n {
+    /**
+     * @param {objec} [options]
+     * @param {string} basePath - the base path for the translation directory (e.g. where themes live)
+     * @param {string} [locale] - a locale string
+     */
+    constructor(options = {}) {
+        super(options);
+        // We don't care what gets passed in, themes use fulltext mode
+        this._stringMode = 'fulltext';
+    }
+
+    /**
+     * Setup i18n support for themes:
+     *  - Load correct language file into memory
+     *
+     * @param {object} options
+     * @param {String} options.activeTheme - name of the currently loaded theme
+     * @param {String} options.locale - name of the currently loaded locale
+     *
+     */
+    init({activeTheme, locale} = {}) {
+        // This function is called during theme initialization, and when switching language or theme.
+        this._locale = locale || this._locale;
+        this._activetheme = activeTheme || this._activetheme;
+
+        super.init();
+    }
+
+    _translationFileDirs() {
+        return [this.basePath, this._activetheme, 'locales'];
+    }
+
+    _handleUninitialisedError(key) {
+        throw new errors.IncorrectUsageError({message: `Theme translation was used before it was initialised with key ${key}`});
+    }
+
+    _handleFallbackToDefault() {
+        this._logging.warn(`Theme translations falling back to locales/${this.defaultLocale()}.json.`);
+    }
+
+    _handleMissingFileError(locale) {
+        if (locale !== this.defaultLocale()) {
+            this._logging.warn(`Theme translations file locales/${locale}.json not found.`);
+        }
+    }
+    _handleInvalidFileError(locale, err) {
+        this._logging.error(new errors.IncorrectUsageError({
+            err,
+            message: `Theme translations unable to parse locales/${locale}.json. Please check that it is valid JSON.`
+        }));
+    }
+
+    _handleEmptyKeyError() {
+        this._logging.warn('Theme translations {{t}} helper called without a translation key.');
+    }
+
+    _handleMissingKeyError() {
+        // This case cannot be reached in themes as we use the key as the fallback
+    }
+
+    _handleInvalidKeyError(key, err) {
+        throw new errors.IncorrectUsageError({
+            err,
+            message: `Theme translations {{t}} helper called with an invalid translation key: ${key}`
+        });
+    }
+}
+
+module.exports = ThemeI18n;

package/core/frontend/web/index.js

@@ -0,0 +1 @@
+module.exports = require('./site');

package/core/{server/web/site → frontend/web}/middleware/handle-image-sizes.js

@@ -2,9 +2,9 @@ const _ = require('lodash');
 const path = require('path');
 const {GhostError} = require('@tryghost/errors');
 const imageTransform = require('@tryghost/image-transform');
-const storage = require('../../../adapters/storage');
-const activeTheme = require('../../../../frontend/services/theme-engine/active');
-const config = require('../../../../shared/config');
+const storage = require('../../../server/adapters/storage');
+const activeTheme = require('../../services/theme-engine/active');
+const config = require('../../../shared/config');
 
 const SIZE_PATH_REGEX = /^\/size\/([^/]+)\//;
 const TRAILING_SLASH_REGEX = /\/+$/;
@@ -63,7 +63,7 @@ module.exports = function (req, res, next) {
         return redirectToOriginal();
     }
 
-    const storageInstance = storage.getStorage();
+    const storageInstance = storage.getStorage('images');
     // CASE: unsupported storage adapter
     if (typeof storageInstance.saveRaw !== 'function') {
         return redirectToOriginal();

package/core/{server/web/site → frontend/web}/middleware/redirect-ghost-to-admin.js

@@ -1,6 +1,6 @@
-const express = require('../../../../shared/express');
-const config = require('../../../../shared/config');
-const urlUtils = require('../../../../shared/url-utils');
+const express = require('../../../shared/express');
+const config = require('../../../shared/config');
+const urlUtils = require('../../../shared/url-utils');
 
 const adminRedirect = (path) => {
     return function doRedirect(req, res) {

package/core/{server/web/site → frontend/web}/middleware/serve-favicon.js

@@ -1,11 +1,11 @@
 const fs = require('fs-extra');
 const path = require('path');
 const crypto = require('crypto');
-const config = require('../../../../shared/config');
-const {blogIcon} = require('../../../lib/image');
-const storage = require('../../../adapters/storage');
-const urlUtils = require('../../../../shared/url-utils');
-const settingsCache = require('../../../../shared/settings-cache');
+const config = require('../../../shared/config');
+const {blogIcon} = require('../../../server/lib/image');
+const storage = require('../../../server/adapters/storage');
+const urlUtils = require('../../../shared/url-utils');
+const settingsCache = require('../../../shared/settings-cache');
 
 let content;
 
@@ -49,7 +49,7 @@ function serveFavicon() {
                     return res.redirect(302, urlUtils.urlFor({relativeUrl: `/favicon${originalExtension}`}));
                 }
 
-                storage.getStorage()
+                storage.getStorage('images')
                     .read({path: filePath})
                     .then((buf) => {
                         iconType = blogIcon.getIconType();

package/core/{server/web/site → frontend/web}/middleware/serve-public-file.js

@@ -2,8 +2,8 @@ const crypto = require('crypto');
 const fs = require('fs-extra');
 const path = require('path');
 const errors = require('@tryghost/errors');
-const config = require('../../../../shared/config');
-const urlUtils = require('../../../../shared/url-utils');
+const config = require('../../../shared/config');
+const urlUtils = require('../../../shared/url-utils');
 const tpl = require('@tryghost/tpl');
 
 const messages = {

package/core/{server/web/site → frontend/web}/middleware/static-theme.js

@@ -1,8 +1,8 @@
 const path = require('path');
-const config = require('../../../../shared/config');
+const config = require('../../../shared/config');
 const constants = require('@tryghost/constants');
-const themeEngine = require('../../../../frontend/services/theme-engine');
-const express = require('../../../../shared/express');
+const themeEngine = require('../../services/theme-engine');
+const express = require('../../../shared/express');
 
 function isBlackListedFileType(file) {
     const blackListedFileTypes = ['.hbs', '.md', '.json'];

package/core/{server/web/site → frontend/web}/routes.js

@@ -1,12 +1,13 @@
 const debug = require('@tryghost/debug')('routing');
-const routing = require('../../../frontend/services/routing');
+
+const routing = require('../services/routing');
 // NOTE: temporary import from the frontend, will become a backend service soon
-const urlService = require('../../../frontend/services/url');
-const routeSettings = require('../../services/route-settings');
+const urlService = require('../../server/services/url');
+const routeSettings = require('../../server/services/route-settings');
 
 module.exports = function siteRoutes(options = {}) {
     debug('site Routes', options);
     options.routerSettings = routeSettings.loadRouteSettingsSync();
     options.urlService = urlService;
-    return routing.bootstrap.init(options);
+    return routing.routerManager.init(options);
 };

package/core/{server/web/site/app.js → frontend/web/site.js}

@@ -1,24 +1,24 @@
 const debug = require('@tryghost/debug')('frontend');
 const path = require('path');
-const express = require('../../../shared/express');
+const express = require('../../shared/express');
 const cors = require('cors');
 const {URL} = require('url');
 const errors = require('@tryghost/errors');
 
 // App requires
-const config = require('../../../shared/config');
+const config = require('../../shared/config');
 const constants = require('@tryghost/constants');
-const storage = require('../../adapters/storage');
-const urlService = require('../../../frontend/services/url');
-const urlUtils = require('../../../shared/url-utils');
-const sitemapHandler = require('../../../frontend/services/sitemap/handler');
-const appService = require('../../../frontend/services/apps');
-const themeEngine = require('../../../frontend/services/theme-engine');
+const storage = require('../../server/adapters/storage');
+const urlService = require('../../server/services/url');
+const urlUtils = require('../../shared/url-utils');
+const sitemapHandler = require('../services/sitemap/handler');
+const appService = require('../services/apps');
+const themeEngine = require('../services/theme-engine');
 const themeMiddleware = themeEngine.middleware;
-const membersService = require('../../services/members');
-const offersService = require('../../services/offers');
+const membersService = require('../../server/services/members');
+const offersService = require('../../server/services/offers');
 const siteRoutes = require('./routes');
-const shared = require('../shared');
+const shared = require('../../server/web/shared');
 const mw = require('./middleware');
 
 const STATIC_IMAGE_URL_PREFIX = `/${urlUtils.STATIC_IMAGE_URL_PREFIX}`;
@@ -106,12 +106,8 @@ module.exports = function setupSiteApp(options = {}) {
     siteApp.use(mw.servePublicFile('public/ghost.css', 'text/css', constants.ONE_HOUR_S));
     siteApp.use(mw.servePublicFile('public/ghost.min.css', 'text/css', constants.ONE_YEAR_S));
 
-    // Serve images for default templates
-    siteApp.use(mw.servePublicFile('public/404-ghost@2x.png', 'image/png', constants.ONE_HOUR_S));
-    siteApp.use(mw.servePublicFile('public/404-ghost.png', 'image/png', constants.ONE_HOUR_S));
-
     // Serve blog images using the storage adapter
-    siteApp.use(STATIC_IMAGE_URL_PREFIX, mw.handleImageSizes, storage.getStorage().serve());
+    siteApp.use(STATIC_IMAGE_URL_PREFIX, mw.handleImageSizes, storage.getStorage('images').serve());
 
     // @TODO find this a better home
     // We do this here, at the top level, because helpers require so much stuff.