How does Erlsom compare to Xmerl for XML parsing in Erlang?

Erlsom offers SAX-based streaming and data binding with XSD validation, while Xmerl provides a DOM-based approach with XPath support. Erlsom is better for large documents and schema-aware parsing, but Xmerl might be preferred for XPath queries and familiarity with its simple form.

How to parse a huge XML file with Erlsom without loading it all into memory?

Use the SAX parser with chunked parsing by implementing a continuation function that returns data in blocks, as shown in the 'continuation' example in the distribution. This allows incremental processing of streaming XML.

Does Erlsom support XML namespaces in data binding mode?

Yes, Erlsom handles namespaces by prefixing elements and attributes in the output, as demonstrated in the misc.xsd example where a prefix parameter is used during XSD compilation.

What are the main limitations of Erlsom's data binder mode?

It ignores many XSD constraints like enumerations and patterns, treats most simple types as strings, and doesn't enforce fixed attributes or key constraints, limiting strict validation as admitted in the Limitations section.

How to generate XML from Erlang records using Erlsom?

Compile an XSD model with erlsom:compile_xsd_file, then use erlsom:write to map Erlang records back to XML, ensuring schema compliance, as illustrated in the erlsom_example.

Is Erlsom good for handling character encodings automatically?

Yes, it automatically detects UTF-8, UTF-16, ISO-8859-1, and ISO-8859-15 encodings from byte order marks or XML declarations, but throws an error for unsupported charsets, requiring manual extension for others.

erlsom

LGPL-3.0Erlangv1.5.2

An Erlang library for parsing and generating XML documents with SAX, simple DOM, and data binding modes.

GitHub

What is erlsom?

Erlsom is an XML parser and generator for Erlang that provides multiple parsing modes to handle XML documents efficiently and flexibly. It solves the problem of processing XML in Erlang by offering SAX-based streaming for large documents, a simple DOM-like structure for easy access, and data binding with XSD schema validation for type-aware output. It is designed to integrate well with Erlang's concurrency model and functional programming paradigms.

Target Audience

Erlang developers working with XML data, particularly those needing to parse large or streaming XML documents, validate XML against schemas, or generate XML from Erlang data structures. It is also suitable for developers building systems like SOAP services, configuration file parsers, or data integration tools in Erlang.

Value Proposition

Developers choose Erlsom over alternatives because it offers a unique combination of SAX streaming for memory-efficient parsing, direct binary support for performance, and data binding with XSD validation for structured output. Its flexibility in handling different parsing modes and seamless integration with Erlang's concurrency model makes it a versatile choice for XML processing in Erlang applications.

Overview

XML parser for Erlang

Use Cases

Best For

Related Projects

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub

269 stars107 forks0 contributors

Parsing large or streaming XML documents that do not fit into memory, using its SAX parser with chunked input support.
Validating XML against XSD schemas and mapping it to Erlang records for type-safe data access in applications like configuration files or data exchanges.
Generating XML from Erlang data structures, especially when combined with schema-based validation for output consistency.
Processing XML in concurrent Erlang systems, leveraging its SAX foundation that aligns with functional and parallel processing patterns.
Handling XML with various character encodings (UTF-8, UTF-16, ISO-8859-1, ISO-8859-15) without manual conversion, optimizing for internationalization.
Integrating XML parsing into Erlang projects where performance with binaries is critical, avoiding list conversions for speed and memory efficiency.

Not Ideal For

Projects requiring strict XSD validation with full support for enumerations, patterns, and other facets, as Erlsom ignores many of these checks.
Systems that need to process XML with external entities or rely on DTD validation, since the SAX parser ignores DTDs and doesn't support external entities.
Applications where uncontrolled atom creation from user input is a security or stability risk, especially in internet-facing services, as compiling XSDs can create new atoms.
Teams looking for a drop-in XML library with extensive community support and plug-and-play documentation; Erlsom requires deeper Erlang expertise and manual setup in some cases.

Pros & Cons

Pros

Flexible Parsing Modes

Offers SAX for streaming, simple DOM for easy access, and data binder for schema-based validation, allowing developers to choose the right approach for their use case, as detailed in the README's examples.

Efficient Large Document Handling

SAX parser with chunked input supports processing XML documents that don't fit in memory, ideal for streaming or big data scenarios, demonstrated in the 'continuation' example.

Performance with Binaries

Works directly on binaries (latin-1, utf-8, utf-16) without conversion to lists, optimizing memory and speed in Erlang 12B or later, as noted in the introduction.

Built-in Encoding Detection

Automatically detects and handles UTF-8, UTF-16, ISO-8859-1, and ISO-8859-15 encodings, simplifying internationalization without manual configuration.

Cons

Limited Schema Validation

Many XSD features like enumerations, patterns, fixed attributes, and key constraints are ignored, reducing validation rigor—the README explicitly lists these limitations in tables.

No External Entity Support

SAX parser does not support external entities and ignores DTDs, which can be a critical gap for XML standards that rely on these features.

Potential Atom Exhaustion

Compiling XSDs creates new atoms, which in uncontrolled environments could lead to system crashes due to Erlang's atom table limits, as warned in the 'Creation of atoms' section.

Frequently Asked Questions

Home

Elixir

sweet_xml

SweetXml is an Elixir library that simplifies working with XML by providing a clean, expressive API for querying and converting XML documents into native Elixir data structures like maps, lists, strings, and numbers. It wraps the Erlang :xmerl module, making XML parsing more accessible and intuitive for Elixir developers. ## Key Features - **XPath Sigil** — Use the `~x` sigil to write concise XPath 1.0 queries with modifiers for lists, strings, integers, and optional nodes. - **Nested Mapping** — Transform complex XML hierarchies into nested Elixir maps and keyword lists directly in query specifications. - **Streaming Support** — Parse large XML documents efficiently using Elixir streams with tag-based streaming and memory management options. - **Namespace Handling** — Work with XML namespaces by adding custom prefixes regardless of the document's original namespace declarations. - **Value Transformation** — Apply custom transformation functions to extracted values using `transform_by/2` for data cleanup or formatting. - **Security Options** — Separate parsing from mapping to apply security settings like disabling DTD processing for untrusted documents. ## Philosophy SweetXml aims to make XML parsing in Elixir as straightforward as possible, providing a thin, idiomatic layer over :xmerl that emphasizes simplicity, composability, and safety.

Stars375

Forks64

Last commit2 months ago