xeus 4.0 updates (#31)

* xeus 4.0 updates

Author: DerThorsten

CMakeLists.txt

@@ -258,17 +258,6 @@ if (XEUS_JAVASCRIPT_BUILD_STATIC)
     list(APPEND XEUS_JAVASCRIPT_TARGETS xeus-javascript-static)
 endif ()
 
-# xjavascript
-# =======
-if (XEUS_JAVASCRIPT_BUILD_EXECUTABLE)
-    find_package(xeus-zmq 1.0.2 REQUIRED)
-    add_executable(xjavascript ${XEUS_JAVASCRIPT_MAIN_SRC})
-    target_compile_features(xjavascript PRIVATE cxx_std_17)
-    xeus_javascript_set_common_options(xjavascript)
-    xeus_javascript_set_kernel_options(xjavascript)
-    target_link_libraries(xjavascript PRIVATE xeus-zmq)
-endif()
-
 
 include(WasmBuildOptions)
 

environment-wasm-host.yml

@@ -4,6 +4,6 @@ channels:
   - https://repo.mamba.pm/conda-forge
 dependencies:
   - nlohmann_json
-  - xeus-lite
-  - xeus >=3.0.5,<4.0
+  - xeus-lite >=2.0.0,<3.0
+  - xeus >=4.0.1,<5.0
   - xtl >=0.7,<0.8

include/xeus-javascript/xinterpreter.hpp

@@ -54,12 +54,12 @@ namespace xeus_javascript
 
         void configure_impl() override;
 
-        nl::json execute_request_impl(int execution_counter,
-                                      const std::string& code,
-                                      bool silent,
-                                      bool store_history,
-                                      nl::json user_expressions,
-                                      bool allow_stdin) override;
+        void execute_request_impl(xeus::xrequest_context request_context,
+                             send_reply_callback cb,
+                             int execution_counter,
+                             const std::string& code,
+                             xeus::execute_request_config config,
+                             nl::json user_expressions) override;
 
         nl::json complete_request_impl(const std::string& code, int cursor_pos) override;
 

src/post.js

@@ -83,42 +83,56 @@ function handle_last_statement(
     code_user,
     ast
 ) {
-    // is the very last character a semicolon?
-    const last_char_is_semicolon =  code_user[code_user.length-1] == ";";
 
     // get the last node
     const last_node = ast.body[ast.body.length-1];
 
+
     // if the last node is an expression statement
     // then we need to add a return statement
     // so that the expression gets returned
-    if(!last_char_is_semicolon && last_node.type == "ExpressionStatement" && last_node.expression.type != "AssignmentExpression"){
+    if(last_node.type == "ExpressionStatement" && last_node.expression.type != "AssignmentExpression"){
 
-        const last_node_start = last_node.start;
-        const last_node_end = last_node.end;
+        const last_node_expr_start = last_node.expression.start;
+        const last_node_expr_end = last_node.expression.end;
 
-        //  remove the last node from the code
-        const modified_user_code = code_user.substring(0, last_node_start) + code_user.substring(last_node_end);
-        const code_of_last_node = code_user.substring(last_node_start, last_node_end);
+        // "rest"
+        const last_node_rest_end = last_node.end
+        // search between last_node_expr_end and last_node_rest_end for a semicolon
+        // if there is a semicolon then we dont need to add a return
 
-        const extra_return_code = `return [${code_of_last_node}];`;
+        let semicolon_found = false;
+        for(let i=last_node_expr_end; i<last_node_rest_end; i++){
+            if(code_user[i] == ";"){
+                semicolon_found = true;
+                break;
+            }
+        }
 
+        if(!semicolon_found){
+            //  remove the last node from the code
+            const modified_user_code = code_user.substring(0, last_node_expr_start) + code_user.substring(last_node_expr_end);
+            const code_of_last_node = code_user.substring(last_node_expr_start, last_node_expr_end);
 
-        return {
-            with_return: true,
-            modified_user_code: modified_user_code,
-            extra_return_code: extra_return_code
+
+            const extra_return_code = `return [${code_of_last_node}];`;
+
+
+            return {
+                with_return: true,
+                modified_user_code: modified_user_code,
+                extra_return_code: extra_return_code
+            }
         }
     }
-    else
-    {
-        return {
-            with_return: false,
-            modified_user_code: code_user,
-            extra_return_code: ""
-        }
+
+    return {
+        with_return: false,
+        modified_user_code: code_user,
+        extra_return_code: ""
     }
 
+
 }
 
 function transform_import_source (source) {
@@ -317,7 +331,7 @@ function _configure() {
                 msg += " ";
             }
         }
-        Module.interpreter.publish_stream("stdout", `${msg}\n`);
+        Module.interpreter.publish_stream(Module.get_request_context(), "stdout", `${msg}\n`);
     }
     // alias
     globalThis.pp = globalThis.pprint;
@@ -330,7 +344,7 @@ function _configure() {
                 msg += " ";
             }
         }
-        Module.interpreter.publish_stream("stdout", `${msg}\n`);
+        Module.interpreter.publish_stream(Module.get_request_context(), "stdout", `${msg}\n`);
     }
     console.error = function (... args) {
         let msg = ""
@@ -340,29 +354,42 @@ function _configure() {
                 msg += " ";
             }
         }
-        Module.interpreter.publish_stream("stderr", `${msg}\n`);
+        Module.interpreter.publish_stream(Module.get_request_context(), "stderr", `${msg}\n`);
     }
 
     // add ijs to global scope
     globalThis["ijs"] = Module["ijs"];
 
     Module.interpreter = Module._get_interpreter();
 
-    Module.interpreter.publish_stream("stdout", "Configured\n");
+
+    // the execute request context
+    Module._xrequest_context = null;
 }
 
 
+Module.get_request_context = function () {
+    return Module._xrequest_context;
+}
+
 Module.get_interpreter = function () {
     return Module.interpreter;
 }
 
 
-async function _call_user_code(code) {
+async function _call_user_code(context, code) {
 
+    // call _xrequest_context.delete() if it exists
+    if(Module._xrequest_context && Module._xrequest_context.delete){
+        Module._xrequest_context.delete();
+    }
+    Module._xrequest_context = context;
 
     try{
+
         const ret = make_async_from_code(code);
         const async_function = ret.async_function;
+
         let result_promise = async_function();
 
         let data = {};
@@ -441,8 +468,6 @@ function complete_line(code_line){
         }
     }
     let pseudo_expression = code_line.substring(code_begin);
-
-
     // pseudo_expression is "fubar.b" "fubar", "fubar." or "fubar['aaa']"
 
     // find part right of dot / bracket
@@ -469,16 +494,13 @@ function complete_line(code_line){
         curser_start += split_pos+1;
     }
 
-
-
     // find root object
     let root_object = globalThis;
     if(root_object_str != ""){
         try{
             root_object = eval(root_object_str);
         }
         catch(err){
-            Module["_publish_stderr_stream"](`${err}\n`);
             return {
                 matches : [],
                 cursor_start : curser_start,
@@ -551,10 +573,10 @@ let ijs = {
     magic_imports: magic_imports,
     display : {
         display: function (data, metadata={}, transient={}) {
-            Module.get_interpreter().display_data(data, metadata, transient);
+            Module.get_interpreter().display_data(Module.get_request_context(), data, metadata, transient);
         },
         update_display_data: function (data, metadata={}, transient={}) {
-            Module.get_interpreter().update_display_data(data, metadata, transient);
+            Module.get_interpreter().update_display_data(Module.get_request_context(), data, metadata, transient);
         },
         mime_type: function (mime_type, data) {
             this.display({ mime_type: data });
@@ -636,7 +658,7 @@ let ijs = {
                 }
             }
             catch(err){
-                Module.interpreter.publish_stream("stderr", `display error: ${err}\n`);
+                Module.interpreter.publish_stream(Module.get_request_context(), "stderr", `display error: ${err}\n`);
             }
         }
 

src/xcomm.cpp

@@ -29,45 +29,50 @@ namespace xeus_javascript
 
     xcomm::xcomm(
         std::string target_name,
-        nl::json data,
-        nl::json metadata,
-        em::val buffers,
         nl::json kwargs
     )
         : m_comm(target(target_name), id(kwargs))
     {
-        m_comm.open(metadata, data, jslist_to_cpp_buffers(buffers));
     }
 
     xcomm::xcomm(xeus::xcomm&& comm)
         : m_comm(std::move(comm))
     {
     }
-
     xcomm::~xcomm()
     {
     }
+    void xcomm::open(
+        nl::json parent_header,
+        const nl::json & data,
+        const nl::json& metadata,
+        const em::val & buffers)
+    {
+        m_comm.open(parent_header, metadata, data, jslist_to_cpp_buffers(buffers));
+    }
 
-    std::string xcomm::comm_id() const
+    void xcomm::close(nl::json parent_header,  const nl::json & data, const nl::json& metadata, const em::val & buffers)
     {
-        return m_comm.id();
+        m_comm.close(parent_header, metadata, data, jslist_to_cpp_buffers(buffers));
     }
 
-    bool xcomm::kernel() const
+    void xcomm::send( nl::json parent_header, const nl::json & data, const nl::json& metadata, const em::val & buffers)
     {
-        return true;
+        m_comm.send(parent_header, metadata, data, jslist_to_cpp_buffers(buffers));
     }
 
-    void xcomm::close(const nl::json & data, const nl::json& metadata, const em::val & buffers)
+
+    std::string xcomm::comm_id() const
     {
-        m_comm.close(metadata, data, jslist_to_cpp_buffers(buffers));
+        return m_comm.id();
     }
 
-    void xcomm::send(const nl::json & data, const nl::json& metadata, const em::val & buffers)
+    bool xcomm::kernel() const
     {
-        m_comm.send(metadata, data, jslist_to_cpp_buffers(buffers));
+        return true;
     }
 
+
     void xcomm::on_msg(const js_callback_type& callback)
     {
         m_comm.on_message(cpp_callback(callback));
@@ -120,9 +125,10 @@ namespace xeus_javascript
 
     void export_xcomm(){
         em::class_<xcomm>("Comm")
-            .constructor<std::string, nl::json, nl::json, em::val, nl::json>()
+            .constructor<std::string,  nl::json>()
             .function("comm_id", &xcomm::comm_id)
             .function("kernel", &xcomm::kernel)
+            .function("open", &xcomm::open)
             .function("close", &xcomm::close)
             .function("send", &xcomm::send)
             .function("on_msg", &xcomm::on_msg)

src/xcomm.hpp

@@ -40,9 +40,6 @@ namespace xeus_javascript
 
         xcomm(
             std::string target_name,
-            nl::json data,
-            nl::json metadata,
-            em::val buffers,
             nl::json extra_kwargs
         );
         xcomm(xeus::xcomm&& comm);
@@ -52,8 +49,9 @@ namespace xeus_javascript
         std::string comm_id() const;
         bool kernel() const;
 
-        void close(const nl::json& data, const nl::json& metadata, const em::val& buffers);
-        void send(const nl::json& data, const nl::json& metadata, const em::val& buffers);
+        void open(nl::json parent_header, const nl::json& data, const nl::json& metadata, const em::val& buffers);
+        void close(nl::json parent_header, const nl::json& data, const nl::json& metadata, const em::val& buffers);
+        void send(nl::json parent_header, const nl::json& data, const nl::json& metadata, const em::val& buffers);
         void on_msg(const js_callback_type& callback);
         void on_close(const js_callback_type& callback);