added functionality to import JSON file and load it into the context

Author: ppaska

index.html

@@ -29,10 +29,9 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-      import '/service.jspy' as obj
-      from '/service.jspy' import func1, func2, func3
+import '/test.json' as obj
 
-      return obj.func1(2, 3)
+return obj.x
     </div>
 
     <button onclick="tokenize()">Tokenize</button>
@@ -95,19 +94,7 @@ <h4>JSPython development console</h4>
 
         interpreter.registerModuleLoader((path => {
           return Promise.resolve(`
-            from 'service' import add
-
-            def multiply(x, y):
-                x * y
-
-            def func1(x, y):
-              print('++>>>', getExecutionContext())
-              multiply(x, y) + add(x, y)
-            
-            name = 'test'
-            someNumber = 55
-            dateValue = dateTime()
-
+          {"x": "test22", "n": 55}
           `);
         }));
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",

src/common/utils.ts

@@ -70,6 +70,15 @@ export function parseDatetimeOrNull(value: string | Date): Date | null {
     return null;
 }
 
+export function getImportType(name: string): 'jspyModule' | 'jsPackage' | 'json' {
+
+    if (name.startsWith('/') || name.startsWith('./')) {
+        return (name.endsWith('.json')) ? 'json' : 'jspyModule';
+    }
+
+    return 'jsPackage';
+}
+
 function jspyErrorMessage(error: string, module: string, line: number, column: number, message: string): string {
     return `${error}: ${module}(${line},${column}): ${message}`;
 }
@@ -99,7 +108,7 @@ export class JspyEvalError extends Error {
 }
 
 export class JspyError extends Error {
-   
+
     constructor(public module: string, public line: number, public column: number, public name: string, public message: string) {
         super();
         this.message = jspyErrorMessage("JspyError", module || 'name.jspy', line, column, message);

src/evaluator/evaluatorAsync.ts

@@ -6,7 +6,7 @@ import {
     getTokenLoc,
     IfNode, ImportNode, IsNullCoelsing, LogicalOpNode, OperationFuncs, Primitive, RaiseNode, ReturnNode, SetSingleVarNode, TryExceptNode, WhileNode
 } from '../common';
-import { JspyEvalError, JspyError } from '../common/utils';
+import { JspyEvalError, JspyError, getImportType } from '../common/utils';
 import { Evaluator } from './evaluator';
 import { BlockContext, cloneContext, Scope } from './scope';
 
@@ -18,13 +18,19 @@ import { BlockContext, cloneContext, Scope } from './scope';
 export class EvaluatorAsync {
 
     private moduleParser: (modulePath: string) => Promise<AstBlock> = () => Promise.reject('Module parser is not registered!');
+    private jsonFileLoader: (jsonFilePath: string) => Promise<string> = () => Promise.reject('{}');
     private blockContextFactory?: (modulePath: string, ast: AstBlock) => BlockContext;
 
     registerModuleParser(moduleParser: (modulePath: string) => Promise<AstBlock>): EvaluatorAsync {
         this.moduleParser = moduleParser;
         return this;
     }
 
+    registerJsonFileLoader(jsonFileLoader: (modulePath: string) => Promise<string>): EvaluatorAsync {
+        this.jsonFileLoader = jsonFileLoader;
+        return this;
+    }
+
     registerBlockContextFactory(blockContextFactory: (modulePath: string, ast: AstBlock) => BlockContext): EvaluatorAsync {
         this.blockContextFactory = blockContextFactory;
         return this;
@@ -50,9 +56,15 @@ export class EvaluatorAsync {
             if (node.type === 'comment') { continue; }
             if (node.type === 'import') {
                 const importNode = node as ImportNode;
+                const iType = getImportType(importNode.module.name);
 
-                if (!importNode.module.name.startsWith('/') /* || !importNode.module.name.endsWith('.jspy')*/) {
-                    // it is not JSPY imort. It is JS and should be handled externally
+                if (iType === 'json') {
+                    const jsonValue = JSON.parse(await this.jsonFileLoader(importNode.module.name));
+                    blockContext.blockScope
+                        .set(importNode.module.alias || this.defaultModuleName(importNode.module.name), jsonValue);
+                    continue;
+                } else if (iType !== 'jspyModule') {
+                    // it is not JSPY import. It is JS and should be handled externally
                     continue;
                 }
 

src/interpreter.spec.ts

@@ -696,27 +696,47 @@ describe('Interpreter', () => {
     }));
 
     const res = await interpreter.evaluate(`
-    import '/service.jspy' as obj
+    import './service.jspy' as obj
 
     return obj.func1(2) + obj.multiply(2, 3)
     `);
 
     expect(res).toBe(261);
   });
 
+  it('Import JSON', async () => {
+    const interpreter = Interpreter.create();
+
+    interpreter.registerModuleLoader((path => {
+      return Promise.resolve(`
+        {"x": "test1", "n": 22}
+      `);
+    }));
+
+    const res = await interpreter.evaluate(`
+    import './some.json' as obj
+
+    return obj
+    `);
+
+    expect(res.x).toBe('test1');
+    expect(res.n).toBe(22);
+  });
+
+
   it('Import with package loader', async () => {
     const interpreter = Interpreter.create();
 
     interpreter.registerPackagesLoader(path =>
-      (
-        path === 'service' ? {
-          add: (x: number, y: number) => x + y,
-          remove: (x: number, y: number) => x - y,
-          times: (x: number, y: number) => x * y,
-        } 
+    (
+      path === 'service' ? {
+        add: (x: number, y: number) => x + y,
+        remove: (x: number, y: number) => x - y,
+        times: (x: number, y: number) => x * y,
+      }
         : null
-      )
-    );    
+    )
+    );
 
     interpreter.registerModuleLoader((path => {
       return Promise.resolve(`
@@ -784,6 +804,6 @@ describe('Interpreter', () => {
     `;
     expect(await interpreter.evalAsync(script)).toBe(55);
     expect(interpreter.eval(script)).toBe(55);
-  });  
+  });
 
 });

src/interpreter.ts

@@ -1,4 +1,5 @@
 import { AstBlock, ImportNode, Token } from './common';
+import { getImportType } from './common/utils';
 import { Evaluator } from './evaluator';
 import { EvaluatorAsync } from './evaluator/evaluatorAsync';
 import { BlockContext, Scope } from './evaluator/scope';
@@ -94,11 +95,15 @@ export class Interpreter {
         this._lastExecutionContext = blockContext.blockScope.getScope();
 
         const result = await evaluator
+            .registerJsonFileLoader(async (modulePath: string) =>
+                await (this.moduleLoader ? this.moduleLoader(modulePath)
+                    : Promise.reject('ModuleLoader is not registered')
+                )
+            )
             .registerModuleParser(async (modulePath) => await this.moduleParser(modulePath))
             .registerBlockContextFactory((moduleName, ast: AstBlock) => {
-                // this line will not be required when we have move package loaders to the evaluator
-                const newContext = this.assignLegacyImportContext(ast, scope);
-
+                // enrich context
+                const newContext = this.assignImportContext(ast, scope);
                 const moduleContext = { moduleName, blockScope: new Scope(newContext) }
                 moduleContext.blockScope.set('printExecutionContext', () => console.log(moduleContext.blockScope.getScope()));
                 moduleContext.blockScope.set('getExecutionContext', () => moduleContext.blockScope.getScope());
@@ -118,15 +123,15 @@ export class Interpreter {
     }
 
     /**
-     * Compatibility method! Will be deprecated soon
+     * Compatibility method (with v1). !
      */
     async evaluate(script: string, context: object = {}, entryFunctionName: string = ''
         , moduleName: string = 'main.jspy'): Promise<any> {
         if (!script || !script.length) { return null; }
         const ast = this.parse(script, moduleName);
 
         context = (context && typeof context === 'object') ? context : {};
-        context = this.assignLegacyImportContext(ast, context);
+        context = this.assignImportContext(ast, context);
 
         const globalScope = {
             ...this.initialScope,
@@ -169,7 +174,7 @@ export class Interpreter {
         return scripts.indexOf(`def ${funcName}`) > -1;
     }
 
-    private assignLegacyImportContext(ast: AstBlock, context: object): Record<string, unknown> {
+    private assignImportContext(ast: AstBlock, context: object): Record<string, unknown> {
 
         const nodeToPackage = (im: ImportNode): PackageToImport => {
             return {
@@ -182,7 +187,7 @@ export class Interpreter {
         const importNodes = ast.body.filter(n => n.type === 'import') as ImportNode[];
 
         const jsImport = importNodes
-            .filter(im => !im.module.name.startsWith('/'))
+            .filter(im => getImportType(im.module.name) === 'jsPackage')
             .map(im => nodeToPackage(im));
 
         if (jsImport.length && this.packageLoader) {