gscan 4.37.0 → 4.37.2

package/lib/ast-linter/linter.js

@@ -20,6 +20,7 @@ class Linter {
         this.helpers = [];
         this.inlinePartials = [];
         this.customThemeSettings = [];
+        this.usedPageProperties = [];
     }
 
     /**
@@ -57,7 +58,8 @@ class Linter {
                 partials: [],
                 helpers: [],
                 inlinePartials: [],
-                customThemeSettings: []
+                customThemeSettings: [],
+                usedPageProperties: []
             };
         }
         Scanner.prototype = new Handlebars.Visitor();
@@ -161,6 +163,10 @@ class Linter {
             this.inlinePartials = scanner.context.inlinePartials;
         }
 
+        if (scanner.context.usedPageProperties) {
+            this.usedPageProperties = scanner.context.usedPageProperties;
+        }
+
         return messages;
     }
 }

package/lib/ast-linter/rules/base.js

@@ -9,6 +9,8 @@ module.exports = class BaseRule {
         this.helpers = options.helpers;
         this.inlinePartials = options.inlinePartials || [];
         this.customThemeSettings = options.customThemeSettings;
+        // TODO: remove hardcoded list of known page builder properties once we have a way to get them from the spec
+        this.knownPageBuilderProperties = options.knownPageBuilderProperties || ['show_title_and_feature_image'];
     }
 
     getVisitor({fileName} = {}) {
@@ -160,6 +162,10 @@ module.exports = class BaseRule {
         return this.helpers && this.helpers.includes(nodeName);
     }
 
+    isValidPageBuilderProperty(property) {
+        return this.knownPageBuilderProperties && this.knownPageBuilderProperties.includes(property);
+    }
+
     isValidCustomThemeSettingReference(name) {
         return this.customThemeSettings && !!this.customThemeSettings[name];
     }

package/lib/ast-linter/rules/index.js

@@ -12,6 +12,7 @@ module.exports = {
     'GS090-NO-PRICE-DATA-CURRENCY-GLOBAL': require('./lint-no-price-data-currency-global'),
     'GS090-NO-PRICE-DATA-CURRENCY-CONTEXT': require('./lint-no-price-data-currency-context'),
     'GS090-NO-PRICE-DATA-MONTHLY-YEARLY': require('./lint-no-price-data-monthly-yearly'),
+    'GS110-NO-UNKNOWN-PAGE-BUILDER-USAGE': require('./lint-no-unknown-page-properties'),
     'no-multi-param-conditionals': require('./lint-no-multi-param-conditionals'),
     'no-nested-async-helpers': require('./lint-no-nested-async-helpers'),
     'no-prev-next-post-outside-post-context': require('./lint-no-prev-next-post-outside-post-context'),

package/lib/ast-linter/rules/lint-no-unknown-page-properties.js

@@ -0,0 +1,21 @@
+const Rule = require('./base');
+const {logNode} = require('../helpers');
+
+module.exports = class NoUnknownPageProperties extends Rule {
+    _checkForUnknownPageProperty(node) {
+        if (node.data && node.parts && node.parts[0] === 'page' && (node.parts.length > 2 || !this.isValidPageBuilderProperty(node.parts[1]))) {
+            this.log({
+                message: `${logNode(node)} is not a known @page property`,
+                line: node.loc && node.loc.start.line,
+                column: node.loc && node.loc.start.column,
+                source: this.sourceForNode(node)
+            });
+        }
+    }
+
+    visitor() {
+        return {
+            PathExpression: this._checkForUnknownPageProperty.bind(this)
+        };
+    }
+};

package/lib/ast-linter/rules/mark-used-page-properties.js

@@ -0,0 +1,15 @@
+const Rule = require('./base');
+
+module.exports = class MarkUsedPageProperties extends Rule {
+    _markUsedPageProperties(node) {
+        if (node.data && node.parts && node.parts.length === 2 && node.parts[0] === 'page') {
+            this.scanner.context.usedPageProperties.push(node.parts[1]);
+        }
+    }
+
+    visitor() {
+        return {
+            PathExpression: this._markUsedPageProperties.bind(this)
+        };
+    }
+};

package/lib/checker.js

@@ -1,6 +1,8 @@
 const Promise = require('bluebird');
 const _ = require('lodash');
 const requireDir = require('require-dir');
+const debug = require('@tryghost/debug')('checker');
+
 const errors = require('@tryghost/errors');
 const versions = require('./utils').versions;
 
@@ -48,8 +50,11 @@ const check = function checkAll(themePath, options = {}) {
             // set the major version to check
             theme.checkedVersion = versions[version].major;
 
-            return Promise.reduce(_.values(checks), function (themeToCheck, checkFunction) {
-                return checkFunction(themeToCheck, options, themePath);
+            return Promise.reduce(_.values(checks), async function (themeToCheck, checkFunction) {
+                const now = Date.now();
+                const result = await checkFunction(themeToCheck, options, themePath);
+                debug(checkFunction.name, 'took', Date.now() - now, 'ms');
+                return result;
             }, theme);
         })
         .catch((error) => {

package/lib/checks/010-package-json.js

@@ -104,7 +104,7 @@ _private.validatePackageJSONFields = function validatePackageJSONFields(packageJ
         markFailed('nameIsLowerCase');
     }
 
-    if (packageJSON.name && !packageJSON.name.match(/^[a-z0-9]+(-?[a-z0-9]+)*$/gi)) {
+    if (packageJSON.name && !packageJSON.name.match(/^([a-z0-9]+-)*[a-z0-9]+$/gi)) {
         markFailed('nameIsHyphenated');
     }
 

package/lib/checks/090-template-syntax.js

@@ -48,7 +48,7 @@ function getCustomThemeSettings(theme) {
     return customThemeSettingsConfig;
 }
 
-const checkTemplatesCompile = function checkTemplatesCompile(theme, options) {
+const checkTemplateSyntax = function checkTemplateSyntax(theme, options) {
     const checkVersion = _.get(options, 'checkVersion', versions.default);
     const ruleSet = spec.get([checkVersion]);
     const customThemeSettings = getCustomThemeSettings(theme);
@@ -73,6 +73,7 @@ const checkTemplatesCompile = function checkTemplatesCompile(theme, options) {
 
         const linter = new ASTLinter({
             partials: theme.partials,
+            inlinePartials: [],
             helpers: [],
             customThemeSettings: customThemeSettings
         });
@@ -95,4 +96,4 @@ const checkTemplatesCompile = function checkTemplatesCompile(theme, options) {
     return theme;
 };
 
-module.exports = checkTemplatesCompile;
+module.exports = checkTemplateSyntax;

package/lib/checks/110-page-builder-usage.js

@@ -0,0 +1,185 @@
+const _ = require('lodash');
+const spec = require('../specs');
+const {versions, normalizePath} = require('../utils');
+const ASTLinter = require('../ast-linter');
+
+function getRules(id, options) {
+    const checkVersion = _.get(options, 'checkVersion', versions.default);
+    let ruleSet = spec.get([checkVersion]);
+
+    const ruleRegex = new RegExp('^' + id + '-.*', 'g');
+    ruleSet = _.pickBy(ruleSet.rules, function (rule, ruleCode) {
+        if (ruleCode.match(ruleRegex)) {
+            return rule;
+        }
+    });
+
+    return ruleSet;
+}
+
+function getLogger({theme, rule, file = null}) {
+    return {
+        failure: (content) => {
+            if (!theme.results.fail[rule.code]) {
+                theme.results.fail[rule.code] = {failures: []};
+            }
+            const failure = {
+                ...content,
+                rule: rule.code
+            };
+            if (file) {
+                failure.ref = file.file;
+            }
+            theme.results.fail[rule.code].failures.push(failure);
+        }
+    };
+}
+
+function applyRule(rule, theme) {
+    // The result variable is passed around to keep a state through the full lifecycle
+    const result = {};
+    try {
+        // Check if the rule is enabled (optional)
+        if (typeof rule.isEnabled === 'function') {
+            if (!rule.isEnabled({theme, log: getLogger({theme, rule}), result, options: rule.options})) {
+                return;
+            }
+        } else if (typeof rule.isEnabled === 'boolean' && !rule.isEnabled) {
+            return;
+        }
+
+        // Initialize the rule (optional)
+        if (typeof rule.init === 'function') {
+            rule.init({theme, log: getLogger({theme, rule}), result});
+        }
+
+        // Run the main function on each theme file (optional)
+        if (typeof rule.eachFile === 'function') {
+            _.each(theme.files, function (themeFile) {
+                rule.eachFile({file: themeFile, theme, log: getLogger({theme, rule}), result});
+            });
+        }
+
+        // Run the final function
+        if (typeof rule.done === 'function') {
+            rule.done({theme, log: getLogger({theme, rule}), result});
+        }
+    } catch (e) {
+        // Output something instead of failing silently (should never happen)
+        // eslint-disable-next-line
+        console.error('gscan failure', e);
+    }
+}
+
+function parseWithAST({theme, log, file, rules, callback}) {
+    const linter = new ASTLinter();
+
+    // // This rule is needed to find partials
+    // // Partials are needed for a full parsing
+    if (!rules['mark-used-partials']) {
+        rules['mark-used-partials'] = require(`../ast-linter/rules/mark-used-partials`);
+    }
+
+    function processFile(themeFile) {
+        if (themeFile.parsed.error) {
+            // Ignore parsing errors, they are handled in 005
+            return;
+        }
+
+        const astResults = linter.verify({
+            parsed: themeFile.parsed,
+            rules,
+            source: themeFile.content,
+            moduleId: themeFile.file
+        });
+
+        if (astResults.length) {
+            log.failure({
+                message: astResults[0].message
+            });
+        }
+
+        if (typeof callback === 'function') {
+            callback(linter);
+        }
+
+        linter.partials.forEach(({node: partial}) => {
+            const partialFile = theme.files.find(f => normalizePath(f.file) === `partials/${normalizePath(partial)}.hbs`);
+            if (partialFile) {
+                processFile(partialFile);
+            }
+        });
+    }
+
+    return processFile(file);
+}
+
+const ruleImplementations = {
+    'GS110-NO-MISSING-PAGE-BUILDER-USAGE': {
+        isEnabled: ({options}) => {
+            // TODO: change to `isEnabled: true` when removing labs flag
+            return options && options.labs && options.labs.pageImprovements;
+        },
+        init: ({result}) => {
+            result.pageBuilderProperties = new Set();
+        },
+        eachFile: ({file, theme, log, result}) => {
+            const templateTest = file.file.match(/(?<!partials\/.+?)\.hbs$/);
+
+            if (templateTest) {
+                parseWithAST({file, theme, rules: {
+                    'mark-used-page-properties': require(`../ast-linter/rules/mark-used-page-properties`)
+                }, log, callback: (linter) => {
+                    linter.usedPageProperties.forEach((variable) => {
+                        result.pageBuilderProperties.add(variable);
+                    });
+                }});
+            }
+        },
+        done: ({log, result}) => {
+            // TODO: get this from the spec rather than hard-coding to account for version changes
+            const knownPageBuilderProperties = ['show_title_and_feature_image'];
+            const notUsedProperties = knownPageBuilderProperties.filter(x => !result.pageBuilderProperties.has(x));
+
+            notUsedProperties.forEach((property) => {
+                log.failure({
+                    ref: `@page.${property}`
+                });
+            });
+        }
+    },
+    'GS110-NO-UNKNOWN-PAGE-BUILDER-USAGE': {
+        isEnabled: ({options}) => {
+            // TODO: change to `isEnabled: true` when removing labs flag
+            return options && options.labs && options.labs.pageImprovements;
+        },
+        eachFile: ({file, theme, log}) => {
+            const templateTest = file.file.match(/(?<!partials\/.+?)\.hbs$/);
+
+            if (templateTest) {
+                parseWithAST({
+                    file, theme, rules: {
+                        'no-unknown-page-properties': require(`../ast-linter/rules/lint-no-unknown-page-properties`)
+                    }, log, callback: () => {}
+                });
+            }
+        }
+    }
+};
+
+function checkUsage(theme, options) {
+    const rules = getRules('GS110', options);
+
+    _.each(rules, function (check, ruleCode) {
+        applyRule({
+            code: ruleCode,
+            ...check,
+            ...ruleImplementations[ruleCode],
+            options
+        }, theme);
+    });
+
+    return theme;
+}
+
+module.exports = checkUsage;

package/lib/specs/canary.js

@@ -712,6 +712,21 @@ let rules = {
         rule: '<code>package.json</code> property <code>config.custom</code> contains an entry with a <code>description</code> that is too long',
         details: oneLineTrim`<code>config.custom</code> entry <code>description</code> should be less than <code>100</code> characters so that it is displayed correctly.<br />
         Check the <a href="${docsBaseUrl}custom-settings" target=_blank><code>config.custom</code> documentation</a> for further information.`
+    },
+
+    'GS110-NO-MISSING-PAGE-BUILDER-USAGE': {
+        level: 'warning',
+        rule: 'Not all page builder features are being used',
+        // TODO: get proper docs link
+        details: oneLineTrim`Some page builder features used via the <code>{{@page}}</code> global are not being used.&nbsp;
+        Check the <a href="${docsBaseUrl}page-builder" target=_blank>page builder documentation</a> for further information.`
+    },
+
+    'GS110-NO-UNKNOWN-PAGE-BUILDER-USAGE': {
+        level: 'error',
+        fatal: true,
+        rule: 'Unsupported page builder feature used',
+        details: oneLineTrim`A page builder feature used via the <code>{{@page}}</code> global was detected but it's not supported by this version of Ghost.`
     }
 };
 

package/lib/specs/index.js

@@ -8,7 +8,7 @@ module.exports = {
             version = 'canary';
         }
 
-        debug('Checking against version: ', version);
+        debug('Checking against version:', version);
 
         return require(`./${[version]}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gscan",
-  "version": "4.37.0",
+  "version": "4.37.2",
   "description": "Scans Ghost themes looking for errors, deprecations, features and compatibility",
   "keywords": [
     "ghost",
@@ -40,7 +40,7 @@
     "gscan": "./bin/cli.js"
   },
   "dependencies": {
-    "@sentry/node": "7.55.2",
+    "@sentry/node": "7.60.0",
     "@tryghost/config": "0.2.17",
     "@tryghost/debug": "0.1.25",
     "@tryghost/errors": "1.2.25",
@@ -59,7 +59,7 @@
     "multer": "1.4.4",
     "pluralize": "8.0.0",
     "require-dir": "1.2.0",
-    "semver": "7.5.2",
+    "semver": "7.5.4",
     "uuid": "9.0.0",
     "validator": "13.0.0"
   },
@@ -68,7 +68,7 @@
     "eslint-plugin-ghost": "2.1.0",
     "istanbul": "0.4.5",
     "mocha": "10.0.0",
-    "node-fetch": "3.3.1",
+    "node-fetch": "3.3.2",
     "nodemon": "2.0.7",
     "rewire": "6.0.0",
     "should": "13.2.3",