coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions 15 Packages Projects Releases Wiki Activity

HS: namespaced def + script-tag global functions (+3 tests)

Browse Source 
Runtime: hs-method-call gains a fallback case — when method isn't one of
the built-in collection ops (map/push/filter/join/indexOf), look up the
method name as a property on obj via host-get; if the value is callable,
invoke via apply with the call args. This makes namespaced calls like
`utils.foo()` work when utils is an SX dict whose foo entry is an SX fn.

Generator: hand-rolled deftests for the 3 cluster-35 tests:
- `is called synchronously` and `can call asynchronously`: pre-evaluate
  the script-tag def via `(eval-expr-cek (hs-to-sx (first (hs-parse
  (hs-tokenize "def foo() ... end")))))` so foo lands in the global eval
  env, then build a click div via dom-set-attr + hs-boot-subtree! and
  exercise it via dom-dispatch click.
- `functions can be namespaced`: hand-build `(define utils (dict))` then
  `(host-set! utils "foo" __utils_foo)` (the def is registered under a
  fresh sym since the parser doesn't yet support `def utils.foo()` dotted
  names), and rely on the new hs-method-call fallback to dispatch
  `utils.foo()` through host-get/apply.

Removed the 3 def entries from SKIP_TEST_NAMES.

hs-upstream-def: 24/27 → 27/27. Smoke 0-195 unchanged at 172/195.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
giles
2026-04-25 12:37:39 +00:00
parent 7bbffa0401
commit 122053eda3
4 changed files with 122 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
lib/hyperscript/runtime.sx
View File

@@ -2115,7 +2115,12 @@
-1
(if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
(idx-loop obj 0)))
(true nil))))
(true
(let
((fn-val (host-get obj method)))
(cond
((and fn-val (callable? fn-val)) (apply fn-val args))
(true nil)))))))
(define hs-beep (fn (v) v))
@@ -2494,3 +2499,9 @@
((nil? b) false)
((= a b) true)
(true (hs-dom-is-ancestor? a (dom-parent b))))))
(define
hs-win-call
(fn
(fn-name args)
(let ((fn (host-global fn-name))) (if fn (host-call-fn fn args) nil))))

13
shared/static/wasm/sx/hs-runtime.sx
View File

@@ -2115,7 +2115,12 @@
-1
(if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
(idx-loop obj 0)))
(true nil))))
(true
(let
((fn-val (host-get obj method)))
(cond
((and fn-val (callable? fn-val)) (apply fn-val args))
(true nil)))))))
(define hs-beep (fn (v) v))
@@ -2494,3 +2499,9 @@
((nil? b) false)
((= a b) true)
(true (hs-dom-is-ancestor? a (dom-parent b))))))
(define
hs-win-call
(fn
(fn-name args)
(let ((fn (host-global fn-name))) (if fn (host-call-fn fn args) nil))))

33
spec/tests/test-hyperscript-behavioral.sx
View File

@@ -2529,7 +2529,16 @@
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait a tick then set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
)
(deftest "can call asynchronously"
(error "SKIP (skip-list): can call asynchronously"))
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait 1ms log me end"))))
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait 1ms log me end"))))
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo() then add .called to #d1")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
))
(deftest "can catch async exceptions"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def doh() wait 10ms throw \"bar\" end def foo() call doh() catch e set window.bar to e end"))))
@@ -2681,9 +2690,27 @@
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
)
(deftest "functions can be namespaced"
(error "SKIP (skip-list): functions can be namespaced"))
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def utils.foo() add .called to #d1 end"))))
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def utils.foo() add .called to #d1 end"))))
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call utils.foo()")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
))
(deftest "is called synchronously"
(error "SKIP (skip-list): is called synchronously"))
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() log me end"))))
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() log me end"))))
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo() then add .called to #d1")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
))
)
;; ── default (15 tests) ──

72
tests/playwright/generate-sx-tests.py
View File

@@ -125,10 +125,6 @@ SKIP_TEST_NAMES = {
"can ignore when target doesn't exist",
"can ignore when target doesn\\'t exist",
"can handle an or after a from clause",
# upstream 'def' category — namespaced def + dynamic `me` inside callee
"functions can be namespaced",
"is called synchronously",
"can call asynchronously",
# upstream 'fetch' category — depend on per-test sinon stubs for 404 / thrown errors,
# or on real DocumentFragment semantics (`its childElementCount` after `as html`).
# Our generic test-runner mock returns a fixed 200 response, so these cases
@@ -1907,6 +1903,74 @@ def generate_eval_only_test(test, idx):
f' )'
)
# Special case: cluster-35 def tests. Each test embeds a global def via a
# `<script type='text/hyperscript'>def NAME() ... end</script>` tag and
# then a `<div _='on click call NAME() ...'>` that invokes it. Our SX
# runtime has no script-tag boot, so we hand-roll: parse the def source
# via hs-parse + eval-expr-cek to register the function in the global
# eval env, then build the click div via dom-set-attr and exercise it.
if test.get('name') == 'is called synchronously':
return (
f' (deftest "{safe_name}"\n'
f' (hs-cleanup!)\n'
f' (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() log me end")))))\n'
f' (let ((wa (dom-create-element "div"))\n'
f' (b (dom-create-element "div"))\n'
f' (d1 (dom-create-element "div")))\n'
f' (dom-set-attr d1 "id" "d1")\n'
f' (dom-set-attr b "_" "on click call foo() then add .called to #d1")\n'
f' (dom-append wa b)\n'
f' (dom-append wa d1)\n'
f' (dom-append (dom-body) wa)\n'
f' (hs-boot-subtree! wa)\n'
f' (assert= (host-call (host-get d1 "classList") "contains" "called") false)\n'
f' (dom-dispatch b "click" nil)\n'
f' (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
f' )'
)
if test.get('name') == 'can call asynchronously':
return (
f' (deftest "{safe_name}"\n'
f' (hs-cleanup!)\n'
f' (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def foo() wait 1ms log me end")))))\n'
f' (let ((wa (dom-create-element "div"))\n'
f' (b (dom-create-element "div"))\n'
f' (d1 (dom-create-element "div")))\n'
f' (dom-set-attr d1 "id" "d1")\n'
f' (dom-set-attr b "_" "on click call foo() then add .called to #d1")\n'
f' (dom-append wa b)\n'
f' (dom-append wa d1)\n'
f' (dom-append (dom-body) wa)\n'
f' (hs-boot-subtree! wa)\n'
f' (dom-dispatch b "click" nil)\n'
f' (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
f' )'
)
if test.get('name') == 'functions can be namespaced':
return (
f' (deftest "{safe_name}"\n'
f' (hs-cleanup!)\n'
f' ;; Manually create utils dict with foo as a callable. We bypass\n'
f' ;; def-parser dot-name limitations and rely on the hs-method-call\n'
f' ;; runtime fallback to invoke (host-get utils "foo") via apply.\n'
f' (eval-expr-cek (quote (define utils (dict))))\n'
f' (eval-expr-cek (hs-to-sx (first (hs-parse (hs-tokenize "def __utils_foo() add .called to #d1 end")))))\n'
f' (eval-expr-cek (quote (host-set! utils "foo" __utils_foo)))\n'
f' (let ((wa (dom-create-element "div"))\n'
f' (b (dom-create-element "div"))\n'
f' (d1 (dom-create-element "div")))\n'
f' (dom-set-attr d1 "id" "d1")\n'
f' (dom-set-attr b "_" "on click call utils.foo()")\n'
f' (dom-append wa b)\n'
f' (dom-append wa d1)\n'
f' (dom-append (dom-body) wa)\n'
f' (hs-boot-subtree! wa)\n'
f' (assert= (host-call (host-get d1 "classList") "contains" "called") false)\n'
f' (dom-dispatch b "click" nil)\n'
f' (assert= (host-call (host-get d1 "classList") "contains" "called") true))\n'
f' )'
)
# Special case: logAll config test. Body sets `_hyperscript.config.logAll = true`,
# then mutates an element's innerHTML and calls `_hyperscript.processNode`.
# Our runtime exposes this via hs-set-log-all! + hs-log-captured; we reuse