Add Beam.XML.parse backed by OTP xmerl

Author: dannote

lib/quickbeam/beam_api.ex

@@ -1,6 +1,11 @@
 defmodule QuickBEAM.BeamAPI do
   @moduledoc false
   import Bitwise
+  require Record
+
+  Record.defrecord(:xml_element, Record.extract(:xmlElement, from_lib: "xmerl/include/xmerl.hrl"))
+  Record.defrecord(:xml_text, Record.extract(:xmlText, from_lib: "xmerl/include/xmerl.hrl"))
+  Record.defrecord(:xml_attribute, Record.extract(:xmlAttribute, from_lib: "xmerl/include/xmerl.hrl"))
 
   @version Mix.Project.config()[:version]
 
@@ -191,6 +196,15 @@ defmodule QuickBEAM.BeamAPI do
     Kernel.inspect(value, pretty: true, width: 80)
   end
 
+  @spec xml_parse([String.t()]) :: map()
+  def xml_parse([xml]) when is_binary(xml) do
+    {document, _rest} = :xmerl_scan.string(String.to_charlist(xml), quiet: true)
+    %{element_name(document) => convert_element(document)}
+  catch
+    :exit, reason ->
+      raise ArgumentError, "invalid XML: #{Exception.format_exit(reason)}"
+  end
+
   @spec password_hash(list()) :: String.t()
   def password_hash([password, iterations])
       when is_binary(password) and is_integer(iterations) and iterations > 0 do
@@ -252,6 +266,78 @@ defmodule QuickBEAM.BeamAPI do
     end
   end
 
+  defp convert_element(element) do
+    attributes =
+      element
+      |> xml_element(:attributes)
+      |> Enum.reduce(%{}, fn attribute, acc ->
+        Map.put(acc, "@#{attribute_name(attribute)}", attribute_value(attribute))
+      end)
+
+    children =
+      element
+      |> xml_element(:content)
+      |> Enum.reduce(%{text: [], elements: %{}}, &reduce_xml_content/2)
+
+    text =
+      children.text
+      |> Enum.reverse()
+      |> Enum.join(" ")
+      |> String.trim()
+
+    cond do
+      map_size(attributes) == 0 and map_size(children.elements) == 0 ->
+        text
+
+      text == "" ->
+        Map.merge(attributes, children.elements)
+
+      true ->
+        Map.merge(attributes, Map.put(children.elements, "#text", text))
+    end
+  end
+
+  defp reduce_xml_content(content, acc) do
+    cond do
+      match?({:xmlText, _, _, _, _, _}, content) ->
+        case text_value(content) do
+          "" -> acc
+          value -> %{acc | text: [value | acc.text]}
+        end
+
+      match?({:xmlElement, _, _, _, _, _, _, _, _, _, _, _}, content) ->
+        name = element_name(content)
+        value = convert_element(content)
+        %{acc | elements: Map.update(acc.elements, name, value, &merge_xml_children(&1, value))}
+
+      true ->
+        acc
+    end
+  end
+
+  defp merge_xml_children(existing, value) when is_list(existing), do: existing ++ [value]
+  defp merge_xml_children(existing, value), do: [existing, value]
+
+  defp element_name(element) do
+    element |> xml_element(:name) |> Atom.to_string()
+  end
+
+  defp attribute_name(attribute) do
+    attribute |> xml_attribute(:name) |> Atom.to_string()
+  end
+
+  defp attribute_value(attribute) do
+    attribute |> xml_attribute(:value) |> to_string()
+  end
+
+  defp text_value(text) do
+    text
+    |> xml_text(:value)
+    |> to_string()
+    |> String.replace(~r/\s+/, " ")
+    |> String.trim()
+  end
+
   defp escape_html_binary(<<>>, acc), do: acc
 
   defp escape_html_binary(<<"&", rest::binary>>, acc),

priv/ts/beam-api.ts

@@ -131,3 +131,9 @@ Beam.password = {
   verify: (password: string, hash: string): Promise<boolean> =>
     Beam.call('__beam_password_verify', password, hash) as Promise<boolean>,
 }
+
+Beam.XML = {
+  parse(xml: string): unknown {
+    return Beam.callSync('__beam_xml_parse', xml)
+  },
+}

priv/ts/quickbeam.d.ts

@@ -52,6 +52,11 @@ interface BeamPassword {
   verify(password: string, hash: string): Promise<boolean>
 }
 
+interface BeamXML {
+  /** Parse XML using OTP's xmerl and return a JS-friendly object tree. */
+  parse(xml: string): unknown
+}
+
 interface BeamAPI {
   /** Call a named BEAM handler (async). Returns a Promise with the result. */
   call(handler: string, ...args: unknown[]): Promise<unknown>
@@ -151,6 +156,9 @@ interface BeamAPI {
 
   /** Password hashing and verification via PBKDF2-SHA256. */
   password: BeamPassword
+
+  /** XML parsing backed by OTP's xmerl. */
+  XML: BeamXML
 }
 
 declare const Beam: BeamAPI

test/core/beam_api_test.exs

@@ -512,6 +512,41 @@ defmodule QuickBEAM.Core.BeamAPITest do
     end
   end
 
+  describe "Beam.XML" do
+    test "parses text-only elements", %{rt: rt} do
+      {:ok, result} = QuickBEAM.eval(rt, ~s[Beam.XML.parse("<root><name>Dan</name></root>")])
+      assert result == %{"root" => %{"name" => "Dan"}}
+    end
+
+    test "parses attributes and repeated children", %{rt: rt} do
+      xml = ~s[<root version="1.0"><item id="1">hello</item><item id="2">world</item></root>]
+      {:ok, result} = QuickBEAM.eval(rt, "Beam.XML.parse(#{inspect(xml)})")
+
+      assert result == %{
+               "root" => %{
+                 "@version" => "1.0",
+                 "item" => [
+                   %{"@id" => "1", "#text" => "hello"},
+                   %{"@id" => "2", "#text" => "world"}
+                 ]
+               }
+             }
+    end
+
+    test "parses empty elements as empty strings", %{rt: rt} do
+      {:ok, result} = QuickBEAM.eval(rt, ~s[Beam.XML.parse("<root><empty /></root>")])
+      assert result == %{"root" => %{"empty" => ""}}
+    end
+
+    test "rejects malformed XML", %{rt: rt} do
+      assert {:error, %QuickBEAM.JSError{message: message}} =
+               QuickBEAM.eval(rt, ~s[Beam.XML.parse("<root><broken></root>")])
+
+
+      assert message =~ "invalid XML"
+    end
+  end
+
   describe "Beam.inspect" do
     test "inspects a number", %{rt: rt} do
       {:ok, result} = QuickBEAM.eval(rt, "Beam.inspect(42)")