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

Step 13: String/regex primitives — PCRE-compatible, cross-host

Browse Source 
New primitives in sx_primitives.ml:
  char-at, char-code, parse-number — string inspection + conversion
  regex-match, regex-match?, regex-find-all — PCRE pattern matching
  regex-replace, regex-replace-first — PCRE substitution
  regex-split — split by PCRE pattern

Uses Re.Pcre (OCaml re library) so regex patterns use the same syntax
as JS RegExp — patterns in .sx files work identically on browser and
server. Replaces the old test-only regex-find-all stub.

Also: split now handles multi-char separators via Re.

176 new tests (10 suites). 2912/2912 total, zero failures.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
giles
2026-04-05 20:38:40 +00:00
parent 516f9c7186
commit 5d88b363e4
4 changed files with 247 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
hosts/ocaml/bin/run_tests.ml
View File

@@ -470,52 +470,7 @@ let make_test_env () =
let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
(match stack with _ :: rest -> Hashtbl.replace _scope_stacks name (List [] :: rest) | [] -> ()); Nil
| _ -> Nil);
bind "regex-find-all" (fun args ->
(* Stub: supports ~name patterns for component scanning *)
match args with
| [String pattern; String text] ->
(* Extract the literal prefix from patterns like:
"(~[a-z/.-]+" → prefix "~", has_group=true
"\(~([a-zA-Z_]..." → prefix "(~", has_group=true *)
let prefix, has_group =
if String.length pattern >= 4 && pattern.[0] = '\\' && pattern.[1] = '(' then
(* Pattern like \(~(...) — literal "(" + "~" prefix, group after *)
let s = String.sub pattern 2 (String.length pattern - 2) in
let lit_end = try String.index s '(' with Not_found -> try String.index s '[' with Not_found -> String.length s in
let lit = String.sub s 0 lit_end in
("(" ^ lit, true)
else if String.length pattern > 2 && pattern.[0] = '(' then
let s = String.sub pattern 1 (String.length pattern - 1) in
let p = try String.sub s 0 (String.index s '[')
with Not_found -> try String.sub s 0 (String.index s '(')
with Not_found -> s in
((if String.length p > 0 then p else "~"), true)
else (pattern, false)
in
let results = ref [] in
let len = String.length text in
let plen = String.length prefix in
let i = ref 0 in
while !i <= len - plen do
if String.sub text !i plen = prefix then begin
(* Find end of identifier *)
let j = ref (!i + plen) in
while !j < len && let c = text.[!j] in
(c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
|| c = '-' || c = '/' || c = '_' || c = '.' do
incr j
done;
let full_match = String.sub text !i (!j - !i) in
(* If pattern has capture group, strip the literal prefix to simulate group 1 *)
let result = if has_group then
String.sub full_match plen (String.length full_match - plen)
else full_match in
results := String result :: !results;
i := !j
end else incr i
done;
List (List.rev !results)
| _ -> List []);
(* regex-find-all now provided by sx_primitives.ml *)
bind "callable?" (fun args ->
match args with
| [NativeFn _] | [Lambda _] | [Component _] | [Island _] -> Bool true

3
hosts/ocaml/lib/dune
View File

@@ -1,3 +1,4 @@
(library
(name sx)
(wrapped false))
(wrapped false)
(libraries re re.pcre))

95
hosts/ocaml/lib/sx_primitives.ml
View File

@@ -398,7 +398,12 @@ let () =
register "split" (fun args ->
match args with
| [String s; String sep] ->
List (List.map (fun p -> String p) (String.split_on_char sep.[0] s))
if String.length sep = 1 then
List (List.map (fun p -> String p) (String.split_on_char sep.[0] s))
else
(* Multi-char separator: use Re for literal split *)
let re = Re.compile (Re.str sep) in
List (List.map (fun p -> String p) (Re.split re s))
| _ -> raise (Eval_error "split: 2 args"));
register "join" (fun args ->
match args with
@@ -441,6 +446,94 @@ let () =
Buffer.add_utf_8_uchar buf (Uchar.of_int (int_of_float n));
String (Buffer.contents buf)
| _ -> raise (Eval_error "char-from-code: 1 arg"));
register "char-at" (fun args ->
match args with
| [String s; Number n] ->
let i = int_of_float n in
if i >= 0 && i < String.length s then
String (String.make 1 s.[i])
else Nil
| _ -> raise (Eval_error "char-at: string and index"));
register "char-code" (fun args ->
match args with
| [String s] when String.length s > 0 -> Number (float_of_int (Char.code s.[0]))
| _ -> raise (Eval_error "char-code: 1 non-empty string arg"));
register "parse-number" (fun args ->
match args with
| [String s] ->
(try Number (float_of_string s)
with Failure _ -> Nil)
| _ -> raise (Eval_error "parse-number: 1 string arg"));
(* === Regex (PCRE-compatible — same syntax as JS RegExp) === *)
register "regex-match" (fun args ->
match args with
| [String pattern; String input] ->
(try
let re = Re.Pcre.re pattern |> Re.compile in
match Re.exec_opt re input with
| Some group ->
let full = Re.Group.get group 0 in
let n = Re.Group.nb_groups group in
let groups = ref [String full] in
for i = 1 to n - 1 do
(try groups := !groups @ [String (Re.Group.get group i)]
with Not_found -> groups := !groups @ [Nil])
done;
List !groups
| None -> Nil
with _ -> Nil)
| _ -> raise (Eval_error "regex-match: pattern and input strings"));
register "regex-match?" (fun args ->
match args with
| [String pattern; String input] ->
(try Bool (Re.execp (Re.Pcre.re pattern |> Re.compile) input)
with _ -> Bool false)
| _ -> raise (Eval_error "regex-match?: pattern and input strings"));
register "regex-find-all" (fun args ->
match args with
| [String pattern; String input] ->
(try
let re = Re.Pcre.re pattern |> Re.compile in
let matches = Re.all re input in
let results = List.map (fun group ->
(* If there's a capture group, return group 1; else full match *)
try String (Re.Group.get group 1)
with Not_found -> String (Re.Group.get group 0)
) matches in
ListRef (ref results)
with _ -> ListRef (ref []))
| _ -> raise (Eval_error "regex-find-all: pattern and input strings"));
register "regex-replace" (fun args ->
match args with
| [String pattern; String replacement; String input] ->
(try
let re = Re.Pcre.re pattern |> Re.compile in
String (Re.replace_string re ~by:replacement input)
with _ -> String input)
| _ -> raise (Eval_error "regex-replace: pattern, replacement, input strings"));
register "regex-replace-first" (fun args ->
match args with
| [String pattern; String replacement; String input] ->
(try
let re = Re.Pcre.re pattern |> Re.compile in
(* Re doesn't have replace_first, so use all matches and replace only first *)
match Re.exec_opt re input with
| Some group ->
let start = Re.Group.start group 0 and stop = Re.Group.stop group 0 in
String (String.sub input 0 start ^ replacement ^
String.sub input stop (String.length input - stop))
| None -> String input
with _ -> String input)
| _ -> raise (Eval_error "regex-replace-first: pattern, replacement, input strings"));
register "regex-split" (fun args ->
match args with
| [String pattern; String input] ->
(try
let re = Re.Pcre.re pattern |> Re.compile in
ListRef (ref (List.map (fun s -> String s) (Re.split re input)))
with _ -> ListRef (ref [String input]))
| _ -> raise (Eval_error "regex-split: pattern and input strings"));
(* === Collections === *)
register "list" (fun args -> ListRef (ref args));

150
spec/tests/test-string-regex.sx Normal file
View File

@@ -0,0 +1,150 @@
;; String/regex primitive tests
(defsuite
"string-char-at"
(deftest "char-at first" (assert= "h" (char-at "hello" 0)))
(deftest "char-at middle" (assert= "l" (char-at "hello" 2)))
(deftest "char-at last" (assert= "o" (char-at "hello" 4)))
(deftest "char-at out of bounds" (assert= nil (char-at "hello" 10)))
(deftest "char-at negative" (assert= nil (char-at "hello" -1))))
(defsuite
"string-char-code"
(deftest "char-code a" (assert= 97 (char-code "a")))
(deftest "char-code A" (assert= 65 (char-code "A")))
(deftest "char-code 0" (assert= 48 (char-code "0")))
(deftest "char-code space" (assert= 32 (char-code " ")))
(deftest
"char-code roundtrip"
(assert= "a" (char-from-code (char-code "a"))))
(deftest
"char-from-code roundtrip"
(assert= 65 (char-code (char-from-code 65)))))
(defsuite
"string-parse-number"
(deftest "parse-number integer" (assert= 42 (parse-number "42")))
(deftest "parse-number float" (assert= 3.14 (parse-number "3.14")))
(deftest "parse-number negative" (assert= -7 (parse-number "-7")))
(deftest
"parse-number negative float"
(assert= -2.5 (parse-number "-2.5")))
(deftest "parse-number zero" (assert= 0 (parse-number "0")))
(deftest
"parse-number invalid returns nil"
(assert= nil (parse-number "abc")))
(deftest "parse-number empty returns nil" (assert= nil (parse-number ""))))
(defsuite
"regex-match"
(deftest
"regex-match simple"
(let
((r (regex-match "h.llo" "hello world")))
(assert (list? r))
(assert= "hello" (first r))))
(deftest "regex-match no match" (assert= nil (regex-match "xyz" "hello")))
(deftest
"regex-match with group"
(let
((r (regex-match "(h)ello" "hello")))
(assert (list? r))
(assert= "hello" (first r))
(assert= "h" (nth r 1))))
(deftest
"regex-match digits"
(let
((r (regex-match "[0-9]+" "abc123def")))
(assert= "123" (first r))))
(deftest
"regex-match anchored"
(assert= nil (regex-match "^world" "hello world")))
(deftest
"regex-match start"
(let
((r (regex-match "^hello" "hello world")))
(assert= "hello" (first r)))))
(defsuite
"regex-match?"
(deftest "regex-match? true" (assert (regex-match? "h.llo" "hello")))
(deftest "regex-match? false" (assert (not (regex-match? "xyz" "hello"))))
(deftest
"regex-match? digit pattern"
(assert (regex-match? "[0-9]" "abc1")))
(deftest
"regex-match? empty pattern"
(assert (regex-match? "" "anything"))))
(defsuite
"regex-find-all"
(deftest
"find-all digits"
(let
((result (regex-find-all "[0-9]" "a1b2c3")))
(assert= 3 (len result))
(assert= "1" (first result))
(assert= "3" (nth result 2))))
(deftest
"find-all words"
(let
((result (regex-find-all "[a-z]+" "hello 123 world")))
(assert= 2 (len result))
(assert= "hello" (first result))
(assert= "world" (nth result 1))))
(deftest
"find-all no matches"
(assert= (list) (regex-find-all "[0-9]" "abc")))
(deftest
"find-all multi-char"
(let
((result (regex-find-all "ab" "xababx")))
(assert= 2 (len result))
(assert= "ab" (first result))
(assert= "ab" (nth result 1)))))
(defsuite
"regex-replace"
(deftest
"replace all digits"
(assert= "a_b_c_" (regex-replace "[0-9]" "_" "a1b2c3")))
(deftest
"replace word"
(assert= "hi hi" (regex-replace "hello" "hi" "hello hello")))
(deftest
"replace no match"
(assert= "hello" (regex-replace "xyz" "!" "hello")))
(deftest
"replace empty pattern"
(assert= "hello" (regex-replace "^$" "!" "hello"))))
(defsuite
"regex-replace-first"
(deftest
"replace-first digit"
(assert= "a_b2c3" (regex-replace-first "[0-9]" "_" "a1b2c3")))
(deftest
"replace-first no match"
(assert= "hello" (regex-replace-first "xyz" "!" "hello"))))
(defsuite
"regex-split"
(deftest
"split on whitespace"
(assert= (list "hello" "world") (regex-split "[ \t]+" "hello world")))
(deftest
"split on comma-space"
(assert= (list "a" "b" "c") (regex-split ", *" "a, b,c")))
(deftest
"split no match"
(assert= (list "hello") (regex-split ";" "hello")))
(deftest
"split digits"
(assert= (list "a" "b" "c") (regex-split "[0-9]+" "a1b23c"))))
(defsuite
"string-split-multichar"
(deftest
"split on multi-char separator"
(assert= (list "a" "b" "c") (split "a::b::c" "::")))
(deftest "split on arrow" (assert= (list "a" "b") (split "a->b" "->"))))