added native module support and default parameters

Pavlo · Pavlo · commit f7c906daf114 · 2021-02-27T19:36:25.000Z
diff --git a/index.html b/index.html
@@ -29,13 +29,10 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-      x = 5
-      y = 10
+      import '/service.jspy' as obj
+      from '/service.jspy' import func1, func2, func3
 
-      if x == 5 or y == 10:
-        return 100
-
-      return 1
+      return obj.func1(2, 3)
     </div>
 
     <button onclick="tokenize()">Tokenize</button>
@@ -55,13 +52,15 @@ <h4>JSPython development console</h4>
     resultEditor.setTheme("ace/theme/monokai");
     resultEditor.session.setMode("ace/mode/json");
 
-    const jsPython = jspython.jsPython;
+    const interpreter = jspython.jsPython();
+    console.log({interpreter});
+
     function tokenize() {
-      tokenizer = (s) => console.log(`tokens => ${s}`, jsPython().tokenize(s))
+      tokenizer = (s) => console.log(`tokens => ${s}`, interpreter().tokenize(s))
 
       const scripts = editor.getValue();
       try {
-        const result = jsPython()
+        const result = interpreter
           .tokenize(scripts)
           .map((t, i) => `${t[1]} : '${t[0]}'`)
           .join('\n');
@@ -78,7 +77,7 @@ <h4>JSPython development console</h4>
 
       const scripts = editor.getValue();
       try {
-        const result = jsPython()
+        const result = interpreter
           .parse(scripts);
 
         const data = typeof result === 'object' ? JSON.stringify(result, null, '\t') : result;
@@ -93,6 +92,25 @@ <h4>JSPython development console</h4>
 
       const scripts = editor.getValue();
       try {
+
+        interpreter.registerModuleLoader((path => {
+          return Promise.resolve(`
+            def multiply(x, y):
+                x * y
+
+            def func1(x, y):
+              if y == null:
+                y = 77
+
+              multiply(x, y) + someNumber
+            
+            name = 'test'
+            someNumber = 55
+            dateValue = dateTime()
+
+          `);
+        }));
+
         const scope = {
           Math,
           errorFunc: p => {
@@ -115,7 +133,7 @@ <h4>JSPython development console</h4>
             }
           }
         };
-        const result = await jsPython()
+        const result = await interpreter
           .evaluate(scripts, scope, undefined, 'index1.jspy');
 
         // const result = jsPython()
@@ -125,6 +143,7 @@ <h4>JSPython development console</h4>
         //   .evalAsync(scripts, scope);
 
         const data = typeof result === 'object' ? JSON.stringify(result, null, '\t') : String(result);
+
         resultEditor.getSession().setValue(data)
       } catch (err) {
         console.log('error', err);
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",
diff --git a/src/evaluator/evaluator.ts b/src/evaluator/evaluator.ts
@@ -25,6 +25,10 @@ export class Evaluator {
 
         for (const node of ast.body) {
             if (node.type === 'comment') { continue; }
+            if (node.type === 'import') {
+                // we can't use it here, because loader has to be promise
+                throw new Error(`Import is not support with 'eval'. Use method 'evalAsync' instead`);
+            }
             try {
                 lastResult = this.evalNode(node, blockContext);
 
@@ -67,21 +71,12 @@ export class Evaluator {
 
         const blockContext = cloneContext(context);
 
-
-        for (let i = 0; i < args?.length || 0; i++) {
-            if (i >= funcDef.params.length) {
-                break;
-                // throw new Error('Too many parameters provided');
-            }
-            blockContext.blockScope.set(funcDef.params[i], args[i]);
+        // set parameters into new scope, based incomming arguments        
+        for (let i = 0; i < funcDef.params?.length || 0; i++) {
+            const argValue = args?.length > i ? args[i] : null;
+            blockContext.blockScope.set(funcDef.params[i], argValue);
         }
 
-        // // set parameters into new scope, based incomming arguments        
-        // for (let i = 0; i < funcDef.params?.length || 0; i++) {
-        //     const argValue = args?.length > i ? args[i] : null;
-        //     blockContext.blockScope.set(funcDef.params[i], argValue);
-        // }
-
         return this.evalBlock(ast, blockContext);
     }
 
diff --git a/src/evaluator/evaluatorAsync.ts b/src/evaluator/evaluatorAsync.ts
@@ -4,7 +4,7 @@ import {
     CreateObjectNode, DotObjectAccessNode, ForNode, FuncDefNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode,
     getStartLine,
     getTokenLoc,
-    IfNode, IsNullCoelsing, LogicalOpNode, OperationFuncs, Primitive, RaiseNode, ReturnNode, SetSingleVarNode, TryExceptNode, WhileNode
+    IfNode, ImportNode, IsNullCoelsing, LogicalOpNode, OperationFuncs, Primitive, RaiseNode, ReturnNode, SetSingleVarNode, TryExceptNode, WhileNode
 } from '../common';
 import { JspyEvalError, JspyError } from '../common/utils';
 import { Evaluator } from './evaluator';
@@ -17,6 +17,19 @@ import { BlockContext, cloneContext, Scope } from './scope';
  */
 export class EvaluatorAsync {
 
+    private moduleParser: (modulePath: string) => Promise<AstBlock> = () => Promise.reject('Module parser is not registered!');
+    private blockContextFactory?: (modulePath: string) => BlockContext;
+
+    registerModuleParser(moduleParser: (modulePath: string) => Promise<AstBlock>): EvaluatorAsync {
+        this.moduleParser = moduleParser;
+        return this;
+    }
+
+    registerBlockContextFactory(blockContextFactory: (modulePath: string) => BlockContext): EvaluatorAsync {
+        this.blockContextFactory = blockContextFactory;
+        return this;
+    }
+
     async evalBlockAsync(ast: AstBlock, blockContext: BlockContext): Promise<unknown> {
         let lastResult = null;
 
@@ -35,6 +48,21 @@ export class EvaluatorAsync {
 
         for (const node of ast.body) {
             if (node.type === 'comment') { continue; }
+            if (node.type === 'import') {
+                const importNode = node as ImportNode;
+
+                if (typeof this.blockContextFactory !== 'function') {
+                    throw new Error('blockContextFactory is not initialized');
+                }
+
+                const moduleAst = await this.moduleParser(importNode.module.name)
+                const moduleBlockContext = this.blockContextFactory(importNode.module.name);
+                await this.evalBlockAsync(moduleAst, moduleBlockContext)
+
+                blockContext.blockScope.set(importNode.module.alias || this.defaultModuleName(importNode.module.name), moduleBlockContext.blockScope.getScope())
+
+                continue;
+            }
 
             try {
                 lastResult = await this.evalNodeAsync(node, blockContext);
@@ -69,28 +97,23 @@ export class EvaluatorAsync {
         return lastResult;
     }
 
+    private defaultModuleName(name: string): string {
+        return name.substring(name.lastIndexOf('/') + 1, name.lastIndexOf('.'))
+    }
+
     private async jspyFuncInvokerAsync(funcDef: FuncDefNode, context: BlockContext, ...args: unknown[]): Promise<unknown> {
 
         const ast = Object.assign({}, funcDef.funcAst);
         ast.type = 'func';
 
         const blockContext = cloneContext(context);
 
-        for (let i = 0; i < args?.length || 0; i++) {
-            if (i >= funcDef.params.length) {
-                break;
-                // throw new Error('Too many parameters provided');
-            }
-            blockContext.blockScope.set(funcDef.params[i], args[i]);
+        // set parameters into new scope, based incomming arguments        
+        for (let i = 0; i < funcDef.params?.length || 0; i++) {
+            const argValue = args?.length > i ? args[i] : null;
+            blockContext.blockScope.set(funcDef.params[i], argValue);
         }
 
-
-        // // set parameters into new scope, based incomming arguments        
-        // for (let i = 0; i < funcDef.params?.length || 0; i++) {
-        //     const argValue = args?.length > i ? args[i] : null;
-        //     blockContext.blockScope.set(funcDef.params[i], argValue);
-        // }
-
         return await this.evalBlockAsync(ast, blockContext);
     }
 
@@ -135,8 +158,7 @@ export class EvaluatorAsync {
 
     private async evalNodeAsync(node: AstNode, blockContext: BlockContext): Promise<unknown> {
         if (node.type === 'import') {
-            // skip this for now. As modules are implemented externally
-            return null;
+            throw new Error('Import should be defined at the start');
         }
 
         if (node.type === 'comment') {
diff --git a/src/evaluator/scope.ts b/src/evaluator/scope.ts
@@ -1,11 +1,11 @@
 
 export interface BlockContext {
     moduleName: string;
-    returnCalled: boolean;
-    breakCalled: boolean;
-    continueCalled: boolean;
-    returnObject: any;
-    blockScope: Scope
+    blockScope: Scope;
+    returnCalled?: boolean;
+    breakCalled?: boolean;
+    continueCalled?: boolean;
+    returnObject?: any;
 }
 
 export function cloneContext(context: BlockContext): BlockContext {
diff --git a/src/interpreter.spec.ts b/src/interpreter.spec.ts
@@ -598,4 +598,83 @@ describe('Interpreter', () => {
   );
 
 
+  it('unknown property is null', async () => {
+    const script = `
+    x = {}
+
+    if x.someValue == null:
+      return true
+    else:
+      return false
+    `
+    expect(await e.evaluate(script)).toBe(true);
+    expect(e.eval(script)).toBe(true);
+  }
+  );
+
+  it('boolean value', async () => {
+    const script = `
+    x = 2 == 2
+
+    if x:
+      return true
+    else:
+      return false
+    `
+    expect(await e.evaluate(script)).toBe(true);
+    expect(e.eval(script)).toBe(true);
+  }
+  );
+
+  it('Import', async () => {
+    const interpreter = Interpreter.create();
+
+    interpreter.registerModuleLoader((path => {
+      return Promise.resolve(`
+        def multiply(x, y):
+            x * y
+
+        def func1(x, y):
+          multiply(x, y) + someNumber
+        
+        someNumber = 55
+      `);
+    }));
+
+    const res = await interpreter.evaluate(`
+    import '/service.jspy' as obj
+
+    return obj.func1(2, 3) + obj.multiply(2, 3) + obj.someNumber
+    `);
+
+    expect(res).toBe(122);
+  });
+
+
+  it('Import and calling function with default value', async () => {
+    const interpreter = Interpreter.create();
+
+    interpreter.registerModuleLoader((path => {
+      return Promise.resolve(`
+        def multiply(x, y):
+            x * y
+
+        def func1(x, y):
+          # if y is null then 100 will be passed
+          multiply(x, y or 100) + someNumber
+        
+        someNumber = 55
+      `);
+    }));
+
+    const res = await interpreter.evaluate(`
+    import '/service.jspy' as obj
+
+    return obj.func1(2) + obj.multiply(2, 3) + obj.someNumber
+    `);
+
+    expect(res).toBe(316);
+  });
+
+
 });
diff --git a/src/interpreter.ts b/src/interpreter.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "jspython-interpreter",`
`3`		`- "version": "2.0.17",`
	`3`	`+ "version": "2.0.18",`
`4`	`4`	`"description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"python",`