Make more robust with better error messages

Author: ericf

src/index.js

@@ -1,5 +1,5 @@
-import * as path from 'path';
-import {readFileSync, writeFileSync} from 'fs';
+import * as p from 'path';
+import {writeFileSync} from 'fs';
 import {sync as mkdirpSync} from 'mkdirp';
 
 const COMPONENT_NAMES = [
@@ -12,111 +12,195 @@ const FUNCTION_NAMES = [
     'formatHTMLMessage',
 ];
 
-const IMPORTED_NAMES = new Set([...COMPONENT_NAMES, ...FUNCTION_NAMES]);
-const ATTR_WHITELIST = new Set(['id', 'description', 'defaultMessage']);
+const IMPORTED_NAMES   = new Set([...COMPONENT_NAMES, ...FUNCTION_NAMES]);
+const DESCRIPTOR_PROPS = new Set(['id', 'description', 'defaultMessage']);
 
 export default function ({Plugin, types: t}) {
-    function referencesImport(node, mod, importedNames) {
-        if (!(t.isIdentifier(node) || t.isJSXIdentifier(node))) {
-            return false;
+    function getModuleSourceName(options) {
+        const reactIntlOptions = options.extra['react-intl'] || {};
+        return reactIntlOptions.moduleSourceName || 'react-intl';
+    }
+
+    function getMessagesDir(options) {
+        const reactIntlOptions = options.extra['react-intl'] || {};
+        return reactIntlOptions.messagesDir;
+    }
+
+    function getMessageDescriptor(propertiesMap) {
+        // Force property order on descriptors.
+        let descriptor = [...DESCRIPTOR_PROPS].reduce((descriptor, key) => {
+            descriptor[key] = undefined;
+            return descriptor;
+        }, {});
+
+        for (let [key, value] of propertiesMap) {
+            key = getMessageDescriptorKey(key);
+
+            if (DESCRIPTOR_PROPS.has(key)) {
+                // TODO: Should this be trimming values?
+                descriptor[key] = getMessageDescriptorValue(value).trim();
+            }
+        }
+
+        return descriptor;
+    }
+
+    function getMessageDescriptorKey(path) {
+        if (path.isIdentifier() || path.isJSXIdentifier()) {
+            return path.node.name;
         }
 
-        return importedNames.some((name) => node.referencesImport(mod, name));
+        let evaluated = path.evaluate();
+        if (evaluated.confident) {
+            return evaluated.value;
+        }
     }
 
-    function checkMessageId(messages, message, node, file) {
-        if (!message.id) {
+    function getMessageDescriptorValue(path) {
+        if (path.isJSXExpressionContainer()) {
+            path = path.get('expression');
+        }
+
+        let evaluated = path.evaluate();
+        if (evaluated.confident) {
+            return evaluated.value;
+        }
+
+        if (path.isTemplateLiteral() && path.get('expressions').length === 0) {
+            let str = path.get('quasis')
+                .map((quasi) => quasi.node.value.cooked)
+                .reduce((str, value) => str + value);
+
+            return str;
+        }
+
+        throw path.errorWithNode(
+            '[React Intl] Messages must be statically evaluate-able for extraction.'
+        );
+    }
+
+    function storeMessage(descriptor, node, file) {
+        const {id}       = descriptor;
+        const {messages} = file.get('react-intl');
+
+        if (!id) {
             throw file.errorWithNode(node,
-                'React Intl message is missing an `id`.'
+                '[React Intl] Message is missing an `id`.'
             );
         }
 
-        if (messages.hasOwnProperty(message.id)) {
+        if (messages.has(id)) {
             throw file.errorWithNode(node,
-                `Duplicate React Intl message id: "${message.id}"`
+                `[React Intl] Duplicate message id: "${id}"`
             );
         }
+
+        if (!descriptor.defaultMessage) {
+            let {loc} = node;
+            file.log.warn(
+                `[React Intl] Line ${loc.start.line}: ` +
+                `Message "${id}" is missing a \`defaultMessage\` ` +
+                `and will not be extracted.`
+            );
+            return;
+        }
+
+        messages.set(id, descriptor);
+    }
+
+    function referencesImport(path, mod, importedNames) {
+        if (!(path.isIdentifier() || path.isJSXIdentifier())) {
+            return false;
+        }
+
+        return importedNames.some((name) => path.referencesImport(mod, name));
     }
 
     return new Plugin('react-intl', {
         visitor: {
             Program: {
                 enter(node, parent, scope, file) {
-                    const {moduleSourceName} = file.opts.extra.reactIntl;
+                    const moduleSourceName = getModuleSourceName(file.opts);
                     const {imports} = file.metadata.modules;
 
-                    let hasReactIntlMessages = imports.some((mod) => {
+                    let mightHaveReactIntlMessages = imports.some((mod) => {
                         if (mod.source === moduleSourceName) {
                             return mod.imported.some((name) => {
                                 return IMPORTED_NAMES.has(name);
                             });
                         }
                     });
 
-                    if (hasReactIntlMessages) {
-                        file.reactIntl = {
-                            messages: {}
-                        };
+                    if (mightHaveReactIntlMessages) {
+                        file.set('react-intl', {
+                            messages: new Map(),
+                        });
                     } else {
                         this.skip();
                     }
                 },
 
                 exit(node, parent, scope, file) {
+                    const {messages}  = file.get('react-intl');
+                    const messagesDir = getMessagesDir(file.opts);
                     const {basename, filename} = file.opts;
-                    const {messagesDir} = file.opts.extra.reactIntl;
 
-                    let messagesFilename = path.join(
-                        messagesDir, path.dirname(filename), basename + '.json'
+                    let messagesFilename = p.join(
+                        messagesDir,
+                        p.dirname(p.relative(process.cwd(), filename)),
+                        basename + '.json'
                     );
 
-                    let {messages}   = file.reactIntl;
-                    let messagesFile = JSON.stringify(messages, null, 2);
+                    let descriptors  = [...messages.values()];
+                    let messagesFile = JSON.stringify(descriptors, null, 2);
 
-                    mkdirpSync(path.dirname(messagesFilename));
+                    mkdirpSync(p.dirname(messagesFilename));
                     writeFileSync(messagesFilename, messagesFile);
                 }
             },
 
             JSXOpeningElement(node, parent, scope, file) {
-                const {moduleSourceName} = file.opts.extra.reactIntl;
+                const moduleSourceName = getModuleSourceName(file.opts);
                 let name = this.get('name');
 
                 if (referencesImport(name, moduleSourceName, COMPONENT_NAMES)) {
-                    let message = node.attributes
-                        .filter((attr) => ATTR_WHITELIST.has(attr.name.name))
-                        .reduce((message, attr) => {
-                            message[attr.name.name] = attr.value.value;
-                            return message;
-                        }, {});
-
-                    let {messages} = file.reactIntl;
+                    let attributes = this.get('attributes')
+                        .map((attr) => [attr.get('name'), attr.get('value')]);
 
-                    checkMessageId(messages, message, node, file);
-                    Object.assign(messages, {[message.id]: message});
+                    let descriptor = getMessageDescriptor(new Map(attributes));
+                    storeMessage(descriptor, node, file);
                 }
             },
 
             CallExpression(node, parent, scope, file) {
-                const {moduleSourceName} = file.opts.extra.reactIntl;
+                const moduleSourceName = getModuleSourceName(file.opts);
 
                 let callee = this.get('callee');
-                let messageArg = node.arguments[1];
 
-                if (referencesImport(callee, moduleSourceName, FUNCTION_NAMES) &&
-                    t.isObjectExpression(messageArg)) {
+                if (referencesImport(callee, moduleSourceName, FUNCTION_NAMES)) {
+                    let messageArg = this.get('arguments')[1];
+                    if (!messageArg) {
+                        throw file.errorWithNode(node,
+                            `[React Intl] \`${callee.node.name}()\` requires ` +
+                            `a message descriptor as the second argument.`
+                        );
+                    }
 
-                    let message = messageArg.properties
-                        .filter((prop) => ATTR_WHITELIST.has(prop.key.name))
-                        .reduce((message, prop) => {
-                            message[prop.key.name] = prop.value.value;
-                            return message;
-                        }, {});
+                    if (!(messageArg && messageArg.isObjectExpression())) {
+                        let {loc} = messageArg.node;
+                        file.log.warn(
+                            `[React Intl] Line ${loc.start.line}: ` +
+                            `\`${callee.node.name}()\` must use an inline ` +
+                            `object expression for the message to be extracted.`
+                        );
+                        return;
+                    }
 
-                    let {messages} = file.reactIntl;
+                    let properties = messageArg.get('properties')
+                        .map((prop) => [prop.get('key'), prop.get('value')]);
 
-                    checkMessageId(messages, message, node, file);
-                    Object.assign(messages, {[message.id]: message});
+                    let descriptor = getMessageDescriptor(new Map(properties));
+                    storeMessage(descriptor, node, file);
                 }
             }
         }