Merge branch 'main' into Xmader/fix/readline-windows

Author: Xmader

.eslintrc.js

@@ -0,0 +1,102 @@
+/**
+ * @file    .eslintrc.js - ESLint configuration file, following the Core Team's JS Style Guide.
+ * @author  Wes Garland <[email protected]>
+ * @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

@@ -222,10 +222,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
@@ -235,14 +235,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

include/DateType.hh

@@ -26,8 +26,19 @@
 struct DateType : public PyType {
 public:
   DateType(PyObject *object);
-  DateType(JSContext *cx, JS::Handle<JSObject *> dateObj);
+  /**
+   * @brief Convert a JS Date object to Python datetime
+   */
+  DateType(JSContext *cx, JS::HandleObject dateObj);
+
   const TYPE returnType = TYPE::DATE;
+
+  /**
+   * @brief Convert a Python datetime object to JS Date
+   *
+   * @param cx - javascript context pointer
+   */
+  JSObject *toJsDate(JSContext *cx);
 };
 
 #endif

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

@@ -44,9 +44,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);
   }

src/DateType.cc

@@ -11,7 +11,7 @@
 
 DateType::DateType(PyObject *object) : PyType(object) {}
 
-DateType::DateType(JSContext *cx, JS::Handle<JSObject *> dateObj) {
+DateType::DateType(JSContext *cx, JS::HandleObject dateObj) {
   JS::Rooted<JS::ValueArray<0>> args(cx);
   JS::Rooted<JS::Value> year(cx);
   JS::Rooted<JS::Value> month(cx);
@@ -33,4 +33,12 @@ DateType::DateType(JSContext *cx, JS::Handle<JSObject *> dateObj) {
     year.toNumber(), month.toNumber() + 1, day.toNumber(),
     hour.toNumber(), minute.toNumber(), second.toNumber(),
     usecond.toNumber() * 1000);
-}
+}
+
+JSObject *DateType::toJsDate(JSContext *cx) {
+  // See https://docs.python.org/3/library/datetime.html#datetime.datetime.timestamp
+  PyObject *timestamp = PyObject_CallMethod(pyObject, "timestamp", NULL); // the result is in seconds
+  double milliseconds = PyFloat_AsDouble(timestamp) * 1000;
+  Py_DECREF(timestamp);
+  return JS::NewDateObject(cx, JS::TimeClip(milliseconds));
+}

src/jsTypeFactory.cc

@@ -20,6 +20,7 @@
 #include "include/StrType.hh"
 #include "include/IntType.hh"
 #include "include/PromiseType.hh"
+#include "include/DateType.hh"
 #include "include/ExceptionType.hh"
 #include "include/BufferType.hh"
 
@@ -28,6 +29,7 @@
 #include <js/Proxy.h>
 
 #include <Python.h>
+#include <datetime.h> // https://docs.python.org/3/c-api/datetime.html
 
 #define HIGH_SURROGATE_START 0xD800
 #define LOW_SURROGATE_START 0xDC00
@@ -65,6 +67,8 @@ size_t UCS4ToUTF16(const uint32_t *chars, size_t length, uint16_t **outStr) {
 }
 
 JS::Value jsTypeFactory(JSContext *cx, PyObject *object) {
+  PyDateTime_IMPORT; // for PyDateTime_Check
+
   JS::RootedValue returnType(cx);
 
   if (PyBool_Check(object)) {
@@ -145,6 +149,10 @@ JS::Value jsTypeFactory(JSContext *cx, PyObject *object) {
     JSObject *error = ExceptionType(object).toJsError(cx);
     returnType.setObject(*error);
   }
+  else if (PyDateTime_Check(object)) {
+    JSObject *dateObj = DateType(object).toJsDate(cx);
+    returnType.setObject(*dateObj);
+  }
   else if (PyObject_CheckBuffer(object)) {
     BufferType *pmBuffer = new BufferType(object);
     JSObject *typedArray = pmBuffer->toJsTypedArray(cx); // may return null

src/modules/pythonmonkey/pythonmonkey.cc

@@ -375,7 +375,7 @@ static bool clearTimeout(JSContext *cx, unsigned argc, JS::Value *vp) {
   // Retrieve the AsyncHandle by `timeoutID`
   int32_t timeoutID = timeoutIdArg.toInt32();
   AsyncHandle *handle = AsyncHandle::fromId((uint32_t)timeoutID);
-  if (!handle) return true;   // does nothing on invalid timeoutID
+  if (!handle) return true; // does nothing on invalid timeoutID
 
   // Cancel this job on Python event-loop
   handle->cancel();

tests/js/console-smoke.simple

@@ -8,7 +8,10 @@
  * @author      Wes Garland, [email protected]
  * @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, [email protected]
+ * @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');
+