Coverage for modules/org/openteacher/logic/javaScript/evaluator/evaluator : 94%

#! /usr/bin/env python3 

# -*- coding: utf-8 -*- 

#       Copyright 2013, 2017, Marten de Vries 

# 

#       This file is part of OpenTeacher. 

# 

#       OpenTeacher is free software: you can redistribute it and/or modify 

#       it under the terms of the GNU General Public License as published by 

#       the Free Software Foundation, either version 3 of the License, or 

#       (at your option) any later version. 

# 

#       OpenTeacher is distributed in the hope that it will be useful, 

#       but WITHOUT ANY WARRANTY; without even the implied warranty of 

#       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 

#       GNU General Public License for more details. 

# 

#       You should have received a copy of the GNU General Public License 

#       along with OpenTeacher.  If not, see <http://www.gnu.org/licenses/>. 

import os 

class JSEvaluatorModule: 

        """Note that this class only implements a small subset of Node, just enough 

        for the JS modules OT needs to run at the time of writing. 

        """ 

        def __init__(self, moduleManager, *args, **kwargs): 

                super().__init__(*args, **kwargs) 

                self._mm = moduleManager 

                self.type = "javaScriptEvaluator" 

                self.requires = ( 

                        self._mm.mods(type="qtApp"), 

                        self._mm.mods(type="javaScriptResolver"), 

                ) 

        @property 

        def _getCode(self): 

                modules = next(iter(self._mm.mods(type='modules'))) 

                return modules.default('active', type='javaScriptResolver').resolve 

        def _buildFsMod(self): 

                mod = {} 

                def readFileSync(path, opts): 

                        with open(path, encoding=opts.encoding) as f: 

                                return f.read() 

                mod['readFileSync'] = readFileSync 

                return mod 

        def _require(self, evaluator, modName): 

                if modName == 'fs': 

                        return self._buildFsMod() 

                path, code = self._getCode(modName) 

                loadMod = evaluator.eval(''' 

                function load(module, exports, __dirname) { 

                "use strict"; 

%s}; 

                function (dirName) { 

                        var mod = {exports: {}}; 

                        load(mod, mod.exports, dirName); 

                        return mod.exports; 

                }; 

                ''' % code) 

                return loadMod(os.path.dirname(path)) 

        def loadModule(self, modName): 

                evaluator = self.createEvaluator() 

                evaluator.global_[modName] = self._require(evaluator, modName) 

                return evaluator 

        def createEvaluator(self): 

                __doc__ = "Returns a:\n\n" + jseval.JSEvaluator.__doc__ 

                evaluator = jseval.JSEvaluator() 

                evaluator.global_.require = lambda *args: self._require(evaluator, *args) 

                return evaluator 

        def enable(self): 

                global jseval 

                try: 

                        import jseval 

                except ImportError as e: 

                        print(e) 

                        return 

                self.active = True 

        def disable(self): 

                self.active = False 

def init(moduleManager): 

        return JSEvaluatorModule(moduleManager)