Merge branch 'MDL-66327-master' of git://github.com/andrewnicols/moodle
[moodle.git] / babel-plugin-add-module-to-define.js
1 // This file is part of Moodle - http://moodle.org/
2 //
3 // Moodle is free software: you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation, either version 3 of the License, or
6 // (at your option) any later version.
7 //
8 // Moodle is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
16 /**
17  * This is a babel plugin to add the Moodle module names to the AMD modules
18  * as part of the transpiling process.
19  *
20  * In addition it will also add a return statement for the default export if the
21  * module is using default exports. This is a highly specific Moodle thing because
22  * we're transpiling to AMD and none of the existing Babel 7 plugins work correctly.
23  *
24  * This will fix the issue where an ES6 module using "export default Foo" will be
25  * transpiled into an AMD module that returns {default: Foo}; Instead it will now
26  * just simply return Foo.
27  *
28  * Note: This means all other named exports in that module are ignored and won't be
29  * exported.
30  *
31  * @copyright  2018 Ryan Wyllie <ryan@moodle.com>
32  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
33  */
35 "use strict";
37 module.exports = ({ template, types }) => {
38     const fs = require('fs');
39     const path = require('path');
40     const glob = require('glob');
41     const cwd = process.cwd();
43     // Static variable to hold the modules.
44     let moodleSubsystems = null;
45     let moodlePlugins = null;
47     /**
48      * Parse Moodle's JSON files containing the lists of components.
49      *
50      * The values are stored in the static variables because we
51      * only need to load them once per transpiling run.
52      */
53     function loadMoodleModules() {
54         moodleSubsystems = {'lib': 'core'};
55         moodlePlugins = {};
56         let components = fs.readFileSync('lib/components.json');
57         components = JSON.parse(components);
59         for (const [component, path] of Object.entries(components.subsystems)) {
60             if (path) {
61                 // Prefix "core_" to the front of the subsystems.
62                 moodleSubsystems[path] = `core_${component}`;
63             }
64         }
66         for (const [component, path] of Object.entries(components.plugintypes)) {
67             if (path) {
68                 moodlePlugins[path] = component;
69             }
70         }
72         for (const file of glob.sync('**/db/subplugins.json')) {
73             var rawContents = fs.readFileSync(file);
74             var subplugins = JSON.parse(rawContents);
76             for (const [component, path] of Object.entries(subplugins.plugintypes)) {
77                 if (path) {
78                     moodlePlugins[path] = component;
79                 }
80             }
81         }
82     }
84     /**
85      * Search the list of components that match the given file name
86      * and return the Moodle component for that file, if found.
87      *
88      * Throw an exception if no matching component is found.
89      *
90      * @throws {Error}
91      * @param {string} searchFileName The file name to look for.
92      * @return {string} Moodle component
93      */
94     function getModuleNameFromFileName(searchFileName) {
95         searchFileName = fs.realpathSync(searchFileName);
96         const relativeFileName = searchFileName.replace(`${cwd}${path.sep}`, '').replace(/\\/g, '/');
97         const [componentPath, file] = relativeFileName.split('/amd/src/');
98         const fileName = file.replace('.js', '');
100         // Check subsystems first which require an exact match.
101         if (moodleSubsystems.hasOwnProperty(componentPath)) {
102             return `${moodleSubsystems[componentPath]}/${fileName}`;
103         }
105         // It's not a subsystem so it must be a plugin. Moodle defines root folders
106         // where plugins can be installed so our path with be <plugin_root>/<plugin_name>.
107         // Let's separate the two.
108         let pathParts = componentPath.split('/');
109         const pluginName = pathParts.pop();
110         const pluginPath = pathParts.join('/');
112         // The plugin path mutch match exactly because some plugins are subplugins of
113         // other plugins which means their paths would partially match.
114         if (moodlePlugins.hasOwnProperty(pluginPath)) {
115             return `${moodlePlugins[pluginPath]}_${pluginName}/${fileName}`;
116         }
118         // This matches the previous PHP behaviour that would throw an exception
119         // if it couldn't parse an AMD file.
120         throw new Error('Unable to find module name for ' + searchFileName);
121     }
123     // This is heavily inspired by the babel-plugin-add-module-exports plugin.
124     // See: https://github.com/59naga/babel-plugin-add-module-exports
125     //
126     // This is used when we detect a module using "export default Foo;" to make
127     // sure the transpiled code just returns Foo directly rather than an object
128     // with the default property (i.e. {default: Foo}).
129     //
130     // Note: This means that we can't support modules that combine named exports
131     // with a default export.
132     function addModuleExportsDefaults(path, exportObjectName) {
133         const rootPath = path.findParent(path => {
134             return path.key === 'body' || !path.parentPath;
135         });
137         // HACK: `path.node.body.push` instead of path.pushContainer(due doesn't work in Plugin.post).
138         // This is hardcoded to work specifically with AMD.
139         rootPath.node.body.push(template(`return ${exportObjectName}.default`)())
140     }
142     return {
143         pre() {
144             this.seenDefine = false;
145             this.addedReturnForDefaultExport = false;
147             if (moodleSubsystems === null) {
148                 loadMoodleModules();
149             }
150         },
151         visitor: {
152             // Plugin ordering is only respected if we visit the "Program" node.
153             // See: https://babeljs.io/docs/en/plugins.html#plugin-preset-ordering
154             //
155             // We require this to run after the other AMD module transformation so
156             // let's visit the "Program" node.
157             Program: {
158                 exit(path) {
159                     path.traverse({
160                         CallExpression(path) {
161                             // If we find a "define" function call.
162                             if (!this.seenDefine && path.get('callee').isIdentifier({name: 'define'})) {
163                                 // We only want to modify the first instance of define that we find.
164                                 this.seenDefine = true;
165                                 // Get the Moodle component for the file being processed.
166                                 var moduleName = getModuleNameFromFileName(this.file.opts.filename);
167                                 // Add the module name as the first argument to the define function.
168                                 path.node.arguments.unshift(types.stringLiteral(moduleName));
169                                 // Add a space after the define function in the built file so that previous versions
170                                 // of Moodle will not try to add the module name to the file when it's being served
171                                 // by PHP. This forces the regex in PHP to not match for this file.
172                                 path.node.callee.name = 'define ';
173                             }
175                             // Check for any Object.defineProperty('exports', 'default') calls.
176                             if (!this.addedReturnForDefaultExport && path.get('callee').matchesPattern('Object.defineProperty')) {
177                                 const [identifier, prop] = path.get('arguments')
178                                 const objectName = identifier.get('name').node
179                                 const propertyName = prop.get('value').node
181                                 if ((objectName === 'exports' || objectName === '_exports') && propertyName === 'default') {
182                                     addModuleExportsDefaults(path, objectName);
183                                     this.addedReturnForDefaultExport = true;
184                                 }
185                             }
186                         },
187                         AssignmentExpression(path) {
188                             // Check for an exports.default assignments.
189                             if (
190                                 !this.addedReturnForDefaultExport &&
191                                 (
192                                     path.get('left').matchesPattern('exports.default') ||
193                                     path.get('left').matchesPattern('_exports.default')
194                                 )
195                             ) {
196                                 const objectName = path.get('left.object.name').node;
197                                 addModuleExportsDefaults(path, objectName);
198                                 this.addedReturnForDefaultExport = true;
199                             }
200                         }
201                     }, this);
202                 }
203             }
204         }
205     };
206 };