rapydscript-ns 0.8.3 → 0.9.0

package/test/vars_locals_globals.pyj

@@ -0,0 +1,94 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+from __python__ import overload_getitem
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── vars(obj) — instance attribute snapshot ───────────────────────────────────
+
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+p = Point(3, 4)
+d = vars(p)
+ae(d['x'], 3)
+ae(d['y'], 4)
+
+# all instance attrs present, no extras
+keys = list(d.keys())
+keys.sort()
+ade(keys, ['x', 'y'])
+
+# snapshot: mutating the result does NOT affect the original object
+d['x'] = 99
+ae(p.x, 3)
+
+# works for arbitrary objects with instance attrs
+class Config:
+    def __init__(self):
+        self.debug = True
+        self.level = 5
+        self.name = 'test'
+
+cfg = Config()
+cv = vars(cfg)
+ae(cv['debug'], True)
+ae(cv['level'], 5)
+ae(cv['name'], 'test')
+
+# ── vars(obj) — object updated after snapshot ─────────────────────────────────
+
+class Box:
+    def __init__(self, value):
+        self.value = value
+
+b = Box(10)
+snap1 = vars(b)
+b.value = 20
+snap2 = vars(b)
+ae(snap1['value'], 10)   # old snapshot unchanged
+ae(snap2['value'], 20)   # new snapshot reflects update
+
+# ── vars() with no argument — returns vars(this) ─────────────────────────────
+
+class WithMethod:
+    def __init__(self):
+        self.a = 1
+        self.b = 2
+
+    def get_vars(self):
+        return vars()
+
+wm = WithMethod()
+wv = wm.get_vars()
+ae(wv['a'], 1)
+ae(wv['b'], 2)
+
+# ── locals() — returns empty dict (JS scope not introspectable) ───────────────
+
+loc = locals()
+ok(loc is not None)
+ok(len(list(loc.keys())) is 0)
+
+# ── globals() — returns a dict of the JS global namespace ────────────────────
+
+g = globals()
+ok(g is not None)
+# Should be dict-like (has .keys())
+gkeys = list(g.keys())
+ok(gkeys.length >= 0)
+# Built-in globals (non-enumerable on globalThis) must be present
+ok('Math' in g)
+ok('Object' in g)
+ok('Array' in g)
+
+# ── vars/locals/globals return proper dict instances ─────────────────────────
+
+ok(isinstance(vars(Point(1, 2)), dict))
+ok(isinstance(vars(), dict))
+ok(isinstance(locals(), dict))
+ok(isinstance(globals(), dict))

package/tools/cli.js

@@ -360,6 +360,17 @@ hash_literals, overload_operators. Prefix a flag with no_ to
 explicitly disable it (e.g. no_bound_methods).
 */});
 
+opt("legacy_rapydscript", "L", 'bool', false, function(){/*
+Use legacy RapydScript behavior (disabled by default). When set to
+true (--legacy-rapydscript), preserves legacy RapydScript behavior
+with no Python compatibility flags enabled by default. When false
+(the default), enables all Python compatibility flags globally
+(dict_literals, overload_getitem, bound_methods, hash_literals,
+overload_operators, truthiness, jsx) and patches String.prototype
+with Python string methods at startup, equivalent to:
+from pythonize import strings; strings()
+*/});
+
 create_group('repl', '', function(){/*
 Run a Read-Eval-Print-Loop (REPL). This allows
 you to type and run RapydScript at a live

package/tools/compile.js

@@ -75,6 +75,11 @@ module.exports = function(start_time, argv, base_path, src_path, lib_path) {
     var num_of_files = files.length || 1;
 
     var global_scoped_flags = build_scoped_flags(argv.python_flags);
+    if (!argv.legacy_rapydscript) {
+        var python_mode_flags = ['dict_literals', 'overload_getitem', 'bound_methods', 'hash_literals', 'overload_operators', 'truthiness', 'jsx'];
+        python_mode_flags.forEach(function(f) { if (!(f in global_scoped_flags)) global_scoped_flags[f] = true; });
+        if (!argv.pythonize_strings) OUTPUT_OPTIONS.pythonize_strings = true;
+    }
 
     function parse_file(code, file, toplevel) {
         return RapydScript.parse(code, {

package/tools/embedded_compiler.js

@@ -7,6 +7,7 @@
 "use strict";  /*jshint node:true */
 
 var has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+var PYTHON_MODE_FLAGS = ['dict_literals', 'overload_getitem', 'bound_methods', 'hash_literals', 'overload_operators', 'truthiness', 'jsx'];
 
 function build_scoped_flags(flags_str) {
     var result = Object.create(null);
@@ -134,8 +135,12 @@ module.exports = function(compiler, baselib, runjs, name, vf_context) {
             opts = opts || {};
             var classes = (this.toplevel) ? this.toplevel.classes : undefined;
             var inherited_flags = (this.toplevel) ? this.toplevel.scoped_flags : undefined;
+            var base_flags = Object.create(null);
+            if (opts.legacy_rapydscript !== true) {
+                PYTHON_MODE_FLAGS.forEach(function(f) { base_flags[f] = true; });
+            }
             var scoped_flags = Object.assign(
-                Object.create(null),
+                base_flags,
                 opts.python_flags ? build_scoped_flags(opts.python_flags) : {},
                 inherited_flags || {}
             );
@@ -165,7 +170,8 @@ module.exports = function(compiler, baselib, runjs, name, vf_context) {
                     libdir: undefined,
                 });
             }
-            var ans = print_ast(this.toplevel, opts.keep_baselib, opts.keep_docstrings, opts.js_version, opts.private_scope, opts.write_name, opts.omit_function_metadata, opts.pythonize_strings);
+            var pythonize_strings = (opts.legacy_rapydscript !== true) ? true : !!opts.pythonize_strings;
+            var ans = print_ast(this.toplevel, opts.keep_baselib, opts.keep_docstrings, opts.js_version, opts.private_scope, opts.write_name, opts.omit_function_metadata, pythonize_strings);
             if (opts.export_main) {
                 ans = ans.replace(/^(function\smain)/gm, 'export $1')
                     .replace(/^(async\sfunction\smain)/gm, 'export $1');
@@ -188,8 +194,12 @@ module.exports = function(compiler, baselib, runjs, name, vf_context) {
             opts = opts || {};
             var classes = (this.toplevel) ? this.toplevel.classes : undefined;
             var inherited_flags = (this.toplevel) ? this.toplevel.scoped_flags : undefined;
+            var base_flags_sm = Object.create(null);
+            if (opts.legacy_rapydscript !== true) {
+                PYTHON_MODE_FLAGS.forEach(function(f) { base_flags_sm[f] = true; });
+            }
             var scoped_flags = Object.assign(
-                Object.create(null),
+                base_flags_sm,
                 opts.python_flags ? build_scoped_flags(opts.python_flags) : {},
                 inherited_flags || {}
             );
@@ -219,11 +229,12 @@ module.exports = function(compiler, baselib, runjs, name, vf_context) {
                     libdir: undefined,
                 });
             }
+            var pythonize_strings_sm = (opts.legacy_rapydscript !== true) ? true : !!opts.pythonize_strings;
             var result = print_ast_with_sourcemap(
                 this.toplevel,
                 opts.keep_baselib, opts.keep_docstrings, opts.js_version,
                 opts.private_scope, opts.write_name, opts.omit_function_metadata,
-                opts.pythonize_strings,
+                pythonize_strings_sm,
                 opts.filename || '<input>',
                 code
             );

package/tools/lint.js

@@ -39,7 +39,7 @@ var BUILTINS = Object.create(null);
  ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
  ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
  ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
- ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN Ellipsis'
+ ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN Ellipsis bytes bytearray'
  ).split(' ').forEach(function(x) { BUILTINS[x] = true; });
 
 Object.keys(RapydScript.NATIVE_CLASSES).forEach(function (name) { BUILTINS[name] = true; });
@@ -353,28 +353,25 @@ function Linter(toplevel, filename, code, options) {
 
     this.handle_for_in = function() {
         var node = this.current_node;
+        var self = this;
+        var add_loop_var = function(cnode) {
+            if (cnode instanceof RapydScript.AST_Seq) {
+                cnode.to_array().forEach(add_loop_var);
+            } else if (cnode instanceof RapydScript.AST_Array) {
+                cnode.elements.forEach(add_loop_var);
+            } else if (cnode instanceof RapydScript.AST_SymbolRef) {
+                self.current_node = cnode;
+                cnode.lint_visited = true;
+                self.add_binding(cnode.name).is_loop = true;
+                self.current_node = node;
+            }
+        };
         if (node.init instanceof RapydScript.AST_SymbolRef) {
             this.add_binding(node.init.name).is_loop = true;
             node.init.lint_visited = true;
         } else if (node.init instanceof RapydScript.AST_Array) {
-            // destructuring assignment: for a, b in []
-            for (var i = 0; i < node.init.elements.length; i++) {
-                var cnode = node.init.elements[i];
-                if (cnode instanceof RapydScript.AST_Seq) cnode = cnode.to_array();
-                if (cnode instanceof RapydScript.AST_SymbolRef) cnode = [cnode];
-                if (Array.isArray(cnode)) {
-                    for (var j = 0; j < cnode.length; j++) {
-                        var elem = cnode[j];
-                        if (elem instanceof RapydScript.AST_SymbolRef) {
-                            this.current_node = elem;
-                            elem.lint_visited = true;
-                            this.add_binding(elem.name).is_loop = true;
-                            this.current_node = node;
-                        }
-                    }
-                }
-            }
- 
+            // destructuring assignment: for a, b in [] or for (a, b), c in []
+            node.init.elements.forEach(add_loop_var);
         }
     };
 

package/tools/repl.js

@@ -93,7 +93,7 @@ module.exports = function(options) {
     options.console.log();
 
     function print_ast(ast, keep_baselib) {
-        var output_options = {omit_baselib:!keep_baselib, write_name:false, private_scope:false, beautify:true, keep_docstrings:true};
+        var output_options = {omit_baselib:!keep_baselib, write_name:false, private_scope:false, beautify:true, keep_docstrings:true, repl_mode:true};
         if (keep_baselib) output_options.baselib_plain = fs.readFileSync(path.join(options.lib_path, 'baselib-plain-pretty.js'), 'utf-8');
         var output = new RapydScript.OutputStream(output_options);
         ast.print(output);

package/web-repl/env.js

@@ -27,6 +27,128 @@ var builtin_modules = {
             if(!ctx) ctx = {};
             if (!ctx.sha1sum) ctx.sha1sum = sha1sum;
             if (!ctx.require) ctx.require = require;
+            if (!ctx.React) ctx.React = (function() {
+                var Fragment = Symbol('React.Fragment');
+
+                function createElement(type, props) {
+                    var children = Array.prototype.slice.call(arguments, 2);
+                    return {
+                        type: type,
+                        props: Object.assign({children: children.length === 1 ? children[0] : children}, props)
+                    };
+                }
+
+                // Minimal hook stubs — enough to run REPL snippets without React DOM.
+                function useState(initial) {
+                    var state = (typeof initial === 'function') ? initial() : initial;
+                    return [state, function(v) { state = (typeof v === 'function') ? v(state) : v; }];
+                }
+
+                function useEffect(fn /*, deps */) {
+                    var cleanup = fn();
+                    // cleanup would be called on unmount; ignored in stub
+                }
+
+                function useLayoutEffect(fn /*, deps */) { fn(); }
+
+                function useMemo(fn /*, deps */) { return fn(); }
+
+                function useCallback(fn /*, deps */) { return fn; }
+
+                function useRef(initial) { return { current: initial }; }
+
+                function useContext(ctx) { return ctx && ctx._currentValue !== undefined ? ctx._currentValue : undefined; }
+
+                function useReducer(reducer, initial, init) {
+                    var state = (init !== undefined) ? init(initial) : initial;
+                    return [state, function(action) { state = reducer(state, action); }];
+                }
+
+                function useImperativeHandle(ref, create /*, deps */) {
+                    if (ref) ref.current = create();
+                }
+
+                function useDebugValue() {}
+
+                function useId() { return ':r' + (Math.random() * 1e9 | 0) + ':'; }
+
+                function useTransition() { return [false, function(fn) { fn(); }]; }
+
+                function useDeferredValue(value) { return value; }
+
+                function useSyncExternalStore(subscribe, getSnapshot) { return getSnapshot(); }
+
+                function useInsertionEffect(fn /*, deps */) { fn(); }
+
+                function createContext(defaultValue) {
+                    return { _currentValue: defaultValue, Provider: function(props) { return props.children; }, Consumer: function(props) { return props.children(defaultValue); } };
+                }
+
+                function createRef() { return { current: null }; }
+
+                function forwardRef(render) {
+                    return function(props) { return render(props, null); };
+                }
+
+                function memo(Component /*, compare */) { return Component; }
+
+                function lazy(factory) { return factory; }
+
+                function cloneElement(element, props) {
+                    return Object.assign({}, element, { props: Object.assign({}, element.props, props) });
+                }
+
+                function isValidElement(obj) {
+                    return obj !== null && typeof obj === 'object' && obj.type !== undefined;
+                }
+
+                function Component() {}
+                Component.prototype.render = function() { return null; };
+                Component.prototype.setState = function(update) {
+                    var next = (typeof update === 'function') ? update(this.state) : update;
+                    this.state = Object.assign({}, this.state, next);
+                };
+
+                function PureComponent() {}
+                PureComponent.prototype = Object.create(Component.prototype);
+                PureComponent.prototype.constructor = PureComponent;
+
+                var StrictMode = { type: Symbol('React.StrictMode') };
+                var Suspense = { type: Symbol('React.Suspense') };
+                var Profiler = { type: Symbol('React.Profiler') };
+
+                return {
+                    Fragment: Fragment,
+                    createElement: createElement,
+                    useState: useState,
+                    useEffect: useEffect,
+                    useLayoutEffect: useLayoutEffect,
+                    useMemo: useMemo,
+                    useCallback: useCallback,
+                    useRef: useRef,
+                    useContext: useContext,
+                    useReducer: useReducer,
+                    useImperativeHandle: useImperativeHandle,
+                    useDebugValue: useDebugValue,
+                    useId: useId,
+                    useTransition: useTransition,
+                    useDeferredValue: useDeferredValue,
+                    useSyncExternalStore: useSyncExternalStore,
+                    useInsertionEffect: useInsertionEffect,
+                    createContext: createContext,
+                    createRef: createRef,
+                    forwardRef: forwardRef,
+                    memo: memo,
+                    lazy: lazy,
+                    cloneElement: cloneElement,
+                    isValidElement: isValidElement,
+                    Component: Component,
+                    PureComponent: PureComponent,
+                    StrictMode: StrictMode,
+                    Suspense: Suspense,
+                    Profiler: Profiler,
+                };
+            })();
             Object.keys(ctx).forEach(function(k) { win[k] = ctx[k]; });
             return win;
         },

package/web-repl/main.js

@@ -18,9 +18,7 @@
     };
 
     function compile(code) {
-        const codeWithoutVariableTypeDefinitions = code.replace(/^ *(?!def\s)([\w.-]+) *: *[\w.-]+ *[:+*\/%&|^><-]*=/gm, '$1');
-        var pythonize_strings = !!(document.getElementById('pythonize_strings') || {}).checked;
-        return web_repl.compile(codeWithoutVariableTypeDefinitions, {omit_function_metadata: false, tree_shake: false, export_main: true, virtual_files: VIRTUAL_FILES, pythonize_strings: pythonize_strings});
+        return web_repl.compile(code, {omit_function_metadata: false, tree_shake: false, export_main: true, virtual_files: VIRTUAL_FILES, legacy_rapydscript: false});
     }
 
     function runjs(code) {