Feature/js test coverage

.eslintrc.js

@@ -0,0 +1,102 @@
+/**
+ * @file    .eslintrc.js - ESLint configuration file, following the Core Team's JS Style Guide.
+ * @author  Wes Garland <wes@distributive.network>
+ * @date    Mar. 2022, July 2023
+ */
+
+/** 
+ * @see {@link https://eslint.org/docs/latest/use/configure/}
+ * @type {import('eslint').Linter.Config}
+ */
+module.exports = {
+  extends: 'eslint:recommended',
+  globals: {
+    'python': true
+  },
+  env: {
+    browser: true,
+    commonjs: true,
+    es2021: true,
+    node: true
+  },
+  parserOptions: {
+    ecmaVersion: 13,
+    sourceType: 'script',
+  },
+  rules: {
+    'indent':                                   [ 'warn', 2, {
+        SwitchCase: 1,
+        ignoredNodes: ['CallExpression', 'ForStatement'],
+      }
+    ],
+    'linebreak-style':                          [ 'error', 'unix' ],
+    'quotes':                                   [ 'warn', 'single' ],
+    'func-call-spacing':                        [ 'off', 'never' ],
+    'no-prototype-builtins':                    'off',
+    'quotes':                                   ['warn', 'single', 'avoid-escape'],
+    'no-empty': [ 'warn' ],
+    'no-multi-spaces':                          [ 'off' ],
+    'prettier/prettier':                        [ 'off' ],
+    'vars-on-top':                              [ 'error' ],
+    'no-var':                                   [ 'off' ],
+    'spaced-comment':                           [ 'warn' ],
+    'brace-style':                              [ 'off' ],
+    'no-eval':                                  [ 'error' ],
+    'object-curly-spacing':                     [ 'warn',       'always' ],
+    'eqeqeq':                                   [ 'warn',       'always' ],
+    'no-dupe-keys':                             [ 'warn' ],
+    'no-constant-condition':                    [ 'warn' ],
+    'no-extra-boolean-cast':                    [ 'warn' ],
+    'no-sparse-arrays':                         [ 'off' ],
+    'no-inner-declarations':                    [ 'off' ],
+    'no-loss-of-precision':                     [ 'warn' ],
+    'require-atomic-updates':                   [ 'warn' ],
+    'no-dupe-keys':                             [ 'warn' ],
+    'no-dupe-class-members':                    [ 'warn' ],
+    'no-fallthrough':                           [ 'warn',       { commentPattern: 'fall[ -]*through' }],
+    'no-invalid-this':                          [ 'error' ],
+    'no-return-assign':                         [ 'error' ],
+    'no-return-await':                          [ 'warn' ],
+    'no-unused-expressions':                    [ 'warn',       { allowShortCircuit: true, allowTernary: true } ],
+    'prefer-promise-reject-errors':             [ 'error' ],
+    'no-throw-literal':                         [ 'error' ],
+    'semi':                                     [ 'off',        { omitLastInOneLineBlock: true }], /* does not work right with exports.X = function allmanStyle */
+    'semi-style':                               [ 'warn',       'last' ],
+    'semi-spacing':                             [ 'error',      {'before': false, 'after': true}],
+    'no-extra-semi':                            [ 'warn' ],
+    'no-tabs':                                  [ 'error' ],
+    'symbol-description':                       [ 'error' ],
+    'operator-linebreak':                       [ 'warn',       'before' ],
+    'new-cap':                                  [ 'warn' ],
+    'consistent-this':                          [ 'error',      'that' ],
+    'no-use-before-define':                     [ 'error',      { functions: false, classes: false } ],
+    'no-shadow':                                [ 'error' ],
+    'no-label-var':                             [ 'error' ],
+    'radix':                                    [ 'error' ],
+    'no-self-compare':                          [ 'error' ],
+    'require-await':                            [ 'error' ],
+    'require-yield':                            [ 'error' ],
+    'no-promise-executor-return':               [ 'off' ],
+    'no-template-curly-in-string':              [ 'warn' ],
+    'no-unmodified-loop-condition':             [ 'warn' ],
+    'no-unused-private-class-members':          [ 'warn' ],
+    'no-use-before-define':                     [ 'error',      { functions: false, classes: true, variables: true }],
+    'no-implicit-coercion':                     [1, {
+      disallowTemplateShorthand: false,
+      boolean: true,
+      number: true,
+      string: true,
+      allow: ['!!'] /* really only want to allow if(x) and if(!x) but not if(!!x) */
+    }],
+    'no-trailing-spaces': [ 'off', {
+        skipBlankLines: true,
+        ignoreComments: true
+      }
+                          ],
+    'no-unused-vars':                           ['warn',        {
+      vars: 'all',
+      args: 'none',
+      ignoreRestSiblings: false
+    }],
+  }
+};

README.md

@@ -221,10 +221,10 @@ that if you update an object in JavaScript, the corresponding Dict in Python wil
 |:---------------------|:----------------|
 | string               | String
 | number               | Float
-| bigint               | Integer
+| bigint               | pythonmonkey.bigint (Integer)
 | boolean              | Bool
 | function             | Function
-| object - most        | JSObjectProxy which inherits from Dict
+| object - most        | pythonmonkey.JSObjectProxy (Dict)
 | object - Date        | datetime
 | object - Array       | List
 | object - Promise     | awaitable
@@ -234,14 +234,23 @@ that if you update an object in JavaScript, the corresponding Dict in Python wil
 
 ## Tricks
 ### Integer Type Coercion
-You can force a number in JavaScript to be coerced as an integer by casting it to BigInt.
+You can force a number in JavaScript to be coerced as an integer by casting it to BigInt:
 ```javascript
 function myFunction(a, b) {
   const result = calculate(a, b);
   return BigInt(Math.floor(result));
 }
 ```
 
+The `pythonmonkey.bigint` object works like an int in Python, but it will be coerced as a BigInt in JavaScript:
+```python
+import pythonmonkey
+
+def fn myFunction()
+  result = 5
+  return pythonmonkey.bigint(result)
+```
+
 ### Symbol injection via cross-language IIFE
 You can use a JavaScript IIFE to create a scope in which you can inject Python symbols:
 ```python

peter-jr

@@ -151,8 +151,8 @@ findTests \
 
     if [ "${ext}" = "failing" ]; then
       knownFail="yes"
-      PASS="$(bggreen PASS) (unexpected)"
-      FAIL="$(dred F̶A̶I̶L̶) (expected)"
+      PASS="$(bggreen PASS) $(grey \(unexpected\))"
+      FAIL="$(dred F̶A̶I̶L̶) $(grey \(expected\))"
       [ ! "${VERBOSE}" ] && thisStderr="/dev/null"
     else
       knownFail=""

python/pythonmonkey/cli/pmjs.py

@@ -40,9 +40,17 @@
     pythonCmd.serial = 0;
     return;
   }
+
+  if (cmd === '')
+  {
+    return;
+  }
+
   try {
     if (arguments[0] === 'from' || arguments[0] === 'import')
-    return python.exec(cmd);
+    {
+      return python.exec(cmd);
+    }
 
     const retval = python.eval(cmd);
   }

tests/js/console-smoke.simple

@@ -8,7 +8,10 @@
  * @author      Wes Garland, wes@distributive.network
  * @date        June 2023
  */
-const console = new (require('console').Console)({stdout: python.stdout, stderr: python.stdout});
+const console = new (require('console').Console)({
+  stdout: python.stdout,
+  stderr: python.stdout
+});
 globalThis.console.log('one');
 globalThis.console.info('two');
 console.debug('three');

tests/js/js2py/array-change-index.simple

@@ -0,0 +1,29 @@
+/**
+ * @file        js2py/array-chnage-index.simple
+ *              Simple test which demonstrates modifying an array
+ *              passed to Python and returning it.
+ * @author      Will Pringle, will@distributive.network
+ * @date        July 2023
+ */
+'use strict';
+
+const numbers = [1,2,3,4,5,6,7,8,9];
+
+python.exec(`
+def setArrayAtIndex(array, index, new):
+  array[1] = new # can't index "array" based on "index"... probably because index is a float. So just pass "1"
+  return array
+`);
+const setArrayAtIndex = python.eval("setArrayAtIndex")
+const numbersBack = setArrayAtIndex(numbers, 1, 999);
+
+// check that the array data was modified by reference in python
+if (numbers[1] !== 999)
+  throw new Error('array not modified by python');
+
+// check that the array we get from python is the same reference as defined in js
+if (!Object.is(numbers, numbersBack))
+  throw new Error('array reference differs between JavaScript and Python');
+
+console.log('pass');
+

tests/js/js2py/arraybuffer.simple

@@ -0,0 +1,30 @@
+/**
+ * @file        js2py/arraybuffer.simple
+ *              Simple test which shows that sending ArrayBuffers to Python and getting them back into JS
+ *              works as expected. Also tests mutation.
+ * @author      Severn Lortie, severn@distributive.network
+ * @date        July 2023
+ */
+'use strict';
+
+const buffer = new ArrayBuffer(5); // 5 bytes
+const bufferView = new Uint8Array(buffer);
+bufferView[0] = 104;
+bufferView[1] = 101;
+bufferView[2] = 108;
+bufferView[3] = 108;
+bufferView[4] = 111;
+
+python.exec(`
+def mutate(x):
+  x[3] = 55;
+  return x;
+`);
+
+const fn = python.eval('mutate');
+const modifiedBuff = fn(buffer); // Call the function which mutates the buffer
+
+// Check that both were updated
+for (let i = 0; i < bufferView.length; i++) 
+  if (modifiedBuff[i] !== bufferView[i]) throw new Error('The buffer was not changed, or not returned correctly.');
+

tests/js/js2py/bigint.simple

@@ -0,0 +1,35 @@
+/**
+ * @file        js2py/bigint.simple
+ *              Simple test which shows that sending bigint to Python and getting them back into JS
+ *              works as expected.
+ * @author      Kirill Kirnichansky, kirill@distributive.network
+ * @date        July 2023
+ */
+'use strict';
+
+const bigint = BigInt(777);
+
+python.exec(`
+def isPythonInt(val):
+  return isinstance(val, int)
+
+def compare(val):
+  if val == int(777):
+    return True
+  return False
+`);
+const isPythonInt = python.eval('isPythonInt');
+const compare = python.eval('compare');
+
+if (!isPythonInt)
+{
+  console.error(`${bigint} is not instance of int in Python.`);
+  throw new Error('test failed');
+}
+if (!compare)
+{
+  console.error(`${bigint} !== 777 in Python`);
+  throw new Error('test failed');
+}
+
+console.log('pass');

tests/js/js2py/boolean.simple

@@ -0,0 +1,27 @@
+/**
+ * @file    js2py/boolean.simple - Asserts that sending primitive and boxed
+ *          booleans to Python and getting them back into JS as primitive
+ *          booleans retains the correponsing logical values.
+ *
+ * @author  Bryan Hoang <bryan@distributive.network>
+ * @date    July 2023
+ */
+'use strict';
+
+const throughPython = python.eval('(lambda x: x)');
+
+const primitiveJsTrue = true;
+const maybePrimitiveJsTrue = throughPython(primitiveJsTrue);
+if (maybePrimitiveJsTrue !== primitiveJsTrue)
+{
+  console.error('Expected', primitiveJsTrue, 'but got', maybePrimitiveJsTrue);
+  throw new Error('Test failed');
+}
+
+const boxedJsFalse = new Boolean(false);
+const maybePrimitiveJsFalse = throughPython(boxedJsFalse);
+if (false !== maybePrimitiveJsFalse)
+{
+  console.error('Expected', false, 'but got', maybePrimitiveJsFalse);
+  throw new Error('Test failed');
+}

tests/js/js2py/datetime.simple.failing

@@ -0,0 +1,40 @@
+/**
+ * @file        js2py/datetime.simple.failing
+ *              Simple test which shows that sending Dates to Python and getting them back into JS
+ *              works as expected
+ * 
+ * @author      Elijah Deluzio, elijah@distributive.network
+ * @date        July 2023
+ */
+'use strict'
+
+const throughPython = python.eval('(lambda x: x)');
+var expectedJsTimestamp;
+var jsDate;
+var pyDate;
+
+// Test 1: Date from timestamp of 0 (1970 - 01 - 01), timestamp = 0
+jsDate = new Date(Date.UTC(1970, 0, 1, 0, 0, 0));
+expectedJsTimestamp = jsDate.getTime();
+pyDate = throughPython(jsDate);
+
+if (expectedJsTimestamp !== pyDate.getTime())
+{
+  console.error('expected', expectedJsTimestamp, 'but got', pyDate.getTime());
+  throw new Error('test failed');
+}
+
+console.log('pass -', pyDate);
+
+// Test 2: Date from 21st century (2222 - 02 - 03), timestamp = 7955193600000
+jsDate = new Date(Date.UTC(2222, 1, 3, 0, 0, 0));
+expectedJsTimestamp = jsDate.getTime();
+pyDate = throughPython(jsDate);
+
+if (expectedJsTimestamp !== pyDate.getTime())
+{
+  console.error('expected', expectedJsTimestamp, 'but got', pyDate.getTime());
+  throw new Error('test failed');
+}
+
+console.log('pass -', pyDate);