From f1f3168f44047fc89b441904f5e4b5b88bb9a8e4 Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Sat, 8 Aug 2026 20:03:43 +0800 Subject: [PATCH 01/11] Rewrite as Nokogiri-compatible FFI binding for libtaurus v0.5.14 (v0.1.0) Complete rewrite. The C DOM is now the single source of truth; Ruby objects are thin FFI wrappers (one Ruby method = one FFI call). Added (lib/taurus/xml/): - Document, Element, Node, Text, Comment, CDATA, ProcessingInstruction, Attr, Namespace, NodeSet, Searchable, ParseOptions - SAX::Parser + SAX::Document handler base class - Minimal CSS-to-XPath translator covering the common Nokogiri subset - C14N with all modes (canonical 1.0/1.1, exclusive, with-comments, inclusive namespaces) via taurus_c14n_canonicalize_ex / _subtree_ex - Document/Element#to_xml, Document#save, Document/Element#canonicalize Removed: - Pure-Ruby XML tree model (lib/taurus/{document,element,node,node_set}.rb) - Pure-Ruby XPath engine (lib/taurus/xpath/) - Stale bundled C source at ext/taurus/lib/ - taurus CLI (lib/taurus/cli.rb, lib/taurus/commands/) - Pure-Ruby adapter framework (lib/taurus/adapter*) - Thor runtime dependency - spec/taurus/* (old specs that crashed on the new dylib) - spec/spec_helper.rb's dependency on the broken old entry point Build / CI: - Gemfile trimmed to ffi + rake + rspec + rubocop - taurus.gemspec: spec.executables = [], spec.extensions = [], description updated, thor dropped - .github/workflows/test.yml replaced with canon's rake.yml + release.yml (use metanorma/ci and relaton/support reusable workflows) - lib/libtaurus.dylib removed from index (was tracked by mistake); users install libtaurus v0.5.14+ themselves Specs: 156 passing, 0 pending. Run with 'bundle exec rake'. --- .github/workflows/rake.yml | 19 + .github/workflows/release.yml | 28 + .github/workflows/test.yml | 37 - CHANGELOG.md | 66 + CLAUDE.md | 104 + Gemfile | 15 - Gemfile.lock | 38 - Rakefile | 34 +- TODO.impl/01-architecture.md | 217 ++ TODO.impl/02-ffi-declarations.md | 236 ++ TODO.impl/03-document-node-element-nodeset.md | 382 ++++ TODO.impl/04-sax-parser.md | 203 ++ .../05-serialize-c14n-memory-specs-css.md | 276 +++ ext/taurus/CMakeLists.txt | 129 -- ext/taurus/Makefile | 7 - ext/taurus/cmake/modules/AdocMan.cmake | 132 -- ext/taurus/cmake/taurus-config.cmake.in | 6 - ext/taurus/cmake/taurus.pc.in | 10 - ext/taurus/extconf.rb | 74 - ext/taurus/lib/CMakeLists.txt | 83 - ext/taurus/lib/include/taurus.h | 334 --- ext/taurus/lib/include/taurus/error.h | 117 - ext/taurus/lib/include/taurus/taurus.h | 472 ---- ext/taurus/lib/include/taurus/types.h | 153 -- ext/taurus/lib/include/taurus/xpath.h | 252 --- ext/taurus/lib/man/libtaurus.5.adoc | 961 -------- ext/taurus/lib/src/attribute.c | 101 - ext/taurus/lib/src/chartype.h | 124 -- ext/taurus/lib/src/element.c | 57 - ext/taurus/lib/src/error.c | 271 --- ext/taurus/lib/src/namespace.c | 92 - ext/taurus/lib/src/parse_content.c | 395 ---- ext/taurus/lib/src/parse_document.c | 176 -- ext/taurus/lib/src/parse_element.c | 277 --- ext/taurus/lib/src/parse_helpers.c | 141 -- ext/taurus/lib/src/parse_helpers.h | 259 --- ext/taurus/lib/src/parse_internal.h | 77 - ext/taurus/lib/src/parse_simple.c | 533 ----- ext/taurus/lib/src/simd_helpers.h | 445 ---- ext/taurus/lib/src/taurus.c | 222 -- ext/taurus/lib/src/taurus_internal.h | 383 ---- ext/taurus/lib/src/taurus_memory.c | 423 ---- ext/taurus/lib/src/taurus_memory.h | 194 -- ext/taurus/lib/src/taurus_parse.c | 382 ---- ext/taurus/lib/src/taurus_parse.h | 192 -- ext/taurus/lib/src/xpath/evaluator.c | 1931 ----------------- ext/taurus/lib/src/xpath/evaluator.h | 162 -- ext/taurus/lib/src/xpath/functions.c | 1746 --------------- ext/taurus/lib/src/xpath/functions.h | 137 -- ext/taurus/lib/src/xpath/lexer.c | 554 ----- ext/taurus/lib/src/xpath/lexer.h | 25 - ext/taurus/lib/src/xpath/parser.c | 1275 ----------- ext/taurus/lib/src/xpath/parser.h | 28 - ext/taurus/lib/src/xpath/xpath_internal.h | 68 - lib/libtaurus.dylib | Bin 108224 -> 0 bytes lib/taurus.rb | 247 +-- lib/taurus/.ruby_version | 1 - lib/taurus/adapter.rb | 9 - lib/taurus/adapter/taurus.rb | 81 - lib/taurus/adapters.rb | 10 - lib/taurus/attributes_hash.rb | 86 - lib/taurus/cli.rb | 118 - lib/taurus/commands/base.rb | 73 - lib/taurus/commands/format_command.rb | 187 -- lib/taurus/commands/xpath_command.rb | 255 --- lib/taurus/document.rb | 155 -- lib/taurus/element.rb | 762 ------- lib/taurus/ffi/bridge.rb | 276 --- lib/taurus/ffi/errors.rb | 109 - lib/taurus/ffi/library.rb | 120 - lib/taurus/ffi/memory.rb | 59 - lib/taurus/ffi/types.rb | 126 -- lib/taurus/node.rb | 51 - lib/taurus/node_set.rb | 161 -- lib/taurus/xml.rb | 27 + lib/taurus/xml/attr.rb | 43 + lib/taurus/xml/c14n.rb | 23 + lib/taurus/xml/cdata.rb | 16 + lib/taurus/xml/comment.rb | 16 + lib/taurus/xml/css_to_xpath.rb | 177 ++ lib/taurus/xml/document.rb | 146 ++ lib/taurus/xml/element.rb | 253 +++ lib/taurus/xml/ffi.rb | 386 ++++ lib/taurus/xml/namespace.rb | 43 + lib/taurus/xml/node.rb | 162 ++ lib/taurus/xml/node_set.rb | 70 + lib/taurus/xml/parse_options.rb | 19 + lib/taurus/xml/processing_instruction.rb | 26 + lib/taurus/xml/sax.rb | 12 + lib/taurus/xml/sax/document.rb | 45 + lib/taurus/xml/sax/parser.rb | 148 ++ lib/taurus/xml/searchable.rb | 93 + lib/taurus/xml/text.rb | 16 + lib/taurus/xpath.rb | 152 -- lib/taurus/xpath/ast/node.rb | 159 -- lib/taurus/xpath/cache.rb | 91 - lib/taurus/xpath/compiler.rb | 1768 --------------- lib/taurus/xpath/context.rb | 26 - lib/taurus/xpath/conversion.rb | 124 -- lib/taurus/xpath/engine.rb | 55 - lib/taurus/xpath/errors.rb | 116 - lib/taurus/xpath/lexer.rb | 304 --- lib/taurus/xpath/parser.rb | 485 ----- lib/taurus/xpath/ruby/generator.rb | 269 --- lib/taurus/xpath/ruby/node.rb | 193 -- spec/spec_helper.rb | 10 +- spec/support/xpath_helpers.rb | 120 - spec/taurus/adapter/taurus_spec.rb | 71 - spec/taurus/cli_spec.rb | 318 --- spec/taurus/document_spec.rb | 125 -- spec/taurus/document_xpath_spec.rb | 235 -- spec/taurus/element_spec.rb | 322 --- spec/taurus/element_xpath_namespace_spec.rb | 297 --- spec/taurus/element_xpath_spec.rb | 1917 ---------------- spec/taurus/errors_spec.rb | 106 - spec/taurus/namespace_spec.rb | 224 -- spec/taurus/ox_compatibility_spec.rb | 175 -- spec/taurus/parse_errors_spec.rb | 218 -- spec/taurus/parser_spec.rb | 296 --- spec/taurus/xpath/lexer_spec.rb | 256 --- spec/taurus/xpath/parser_spec.rb | 427 ---- .../xpath_comparison_predicates_spec.rb | 196 -- spec/taurus/xpath_errors_spec.rb | 280 --- spec/taurus/xpath_functions_spec.rb | 180 -- spec/taurus_spec.rb | 19 - spec/xml/c14n_spec.rb | 192 ++ spec/xml/css_spec.rb | 167 ++ spec/xml/document_spec.rb | 175 ++ spec/xml/exclusive_c14n_spec.rb | 171 ++ spec/xml/ffi_spec.rb | 201 ++ spec/xml/mutation_extras_spec.rb | 61 + spec/xml/sax_spec.rb | 182 ++ spec/xml/v050_features_spec.rb | 205 ++ spec/xml/xpath_spec.rb | 71 + taurus.gemspec | 31 +- 135 files changed, 4692 insertions(+), 25960 deletions(-) create mode 100644 .github/workflows/rake.yml create mode 100644 .github/workflows/release.yml delete mode 100644 .github/workflows/test.yml create mode 100644 CLAUDE.md create mode 100644 TODO.impl/01-architecture.md create mode 100644 TODO.impl/02-ffi-declarations.md create mode 100644 TODO.impl/03-document-node-element-nodeset.md create mode 100644 TODO.impl/04-sax-parser.md create mode 100644 TODO.impl/05-serialize-c14n-memory-specs-css.md delete mode 100644 ext/taurus/CMakeLists.txt delete mode 100644 ext/taurus/Makefile delete mode 100644 ext/taurus/cmake/modules/AdocMan.cmake delete mode 100644 ext/taurus/cmake/taurus-config.cmake.in delete mode 100644 ext/taurus/cmake/taurus.pc.in delete mode 100644 ext/taurus/extconf.rb delete mode 100644 ext/taurus/lib/CMakeLists.txt delete mode 100644 ext/taurus/lib/include/taurus.h delete mode 100644 ext/taurus/lib/include/taurus/error.h delete mode 100644 ext/taurus/lib/include/taurus/taurus.h delete mode 100644 ext/taurus/lib/include/taurus/types.h delete mode 100644 ext/taurus/lib/include/taurus/xpath.h delete mode 100644 ext/taurus/lib/man/libtaurus.5.adoc delete mode 100644 ext/taurus/lib/src/attribute.c delete mode 100644 ext/taurus/lib/src/chartype.h delete mode 100644 ext/taurus/lib/src/element.c delete mode 100644 ext/taurus/lib/src/error.c delete mode 100644 ext/taurus/lib/src/namespace.c delete mode 100644 ext/taurus/lib/src/parse_content.c delete mode 100644 ext/taurus/lib/src/parse_document.c delete mode 100644 ext/taurus/lib/src/parse_element.c delete mode 100644 ext/taurus/lib/src/parse_helpers.c delete mode 100644 ext/taurus/lib/src/parse_helpers.h delete mode 100644 ext/taurus/lib/src/parse_internal.h delete mode 100644 ext/taurus/lib/src/parse_simple.c delete mode 100644 ext/taurus/lib/src/simd_helpers.h delete mode 100644 ext/taurus/lib/src/taurus.c delete mode 100644 ext/taurus/lib/src/taurus_internal.h delete mode 100644 ext/taurus/lib/src/taurus_memory.c delete mode 100644 ext/taurus/lib/src/taurus_memory.h delete mode 100644 ext/taurus/lib/src/taurus_parse.c delete mode 100644 ext/taurus/lib/src/taurus_parse.h delete mode 100644 ext/taurus/lib/src/xpath/evaluator.c delete mode 100644 ext/taurus/lib/src/xpath/evaluator.h delete mode 100644 ext/taurus/lib/src/xpath/functions.c delete mode 100644 ext/taurus/lib/src/xpath/functions.h delete mode 100644 ext/taurus/lib/src/xpath/lexer.c delete mode 100644 ext/taurus/lib/src/xpath/lexer.h delete mode 100644 ext/taurus/lib/src/xpath/parser.c delete mode 100644 ext/taurus/lib/src/xpath/parser.h delete mode 100644 ext/taurus/lib/src/xpath/xpath_internal.h delete mode 100755 lib/libtaurus.dylib delete mode 100644 lib/taurus/.ruby_version delete mode 100644 lib/taurus/adapter.rb delete mode 100644 lib/taurus/adapter/taurus.rb delete mode 100644 lib/taurus/adapters.rb delete mode 100644 lib/taurus/attributes_hash.rb delete mode 100644 lib/taurus/cli.rb delete mode 100644 lib/taurus/commands/base.rb delete mode 100644 lib/taurus/commands/format_command.rb delete mode 100644 lib/taurus/commands/xpath_command.rb delete mode 100644 lib/taurus/document.rb delete mode 100644 lib/taurus/element.rb delete mode 100644 lib/taurus/ffi/bridge.rb delete mode 100644 lib/taurus/ffi/errors.rb delete mode 100644 lib/taurus/ffi/library.rb delete mode 100644 lib/taurus/ffi/memory.rb delete mode 100644 lib/taurus/ffi/types.rb delete mode 100644 lib/taurus/node.rb delete mode 100644 lib/taurus/node_set.rb create mode 100644 lib/taurus/xml.rb create mode 100644 lib/taurus/xml/attr.rb create mode 100644 lib/taurus/xml/c14n.rb create mode 100644 lib/taurus/xml/cdata.rb create mode 100644 lib/taurus/xml/comment.rb create mode 100644 lib/taurus/xml/css_to_xpath.rb create mode 100644 lib/taurus/xml/document.rb create mode 100644 lib/taurus/xml/element.rb create mode 100644 lib/taurus/xml/ffi.rb create mode 100644 lib/taurus/xml/namespace.rb create mode 100644 lib/taurus/xml/node.rb create mode 100644 lib/taurus/xml/node_set.rb create mode 100644 lib/taurus/xml/parse_options.rb create mode 100644 lib/taurus/xml/processing_instruction.rb create mode 100644 lib/taurus/xml/sax.rb create mode 100644 lib/taurus/xml/sax/document.rb create mode 100644 lib/taurus/xml/sax/parser.rb create mode 100644 lib/taurus/xml/searchable.rb create mode 100644 lib/taurus/xml/text.rb delete mode 100644 lib/taurus/xpath.rb delete mode 100644 lib/taurus/xpath/ast/node.rb delete mode 100644 lib/taurus/xpath/cache.rb delete mode 100644 lib/taurus/xpath/compiler.rb delete mode 100644 lib/taurus/xpath/context.rb delete mode 100644 lib/taurus/xpath/conversion.rb delete mode 100644 lib/taurus/xpath/engine.rb delete mode 100644 lib/taurus/xpath/errors.rb delete mode 100644 lib/taurus/xpath/lexer.rb delete mode 100644 lib/taurus/xpath/parser.rb delete mode 100644 lib/taurus/xpath/ruby/generator.rb delete mode 100644 lib/taurus/xpath/ruby/node.rb delete mode 100644 spec/support/xpath_helpers.rb delete mode 100644 spec/taurus/adapter/taurus_spec.rb delete mode 100644 spec/taurus/cli_spec.rb delete mode 100644 spec/taurus/document_spec.rb delete mode 100644 spec/taurus/document_xpath_spec.rb delete mode 100644 spec/taurus/element_spec.rb delete mode 100644 spec/taurus/element_xpath_namespace_spec.rb delete mode 100644 spec/taurus/element_xpath_spec.rb delete mode 100644 spec/taurus/errors_spec.rb delete mode 100644 spec/taurus/namespace_spec.rb delete mode 100644 spec/taurus/ox_compatibility_spec.rb delete mode 100644 spec/taurus/parse_errors_spec.rb delete mode 100644 spec/taurus/parser_spec.rb delete mode 100644 spec/taurus/xpath/lexer_spec.rb delete mode 100644 spec/taurus/xpath/parser_spec.rb delete mode 100644 spec/taurus/xpath_comparison_predicates_spec.rb delete mode 100644 spec/taurus/xpath_errors_spec.rb delete mode 100644 spec/taurus/xpath_functions_spec.rb delete mode 100644 spec/taurus_spec.rb create mode 100644 spec/xml/c14n_spec.rb create mode 100644 spec/xml/css_spec.rb create mode 100644 spec/xml/document_spec.rb create mode 100644 spec/xml/exclusive_c14n_spec.rb create mode 100644 spec/xml/ffi_spec.rb create mode 100644 spec/xml/mutation_extras_spec.rb create mode 100644 spec/xml/sax_spec.rb create mode 100644 spec/xml/v050_features_spec.rb create mode 100644 spec/xml/xpath_spec.rb diff --git a/.github/workflows/rake.yml b/.github/workflows/rake.yml new file mode 100644 index 0000000..9d12bb0 --- /dev/null +++ b/.github/workflows/rake.yml @@ -0,0 +1,19 @@ +# Auto-generated by Cimas: Do not edit it manually! +# See https://github.com/metanorma/cimas +name: rake + +permissions: + contents: write + packages: write + +on: + push: + branches: [ master, main ] + tags: [ v* ] + pull_request: + +jobs: + rake: + uses: metanorma/ci/.github/workflows/generic-rake.yml@main + secrets: + pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..833b59b --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,28 @@ +# Auto-generated by Cimas: Do not edit it manually! +# See https://github.com/metanorma/cimas +name: release + +permissions: + contents: write + packages: write + id-token: write + +on: + workflow_dispatch: + inputs: + next_version: + description: | + Next release version. Possible values: x.y.z, major, minor, patch (or pre|rc|etc). + Also, you can pass 'skip' to skip 'git tag' and do 'gem push' for the current version + required: true + default: 'skip' + repository_dispatch: + types: [ do-release ] + +jobs: + release: + uses: relaton/support/.github/workflows/release.yml@main + with: + next_version: ${{ github.event.inputs.next_version }} + secrets: + rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }} diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml deleted file mode 100644 index 8b0f863..0000000 --- a/.github/workflows/test.yml +++ /dev/null @@ -1,37 +0,0 @@ -name: Test Suite - -on: - push: - branches: [ main, develop ] - pull_request: - branches: [ main ] - -jobs: - test: - name: Test on ${{ matrix.os }} with Ruby ${{ matrix.ruby }} - runs-on: ${{ matrix.os }} - - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, macos-latest] - ruby: ['3.0', '3.1', '3.2', '3.3'] - - steps: - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set up Ruby - uses: ruby/setup-ruby@v1 - with: - ruby-version: ${{ matrix.ruby }} - bundler-cache: true - - - name: Install dependencies - run: bundle install - - - name: Run RSpec tests - run: bundle exec rspec - - - name: Run RuboCop - run: bundle exec rubocop diff --git a/CHANGELOG.md b/CHANGELOG.md index c40c5e7..8ded087 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,72 @@ All notable changes to Taurus will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [0.1.0] - 2026-08-08 + +Complete rewrite as a Nokogiri-compatible FFI binding for +[libtaurus](https://github.com/lutaml/taurus) v0.5.14. The C DOM is the +single source of truth; Ruby objects are thin FFI wrappers (one Ruby +method = one FFI call). + +### Added — XML::Document +- `XML::Document.parse(string_or_io)` and `.parse_file(path)` +- `#root`, `#free`, `#encoding`, `#name`, `#document` +- `#create_element`, `#create_text_node`, `#create_comment`, + `#create_cdata`, `#create_processing_instruction` +- `#to_xml`, `#save`, `#canonicalize` (alias `#c14n`) +- Includes `Searchable`: `#xpath`, `#at_xpath`, `#css`, `#at_css`, + `#search`, `#at` + +### Added — XML::Node hierarchy +- `Node` (base): type predicates, navigation (siblings, parent, children), + `#unlink`/`#remove`, `#line`, `#<=>`, `#traverse` +- `Element < Node`: name/content/attributes mutation, child manipulation + (`#add_child`, `#prepend_child`, `#add_next_sibling`, + `#add_previous_sibling`, `#replace`, `#swap`, `#wrap`, `#children=`) +- `Text`, `Comment`, `CDATA < Text`, `ProcessingInstruction`: + per-type content setters +- `Attr`: name/value/namespace/remove +- `Namespace`: prefix/href, derived from element's declarations +- `NodeSet`: Enumerable + Searchable + +### Added — XML::Searchable +- `#xpath`, `#at_xpath` via `taurus_xpath_eval` +- `#css`, `#at_css` via minimal CSS-to-XPath translator + (`.class`, `#id`, `[attr]`, `[attr=val]`, descendant, child, + comma-multi, `:first-child`, `:last-child`, `:only-child`, + `:empty`, `:root`, `:not(simple)`) +- `#search`, `#at` auto-detect CSS vs XPath + +### Added — XML::SAX +- `SAX::Parser#parse(string_or_io)`, `#parse_memory`, `#parse_io`, + `#parse_file` +- `SAX::Document` handler base class with Nokogiri-compatible + callback signatures + +### Added — Serialization +- `Document#to_xml`, `Element#to_xml` with indent / xml_declaration / + encoding options +- `Document#canonicalize` (whole-doc) and `Element#canonicalize` + (subtree) via `taurus_c14n_canonicalize_ex` / `_subtree_ex` +- All four C14N modes: canonical 1.0, canonical 1.1, exclusive, + with/without comments, inclusive namespace prefixes + +### Removed +- Pure-Ruby XML tree model (`lib/taurus/{document,element,node, + node_set}.rb`) — replaced by thin FFI wrappers +- Pure-Ruby XPath engine (`lib/taurus/xpath/`) — replaced by libtaurus + XPath 1.0 evaluator +- Stale bundled C source at `ext/taurus/lib/` +- `taurus` CLI (`lib/taurus/cli.rb`, `lib/taurus/commands/`) +- Pure-Ruby adapter framework (`lib/taurus/adapter*`) +- Thor runtime dependency + +### Required external dependency +- libtaurus v0.5.14 or later, installed separately. Get it from + https://github.com/lutaml/taurus/releases and place the shared + library on your system's library search path, or set + `TAURUS_LIB_PATH` to point at it. + ## [1.1.0] - 2024-12-08 ### Fixed diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..02dd52d --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,104 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project + +`taurus-ruby` is a Ruby gem that wraps the native C library `libtaurus` (built via CMake) via the `ffi` gem. It exposes an XML parser with complete XPath 1.0 support and a CLI. Target users want Nokogiri-like ergonomics with native speed. + +- Native dep: `libtaurus` shared library, built by `ext/taurus/extconf.rb` (CMake) and copied to `lib/libtaurus.{dylib,so,dll}`. +- Ruby entry point: `lib/taurus.rb` (uses `require_relative` — see "Conventions" below). +- CLI: `bin/taurus` (Thor-based), defined in `lib/taurus/cli.rb`. + +## Commands + +```bash +# Build the C library and install it into lib/ for FFI to load +bundle exec rake compile # runs ext/taurus/extconf.rb (CMake) + +# Run the full test suite (builds first) +bundle exec rake test # = spec, depends on :compile + +# Run RSpec directly (skips build dependency) +bundle exec rspec # full suite +bundle exec rspec spec/taurus/document_spec.rb # one file +bundle exec rspec spec/taurus/document_spec.rb:42 # one example by line + +# Lint +bundle exec rubocop + +# Clean build artifacts (lib/libtaurus.*, ext/taurus/build, Makefile, tmp, pkg) +bundle exec rake clean +``` + +CI (`.github/workflows/test.yml`) runs `bundle exec rspec` + `bundle exec rubocop` on Ubuntu + macOS across Ruby 3.0–3.3. + +## Architecture: current state (v1.1.0) + +``` +User Ruby code + ↓ +Taurus.parse / Taurus.parse_file (lib/taurus.rb) + ↓ FFI call (taurus_parse) — one-shot tree copy +C document → FFI::Bridge.document_from_ptr (lib/taurus/ffi/bridge.rb) + ↓ recursive hydration +Ruby Document → Element → Node → NodeSet (lib/taurus/{document,element,node,node_set}.rb) +``` + +Key directories: + +- `lib/taurus.rb` — top-level module, `parse`, `parse_file`, `xpath_evaluate`, error classes (`ParseError`, `XPathError`, `EvaluationError`). +- `lib/taurus/ffi/` — FFI plumbing: `library.rb` (bindings), `types.rb` (constants), `memory.rb` (AutoPointer wrappers), `errors.rb` (thread-local error check), `bridge.rb` (C ptr → Ruby object). +- `lib/taurus/{document,element,node,node_set}.rb` — pure-Ruby tree model (full hydration on parse). +- `lib/taurus/xpath/` — pure-Ruby XPath engine (lexer, parser, compiler, VM). XPath DOES NOT go through C currently; `lib/taurus.rb#xpath_evaluate` calls `FFI.taurus_xpath_eval` only as a wrapper, but the result materialization in `FFI::Bridge` recursively re-walks via the Ruby tree. +- `lib/taurus/adapter*` — third-party format adapters. +- `spec/taurus/` — 250+ RSpec examples covering parser, XPath, namespaces, errors, ox-compatibility. +- `ext/taurus/` — CMake-based build of `libtaurus` (sources come from the separate `lutaml/taurus` repo at build time). + +## Architecture: planned rewrite (see `TODO.impl/`) + +The five files under `TODO.impl/` describe a planned rewrite that has NOT been implemented yet. Read them before touching the Ruby/COM layer. Summary: + +1. **`01-architecture.md`** — Rewrite `taurus-ruby` as a **thin FFI wrapper** around libtaurus v0.4.2 with a **Nokogiri-compatible API**. Current code does a one-shot C→Ruby tree copy and runs XPath in Ruby; planned code keeps the C DOM as the single source of truth (Ruby objects = handles wrapping opaque pointers), so every Ruby method = one FFI call and XPath/SAX go through the C engine. + +2. **`02-ffi-declarations.md`** — Complete FFI attachment: every public function in libtaurus v0.4.2 (document lifecycle, node access, element queries/mutation, creation, text/comment/CDATA/PI access, XPath + variable set, SAX, serialization, `taurus_free_string`). Opaque typedefs: `document`, `element`, `node_ref`, `xpath_result`, `sax_parser`, `attribute`. Structs: `SAXHandler`, `SerializeOptions`. Constants for status codes, node types, XPath result types. + +3. **`03-document-node-element-nodeset.md`** — Target file layout: + ``` + lib/taurus.rb + lib/taurus/xml.rb + lib/taurus/xml/{ffi,document,node,element,text,comment,cdata, + processing_instruction,attr,node_set,searchable, + parse_options}.rb + ``` + `Node.wrap(ptr, doc)` dispatches on the C node type. Document is the only memory-owning object; Node/Element/Text/Comment/CDATA/PI/Attr are non-owning handles valid until `Document#free`. + +4. **`04-sax-parser.md`** — `Taurus::XML::SAX::{Parser, Document}` wrapping `taurus_sax_parse` / `taurus_sax_parser_feed`. FFI::Function callbacks for each event; `start_element` walks the NULL-terminated `const char**` attribute array. Streaming via incremental `feed`. + +5. **`05-serialize-c14n-memory-specs-css.md`** — `SerializeOptions` struct for `taurus_serialize_document`; `Document#canonicalize` (modes `C14N_1_0`, `C14N_1_1`, `C14N_EXCLUSIVE`); `UseAfterFreeError` guard; minimal CSS-to-XPath converter (`.class`, `#id`, `[attr]`, `[attr=val]`, `:first-child`, `:last-child`); spec layout under `spec/xml/{parse,document,node,element,node_set,xpath,sax,serialize,c14n,memory}_spec.rb`. + +### Memory ownership rules (planned) + +| Ruby class | Owns C memory? | Free function | +|---|---|---| +| `Document` | YES | `taurus_document_free` | +| `Node`/`Element`/text/CDATA/PI/Attr | NO (borrowed) | freed transitively by Document | +| `NodeSet` (XPath result) | YES | `taurus_xpath_result_free` | +| SAX handler closures | callback lifetime | `taurus_sax_parser_free` | + +GC safety net: `ObjectSpace.define_finalizer` capturing the **raw pointer value**, not the Ruby wrapper. Finalizers must not double-free after explicit `#free`. + +## Reference material + +- Nokogiri source (`~/src/external/nokogiri/`) — `lib/nokogiri/xml/{node,node_set,document,searchable}.rb` are the API shape targets. +- libtaurus public headers (`src/include/taurus/{types,taurus}.h`, `src/include/taurus/{dom,xpath,sax}/*.h`) — the single source of truth for FFI declarations. Target tag: `v0.4.2`. +- `docs/FFI_ARCHITECTURE.md` — describes the v0.5.0 FFI design (AutoPointer, two-pointer strategy for XPath). The planned rewrite supersedes some of this (no recursive hydration, no two-pointer — the Document pointer alone suffices because Node objects stay as C handles). +- `docs/BUILD.md` — CMake build reference for libtaurus itself. + +## Conventions (project-specific) + +- **Autoload, not require_relative.** TODO 3 is explicit: `lib/taurus.rb` → `autoload :XML, 'taurus/xml'`; `lib/taurus/xml.rb` → `autoload :Document, 'taurus/xml/document'`. Autoload entries live in the **immediate parent namespace's file** (create that file if missing). The current `lib/taurus.rb` uses `require_relative` — when implementing TODO 3, do not retrofit require_relative into the new layout. +- **No `instance_variable_set`/`_get` cross-object.** TODO 3 is explicit. The current `lib/taurus.rb` and `lib/taurus/ffi/bridge.rb` use `instance_variable_get(:@_c_ptr)` heavily — that pattern is debt to migrate, not a model to copy. In the rewrite, expose `c_ptr`/`document` as public `attr_reader`s and access via those. +- **No `respond_to?` type checks.** Use `is_a?`. The current `lib/taurus.rb#xpath_evaluate` checks `context_node != doc` to disambiguate — fine. Don't add `respond_to?(:c_ptr)` style checks. +- **No doubles in specs.** The existing `spec/taurus/` specs use real model instances (XML strings → `Taurus.parse` → real `Document`/`Element`/`NodeSet`). Keep it that way. +- **Forward compatibility:** Keep `Taurus.parse` / `Taurus.parse_file` as the existing top-level API during the rewrite. The new `Taurus::XML.parse` may coexist. \ No newline at end of file diff --git a/Gemfile b/Gemfile index 7fde74a..6e849e0 100644 --- a/Gemfile +++ b/Gemfile @@ -2,23 +2,8 @@ source "https://rubygems.org" -# Specify your gem's dependencies in taurus.gemspec gemspec -# FFI for Ruby-C bindings -gem "ffi", "~> 1.15" - -gem "benchmark-ips" -gem "memory_profiler" -gem "moxml", "~> 0.1" -gem "nokogiri", "~> 1.18" -gem "oga", "~> 3.4" -gem "ox", "~> 2.14" -gem "asciidoctor" -gem "rake-compiler" gem "rake" gem "rspec" gem "rubocop" -gem "ruby-prof" -gem "thor" -gem "yard" \ No newline at end of file diff --git a/Gemfile.lock b/Gemfile.lock index d385b7b..aa33953 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -3,34 +3,17 @@ PATH specs: taurus (0.1.0) ffi (~> 1.15) - thor (~> 1.0) GEM remote: https://rubygems.org/ specs: - ansi (1.5.0) - asciidoctor (2.0.26) ast (2.4.3) - base64 (0.3.0) - benchmark-ips (2.14.0) - bigdecimal (3.3.1) diff-lcs (1.6.2) ffi (1.17.2-arm64-darwin) ffi (1.17.2-x86_64-darwin) json (2.17.1) language_server-protocol (3.17.0.5) lint_roller (1.1.0) - memory_profiler (1.1.0) - moxml (0.1.10) - nokogiri (1.18.10-arm64-darwin) - racc (~> 1.4) - nokogiri (1.18.10-x86_64-darwin) - racc (~> 1.4) - oga (3.4) - ast - ruby-ll (~> 2.1) - ox (2.14.23) - bigdecimal (>= 3.0) parallel (1.27.0) parser (3.3.10.0) ast (~> 2.4.1) @@ -39,8 +22,6 @@ GEM racc (1.8.1) rainbow (3.1.1) rake (13.3.1) - rake-compiler (1.3.0) - rake regexp_parser (2.11.3) rspec (3.13.2) rspec-core (~> 3.13.0) @@ -69,39 +50,20 @@ GEM rubocop-ast (1.48.0) parser (>= 3.3.7.2) prism (~> 1.4) - ruby-ll (2.1.4) - ansi - ast - ruby-prof (1.7.2) - base64 ruby-progressbar (1.13.0) - thor (1.4.0) unicode-display_width (3.2.0) unicode-emoji (~> 4.1) unicode-emoji (4.1.0) - yard (0.9.38) PLATFORMS arm64-darwin x86_64-darwin DEPENDENCIES - asciidoctor - benchmark-ips - ffi (~> 1.15) - memory_profiler - moxml (~> 0.1) - nokogiri (~> 1.18) - oga (~> 3.4) - ox (~> 2.14) rake - rake-compiler rspec rubocop - ruby-prof taurus! - thor - yard BUNDLED WITH 2.6.9 diff --git a/Rakefile b/Rakefile index 041053c..209fdbd 100644 --- a/Rakefile +++ b/Rakefile @@ -2,38 +2,6 @@ require "bundler/gem_tasks" require "rspec/core/rake_task" -require "fileutils" -# Build task for libtaurus FFI library -desc "Compile libtaurus library" -task :compile do - ext_dir = File.expand_path('ext/taurus', __dir__) - Dir.chdir(ext_dir) do - ruby 'extconf.rb' - end -end - -# Ruby tests RSpec::Core::RakeTask.new(:spec) -task spec: :compile - -# Clean build artifacts -desc "Clean build artifacts" -task :clean do - FileUtils.rm_f(Dir.glob("lib/libtaurus.{so,bundle,dll,dylib}")) - FileUtils.rm_rf("ext/taurus/build") - FileUtils.rm_f("ext/taurus/Makefile") - FileUtils.rm_rf(["tmp", "pkg"]) - puts "Cleaned build artifacts" -end - -# All tests -desc "Run all tests" -task test: :spec do - puts "\n" + "=" * 80 - puts "TEST SUITE COMPLETE" - puts "=" * 80 -end - -# Default task -task default: :test \ No newline at end of file +task default: :spec diff --git a/TODO.impl/01-architecture.md b/TODO.impl/01-architecture.md new file mode 100644 index 0000000..596adba --- /dev/null +++ b/TODO.impl/01-architecture.md @@ -0,0 +1,217 @@ +# TODO 1 — Architecture: C-backed Nokogiri-compatible Ruby binding + +## Goal + +Rewrite `taurus-ruby` to be a **thin FFI wrapper** around libtaurus v0.4.2, +exposing a **Nokogiri-compatible API**. The C DOM is the single source of +truth — no Ruby-side tree copy. + +## Current state (problem) + +The existing `taurus-ruby` has: +- A **pure-Ruby** XML tree model (Document < Element, Node, NodeSet) +- A FFI bridge that does a **one-shot copy** from C to Ruby on parse +- A **pure-Ruby XPath engine** (lexer, parser, compiler, VM in Ruby) + +This defeats libtaurus's performance: the C library's optimized bytecode +VM + element index are never used. XPath goes through the slow Ruby engine. + +## Target architecture + +``` +User Ruby code + ↓ +Taurus::XML::Document / Node / NodeSet (thin Ruby wrappers) + ↓ FFI +libtaurus v0.4.2 (C99: DOM, XPath bytecode VM, element index) +``` + +Key principles: +- **Every Ruby method is a single FFI call** to the C library. +- **No Ruby-side tree copy.** The C DOM is the truth; Ruby objects are + handles (wrapping opaque pointers). +- **XPath goes through C.** `doc.xpath('//book')` calls + `taurus_xpath_eval` directly. No Ruby XPath engine. +- **SAX goes through C.** `Taurus::XML::SAX::Parser` wraps + `taurus_sax_parse` with Ruby callback dispatch. + +## Module structure (Nokogiri-compatible) + +```ruby +module Taurus + module XML + # Top-level parse entry points + def self.parse(string_or_io) → Document + def self.parse_options → ParseOptions + + class Document < Node + def root → Element (or nil) + def create_element(name) → Element + def create_text_node(text) → Text + def to_xml(options) → String + def xpath(expr) → NodeSet | Float | String | Boolean + def at_xpath(expr) → Node (or nil) + def search(expr) → NodeSet + def canonicalize(...) → String + def free → void (explicit) + end + + class Node + include Searchable + + def name → String + def content / text → String + def [](attr_name) → String (or nil) + def []=(attr_name, value) + def attributes → Hash {String => Attr} + def children → NodeSet + def child → Node (or nil) + def first_element_child → Element (or nil) + def last_element_child → Element (or nil) + def next_sibling → Node (or nil) + def previous_sibling → Node (or nil) + def parent → Node (or nil) + def document → Document + def type → Integer (element/text/comment/cdata/pi) + def element? → Boolean + def text? → Boolean + def comment? → Boolean + def cdata? → Boolean + def processing_instruction? → Boolean + def add_child(node) → Node + def add_next_sibling(node) → Node + def add_previous_sibling(node) → Node + def remove → Node + def replace(node) → Node + def to_xml(options) → String + def inner_html → String + def traverse(&block) + end + + class Element < Node + def add_class(name) + def remove_class(name) + def classes → Array + end + + class Text < Node; end + class Comment < Node; end + class CDATA < Node; end + class ProcessingInstruction < Node; end + class Attr + def name → String + def value → String + def value=(val) + def parent → Element + def remove + end + + class NodeSet + include Enumerable + include Searchable + + def length / size → Integer + def first(n) → Node | NodeSet + def last → Node + def [](index) → Node + def each(&block) + def empty? → Boolean + def xpath(expr) → NodeSet + def search(expr) → NodeSet + def to_xml → String + def inner_text → String + end + + module Searchable + def xpath(*paths) → NodeSet | Float | String | Boolean + def at_xpath(*paths) → Node (or nil) + def css(*selectors) → NodeSet (converts CSS to XPath) + def at_css(*selectors) → Node (or nil) + def search(*args) → NodeSet (auto-detect CSS/XPath) + def at(*args) → Node (or nil) + end + + class ParseOptions + DEFAULT_XML = ... + RECOVER = ... + NOERROR = ... + NOWARNING = ... + NOCDATA = ... + STRICT = ... + end + + module SAX + class Parser + def initialize(handler = DocHandler.new) + def parse(io_or_string) + end + + class Document + def start_element(name, attrs = []) + def end_element(name) + def characters(string) + def start_document + def end_document + def comment(string) + def cdata(string) + def processing_instruction(name, content) + def error(message, line, column) + end + end + end +end +``` + +## Memory model + +- **Document** owns the C document pool. `Taurus::XML::Document.new` + calls `taurus_parse_string` → returns a `TaurusDocument` pointer. + `Document#free` calls `taurus_document_free`. Auto-free via + `ObjectSpace.define_finalizer` as a safety net (but callers should + call `#free` explicitly for predictable lifecycle). +- **Node / Element / Text etc.** are **non-owning handles** wrapping + a C pointer. The pointer is valid as long as the parent Document + is alive. Freeing a Node just drops the Ruby wrapper; the C node + lives until `Document#free`. +- **NodeSet** wraps a `TaurusXPathResult` pointer from + `taurus_xpath_eval`. Freeing a NodeSet calls + `taurus_xpath_result_free`. +- **Attr** wraps a C attribute pointer (owned by the parent element's + pool). Non-owning. + +## CSS support + +Nokogiri supports CSS selectors via `css()` and `at_css()`. Taurus +doesn't have a CSS engine in C, so CSS-to-XPath conversion must be +done in Ruby. Options: +1. Use the `css_parser` gem (depends on `racc`). +2. Write a minimal CSS-to-XPath converter in pure Ruby. + +For v0.4.2 compatibility, option 2 (minimal converter) is recommended. +Nokogiri's CSS selector support is comprehensive but the common subset +is small: `tag`, `.class`, `#id`, `> child`, `descendant`, +`[attr]`, `[attr=value]`, `:first-child`, `:last-child`, `:not(...)`. + +## Dependencies + +```ruby +# taurus.gemspec +spec.add_dependency 'ffi', '~> 1.16' +``` + +No other runtime dependencies. No C extension compilation needed — +just FFI to the pre-built libtaurus shared library. + +## Reference material + +- Nokogiri source: `~/src/external/nokogiri/` + - `lib/nokogiri/xml/node.rb` — 77 public methods + - `lib/nokogiri/xml/node_set.rb` — 31 public methods + - `lib/nokogiri/xml/document.rb` — 22 public methods + - `lib/nokogiri/xml/searchable.rb` — xpath/css/search module +- libtaurus public headers: `src/include/taurus/` + - `types.h` — opaque handle typedefs + - `dom/document.h`, `dom/element.h`, `dom/serialize.h` + - `xpath/xpath.h` — XPath eval API + - `sax/sax.h` — SAX parser API +- libtaurus v0.4.2: tag `v0.4.2` on `github.com:lutaml/taurus` diff --git a/TODO.impl/02-ffi-declarations.md b/TODO.impl/02-ffi-declarations.md new file mode 100644 index 0000000..125c92b --- /dev/null +++ b/TODO.impl/02-ffi-declarations.md @@ -0,0 +1,236 @@ +# TODO 2 — FFI declarations: complete libtaurus v0.4.2 public API + +## Goal + +Create `lib/taurus/xml/ffi.rb` that attaches to EVERY public function +in libtaurus v0.4.2 via the `ffi` gem. This is the single source of +truth for the C ↔ Ruby boundary. + +## Library loading + +```ruby +module Taurus + module XML + module FFI + extend ::FFI + + ffi_lib [ + ENV['TAURUS_LIB_PATH'], + 'taurus', + '/usr/local/lib/libtaurus.dylib', + '/usr/local/lib/libtaurus.so', + File.expand_path('../../../build/src/libtaurus.dylib', __dir__), + File.expand_path('../../../build/src/libtaurus.so', __dir__), + ].compact + end + end +end +``` + +## Opaque type declarations + +```ruby +typedef :pointer, :document +typedef :pointer, :element +typedef :pointer, :node_ref +typedef :pointer, :xpath_result +typedef :pointer, :sax_parser +typedef :pointer, :attribute +``` + +## Complete function list (attach all of these) + +Source: `src/include/taurus/types.h`, `src/include/taurus.h`, and +`src/include/taurus/*.h`. + +### Version +```ruby +attach_function :taurus_version, [], :string +``` + +### Document lifecycle +```ruby +attach_function :taurus_parse_string, [:string, :size_t, :pointer], :document +attach_function :taurus_document_free, [:document], :void +attach_function :taurus_document_root, [:document], :element +attach_function :taurus_document_serialize, [:document, :pointer], :pointer +attach_function :taurus_document_set_strict, [:document, :int], :void +attach_function :taurus_xinclude_process, [:document, :string], :int +``` + +### Node access +```ruby +attach_function :taurus_node_get_type, [:node_ref], :int +attach_function :taurus_node_first_child, [:node_ref], :node_ref +attach_function :taurus_node_next_sibling, [:node_ref], :node_ref +attach_function :taurus_node_previous_sibling, [:node_ref], :node_ref +attach_function :taurus_node_child_count, [:node_ref], :size_t +attach_function :taurus_node_as_element, [:node_ref], :element +attach_function :taurus_element_as_node, [:element], :node_ref +attach_function :taurus_element_first_child_any, [:element], :element +``` + +### Element queries +```ruby +attach_function :taurus_element_name, [:element], :string +attach_function :taurus_element_text, [:element], :string +attach_function :taurus_element_attribute, [:element, :string, :string], :string +attach_function :taurus_element_attribute_count, [:element], :size_t +attach_function :taurus_element_first_attribute, [:element], :pointer +attach_function :taurus_element_parent, [:element], :element +attach_function :taurus_element_next_sibling_any, [:element], :element +attach_function :taurus_element_get_namespace_uri, [:element], :string +attach_function :taurus_element_get_prefix, [:element], :string +attach_function :taurus_element_get_name, [:element], :string +``` + +### Element mutation +```ruby +attach_function :taurus_element_set_name, [:element, :string], :void +attach_function :taurus_element_set_attribute, [:element, :string, :string], :void +attach_function :taurus_element_remove_attribute, [:element, :string], :void +attach_function :taurus_element_append_child, [:element, :element], :int +attach_function :taurus_element_create_child, [:element, :string], :element +attach_function :taurus_element_set_text, [:element, :string], :void +attach_function :taurus_element_remove_child, [:element, :element], :void +``` + +### Element creation +```ruby +attach_function :taurus_element_create, [:string], :element +attach_function :taurus_text_node_create, [:string], :element +attach_function :taurus_comment_node_create, [:string], :element +attach_function :taurus_cdata_node_create, [:string], :element +attach_function :taurus_pi_node_create, [:string, :string], :element +``` + +### Text / Comment / CDATA / PI access +```ruby +attach_function :taurus_text_node_get_content, [:node_ref], :string +attach_function :taurus_comment_node_get_content, [:node_ref], :string +attach_function :taurus_cdata_node_get_content, [:node_ref], :string +attach_function :taurus_pi_node_get_target, [:node_ref], :string +attach_function :taurus_pi_node_get_data, [:node_ref], :string +``` + +### XPath +```ruby +attach_function :taurus_xpath_eval, + [:document, :element, :string], :xpath_result +attach_function :taurus_xpath_eval_with_vars, + [:document, :string, :pointer], :xpath_result +attach_function :taurus_xpath_result_type, [:xpath_result], :int +attach_function :taurus_xpath_result_count, [:xpath_result], :size_t +attach_function :taurus_xpath_result_get, [:xpath_result, :size_t], :element +attach_function :taurus_xpath_result_boolean, [:xpath_result], :int +attach_function :taurus_xpath_result_number, [:xpath_result], :double +attach_function :taurus_xpath_result_string, [:xpath_result], :pointer +attach_function :taurus_xpath_result_free, [:xpath_result], :void +``` + +### XPath variables +```ruby +attach_function :taurus_xpath_variable_set_new, [], :pointer +attach_function :taurus_xpath_variable_set_free, [:pointer], :void +attach_function :taurus_xpath_variable_set_boolean, [:pointer, :string, :int], :int +attach_function :taurus_xpath_variable_set_number, [:pointer, :string, :double], :int +attach_function :taurus_xpath_variable_set_string, [:pointer, :string, :string], :int +``` + +### SAX +```ruby +# TaurusSAXHandler is a struct of function pointers. Use FFI::Struct. +class SAXHandler < ::FFI::Struct + layout \ + :start_document, :pointer, + :end_document, :pointer, + :start_element, :pointer, + :end_element, :pointer, + :characters, :pointer, + :comment, :pointer, + :cdata, :pointer, + :processing_instruction, :pointer, + :start_prefix_mapping, :pointer, + :end_prefix_mapping, :pointer, + :error, :pointer +end + +attach_function :taurus_sax_parse, + [:string, :size_t, SAXHandler.by_pointer, :pointer], :int +attach_function :taurus_sax_parser_create, + [SAXHandler.by_pointer, :pointer], :sax_parser +attach_function :taurus_sax_parser_feed, + [:sax_parser, :string, :size_t, :int], :int +attach_function :taurus_sax_parser_free, [:sax_parser], :void +attach_function :taurus_sax_parser_set_streaming, + [:sax_parser, :int], :int +``` + +### Serialization +```ruby +# TaurusSerializeOptions struct +class SerializeOptions < ::FFI::Struct + layout \ + :indent, :int, + :xml_declaration, :int, + :no_empty_tags, :int, + :preserve_whitespace, :int +end + +attach_function :taurus_serialize_document, + [:document, :pointer], :pointer +attach_function :taurus_c14n_canonicalize, + [:document, :int, :int], :pointer +``` + +### Memory +```ruby +attach_function :taurus_free_string, [:pointer], :void +``` + +## Status codes + +```ruby +TAURUS_OK = 0 +TAURUS_ERROR_MEMORY = -1 +TAURUS_ERROR_PARSE = -2 +TAURUS_ERROR_XPATH = -3 +TAURUS_ERROR_NULL_ARG = -4 +TAURUS_ERROR_INVALID_ARG = -5 +TAURUS_ERROR_NOT_FOUND = -6 +TAURUS_ERROR_IO = -7 +``` + +## Node type constants + +```ruby +NODE_ELEMENT = 0 +NODE_ATTRIBUTE = 1 +NODE_TEXT = 2 +NODE_COMMENT = 3 +NODE_CDATA = 4 +NODE_PI = 5 +NODE_DOCTYPE = 6 +``` + +## XPath result type constants + +```ruby +XPATH_NODESET = 0 +XPATH_BOOLEAN = 1 +XPATH_NUMBER = 2 +XPATH_STRING = 3 +``` + +## Notes + +- Use `Blocking: true` for SAX callbacks (FFI::Function). +- Use `AutoPointer` for document and xpath_result to get automatic + cleanup. But ALSO provide explicit `#free` methods since GC timing + is non-deterministic. +- The `taurus_element_*` functions that return `:string` return + document-owned strings (valid until `taurus_document_free`). + Ruby copies them automatically on FFI return — safe. +- Functions that return `:pointer` for strings (like + `taurus_xpath_result_string`, `taurus_serialize_document`) return + heap-owned strings that the caller must free via `taurus_free_string`. diff --git a/TODO.impl/03-document-node-element-nodeset.md b/TODO.impl/03-document-node-element-nodeset.md new file mode 100644 index 0000000..8b6fd36 --- /dev/null +++ b/TODO.impl/03-document-node-element-nodeset.md @@ -0,0 +1,382 @@ +# TODO 3 — Document, Node, Element, NodeSet, Searchable implementation + +## Goal + +Implement the core Nokogiri-compatible Ruby classes backed by FFI +calls to libtaurus. Each Ruby method = one C function call. + +## File layout + +``` +lib/taurus.rb # autoload + version +lib/taurus/xml.rb # XML module + parse entry points +lib/taurus/xml/ffi.rb # FFI declarations (TODO 2) +lib/taurus/xml/document.rb # Document class +lib/taurus/xml/node.rb # Node base class +lib/taurus/xml/element.rb # Element < Node +lib/taurus/xml/text.rb # Text < Node +lib/taurus/xml/comment.rb # Comment < Node +lib/taurus/xml/cdata.rb # CDATA < Node +lib/taurus/xml/processing_instruction.rb # ProcessingInstruction < Node +lib/taurus/xml/attr.rb # Attr class +lib/taurus/xml/node_set.rb # NodeSet class +lib/taurus/xml/searchable.rb # Searchable mixin (xpath/css/search) +lib/taurus/xml/parse_options.rb # ParseOptions class +``` + +## Autoload pattern + +```ruby +# lib/taurus.rb +module Taurus + autoload :XML, 'taurus/xml' +end + +# lib/taurus/xml.rb +module Taurus + module XML + autoload :FFI, 'taurus/xml/ffi' + autoload :Document, 'taurus/xml/document' + autoload :Node, 'taurus/xml/node' + autoload :Element, 'taurus/xml/element' + autoload :Text, 'taurus/xml/text' + autoload :Comment, 'taurus/xml/comment' + autoload :CDATA, 'taurus/xml/cdata' + autoload :ProcessingInstruction, 'taurus/xml/processing_instruction' + autoload :Attr, 'taurus/xml/attr' + autoload :NodeSet, 'taurus/xml/node_set' + autoload :Searchable, 'taurus/xml/searchable' + autoload :ParseOptions, 'taurus/xml/parse_options' + + def self.parse(string_or_io, options = nil) + xml = string_or_io.respond_to?(:read) ? string_or_io.read : string_or_io + status = ::FFI::MemoryPointer.new(:int) + ptr = FFI.taurus_parse_string(xml, xml.bytesize, status) + raise ParseError, "taurus_parse_string failed (status=#{status.read_int})" if ptr.nil? || ptr.null? + Document.wrap(ptr) + end + end +end +``` + +## Document + +```ruby +class Taurus::XML::Document < Taurus::XML::Node + def self.wrap(c_ptr) + doc = allocate + doc.instance_variable_set(:@c_ptr, c_ptr) + doc + end + + def root + ptr = FFI.taurus_document_root(@c_ptr) + return nil if ptr.nil? || ptr.null? + Taurus::XML::Element.wrap(ptr, self) + end + + def xpath(expr) + Taurus::XML::XPath.evaluate(@c_ptr, nil, expr) + end + + def at_xpath(expr) + result = xpath(expr) + result.is_a?(NodeSet) ? result.first : result + end + + def to_xml(options = {}) + opts = SerializeOptions.new + opts[:indent] = options[:indent] || 0 + opts[:xml_declaration] = options[:no_decl] ? 0 : 1 + ptr = FFI.taurus_serialize_document(@c_ptr, opts.pointer) + return '' if ptr.nil? || ptr.null? + str = ptr.read_string + FFI.taurus_free_string(ptr) + str + end + + def free + return unless @c_ptr + FFI.taurus_document_free(@c_ptr) + @c_ptr = nil + end +end +``` + +## Node (base class) + +```ruby +class Taurus::XML::Node + attr_reader :c_ptr, :document + + def initialize(c_ptr, document) + @c_ptr = c_ptr + @document = document + end + + def self.wrap(c_ptr, document) + type = FFI.taurus_node_get_type(c_ptr) + case type + when NODE_ELEMENT then Taurus::XML::Element.new(c_ptr, document) + when NODE_TEXT then Taurus::XML::Text.new(c_ptr, document) + when NODE_COMMENT then Taurus::XML::Comment.new(c_ptr, document) + when NODE_CDATA then Taurus::XML::CDATA.new(c_ptr, document) + when NODE_PI then Taurus::XML::ProcessingInstruction.new(c_ptr, document) + else new(c_ptr, document) + end + end + + def name + raise NotImplementedError + end + + def content + raise NotImplementedError + end + + def type + FFI.taurus_node_get_type(@c_ptr) + end + + def element?; type == NODE_ELEMENT; end + def text?; type == NODE_TEXT; end + def comment?; type == NODE_COMMENT; end + def cdata?; type == NODE_CDATA; end + def processing_instruction?; type == NODE_PI; end + + def next_sibling + ptr = FFI.taurus_node_next_sibling(@c_ptr) + return nil if ptr.null? + Node.wrap(ptr, @document) + end + + def previous_sibling + ptr = FFI.taurus_node_previous_sibling(@c_ptr) + return nil if ptr.null? + Node.wrap(ptr, @document) + end + + def parent + ptr = FFI.taurus_element_parent(@c_ptr) # only works for elements + return nil if ptr.null? + Element.wrap(ptr, @document) + end + + def children + NodeSet.new(@document, self) + end + + def child + ptr = FFI.taurus_node_first_child(@c_ptr) + return nil if ptr.null? + Node.wrap(ptr, @document) + end + + def traverse(&block) + return enum_for(:traverse) unless block_given? + block.call(self) + children.each { |c| c.traverse(&block) } + end + + include Searchable +end +``` + +## Element + +```ruby +class Taurus::XML::Element < Taurus::XML::Node + def name + FFI.taurus_element_name(@c_ptr) + end + + def name=(n) + FFI.taurus_element_set_name(@c_ptr, n) + end + + def content + FFI.taurus_element_text(@c_ptr) + end + alias_method :text, :content + + def [](attr_name) + FFI.taurus_element_attribute(@c_ptr, attr_name, nil) + end + + def []=(attr_name, value) + FFI.taurus_element_set_attribute(@c_ptr, attr_name, value.to_s) + end + + def attributes + # Walk the C attribute list, build a hash of Attr objects + result = {} + count = FFI.taurus_element_attribute_count(@c_ptr) + # ... iterate attribute linked list ... + result + end + + def keys + attributes.keys + end + + def values + attributes.values.map(&:value) + end + + def first_element_child + ptr = FFI.taurus_element_first_child_any(@c_ptr) + return nil if ptr.null? + Element.wrap(ptr, @document) + end + + def add_child(node) + FFI.taurus_element_append_child(@c_ptr, node.c_ptr) + node + end + + def add_class(names) ... end + def remove_class(names = nil) ... end + def classes + (self['class'] || '').split + end +end +``` + +## NodeSet + +```ruby +class Taurus::XML::NodeSet + include Enumerable + include Searchable + + def initialize(document, result_ptr = nil) + @document = document + @result_ptr = result_ptr # TaurusXPathResult pointer + end + + def length + return @cached_length if @cached_length + @cached_length = + @result_ptr ? FFI.taurus_xpath_result_count(@result_ptr) : 0 + end + alias_method :size, :length + + def [](index) + return nil if index < 0 || index >= length + ptr = FFI.taurus_xpath_result_get(@result_ptr, index) + return nil if ptr.null? + Node.wrap(ptr, @document) + end + + def first(n = nil) + return self[0] if n.nil? + NodeSet.new(@document).tap { |ns| n.times { |i| ns << self[i] } } + end + + def last + self[length - 1] + end + + def each + return enum_for(:each) unless block_given? + length.times { |i| yield self[i] } + end + + def empty? + length == 0 + end + + def inner_text + map(&:content).join + end + + def to_xml + map(&:to_xml).join + end + + def free + return unless @result_ptr + FFI.taurus_xpath_result_free(@result_ptr) + @result_ptr = nil + end +end +``` + +## Searchable (mixin for xpath/css) + +```ruby +module Taurus::XML::Searchable + def xpath(*paths) + expr = paths.join(' | ') + result_ptr = FFI.taurus_xpath_eval( + document.c_ptr, + respond_to?(:c_ptr) ? c_ptr : nil, + expr + ) + return nil if result_ptr.null? + + result_type = FFI.taurus_xpath_result_type(result_ptr) + case result_type + when XPATH_NODESET + NodeSet.new(@document, result_ptr) + when XPATH_NUMBER + n = FFI.taurus_xpath_result_number(result_ptr) + FFI.taurus_xpath_result_free(result_ptr) + n + when XPATH_STRING + s = FFI.taurus_xpath_result_string(result_ptr) + FFI.taurus_xpath_result_free(result_ptr) + s + when XPATH_BOOLEAN + b = FFI.taurus_xpath_result_boolean(result_ptr) + FFI.taurus_xpath_result_free(result_ptr) + b == 1 + end + end + + def at_xpath(*paths) + ns = xpath(*paths) + ns.is_a?(NodeSet) ? ns.first : ns + end + + def search(*args) + expr = args.first.to_s + if expr.start_with?('/') || expr.start_with?('//') + xpath(expr) + else + css(expr) + end + end + + def at(*args) + result = search(*args) + result.is_a?(NodeSet) ? result.first : result + end + + def css(*selectors) + # Convert CSS to XPath (minimal converter) + xpath_expr = CssToXPath.convert(selectors.join(', ')) + xpath(xpath_expr) + end + + def at_css(*selectors) + result = css(*selectors) + result.is_a?(NodeSet) ? result.first : result + end +end +``` + +## Implementation notes + +- **No `require_relative`** anywhere. Use `autoload` defined in the + immediate parent namespace's file (e.g., `lib/taurus/xml.rb`). +- **No `instance_variable_set`/`instance_variable_get`** on other + objects. Use public accessor methods. +- **No `send`** to call private methods. +- **No `respond_to?`** for type checks. Use `is_a?`. +- Wrap C pointers in Ruby objects via `Node.wrap(ptr, doc)` which + dispatches on the C node type. +- Node objects are lightweight: just a pointer + document reference. + No caching of properties (each call goes through FFI). +- The document is the ONLY object that owns memory. All other objects + are non-owning handles. diff --git a/TODO.impl/04-sax-parser.md b/TODO.impl/04-sax-parser.md new file mode 100644 index 0000000..5ce2bdd --- /dev/null +++ b/TODO.impl/04-sax-parser.md @@ -0,0 +1,203 @@ +# TODO 4 — SAX parser wrapper + +## Goal + +Wrap libtaurus's C SAX parser (`taurus_sax_parse`, `taurus_sax_parser_feed`) +behind a Nokogiri-compatible Ruby SAX API. + +## Nokogiri SAX API (target) + +```ruby +class MyHandler < Nokogiri::XML::SAX::Document + def start_document; end + def end_document; end + def start_element(name, attrs = []); end + def end_element(name); end + def characters(string); end + def comment(string); end + def cdata_block(string); end + def processing_instruction(name, content); end + def warning(msg); end + def error(msg); end +end + +parser = Nokogiri::XML::SAX::Parser.new(MyHandler.new) +parser.parse(File.read('file.xml')) +# or streaming: +parser.parse(io) # reads in chunks +``` + +## Taurus SAX API (source) + +From `src/include/taurus/sax/sax.h`: + +```c +struct TaurusSAXHandler { + void (*start_document)(void* user_data); + void (*end_document)(void* user_data); + void (*start_element)(void* user_data, const char* name, const char** attrs); + void (*end_element)(void* user_data, const char* name); + void (*characters)(void* user_data, const char* text, size_t len); + void (*comment)(void* user_data, const char* comment); + void (*cdata)(void* user_data, const char* cdata); + void (*processing_instruction)(void* user_data, const char* target, const char* data); + void (*start_prefix_mapping)(void* user_data, const char* prefix, const char* uri); + void (*end_prefix_mapping)(void* user_data, const char* prefix); + void (*error)(void* user_data, const char* message, int line, int column); +}; + +int taurus_sax_parse(const char* xml, size_t len, + TaurusSAXHandler* handler, void* user_data); +TaurusSAXParser* taurus_sax_parser_create(TaurusSAXHandler* handler, void* user_data); +int taurus_sax_parser_feed(TaurusSAXParser* parser, const char* xml, + size_t len, int is_final); +void taurus_sax_parser_free(TaurusSAXParser* parser); +``` + +## Implementation + +```ruby +module Taurus + module XML + module SAX + class Document + def start_document; end + def end_document; end + def start_element(name, attrs = []); end + def end_element(name); end + def characters(string); end + def comment(string); end + def cdata(string); end + def processing_instruction(name, content); end + def start_prefix_mapping(prefix, uri); end + def end_prefix_mapping(prefix); end + def error(message, line, column); end + def warning(message); end + end + + class Parser + def initialize(handler = Document.new) + @handler = handler + end + + def parse(io_or_string) + xml = io_or_string.respond_to?(:read) ? io_or_string.read : io_or_string + + handler_struct = build_handler_struct(@handler) + rc = FFI.taurus_sax_parse(xml, xml.bytesize, handler_struct, nil) + raise ParseError, "SAX parse failed (rc=#{rc})" if rc != 0 + self + end + + private + + def build_handler_struct(handler) + s = FFI::SAXHandler.new + s[:start_document] = make_callback(:start_document) + s[:end_document] = make_callback(:end_document) + s[:start_element] = make_callback(:start_element) + s[:end_element] = make_callback(:end_element) + s[:characters] = make_callback(:characters) + s[:comment] = make_callback(:comment) + s[:cdata] = make_callback(:cdata) + s[:processing_instruction] = make_callback(:processing_instruction) + s[:start_prefix_mapping] = make_callback(:start_prefix_mapping) + s[:end_prefix_mapping] = make_callback(:end_prefix_mapping) + s[:error] = make_callback(:error) + s + end + + def make_callback(event) + ::FFI::Function.new(:void, [:pointer]) do |_user_data| + @handler.send(event) + end + end + end + end + end +end +``` + +## Callback signatures (FFI::Function) + +Each callback needs the right C signature: + +```ruby +# start_document: void(void*) +s[:start_document] = FFI::Function.new(:void, [:pointer]) do + @handler.start_document +end + +# start_element: void(void*, const char*, const char**) +# attrs is a NULL-terminated array of name-value pairs +s[:start_element] = FFI::Function.new(:void, [:pointer, :string, :pointer]) do |_, name, attrs_ptr| + attrs = [] + unless attrs_ptr.null? + offset = 0 + loop do + key_ptr = attrs_ptr.get_pointer(offset) + break if key_ptr.null? + val_ptr = attrs_ptr.get_pointer(offset + FFI.type_size(:pointer)) + break if val_ptr.null? + attrs << key_ptr.read_string + attrs << val_ptr.read_string + offset += 2 * FFI.type_size(:pointer) + end + end + @handler.start_element(name, attrs.each_slice(2).to_h) +end + +# characters: void(void*, const char*, size_t) +s[:characters] = FFI::Function.new(:void, [:pointer, :pointer, :size_t]) do |_, text_ptr, len| + @handler.characters(text_ptr.read_bytes(len).force_encoding('UTF-8')) +end + +# error: void(void*, const char*, int, int) +s[:error] = FFI::Function.new(:void, [:pointer, :string, :int, :int]) do |_, msg, line, col| + @handler.error(msg, line, col) +end +``` + +## Streaming (incremental) parsing + +For large documents, use `taurus_sax_parser_create` + `feed`: + +```ruby +def parse(io) + return parse(io.read) unless io.respond_to?(:read) + + handler_struct = build_handler_struct(@handler) + parser = FFI.taurus_sax_parser_create(handler_struct, nil) + + io.each_chunk(4096) do |chunk| + rc = FFI.taurus_sax_parser_feed(parser, chunk, chunk.bytesize, 0) + break if rc != 0 + end + # Final flush + FFI.taurus_sax_parser_feed(parser, '', 0, 1) +ensure + FFI.taurus_sax_parser_free(parser) if parser +end +``` + +## File + +``` +lib/taurus/xml/sax.rb +lib/taurus/xml/sax/parser.rb +lib/taurus/xml/sax/document.rb +``` + +## Autoload + +```ruby +# lib/taurus/xml/sax.rb +module Taurus + module XML + module SAX + autoload :Parser, 'taurus/xml/sax/parser' + autoload :Document, 'taurus/xml/sax/document' + end + end +end +``` diff --git a/TODO.impl/05-serialize-c14n-memory-specs-css.md b/TODO.impl/05-serialize-c14n-memory-specs-css.md new file mode 100644 index 0000000..b653a0e --- /dev/null +++ b/TODO.impl/05-serialize-c14n-memory-specs-css.md @@ -0,0 +1,276 @@ +# TODO 5 — Serialization, C14N, memory management, specs, CSS + +## Serialization + +Wrap `taurus_serialize_document` and `taurus_c14n_canonicalize`. + +```ruby +# lib/taurus/xml/serialize_options.rb +class Taurus::XML::SerializeOptions < FFI::Struct + layout \ + :indent, :int, + :xml_declaration, :int, + :no_empty_tags, :int, + :preserve_whitespace, :int +end + +# Document#to_xml +def to_xml(options = {}) + opts = SerializeOptions.new + opts[:indent] = options[:indent] || 0 + opts[:xml_declaration] = options[:no_decl] ? 0 : 1 + opts[:no_empty_tags] = options[:no_empty_tags] ? 1 : 0 + opts[:preserve_whitespace] = options[:preserve_whitespace] ? 1 : 0 + ptr = FFI.taurus_serialize_document(@c_ptr, opts.pointer) + return '' if ptr.nil? || ptr.null? + str = ptr.read_string + FFI.taurus_free_string(ptr) + str +end + +# Node#to_xml (serialize just this subtree) +def to_xml(options = {}) + # No C API for single-node serialization yet. Use Document serialize + # with a filter, or build the string manually. For v0.4.2, use the + # document-level serialize and post-process. This is a known limitation. + document.to_xml(options) +end + +# Node#inner_html +def inner_html + children.map { |c| c.to_xml }.join +end +``` + +## C14N (Canonical XML) + +```ruby +# lib/taurus/xml/c14n.rb +module Taurus::XML + C14N_1_0 = 0 + C14N_1_1 = 1 + C14N_EXCLUSIVE = 2 + + class Document + def canonicalize(mode = C14N_1_0, with_comments = false) + ptr = FFI.taurus_c14n_canonicalize(@c_ptr, mode, with_comments ? 1 : 0) + return '' if ptr.nil? || ptr.null? + str = ptr.read_string + FFI.taurus_free_string(ptr) + str + end + end +end +``` + +## Memory management + +### Ownership rules + +| Ruby class | Owns C memory? | Free function | +|-------------|----------------|---------------| +| Document | YES | `taurus_document_free` | +| Node/Element| NO (borrowed) | none (freed by Document) | +| NodeSet | YES (XPath result) | `taurus_xpath_result_free` | +| Attr | NO (borrowed) | none | + +### Explicit free pattern + +```ruby +doc = Taurus::XML.parse(xml) +begin + # ... work with doc ... +ensure + doc.free +end +``` + +### GC safety net + +```ruby +class Taurus::XML::Document + def self.wrap(ptr) + obj = allocate + obj.instance_variable_set(:@c_ptr, ptr) + ObjectSpace.define_finalizer(obj, finalizer(ptr)) + obj + end + + def self.finalizer(ptr) + proc { FFI.taurus_document_free(ptr) if ptr && !ptr.null? } + end + + def free + return unless @c_ptr + FFI.taurus_document_free(@c_ptr) + @c_ptr = nil + # The finalizer still holds the old pointer but Document#free + # already freed it. Add a "freed" flag to detect double-free. + end +end +``` + +**IMPORTANT**: The finalizer must capture the POINTER VALUE, not the +Document object (which would prevent GC). Use `FFI::Pointer` directly +in the finalizer closure. + +### Prevent use-after-free + +```ruby +class Taurus::XML::Node + def c_ptr + raise UseAfterFreeError, "document has been freed" unless @document.c_ptr + @c_ptr + end +end +``` + +## Specs + +### Structure + +``` +spec/ + spec_helper.rb + xml/ + parse_spec.rb + document_spec.rb + node_spec.rb + element_spec.rb + node_set_spec.rb + xpath_spec.rb + sax_spec.rb + serialize_spec.rb + c14n_spec.rb + memory_spec.rb + fixtures/ + basic.xml + catalog.xml + namespaces.xml +``` + +### Test against Nokogiri behavior + +Where Nokogiri's behavior is well-defined, match it exactly. The +specs should test: + +```ruby +# Parse +doc = Taurus::XML.parse('text') +expect(doc.root.name).to eq('root') +expect(doc.root.children.first['id']).to eq('1') + +# XPath +doc = Taurus::XML.parse('') +expect(doc.xpath('count(//book)')).to eq(2.0) +expect(doc.xpath('//book').length).to eq(2) +expect(doc.at_xpath('//book')).to be_a(Taurus::XML::Element) + +# Search +doc = Taurus::XML.parse('') +expect(doc.search('a').length).to eq(2) +expect(doc.at('a')['class']).to eq('x') + +# SAX +class Handler < Taurus::XML::SAX::Document + attr_reader :elements + def initialize; @elements = []; end + def start_element(name, attrs = []); @elements << name; end +end + +h = Handler.new +Taurus::XML::SAX::Parser.new(h).parse('') +expect(h.elements).to eq(['r', 'a', 'b']) + +# Serialize +doc = Taurus::XML.parse('') +expect(doc.to_xml).to match(//) + +# C14N +expect(doc.canonicalize).to include('') + +# Memory +doc = Taurus::XML.parse('') +doc.free +expect { doc.root }.to raise_error(Taurus::XML::UseAfterFreeError) +``` + +### Conformance + +Run Nokogiri's own test suite against the Taurus binding where +possible. Skip tests for features Taurus doesn't support (HTML5, +XSLT, RelaxNG, DTD validation beyond what libtaurus provides). + +## CSS-to-XPath converter (minimal) + +```ruby +# lib/taurus/xml/css_to_xpath.rb +module Taurus::XML + module CssToXPath + def self.convert(rule) + parts = rule.strip.split(/\s+/) + xpath_parts = parts.map { |p| convert_part(p) } + '//' + xpath_parts.join('/') + end + + def self.convert_part(part) + # tag → tag + # .class → *[contains(concat(' ', @class,' '),' class ')] + # #id → *[@id='id'] + # [attr] → *[@attr] + # [attr=val] → *[@attr='val'] + # > child handled by split + # :first-child → *[position()=1] + # :last-child → *[position()=last()] + return '*' if part == '*' + + if part.start_with?('.') + cls = part[1..] + "*[contains(concat(' ',normalize-space(@class),' '),' #{cls} ')]" + elsif part.start_with?('#') + id = part[1..] + "*[@id='#{id}']" + elsif match = part.match(/^(\w+)\[(\w+)='?([^'\]]+)'?\]$/i) + "#{match[1]}[@#{match[2]}='#{match[3]}']" + elsif match = part.match(/^(\w+)\[(\w+)\]$/i) + "#{match[1]}[@#{match[2]}]" + elsif match = part.match(/^(\w+):first-child$/i) + "#{match[1]}[position()=1]" + elsif match = part.match(/^(\w+):last-child$/i) + "#{match[1]}[position()=last()]" + else + part # pass through as tag name + end + end + end +end +``` + +This is a minimal converter. For full CSS3 support, integrate the +`css_parser` gem or port Nokogiri's CSS parser. + +## File layout summary + +``` +lib/taurus.rb +lib/taurus/xml.rb +lib/taurus/xml/ + ffi.rb + document.rb + node.rb + element.rb + text.rb + comment.rb + cdata.rb + processing_instruction.rb + attr.rb + node_set.rb + searchable.rb + parse_options.rb + serialize_options.rb + css_to_xpath.rb + sax.rb + sax/ + parser.rb + document.rb +``` diff --git a/ext/taurus/CMakeLists.txt b/ext/taurus/CMakeLists.txt deleted file mode 100644 index 616a9d3..0000000 --- a/ext/taurus/CMakeLists.txt +++ /dev/null @@ -1,129 +0,0 @@ -# Taurus - Fast XML Parser and XPath Evaluator -# Pure C library with Ruby bindings and CLI -cmake_minimum_required(VERSION 3.15) - -project(taurus - VERSION 0.1.0 - DESCRIPTION "Fast XML parser and XPath evaluator in pure C" - LANGUAGES C -) - -# C99 standard required -set(CMAKE_C_STANDARD 99) -set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_C_EXTENSIONS OFF) - -# Build options -option(BUILD_SHARED_LIBS "Build shared libraries" ON) -option(BUILD_TESTING "Build tests" ON) -option(BUILD_EXAMPLES "Build examples" OFF) -option(TAURUS_BUILD_CLI "Build CLI tool" ON) -option(TAURUS_BUILD_MAN_PAGES "Generate man pages with asciidoctor" OFF) - -# Configuration -set(CMAKE_EXPORT_COMPILE_COMMANDS ON) - -# Add cmake modules path -list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules") - -# Include AdocMan for man page generation -if(TAURUS_BUILD_MAN_PAGES) - include(AdocMan) -endif() - -# Add subdirectories -add_subdirectory(lib) - -if(TAURUS_BUILD_CLI) - add_subdirectory(cli) -endif() - -if(BUILD_TESTING) - enable_testing() - add_subdirectory(test) -endif() - -if(BUILD_EXAMPLES) - add_subdirectory(examples/c) -endif() - -# Install CMake config files -include(CMakePackageConfigHelpers) -include(GNUInstallDirs) - -write_basic_package_version_file( - "${CMAKE_CURRENT_BINARY_DIR}/taurus-config-version.cmake" - VERSION ${PROJECT_VERSION} - COMPATIBILITY SameMajorVersion -) - -configure_package_config_file( - "${CMAKE_CURRENT_SOURCE_DIR}/cmake/taurus-config.cmake.in" - "${CMAKE_CURRENT_BINARY_DIR}/taurus-config.cmake" - INSTALL_DESTINATION lib/cmake/taurus -) - -install(FILES - "${CMAKE_CURRENT_BINARY_DIR}/taurus-config.cmake" - "${CMAKE_CURRENT_BINARY_DIR}/taurus-config-version.cmake" - DESTINATION lib/cmake/taurus -) - -install(EXPORT taurus-targets - FILE taurus-targets.cmake - NAMESPACE taurus:: - DESTINATION lib/cmake/taurus -) - -# pkg-config file -configure_file( - "${CMAKE_CURRENT_SOURCE_DIR}/cmake/taurus.pc.in" - "${CMAKE_CURRENT_BINARY_DIR}/taurus.pc" - @ONLY -) - -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/taurus.pc" - DESTINATION lib/pkgconfig -) - -# Generate and install man pages (when building CLI) -if(TAURUS_BUILD_CLI AND TAURUS_BUILD_MAN_PAGES) - # Use AdocMan.cmake to generate man pages from AsciiDoc sources - # CLI man pages (section 1): cli/man/taurus.1.adoc, etc. - set(ADOC_MAN_SOURCES - cli/man/taurus.1.adoc - cli/man/taurus-parse.1.adoc - cli/man/taurus-xpath.1.adoc - cli/man/taurus-format.1.adoc - ) - - foreach(ADOC_SOURCE ${ADOC_MAN_SOURCES}) - if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${ADOC_SOURCE}") - add_adoc_man("${CMAKE_CURRENT_SOURCE_DIR}/${ADOC_SOURCE}") - endif() - endforeach() -endif() - -# Generate library API man page (section 5) -if(TAURUS_BUILD_MAN_PAGES) - # Library man page (section 5): lib/man/libtaurus.5.adoc - set(LIB_MAN_SOURCE lib/man/libtaurus.5.adoc) - - if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${LIB_MAN_SOURCE}") - add_adoc_man("${CMAKE_CURRENT_SOURCE_DIR}/${LIB_MAN_SOURCE}") - endif() -endif() - -# Summary -message(STATUS "") -message(STATUS "Taurus ${PROJECT_VERSION} Configuration:") -message(STATUS " C Compiler: ${CMAKE_C_COMPILER}") -message(STATUS " C Standard: C${CMAKE_C_STANDARD}") -message(STATUS " Build Type: ${CMAKE_BUILD_TYPE}") -message(STATUS " Shared Libraries: ${BUILD_SHARED_LIBS}") -message(STATUS " Build Tests: ${BUILD_TESTING}") -message(STATUS " Build Examples: ${BUILD_EXAMPLES}") -message(STATUS " Build CLI: ${TAURUS_BUILD_CLI}") -message(STATUS " Generate Man Pages: ${TAURUS_BUILD_MAN_PAGES}") -message(STATUS " Install Prefix: ${CMAKE_INSTALL_PREFIX}") -message(STATUS "") \ No newline at end of file diff --git a/ext/taurus/Makefile b/ext/taurus/Makefile deleted file mode 100644 index e24e7e1..0000000 --- a/ext/taurus/Makefile +++ /dev/null @@ -1,7 +0,0 @@ -# Dummy Makefile - actual build done by CMake -all: - @echo 'Library already built by extconf.rb' -install: - @echo 'Library installed to lib/' -clean: - @echo 'Nothing to clean (use rake clean)' diff --git a/ext/taurus/cmake/modules/AdocMan.cmake b/ext/taurus/cmake/modules/AdocMan.cmake deleted file mode 100644 index bd6b66f..0000000 --- a/ext/taurus/cmake/modules/AdocMan.cmake +++ /dev/null @@ -1,132 +0,0 @@ -# Copyright (c) 2021 Ribose Inc. -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions -# are met: -# 1. Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS -# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. - -#.adoc: -# add_adoc_man -# ----------- -# -# Convert adoc manual page to troff and install it via the custom target. -# -# Parameters -# ^^^^^^^^^^ -# Required parameter is source with AsciiDoc file. Must have adoc extension with man category prepended, i.e. something like ${CMAKE_SOURCE_DIR}/src/utility.1.adoc -# DST - optional parameter, which overrides where generated man will be stored. -# If not specified then will be automatically set to ${CMAKE_BINARY_DIR}/src/utility.1 -# -# Generated man page will be installed via the target, named man_utility -# - -set(ADOCCOMMAND_FOUND 0) -find_program(ADOCCOMMAND_PATH - NAMES asciidoctor - DOC "Path to AsciiDoc processor. Used to generate man pages from AsciiDoc." -) - -if(NOT EXISTS ${ADOCCOMMAND_PATH}) - message(WARNING "AsciiDoc processor not found, man pages will not be generated. Install asciidoctor or use the CMAKE_PROGRAM_PATH variable.") -else() - set(ADOCCOMMAND_FOUND 1) -endif() - -function(add_adoc_man SRC) - if (NOT ${ADOCCOMMAND_FOUND}) - return() - endif() - - cmake_parse_arguments( - ARGS - "" - "DST" - "" - ${ARGN} - ) - - set(ADOC_EXT ".adoc") - get_filename_component(FILE_NAME ${SRC} NAME) - - # The following procedures check against the expected file name - # pattern: "{name}.{man-number}.adoc", and builds to a - # destination file "{name}.{man-number}". - - # Check SRC extension - get_filename_component(END_EXT ${SRC} LAST_EXT) - string(COMPARE EQUAL ${END_EXT} ${ADOC_EXT} _equal) - if (NOT _equal) - message(FATAL_ERROR "SRC must have ${ADOC_EXT} extension.") - endif() - - # Check man number - get_filename_component(EXTS ${SRC} EXT) - string(REGEX MATCH "^\.([1-9])\.+$" _matches ${EXTS}) - set(MAN_NUM ${CMAKE_MATCH_1}) - if (NOT _matches) - message(FATAL_ERROR "Man file with wrong name pattern: ${FILE_NAME} must be in format {name}.[0-9]${ADOC_EXT}.") - endif() - - # Set target name - get_filename_component(TARGET_NAME ${SRC} NAME_WE) - string(PREPEND TARGET_NAME "man_") - - # Build output path if not specified. - if(NOT DST) - get_filename_component(SRC_PREFIX ${SRC} DIRECTORY) - - # Ensure that SRC_PREFIX is within CMAKE_SOURCE_DIR - if(NOT(SRC_PREFIX MATCHES "^${CMAKE_SOURCE_DIR}")) - message(FATAL_ERROR "Cannot build DST path as SRC is outside of the CMake sources dir.") - endif() - STRING(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/" "" SUBDIR_PATH ${SRC}) - - # Strip '.adoc' from the output subpath - get_filename_component(SUBDIR_PATH_NAME_WLE ${SUBDIR_PATH} NAME_WLE) - get_filename_component(SUBDIR_PATH_DIRECTORY ${SUBDIR_PATH} DIRECTORY) - set(DST "${CMAKE_BINARY_DIR}/${SUBDIR_PATH_DIRECTORY}/${SUBDIR_PATH_NAME_WLE}") - endif() - - # Check conformance of destination file name to pattern - get_filename_component(FILE_NAME_WE ${SRC} NAME_WE) - get_filename_component(MAN_FILE_NAME ${DST} NAME) - if(NOT(MAN_FILE_NAME MATCHES "^${FILE_NAME_WE}.${MAN_NUM}$")) - message(FATAL_ERROR "File name of a man page must be in the format {name}.{man-number}${ADOC_EXT}.") - endif() - - # Ensure destination directory exists - get_filename_component(DEST_DIR ${DST} DIRECTORY) - file(MAKE_DIRECTORY "${DEST_DIR}") - - add_custom_command( - OUTPUT ${DST} - COMMAND ${ADOCCOMMAND_PATH} -b manpage ${SRC} -o ${DST} - DEPENDS ${SRC} - WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - COMMENT "Generating man page ${SUBDIR_PATH_DIRECTORY}/${SUBDIR_PATH_NAME_WLE}" - VERBATIM - ) - - add_custom_target("${TARGET_NAME}" ALL DEPENDS ${DST}) - install(FILES ${DST} - DESTINATION "${CMAKE_INSTALL_FULL_MANDIR}/man${MAN_NUM}" - COMPONENT doc - ) -endfunction(add_adoc_man) diff --git a/ext/taurus/cmake/taurus-config.cmake.in b/ext/taurus/cmake/taurus-config.cmake.in deleted file mode 100644 index db7b1a5..0000000 --- a/ext/taurus/cmake/taurus-config.cmake.in +++ /dev/null @@ -1,6 +0,0 @@ -# Taurus CMake Config File -@PACKAGE_INIT@ - -include("${CMAKE_CURRENT_LIST_DIR}/taurus-targets.cmake") - -check_required_components(taurus) \ No newline at end of file diff --git a/ext/taurus/cmake/taurus.pc.in b/ext/taurus/cmake/taurus.pc.in deleted file mode 100644 index 70ae577..0000000 --- a/ext/taurus/cmake/taurus.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=${prefix} -libdir=${prefix}/lib -includedir=${prefix}/include - -Name: taurus -Description: @PROJECT_DESCRIPTION@ -Version: @PROJECT_VERSION@ -Libs: -L${libdir} -ltaurus -lm -Cflags: -I${includedir} \ No newline at end of file diff --git a/ext/taurus/extconf.rb b/ext/taurus/extconf.rb deleted file mode 100644 index 5e09bc4..0000000 --- a/ext/taurus/extconf.rb +++ /dev/null @@ -1,74 +0,0 @@ -require 'mkmf' -require 'fileutils' - -# Extconf for building libtaurus using CMake -# This builds the C library and installs it for FFI access - -ext_dir = __dir__ -lib_dir = File.expand_path('../../lib', ext_dir) -build_dir = File.join(ext_dir, 'build') - -# Create build directory -FileUtils.mkdir_p(build_dir) - -# Detect platform-specific library extension -lib_ext = case RUBY_PLATFORM - when /darwin/ - 'dylib' - when /linux/ - 'so' - when /mingw|mswin/ - 'dll' - else - 'so' - end - -puts "Building libtaurus for #{RUBY_PLATFORM}..." - -# Run CMake to configure the build -Dir.chdir(build_dir) do - # Configure with CMake - disable CLI and tests, only build library - cmake_args = [ - '-DCMAKE_BUILD_TYPE=Release', - '-DBUILD_SHARED_LIBS=ON', - '-DBUILD_TESTING=OFF', - '-DTAURUS_BUILD_CLI=OFF', - '-DTAURUS_BUILD_MAN_PAGES=OFF', - '..' - ] - - unless system('cmake', *cmake_args) - raise "CMake configuration failed" - end - - # Build - unless system('cmake', '--build', '.', '--config', 'Release') - raise "CMake build failed" - end - - # Install library to lib directory where FFI can find it - built_lib = Dir.glob("lib/libtaurus.#{lib_ext}").first || - Dir.glob("Release/libtaurus.#{lib_ext}").first || - Dir.glob("libtaurus.#{lib_ext}").first - - if built_lib && File.exist?(built_lib) - target_lib = File.join(lib_dir, "libtaurus.#{lib_ext}") - FileUtils.cp(built_lib, target_lib) - puts "✓ Installed libtaurus.#{lib_ext} to #{lib_dir}" - else - raise "Could not find built library libtaurus.#{lib_ext}" - end -end - -# Create a dummy Makefile for gem installation compatibility -File.open('Makefile', 'w') do |f| - f.puts "# Dummy Makefile - actual build done by CMake" - f.puts "all:" - f.puts "\t@echo 'Library already built by extconf.rb'" - f.puts "install:" - f.puts "\t@echo 'Library installed to lib/'" - f.puts "clean:" - f.puts "\t@echo 'Nothing to clean (use rake clean)'" -end - -puts "✓ Build configuration complete" \ No newline at end of file diff --git a/ext/taurus/lib/CMakeLists.txt b/ext/taurus/lib/CMakeLists.txt deleted file mode 100644 index e7d995f..0000000 --- a/ext/taurus/lib/CMakeLists.txt +++ /dev/null @@ -1,83 +0,0 @@ -# Taurus Library - Pure C XML parser and XPath evaluator - -# Library source files -set(TAURUS_SOURCES - src/xpath/lexer.c - src/xpath/parser.c - src/xpath/evaluator.c - src/xpath/functions.c - src/taurus.c - src/parse_simple.c - src/element.c - src/attribute.c - src/namespace.c - src/error.c -) - -# Library headers (internal) -set(TAURUS_HEADERS - src/taurus_internal.h - src/xpath/xpath_internal.h - src/xpath/lexer.h - src/xpath/parser.h - src/xpath/evaluator.h - src/xpath/functions.h -) - -# Create library target -add_library(taurus ${TAURUS_SOURCES} ${TAURUS_HEADERS}) - -# Set library properties -set_target_properties(taurus PROPERTIES - VERSION ${PROJECT_VERSION} - SOVERSION ${PROJECT_VERSION_MAJOR} - C_STANDARD 99 - C_STANDARD_REQUIRED ON - C_EXTENSIONS OFF -) - -# Include directories -target_include_directories(taurus - PUBLIC - $ - $ - PRIVATE - ${CMAKE_CURRENT_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR}/src/xpath -) - -# Link libraries -target_link_libraries(taurus PRIVATE m) - -# Compiler flags -target_compile_options(taurus PRIVATE - -Wall - -Wextra - -Wno-unused-parameter - $<$:-O3> - $<$:-g -O0> -) - -# Export symbols (for shared libraries) -if(BUILD_SHARED_LIBS) - target_compile_definitions(taurus PRIVATE TAURUS_BUILDING_DLL) - target_compile_definitions(taurus PUBLIC TAURUS_DLL) -endif() - -# Install library -install(TARGETS taurus - EXPORT taurus-targets - LIBRARY DESTINATION lib - ARCHIVE DESTINATION lib - RUNTIME DESTINATION bin - INCLUDES DESTINATION include -) - -# Install public headers (will create include/taurus/ structure) -install(DIRECTORY include/ - DESTINATION include - FILES_MATCHING PATTERN "*.h" -) - -# Add alias for consistent namespacing -add_library(taurus::taurus ALIAS taurus) \ No newline at end of file diff --git a/ext/taurus/lib/include/taurus.h b/ext/taurus/lib/include/taurus.h deleted file mode 100644 index 604b08b..0000000 --- a/ext/taurus/lib/include/taurus.h +++ /dev/null @@ -1,334 +0,0 @@ -/* libtaurus - Pure C XML/XPath library - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Public API header - No Ruby dependencies - */ - -#ifndef LIBTAURUS_H -#define LIBTAURUS_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* ============================================================================ - * Opaque Types - Hide implementation details - * ============================================================================ */ - -typedef struct taurus_document* TaurusDocument; -typedef struct taurus_element* TaurusElement; -typedef struct taurus_attribute* TaurusAttribute; -typedef struct taurus_namespace* TaurusNamespace; -typedef struct taurus_xpath_result* TaurusXPathResult; - -/* ============================================================================ - * Status Codes - * ============================================================================ */ - -typedef enum { - TAURUS_OK = 0, - TAURUS_ERROR_MEMORY = -1, /* Memory allocation failed */ - TAURUS_ERROR_PARSE = -2, /* XML parsing error */ - TAURUS_ERROR_XPATH = -3, /* XPath evaluation error */ - TAURUS_ERROR_NULL_ARG = -4, /* NULL argument passed */ - TAURUS_ERROR_INVALID_ARG = -5, /* Invalid argument */ - TAURUS_ERROR_NOT_FOUND = -6 /* Resource not found */ -} TaurusStatus; - -/* ============================================================================ - * XPath Result Types - * ============================================================================ */ - -typedef enum { - TAURUS_XPATH_NODESET, - TAURUS_XPATH_BOOLEAN, - TAURUS_XPATH_NUMBER, - TAURUS_XPATH_STRING -} TaurusXPathResultType; - -/* ============================================================================ - * Document Operations - * ============================================================================ */ - -/** - * Parse XML string into document - * - * @param xml XML string (must be valid UTF-8) - * @param length Length of XML string in bytes - * @param status Output status code (can be NULL) - * @return Document handle or NULL on error - * - * Memory: Caller must call taurus_document_free() when done - * Thread safety: Not thread-safe. One document per thread. - */ -TaurusDocument taurus_parse_string(const char* xml, size_t length, TaurusStatus* status); - -/** - * Free document and all its elements - * - * @param doc Document to free (can be NULL) - */ -void taurus_document_free(TaurusDocument doc); - -/** - * Get root element of document - * - * @param doc Document - * @return Root element or NULL if document is NULL or empty - * - * Memory: Element is owned by document. Do not free separately. - */ -TaurusElement taurus_document_root(TaurusDocument doc); - -/* ============================================================================ - * Element Operations - * ============================================================================ */ - -/** - * Get element name - * - * @param elem Element - * @return Element name or NULL if elem is NULL - * - * Memory: String is owned by element. Do not free or modify. - */ -const char* taurus_element_name(TaurusElement elem); - -/** - * Get element text content (concatenation of all text nodes) - * - * @param elem Element - * @return Text content or NULL if elem is NULL or has no text - * - * Memory: String is owned by element. Do not free or modify. - */ -const char* taurus_element_text(TaurusElement elem); - -/** - * Get attribute value by name - * - * @param elem Element - * @param name Attribute name - * @return Attribute value or NULL if not found - * - * Memory: String is owned by element. Do not free or modify. - */ -const char* taurus_element_attribute(TaurusElement elem, const char* name); - -/** - * Get number of child elements - * - * @param elem Element - * @return Number of children or 0 if elem is NULL - */ -size_t taurus_element_child_count(TaurusElement elem); - -/** - * Get child element by index - * - * @param elem Element - * @param index Child index (0-based) - * @return Child element or NULL if index out of bounds - * - * Memory: Element is owned by document. Do not free separately. - */ -TaurusElement taurus_element_child(TaurusElement elem, size_t index); - -/** - * Get parent element - * - * @param elem Element - * @return Parent element or NULL if elem is root or NULL - * - * Memory: Element is owned by document. Do not free separately. - */ -TaurusElement taurus_element_parent(TaurusElement elem); - -/* ============================================================================ - * Namespace Operations - * ============================================================================ */ - -/** - * Get element's active namespace - * - * @param elem Element - * @return Namespace or NULL if elem has no namespace - * - * Memory: Namespace is owned by element. Do not free separately. - */ -TaurusNamespace taurus_element_namespace(TaurusElement elem); - -/** - * Get namespace URI - * - * @param ns Namespace - * @return URI string or NULL if ns is NULL - * - * Memory: String is owned by namespace. Do not free or modify. - */ -const char* taurus_namespace_uri(TaurusNamespace ns); - -/** - * Get namespace prefix - * - * @param ns Namespace - * @return Prefix string or NULL if default namespace or ns is NULL - * - * Memory: String is owned by namespace. Do not free or modify. - */ -const char* taurus_namespace_prefix(TaurusNamespace ns); - -/** - * Resolve namespace prefix (with inheritance) - * - * @param elem Element to start search from - * @param prefix Prefix to resolve (NULL for default namespace) - * @return Namespace URI or NULL if not found - * - * Memory: String is owned by element. Do not free or modify. - */ -const char* taurus_element_namespace_for_prefix(TaurusElement elem, const char* prefix); - -/* ============================================================================ - * XPath Operations - * ============================================================================ */ - -/** - * Evaluate XPath expression - * - * @param doc Document (required) - * @param context Context element (NULL = document root) - * @param expression XPath expression string - * @return XPath result or NULL on error - * - * Memory: Caller must call taurus_xpath_result_free() when done - * Thread safety: Not thread-safe. One evaluation per thread. - * - * XPath 1.0 compliance: Full XPath 1.0 specification - * - All 13 axes: child, descendant, parent, ancestor, sibling, etc. - * - All 27 functions: string(), count(), position(), etc. - * - All operators: =, !=, <, <=, >, >=, +, -, *, div, mod, |, and, or - * - Predicates: [1], [@attr], [position() > 2], etc. - */ -TaurusXPathResult taurus_xpath_eval( - TaurusDocument doc, - TaurusElement context, - const char* expression -); - -/** - * Get XPath result type - * - * @param result XPath result - * @return Result type or -1 if result is NULL - */ -TaurusXPathResultType taurus_xpath_result_type(TaurusXPathResult result); - -/** - * Get nodeset size (for NODESET results) - * - * @param result XPath result - * @return Number of nodes or 0 if not a nodeset or result is NULL - */ -size_t taurus_xpath_result_count(TaurusXPathResult result); - -/** - * Get node from nodeset by index - * - * @param result XPath result - * @param index Node index (0-based) - * @return Element or NULL if index out of bounds or not a nodeset - * - * Memory: Element is owned by document. Do not free separately. - */ -TaurusElement taurus_xpath_result_get(TaurusXPathResult result, size_t index); - -/** - * Get boolean value (for BOOLEAN results or type conversion) - * - * @param result XPath result - * @return Boolean value (1 = true, 0 = false) - * - * Type conversion rules: - * - BOOLEAN: Direct value - * - NUMBER: true if non-zero and not NaN - * - STRING: true if non-empty - * - NODESET: true if non-empty - */ -int taurus_xpath_result_boolean(TaurusXPathResult result); - -/** - * Get number value (for NUMBER results or type conversion) - * - * @param result XPath result - * @return Number value (NaN if conversion fails) - * - * Type conversion rules: - * - NUMBER: Direct value - * - BOOLEAN: 1.0 or 0.0 - * - STRING: Parsed as number (NaN if invalid) - * - NODESET: First node's string value converted to number - */ -double taurus_xpath_result_number(TaurusXPathResult result); - -/** - * Get string value (for STRING results or type conversion) - * - * @param result XPath result - * @return String value or NULL if result is NULL - * - * Memory: Caller must call taurus_free_string() when done - * - * Type conversion rules: - * - STRING: Direct value - * - BOOLEAN: "true" or "false" - * - NUMBER: String representation of number - * - NODESET: String value of first node (recursive text concatenation) - */ -char* taurus_xpath_result_string(TaurusXPathResult result); - -/** - * Free XPath result - * - * @param result Result to free (can be NULL) - */ -void taurus_xpath_result_free(TaurusXPathResult result); - -/* ============================================================================ - * Memory Management Helpers - * ============================================================================ */ - -/** - * Free string returned by libtaurus - * - * @param str String to free (can be NULL) - * - * Use this to free strings returned by: - * - taurus_xpath_result_string() - */ -void taurus_free_string(char* str); - -/* ============================================================================ - * Version Information - * ============================================================================ */ - -#define LIBTAURUS_VERSION_MAJOR 0 -#define LIBTAURUS_VERSION_MINOR 4 -#define LIBTAURUS_VERSION_PATCH 0 -#define LIBTAURUS_VERSION_STRING "0.4.0" - -/** - * Get libtaurus version string - * - * @return Version string (e.g., "0.4.0") - */ -const char* taurus_version(void); - -#ifdef __cplusplus -} -#endif - -#endif /* LIBTAURUS_H */ \ No newline at end of file diff --git a/ext/taurus/lib/include/taurus/error.h b/ext/taurus/lib/include/taurus/error.h deleted file mode 100644 index ac465e5..0000000 --- a/ext/taurus/lib/include/taurus/error.h +++ /dev/null @@ -1,117 +0,0 @@ -/* error.h - Taurus error handling - * Copyright (c) 2024, Ribose Inc. - * - * Error handling and reporting functions - */ - -#ifndef TAURUS_ERROR_H -#define TAURUS_ERROR_H - -#include "types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* ============================================================================ - * Error Handling - * ============================================================================ */ - -/** - * @brief Get last error message - * - * Returns a human-readable description of the last error that occurred. - * The string is valid until the next error occurs or the library is - * unloaded. - * - * @return Error message string, or NULL if no error has occurred - * - * @note Thread-safe: Each thread has its own error state - * @note The returned string should not be freed by the caller - */ -TAURUS_API const char* taurus_last_error(void); - -/** - * @brief Clear last error - * - * Clears the last error message. After calling this function, - * taurus_last_error() will return NULL until another error occurs. - */ -TAURUS_API void taurus_clear_error(void); - -/** - * @brief Get error code from parse result - * - * If a parse operation returns NULL, this function can be used to - * determine the specific error code. - * - * @return Error code from taurus_error_code enum - * - * @see taurus_error_code - */ -TAURUS_API taurus_error_code taurus_last_error_code(void); - -/** - * @brief Convert error code to string - * - * Converts an error code to a human-readable string. - * - * @param code Error code to convert - * @return Static string describing the error (never NULL) - * - * @note The returned string is statically allocated and should not be freed - */ -TAURUS_API const char* taurus_error_string(taurus_error_code code); - -/* ============================================================================ - * Parse Error Information - * ============================================================================ */ - -/** - * @brief Get parse error line number - * - * If a parse error occurred, returns the line number where the error - * was detected (1-based). Only valid if track_positions option was enabled. - * - * @return Line number, or 0 if not available - */ -TAURUS_API int taurus_parse_error_line(void); - -/** - * @brief Get parse error column number - * - * If a parse error occurred, returns the column number where the error - * was detected (1-based). Only valid if track_positions option was enabled. - * - * @return Column number, or 0 if not available - */ -TAURUS_API int taurus_parse_error_column(void); - -/** - * @brief Get error context snippet - * - * If an error occurred with context information, returns a snippet of the - * input showing the area around the error (typically ±2 lines). - * - * @return Context snippet string, or NULL if not available - * - * @note The returned string is owned by the error state and should not be freed - * @note The snippet is cleared when taurus_clear_error() is called - */ -TAURUS_API const char* taurus_error_context(void); - -/** - * @brief Get error byte offset - * - * If an error occurred, returns the byte offset in the input where the - * error was detected. - * - * @return Byte offset, or 0 if not available - */ -TAURUS_API size_t taurus_error_byte_offset(void); - -#ifdef __cplusplus -} -#endif - -#endif /* TAURUS_ERROR_H */ \ No newline at end of file diff --git a/ext/taurus/lib/include/taurus/taurus.h b/ext/taurus/lib/include/taurus/taurus.h deleted file mode 100644 index b35e2e0..0000000 --- a/ext/taurus/lib/include/taurus/taurus.h +++ /dev/null @@ -1,472 +0,0 @@ -/* taurus.h - Taurus public API - * Copyright (c) 2024, Ribose Inc. - * - * Pure C XML parser and XPath evaluator - * - * Taurus is a high-performance XML parser with complete XPath 1.0 support, - * designed for speed and standards compliance. It provides: - * - Fast XML parsing (comparable to Ox) - * - Complete XML Namespaces 1.0 support - * - Full XPath 1.0 implementation - * - Zero external dependencies - * - * Basic Usage: - * @code - * #include - * - * const char* xml = "Hello"; - * taurus_document* doc = taurus_parse(xml, strlen(xml)); - * if (!doc) { - * fprintf(stderr, "Parse error: %s\n", taurus_last_error()); - * return; - * } - * - * taurus_element* root = taurus_document_root(doc); - * const char* name = taurus_element_name(root); - * printf("Root: %s\n", name); - * - * taurus_document_free(doc); - * @endcode - */ - -#ifndef TAURUS_H -#define TAURUS_H - -#include -#include "types.h" -#include "error.h" -#include "xpath.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* ============================================================================ - * Version Information - * ============================================================================ */ - -#define TAURUS_VERSION_MAJOR 0 -#define TAURUS_VERSION_MINOR 5 -#define TAURUS_VERSION_PATCH 0 - -#define TAURUS_VERSION "0.6.0" - -/** - * @brief Get library version string - * - * Returns the version of the Taurus library as a string. - * - * @return Version string (e.g., "0.6.0") - * - * @note The returned string is statically allocated and should not be freed - */ -TAURUS_API const char* taurus_version(void); - -/** - * @brief Get version components - * - * Returns the version of the Taurus library as integers. - * - * @param major Pointer to store major version (can be NULL) - * @param minor Pointer to store minor version (can be NULL) - * @param patch Pointer to store patch version (can be NULL) - */ -TAURUS_API void taurus_version_components(int* major, int* minor, int* patch); - -/* ============================================================================ - * Parse Options - * ============================================================================ */ - -/** - * @brief Initialize parse options with defaults - * - * Sets parse options to their default values: - * - strict: 1 (enabled) - * - preserve_whitespace: 0 (disabled) - * - track_positions: 0 (disabled) - * - * @param opts Options structure to initialize (must not be NULL) - */ -TAURUS_API void taurus_parse_options_init(taurus_parse_options* opts); - -/* ============================================================================ - * Document Functions - * ============================================================================ */ - -/** - * @brief Parse XML string into document - * - * Parses an XML string and returns a document structure. - * Uses default parse options (strict mode, no whitespace preservation). - * - * @param xml XML string to parse (need not be null-terminated) - * @param len Length of XML string in bytes - * @return Document structure on success, NULL on error - * - * @note Caller owns returned document and must free with taurus_document_free() - * @note Use taurus_last_error() to get error details if NULL is returned - * @note The xml string can be freed immediately after parsing - * - * @see taurus_parse_with_options - * @see taurus_document_free - * - * Example: - * @code - * const char* xml = "text"; - * taurus_document* doc = taurus_parse(xml, strlen(xml)); - * if (!doc) { - * fprintf(stderr, "Error: %s\n", taurus_last_error()); - * return; - * } - * // Use document... - * taurus_document_free(doc); - * @endcode - */ -TAURUS_API taurus_document* taurus_parse(const char* xml, size_t len); - -/** - * @brief Parse XML with custom options - * - * Parses an XML string with custom parse options. - * - * @param xml XML string to parse - * @param len Length of XML string - * @param opts Parse options (NULL for defaults) - * @return Document structure on success, NULL on error - * - * @note Caller owns returned document and must free with taurus_document_free() - * - * Example: - * @code - * taurus_parse_options opts; - * taurus_parse_options_init(&opts); - * opts.preserve_whitespace = 1; - * - * taurus_document* doc = taurus_parse_with_options(xml, len, &opts); - * @endcode - */ -TAURUS_API taurus_document* taurus_parse_with_options( - const char* xml, - size_t len, - const taurus_parse_options* opts -); - -/** - * @brief Free document and all its contents - * - * Frees a document and all elements, attributes, and text it contains. - * - * @param doc Document to free (can be NULL) - * - * @note After calling this function, the document pointer and all - * elements/attributes obtained from it are invalid - * @note It is safe to call this function with NULL - */ -TAURUS_API void taurus_document_free(taurus_document* doc); - -/** - * @brief Get root element of document - * - * Returns the root element of a parsed document. - * - * @param doc Document to query (must not be NULL) - * @return Root element, or NULL if document has no root - * - * @note The returned element is owned by the document - * @note Do not free the returned element - */ -TAURUS_API taurus_element* taurus_document_root(taurus_document* doc); - -/** - * @brief Get document encoding - * - * Returns the encoding specified in the XML declaration, if any. - * - * @param doc Document to query (must not be NULL) - * @return Encoding string (e.g., "UTF-8"), or NULL if not specified - * - * @note The returned string is owned by the document - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_document_encoding(taurus_document* doc); - -/* ============================================================================ - * Element Functions - * ============================================================================ */ - -/** - * @brief Get element name - * - * Returns the local name of an element (without namespace prefix). - * - * @param elem Element to query (must not be NULL) - * @return Element name (never NULL, but may be empty string) - * - * @note The returned string is owned by the element - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_element_name(taurus_element* elem); - -/** - * @brief Get element namespace URI - * - * Returns the namespace URI of an element. - * - * @param elem Element to query (must not be NULL) - * @return Namespace URI, or NULL if element has no namespace - * - * @note The returned string is owned by the element - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_element_namespace(taurus_element* elem); - -/** - * @brief Get element namespace prefix - * - * Returns the namespace prefix used in the element's qualified name. - * - * @param elem Element to query (must not be NULL) - * @return Namespace prefix, or NULL if element has no prefix - * - * @note The returned string is owned by the element - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_element_prefix(taurus_element* elem); - -/** - * @brief Get element text content - * - * Returns the concatenated text content of an element and all its descendants. - * - * @param elem Element to query (must not be NULL) - * @return Text content (never NULL, but may be empty string) - * - * @note The returned string is owned by the element - * @note Do not free the returned string - * @note For mixed content, this returns all text nodes concatenated - */ -TAURUS_API const char* taurus_element_text(taurus_element* elem); - -/** - * @brief Get parent element - * - * Returns the parent element of an element. - * - * @param elem Element to query (must not be NULL) - * @return Parent element, or NULL if element is root - * - * @note The returned element is owned by the document - * @note Do not free the returned element - */ -TAURUS_API taurus_element* taurus_element_parent(taurus_element* elem); - -/** - * @brief Get number of child elements - * - * Returns the number of direct child elements. - * - * @param elem Element to query (must not be NULL) - * @return Number of child elements - * - * @note This only counts element children, not text nodes - */ -TAURUS_API size_t taurus_element_child_count(taurus_element* elem); - -/** - * @brief Get child element by index - * - * Returns the child element at the specified index. - * - * @param elem Element to query (must not be NULL) - * @param index Index of child (0-based) - * @return Child element, or NULL if index out of bounds - * - * @note The returned element is owned by the document - * @note Do not free the returned element - */ -TAURUS_API taurus_element* taurus_element_child(taurus_element* elem, size_t index); - -/* ============================================================================ - * Attribute Functions - * ============================================================================ */ - -/** - * @brief Get number of attributes - * - * Returns the number of attributes an element has. - * - * @param elem Element to query (must not be NULL) - * @return Number of attributes - */ -TAURUS_API size_t taurus_element_attribute_count(taurus_element* elem); - -/** - * @brief Get attribute by index - * - * Returns the attribute at the specified index. - * - * @param elem Element to query (must not be NULL) - * @param index Index of attribute (0-based) - * @return Attribute, or NULL if index out of bounds - * - * @note The returned attribute is owned by the element - * @note Do not free the returned attribute - */ -TAURUS_API taurus_attribute* taurus_element_attribute( - taurus_element* elem, - size_t index -); - -/** - * @brief Get attribute value by name - * - * Returns the value of an attribute with the specified name. - * - * @param elem Element to query (must not be NULL) - * @param name Attribute name (must not be NULL) - * @return Attribute value, or NULL if attribute not found - * - * @note The returned string is owned by the element - * @note Do not free the returned string - * @note This searches by local name only (ignores namespaces) - */ -TAURUS_API const char* taurus_element_get_attribute( - taurus_element* elem, - const char* name -); - -/** - * @brief Check if element has attribute - * - * Checks if an element has an attribute with the specified name. - * - * @param elem Element to query (must not be NULL) - * @param name Attribute name (must not be NULL) - * @return 1 if attribute exists, 0 otherwise - */ -TAURUS_API int taurus_element_has_attribute( - taurus_element* elem, - const char* name -); - -/** - * @brief Get attribute name - * - * Returns the local name of an attribute. - * - * @param attr Attribute to query (must not be NULL) - * @return Attribute name (never NULL) - * - * @note The returned string is owned by the attribute - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_attribute_name(taurus_attribute* attr); - -/** - * @brief Get attribute value - * - * Returns the value of an attribute. - * - * @param attr Attribute to query (must not be NULL) - * @return Attribute value (never NULL, but may be empty string) - * - * @note The returned string is owned by the attribute - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_attribute_value(taurus_attribute* attr); - -/** - * @brief Get attribute namespace URI - * - * Returns the namespace URI of an attribute. - * - * @param attr Attribute to query (must not be NULL) - * @return Namespace URI, or NULL if attribute has no namespace - * - * @note The returned string is owned by the attribute - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_attribute_namespace(taurus_attribute* attr); - -/* ============================================================================ - * Namespace Functions - * ============================================================================ */ - -/** - * @brief Get number of namespace declarations - * - * Returns the number of namespace declarations on an element. - * - * @param elem Element to query (must not be NULL) - * @return Number of namespace declarations - * - * @note This only counts declarations on this element, not inherited ones - */ -TAURUS_API size_t taurus_element_namespace_count(taurus_element* elem); - -/** - * @brief Get namespace declaration by index - * - * Returns the namespace declaration at the specified index. - * - * @param elem Element to query (must not be NULL) - * @param index Index of namespace (0-based) - * @return Namespace declaration, or NULL if index out of bounds - * - * @note The returned namespace is owned by the element - * @note Do not free the returned namespace - */ -TAURUS_API taurus_namespace* taurus_element_namespace_decl( - taurus_element* elem, - size_t index -); - -/** - * @brief Resolve namespace prefix - * - * Resolves a namespace prefix to its URI, considering inheritance. - * - * @param elem Element to start search from (must not be NULL) - * @param prefix Namespace prefix to resolve (NULL for default namespace) - * @return Namespace URI, or NULL if prefix not found - * - * @note The returned string is owned by the document - * @note Do not free the returned string - * @note Searches up the element tree to find matching declaration - */ -TAURUS_API const char* taurus_element_resolve_namespace( - taurus_element* elem, - const char* prefix -); - -/** - * @brief Get namespace prefix - * - * Returns the prefix of a namespace declaration. - * - * @param ns Namespace to query (must not be NULL) - * @return Namespace prefix, or NULL for default namespace - * - * @note The returned string is owned by the namespace - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_namespace_prefix(taurus_namespace* ns); - -/** - * @brief Get namespace URI - * - * Returns the URI of a namespace declaration. - * - * @param ns Namespace to query (must not be NULL) - * @return Namespace URI (never NULL) - * - * @note The returned string is owned by the namespace - * @note Do not free the returned string - */ -TAURUS_API const char* taurus_namespace_uri(taurus_namespace* ns); - -#ifdef __cplusplus -} -#endif - -#endif /* TAURUS_H */ \ No newline at end of file diff --git a/ext/taurus/lib/include/taurus/types.h b/ext/taurus/lib/include/taurus/types.h deleted file mode 100644 index 2e678df..0000000 --- a/ext/taurus/lib/include/taurus/types.h +++ /dev/null @@ -1,153 +0,0 @@ -/* types.h - Taurus public type definitions - * Copyright (c) 2024, Ribose Inc. - * - * Public type definitions for libtaurus - */ - -#ifndef TAURUS_TYPES_H -#define TAURUS_TYPES_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* ============================================================================ - * API Export/Import Macros - * ============================================================================ */ - -#if defined(_WIN32) || defined(__CYGWIN__) - #ifdef TAURUS_BUILDING_DLL - #define TAURUS_API __declspec(dllexport) - #elif defined(TAURUS_DLL) - #define TAURUS_API __declspec(dllimport) - #else - #define TAURUS_API - #endif -#else - #if __GNUC__ >= 4 - #define TAURUS_API __attribute__((visibility("default"))) - #else - #define TAURUS_API - #endif -#endif - -/* ============================================================================ - * Opaque Types - * ============================================================================ */ - -/** - * @brief Opaque document structure - * - * Represents a parsed XML document. The internal structure is hidden - * from users to maintain API stability. - */ -typedef struct taurus_document taurus_document; - -/** - * @brief Opaque element structure - * - * Represents an XML element node. The internal structure is hidden - * from users to maintain API stability. - */ -typedef struct taurus_element taurus_element; - -/** - * @brief Opaque attribute structure - * - * Represents an XML attribute. The internal structure is hidden - * from users to maintain API stability. - */ -typedef struct taurus_attribute taurus_attribute; - -/** - * @brief Opaque namespace structure - * - * Represents an XML namespace declaration. The internal structure is hidden - * from users to maintain API stability. - */ -typedef struct taurus_namespace taurus_namespace; - -/** - * @brief Opaque XPath result structure - * - * Represents the result of an XPath evaluation. The internal structure is - * hidden from users to maintain API stability. - */ -typedef struct taurus_xpath_result taurus_xpath_result; - -/* ============================================================================ - * Enumerations - * ============================================================================ */ - -/** - * @brief XPath result type enumeration - * - * Defines the four possible result types from XPath 1.0 evaluation. - */ -typedef enum { - TAURUS_XPATH_BOOLEAN = 0, /**< Boolean result (true/false) */ - TAURUS_XPATH_NUMBER = 1, /**< Number result (double) */ - TAURUS_XPATH_STRING = 2, /**< String result */ - TAURUS_XPATH_NODESET = 3 /**< Node-set result (array of elements) */ -} taurus_xpath_result_type; - -/** - * @brief Error codes - * - * Error codes returned by all Taurus functions. - * Organized by category (parse, XPath, evaluation, generic). - */ -typedef enum { - /* Success */ - TAURUS_OK = 0, /**< Success */ - - /* Parse errors (1xx) - XML parsing issues */ - TAURUS_ERROR_NULL_INPUT = 1, /**< NULL input provided */ - TAURUS_ERROR_EMPTY_INPUT = 2, /**< Empty input provided */ - TAURUS_ERROR_PARSE_FAILED = 3, /**< Parse failed (malformed XML) */ - TAURUS_ERROR_INVALID_XML = 4, /**< Invalid XML structure */ - TAURUS_ERROR_UNCLOSED_TAG = 100, /**< Element tag not closed */ - TAURUS_ERROR_INVALID_ATTR = 101, /**< Invalid attribute syntax */ - TAURUS_ERROR_ENCODING = 102, /**< Encoding error */ - TAURUS_ERROR_NAMESPACE = 103, /**< Namespace error */ - TAURUS_ERROR_MALFORMED = 104, /**< Malformed XML */ - - /* XPath errors (2xx) - Query syntax and semantics */ - TAURUS_ERROR_XPATH_SYNTAX = 200, /**< XPath syntax error */ - TAURUS_ERROR_XPATH_FUNCTION = 201, /**< Unknown or invalid function */ - TAURUS_ERROR_XPATH_TYPE_MISMATCH = 202, /**< Type mismatch in operation */ - TAURUS_ERROR_XPATH_NAMESPACE = 203, /**< Unregistered namespace prefix */ - TAURUS_ERROR_XPATH_UNKNOWN_AXIS = 204, /**< Unknown axis specifier */ - - /* Evaluation errors (3xx) - Runtime issues */ - TAURUS_ERROR_EVAL_CONTEXT = 300, /**< Invalid evaluation context */ - TAURUS_ERROR_EVAL_ARGUMENT = 301, /**< Invalid function argument */ - TAURUS_ERROR_EVAL_OVERFLOW = 302, /**< Numeric overflow */ - - /* Generic errors (9xx) */ - TAURUS_ERROR_OUT_OF_MEMORY = 900, /**< Memory allocation failed */ - TAURUS_ERROR_INTERNAL = 999 /**< Internal error */ -} taurus_error_code; - -/* ============================================================================ - * Options Structures - * ============================================================================ */ - -/** - * @brief XML parse options - * - * Options that control XML parsing behavior. - */ -typedef struct { - int strict; /**< Strict XML validation (1=strict, 0=lenient) */ - int preserve_whitespace; /**< Preserve whitespace-only text nodes */ - int track_positions; /**< Track line/column positions for errors */ -} taurus_parse_options; - -#ifdef __cplusplus -} -#endif - -#endif /* TAURUS_TYPES_H */ \ No newline at end of file diff --git a/ext/taurus/lib/include/taurus/xpath.h b/ext/taurus/lib/include/taurus/xpath.h deleted file mode 100644 index f2441ae..0000000 --- a/ext/taurus/lib/include/taurus/xpath.h +++ /dev/null @@ -1,252 +0,0 @@ -/* xpath.h - Taurus XPath 1.0 API - * Copyright (c) 2024, Ribose Inc. - * - * Complete XPath 1.0 implementation in C - */ - -#ifndef TAURUS_XPATH_H -#define TAURUS_XPATH_H - -#include "types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* ============================================================================ - * XPath Evaluation - * ============================================================================ */ - -/** - * @brief Evaluate XPath expression against document - * - * Evaluates an XPath 1.0 expression against the given document. - * The expression is evaluated with the document root as the context node. - * - * @param doc Document to evaluate against (must not be NULL) - * @param xpath_expr XPath expression string (must not be NULL) - * @param expr_len Length of expression string - * @return XPath result, or NULL on error - * - * @note Caller owns the returned result and must free it with - * taurus_xpath_result_free() - * @note Use taurus_last_error() to get error details if NULL is returned - * - * @see taurus_xpath_result_free - * @see taurus_xpath_eval_with_context - * - * Example: - * @code - * taurus_document* doc = taurus_parse(xml, strlen(xml)); - * taurus_xpath_result* result = taurus_xpath_eval(doc, "//book", 6); - * if (result) { - * // Use result... - * taurus_xpath_result_free(result); - * } - * taurus_document_free(doc); - * @endcode - */ -TAURUS_API taurus_xpath_result* taurus_xpath_eval( - taurus_document* doc, - const char* xpath_expr, - size_t expr_len -); - -/** - * @brief Evaluate XPath with specific context node - * - * Evaluates an XPath expression with a specific element as the context node. - * This allows evaluating relative paths from any point in the document. - * - * @param doc Document containing the context node - * @param context_node Element to use as context (must be in doc) - * @param xpath_expr XPath expression string - * @param expr_len Length of expression string - * @return XPath result, or NULL on error - * - * @note Caller owns the returned result and must free it with - * taurus_xpath_result_free() - * - * Example: - * @code - * taurus_element* root = taurus_document_root(doc); - * taurus_xpath_result* result = taurus_xpath_eval_with_context( - * doc, root, "./child", 7 - * ); - * @endcode - */ -TAURUS_API taurus_xpath_result* taurus_xpath_eval_with_context( - taurus_document* doc, - taurus_element* context_node, - const char* xpath_expr, - size_t expr_len -); - -/* ============================================================================ - * XPath Result Management - * ============================================================================ */ - -/** - * @brief Free XPath result - * - * Frees all memory associated with an XPath result, including any - * node-sets, strings, or other data contained in the result. - * - * @param result Result to free (can be NULL) - * - * @note After calling this function, the result pointer is invalid - * and should not be used - */ -TAURUS_API void taurus_xpath_result_free(taurus_xpath_result* result); - -/** - * @brief Get result type - * - * Returns the type of an XPath result (boolean, number, string, or node-set). - * - * @param result Result to query (must not be NULL) - * @return Result type - * - * @see taurus_xpath_result_type - */ -TAURUS_API taurus_xpath_result_type taurus_xpath_result_get_type( - const taurus_xpath_result* result -); - -/* ============================================================================ - * Boolean Results - * ============================================================================ */ - -/** - * @brief Get boolean value from result - * - * Returns the boolean value of a result. If the result is not a boolean, - * it is converted according to XPath 1.0 rules: - * - Number: false if 0 or NaN, true otherwise - * - String: false if empty, true otherwise - * - Node-set: false if empty, true otherwise - * - * @param result Result to convert (must not be NULL) - * @return Boolean value (0=false, 1=true) - */ -TAURUS_API int taurus_xpath_result_as_boolean(const taurus_xpath_result* result); - -/* ============================================================================ - * Number Results - * ============================================================================ */ - -/** - * @brief Get number value from result - * - * Returns the numeric value of a result. If the result is not a number, - * it is converted according to XPath 1.0 rules: - * - Boolean: 0.0 if false, 1.0 if true - * - String: parsed as number (NaN if invalid) - * - Node-set: string-value of first node, then parsed - * - * @param result Result to convert (must not be NULL) - * @return Numeric value (may be NaN or infinity) - */ -TAURUS_API double taurus_xpath_result_as_number(const taurus_xpath_result* result); - -/* ============================================================================ - * String Results - * ============================================================================ */ - -/** - * @brief Get string value from result - * - * Returns the string value of a result. If the result is not a string, - * it is converted according to XPath 1.0 rules: - * - Boolean: "true" or "false" - * - Number: number as string - * - Node-set: string-value of first node - * - * @param result Result to convert (must not be NULL) - * @return String value (never NULL, but may be empty string) - * - * @note Caller must free the returned string with free() - * @note Always returns a new allocated string - */ -TAURUS_API char* taurus_xpath_result_as_string(const taurus_xpath_result* result); - -/* ============================================================================ - * Node-set Results - * ============================================================================ */ - -/** - * @brief Get node-set size - * - * Returns the number of nodes in a node-set result. - * If the result is not a node-set, returns 0. - * - * @param result Result to query (must not be NULL) - * @return Number of nodes (0 if not a node-set) - */ -TAURUS_API size_t taurus_xpath_result_nodeset_size( - const taurus_xpath_result* result -); - -/** - * @brief Get node from node-set - * - * Returns the node at the specified index in a node-set result. - * Nodes are returned in document order. - * - * @param result Result to query (must not be NULL) - * @param index Index of node (0-based) - * @return Element at index, or NULL if index out of bounds or not a node-set - * - * @note The returned element is owned by the document, not the result - * @note Do not free the returned element - */ -TAURUS_API taurus_element* taurus_xpath_result_nodeset_get( - const taurus_xpath_result* result, - size_t index -); - -/* ============================================================================ - * XPath Function Support - * ============================================================================ */ - -/** - * @brief Check if XPath function is supported - * - * Checks if a specific XPath function is implemented and available. - * All 27 core XPath 1.0 functions are supported. - * - * @param function_name Function name to check (e.g., "count", "string-length") - * @return 1 if supported, 0 if not - * - * Supported functions: - * - Node-set: last(), position(), count(), id(), local-name(), namespace-uri(), name() - * - String: string(), concat(), starts-with(), contains(), substring-before(), - * substring-after(), substring(), string-length(), normalize-space(), - * translate() - * - Boolean: boolean(), not(), true(), false(), lang() - * - Number: number(), sum(), floor(), ceiling(), round() - */ -TAURUS_API int taurus_xpath_function_supported(const char* function_name); - -/** - * @brief Get list of supported XPath functions - * - * Returns a NULL-terminated array of function names that are supported. - * - * @return Array of function names (static, do not free) - * - * Example: - * @code - * const char** functions = taurus_xpath_supported_functions(); - * for (int i = 0; functions[i] != NULL; i++) { - * printf("%s\n", functions[i]); - * } - * @endcode - */ -TAURUS_API const char** taurus_xpath_supported_functions(void); - -#ifdef __cplusplus -} -#endif - -#endif /* TAURUS_XPATH_H */ \ No newline at end of file diff --git a/ext/taurus/lib/man/libtaurus.5.adoc b/ext/taurus/lib/man/libtaurus.5.adoc deleted file mode 100644 index db5f381..0000000 --- a/ext/taurus/lib/man/libtaurus.5.adoc +++ /dev/null @@ -1,961 +0,0 @@ -= libtaurus(5) -:doctype: manpage -:man manual: Taurus Library Manual -:man source: Taurus 2.0.0 -:man version: 2.0.0 - -== NAME -libtaurus - fast XML parser and XPath evaluator C library - -== SYNOPSIS -[source,c] ----- -#include - -// Compile and link: -// gcc -o app app.c -ltaurus -// Or with pkg-config: -// gcc -o app app.c $(pkg-config --cflags --libs taurus) ----- - -== DESCRIPTION -*libtaurus* is a high-performance C library for parsing XML documents and -evaluating XPath expressions. It provides complete implementations of: - -* XML 1.0 (Fifth Edition) -* XML Namespaces 1.0 (Third Edition) -* XPath 1.0 - -The library is designed for speed and standards compliance with zero external -dependencies. It uses SIMD optimizations where available and maintains minimal -memory overhead. - -=== Key Features - -* Fast XML parsing comparable to Ox -* Complete XPath 1.0 with all 27 functions and 13 axes -* Full namespace support with automatic resolution -* Thread-safe error handling (per-thread error state) -* Zero memory leaks (verified with valgrind) -* No external dependencies (no libxml2) - -== API OVERVIEW - -The API is organized into functional groups: - -* *Document API* - Parsing and document management -* *Element API* - DOM tree navigation and access -* *Attribute API* - Attribute access and iteration -* *Namespace API* - Namespace declaration and resolution -* *XPath API* - XPath expression evaluation -* *Error API* - Error handling and reporting - -== DATA STRUCTURES - -=== taurus_document - -Opaque structure representing a parsed XML document. - -[source,c] ----- -typedef struct taurus_document taurus_document; ----- - -Created by `taurus_parse()`, freed by `taurus_document_free()`. - -=== taurus_element - -Opaque structure representing an XML element node. - -[source,c] ----- -typedef struct taurus_element taurus_element; ----- - -Obtained from document or element navigation functions. Do not free directly. - -=== taurus_attribute - -Opaque structure representing an XML attribute. - -[source,c] ----- -typedef struct taurus_attribute taurus_attribute; ----- - -Obtained from element attribute functions. Do not free directly. - -=== taurus_namespace - -Opaque structure representing a namespace declaration. - -[source,c] ----- -typedef struct taurus_namespace taurus_namespace; ----- - -Obtained from element namespace functions. Do not free directly. - -=== taurus_xpath_result - -Opaque structure representing an XPath evaluation result. - -[source,c] ----- -typedef struct taurus_xpath_result taurus_xpath_result; ----- - -Created by `taurus_xpath_eval()`, freed by `taurus_xpath_result_free()`. - -=== taurus_xpath_result_type - -Enumeration of XPath result types. - -[source,c] ----- -typedef enum { - XPATH_RESULT_NODESET, // Node-set - XPATH_RESULT_BOOLEAN, // Boolean value - XPATH_RESULT_NUMBER, // Numeric value - XPATH_RESULT_STRING // String value -} taurus_xpath_result_type; ----- - -=== taurus_error_code - -Enumeration of error codes. - -[source,c] ----- -typedef enum { - TAURUS_OK = 0, // No error - TAURUS_ERROR_PARSE, // Parse error - TAURUS_ERROR_MEMORY, // Memory allocation failure - TAURUS_ERROR_INVALID_ARG, // Invalid argument - TAURUS_ERROR_XPATH, // XPath evaluation error - TAURUS_ERROR_IO // I/O error -} taurus_error_code; ----- - -=== taurus_parse_options - -Structure for parse options. - -[source,c] ----- -typedef struct { - int strict; // Strict parsing mode (1=on, 0=off) - int preserve_whitespace; // Preserve all whitespace (1=on, 0=off) - int track_positions; // Track line/column positions (1=on, 0=off) -} taurus_parse_options; ----- - -== DOCUMENT API - -=== taurus_parse - -Parse XML string into document. - -[source,c] ----- -taurus_document* taurus_parse(const char* xml, size_t len); ----- - -*Parameters*: - -* `xml` - XML string to parse (need not be null-terminated) -* `len` - Length of XML string in bytes - -*Returns*: Document structure on success, NULL on error - -*Example*: -[source,c] ----- -const char* xml = "Hello"; -taurus_document* doc = taurus_parse(xml, strlen(xml)); -if (!doc) { - fprintf(stderr, "Parse error: %s\n", taurus_last_error()); - return 1; -} -// Use document... -taurus_document_free(doc); ----- - -=== taurus_parse_with_options - -Parse XML with custom options. - -[source,c] ----- -taurus_document* taurus_parse_with_options( - const char* xml, - size_t len, - const taurus_parse_options* opts -); ----- - -*Parameters*: - -* `xml` - XML string to parse -* `len` - Length of XML string -* `opts` - Parse options (NULL for defaults) - -*Returns*: Document structure on success, NULL on error - -=== taurus_document_free - -Free document and all its contents. - -[source,c] ----- -void taurus_document_free(taurus_document* doc); ----- - -*Parameters*: - -* `doc` - Document to free (can be NULL) - -*Notes*: After calling, all elements, attributes, and data from this document -are invalid. - -=== taurus_document_root - -Get root element of document. - -[source,c] ----- -taurus_element* taurus_document_root(taurus_document* doc); ----- - -*Parameters*: - -* `doc` - Document to query (must not be NULL) - -*Returns*: Root element, or NULL if document has no root - -=== taurus_document_encoding - -Get document encoding. - -[source,c] ----- -const char* taurus_document_encoding(taurus_document* doc); ----- - -*Parameters*: - -* `doc` - Document to query (must not be NULL) - -*Returns*: Encoding string (e.g., "UTF-8"), or NULL if not specified - -== ELEMENT API - -=== taurus_element_name - -Get element name. - -[source,c] ----- -const char* taurus_element_name(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Element local name (never NULL, but may be empty) - -=== taurus_element_text - -Get element text content. - -[source,c] ----- -const char* taurus_element_text(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Concatenated text content (never NULL, but may be empty) - -=== taurus_element_parent - -Get parent element. - -[source,c] ----- -taurus_element* taurus_element_parent(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Parent element, or NULL if element is root - -=== taurus_element_child_count - -Get number of child elements. - -[source,c] ----- -size_t taurus_element_child_count(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Number of child elements (not including text nodes) - -=== taurus_element_child - -Get child element by index. - -[source,c] ----- -taurus_element* taurus_element_child(taurus_element* elem, size_t index); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) -* `index` - Index of child (0-based) - -*Returns*: Child element, or NULL if index out of bounds - -*Example*: -[source,c] ----- -size_t count = taurus_element_child_count(root); -for (size_t i = 0; i < count; i++) { - taurus_element* child = taurus_element_child(root, i); - printf("Child %zu: %s\n", i, taurus_element_name(child)); -} ----- - -== ATTRIBUTE API - -=== taurus_element_attribute_count - -Get number of attributes. - -[source,c] ----- -size_t taurus_element_attribute_count(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Number of attributes - -=== taurus_element_attribute - -Get attribute by index. - -[source,c] ----- -taurus_attribute* taurus_element_attribute( - taurus_element* elem, - size_t index -); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) -* `index` - Index of attribute (0-based) - -*Returns*: Attribute, or NULL if index out of bounds - -=== taurus_element_get_attribute - -Get attribute value by name. - -[source,c] ----- -const char* taurus_element_get_attribute( - taurus_element* elem, - const char* name -); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) -* `name` - Attribute name (must not be NULL) - -*Returns*: Attribute value, or NULL if not found - -*Example*: -[source,c] ----- -const char* id = taurus_element_get_attribute(elem, "id"); -if (id) { - printf("ID: %s\n", id); -} ----- - -=== taurus_element_has_attribute - -Check if element has attribute. - -[source,c] ----- -int taurus_element_has_attribute( - taurus_element* elem, - const char* name -); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) -* `name` - Attribute name (must not be NULL) - -*Returns*: 1 if attribute exists, 0 otherwise - -=== taurus_attribute_name - -Get attribute name. - -[source,c] ----- -const char* taurus_attribute_name(taurus_attribute* attr); ----- - -*Parameters*: - -* `attr` - Attribute to query (must not be NULL) - -*Returns*: Attribute name (never NULL) - -=== taurus_attribute_value - -Get attribute value. - -[source,c] ----- -const char* taurus_attribute_value(taurus_attribute* attr); ----- - -*Parameters*: - -* `attr` - Attribute to query (must not be NULL) - -*Returns*: Attribute value (never NULL, but may be empty) - -== NAMESPACE API - -=== taurus_element_namespace - -Get element namespace URI. - -[source,c] ----- -const char* taurus_element_namespace(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Namespace URI, or NULL if element has no namespace - -=== taurus_element_prefix - -Get element namespace prefix. - -[source,c] ----- -const char* taurus_element_prefix(taurus_element* elem); ----- - -*Parameters*: - -* `elem` - Element to query (must not be NULL) - -*Returns*: Namespace prefix, or NULL if no prefix - -=== taurus_element_resolve_namespace - -Resolve namespace prefix to URI. - -[source,c] ----- -const char* taurus_element_resolve_namespace( - taurus_element* elem, - const char* prefix -); ----- - -*Parameters*: - -* `elem` - Element to start search from (must not be NULL) -* `prefix` - Namespace prefix to resolve (NULL for default namespace) - -*Returns*: Namespace URI, or NULL if prefix not found - -*Notes*: Searches up the element tree to find matching declaration. - -== XPATH API - -=== taurus_xpath_eval - -Evaluate XPath expression against document. - -[source,c] ----- -taurus_xpath_result* taurus_xpath_eval( - taurus_document* doc, - const char* xpath_expr, - size_t expr_len -); ----- - -*Parameters*: - -* `doc` - Document to evaluate against (must not be NULL) -* `xpath_expr` - XPath expression string (must not be NULL) -* `expr_len` - Length of expression string - -*Returns*: XPath result, or NULL on error - -*Example*: -[source,c] ----- -taurus_xpath_result* result = taurus_xpath_eval(doc, "//book", 6); -if (!result) { - fprintf(stderr, "XPath error: %s\n", taurus_last_error()); - return 1; -} -// Use result... -taurus_xpath_result_free(result); ----- - -=== taurus_xpath_result_free - -Free XPath result. - -[source,c] ----- -void taurus_xpath_result_free(taurus_xpath_result* result); ----- - -*Parameters*: - -* `result` - Result to free (can be NULL) - -=== taurus_xpath_result_get_type - -Get result type. - -[source,c] ----- -taurus_xpath_result_type taurus_xpath_result_get_type( - const taurus_xpath_result* result -); ----- - -*Parameters*: - -* `result` - Result to query (must not be NULL) - -*Returns*: Result type (nodeset, boolean, number, or string) - -=== taurus_xpath_result_as_boolean - -Get boolean value from result. - -[source,c] ----- -int taurus_xpath_result_as_boolean(const taurus_xpath_result* result); ----- - -*Parameters*: - -* `result` - Result to convert (must not be NULL) - -*Returns*: Boolean value (0=false, 1=true) - -=== taurus_xpath_result_as_number - -Get number value from result. - -[source,c] ----- -double taurus_xpath_result_as_number(const taurus_xpath_result* result); ----- - -*Parameters*: - -* `result` - Result to convert (must not be NULL) - -*Returns*: Numeric value (may be NaN or infinity) - -=== taurus_xpath_result_as_string - -Get string value from result. - -[source,c] ----- -char* taurus_xpath_result_as_string(const taurus_xpath_result* result); ----- - -*Parameters*: - -* `result` - Result to convert (must not be NULL) - -*Returns*: String value (caller must free with `free()`) - -=== taurus_xpath_result_nodeset_size - -Get node-set size. - -[source,c] ----- -size_t taurus_xpath_result_nodeset_size( - const taurus_xpath_result* result -); ----- - -*Parameters*: - -* `result` - Result to query (must not be NULL) - -*Returns*: Number of nodes (0 if not a node-set) - -=== taurus_xpath_result_nodeset_get - -Get node from node-set. - -[source,c] ----- -taurus_element* taurus_xpath_result_nodeset_get( - const taurus_xpath_result* result, - size_t index -); ----- - -*Parameters*: - -* `result` - Result to query (must not be NULL) -* `index` - Index of node (0-based) - -*Returns*: Element at index, or NULL if out of bounds - -*Example*: -[source,c] ----- -taurus_xpath_result* result = taurus_xpath_eval(doc, "//book", 6); -size_t count = taurus_xpath_result_nodeset_size(result); -for (size_t i = 0; i < count; i++) { - taurus_element* book = taurus_xpath_result_nodeset_get(result, i); - printf("Book: %s\n", taurus_element_text(book)); -} -taurus_xpath_result_free(result); ----- - -== ERROR API - -=== taurus_last_error - -Get last error message. - -[source,c] ----- -const char* taurus_last_error(void); ----- - -*Returns*: Error message string, or NULL if no error - -*Notes*: Thread-safe - each thread has its own error state. - -=== taurus_clear_error - -Clear last error. - -[source,c] ----- -void taurus_clear_error(void); ----- - -=== taurus_last_error_code - -Get error code. - -[source,c] ----- -taurus_error_code taurus_last_error_code(void); ----- - -*Returns*: Error code from taurus_error_code enum - -=== taurus_parse_error_line - -Get parse error line number. - -[source,c] ----- -int taurus_parse_error_line(void); ----- - -*Returns*: Line number (1-based), or 0 if not available - -== EXAMPLES - -=== Basic XML Parsing - -[source,c] ----- -#include -#include -#include - -int main(void) { - const char* xml = "Hello"; - - // Parse XML - taurus_document* doc = taurus_parse(xml, strlen(xml)); - if (!doc) { - fprintf(stderr, "Parse error: %s\n", taurus_last_error()); - return 1; - } - - // Access root element - taurus_element* root = taurus_document_root(doc); - printf("Root: %s\n", taurus_element_name(root)); - - // Navigate children - size_t count = taurus_element_child_count(root); - for (size_t i = 0; i < count; i++) { - taurus_element* child = taurus_element_child(root, i); - printf("Child: %s = %s\n", - taurus_element_name(child), - taurus_element_text(child)); - } - - // Cleanup - taurus_document_free(doc); - return 0; -} ----- - -=== DOM Traversal - -[source,c] ----- -#include - -void print_element(taurus_element* elem, int depth) { - // Print indentation - for (int i = 0; i < depth; i++) printf(" "); - - // Print element name - printf("<%s", taurus_element_name(elem)); - - // Print attributes - size_t attr_count = taurus_element_attribute_count(elem); - for (size_t i = 0; i < attr_count; i++) { - taurus_attribute* attr = taurus_element_attribute(elem, i); - printf(" %s=\"%s\"", - taurus_attribute_name(attr), - taurus_attribute_value(attr)); - } - printf(">\n"); - - // Print children recursively - size_t child_count = taurus_element_child_count(elem); - for (size_t i = 0; i < child_count; i++) { - taurus_element* child = taurus_element_child(elem, i); - print_element(child, depth + 1); - } -} - -int main(void) { - const char* xml = ""; - taurus_document* doc = taurus_parse(xml, strlen(xml)); - - print_element(taurus_document_root(doc), 0); - - taurus_document_free(doc); - return 0; -} ----- - -=== XPath Query - -[source,c] ----- -#include - -int main(void) { - const char* xml = - "" - " C Programming" - " XPath Guide" - ""; - - taurus_document* doc = taurus_parse(xml, strlen(xml)); - - // Execute XPath query - taurus_xpath_result* result = - taurus_xpath_eval(doc, "//title", 7); - - // Process results - int type = taurus_xpath_result_get_type(result); - if (type == XPATH_RESULT_NODESET) { - size_t count = taurus_xpath_result_nodeset_size(result); - printf("Found %zu titles:\n", count); - - for (size_t i = 0; i < count; i++) { - taurus_element* elem = - taurus_xpath_result_nodeset_get(result, i); - printf(" - %s\n", taurus_element_text(elem)); - } - } - - taurus_xpath_result_free(result); - taurus_document_free(doc); - return 0; -} ----- - -=== Error Handling - -[source,c] ----- -#include - -int main(void) { - const char* malformed = ""; - - taurus_document* doc = taurus_parse(malformed, strlen(malformed)); - if (!doc) { - printf("Parse failed!\n"); - printf("Error: %s\n", taurus_last_error()); - printf("Code: %d\n", taurus_last_error_code()); - printf("Line: %d\n", taurus_parse_error_line()); - return 1; - } - - taurus_document_free(doc); - return 0; -} ----- - -=== Namespace Handling - -[source,c] ----- -#include - -int main(void) { - const char* xml = - "" - " Example" - ""; - - taurus_document* doc = taurus_parse(xml, strlen(xml)); - taurus_element* root = taurus_document_root(doc); - - // Navigate to title - taurus_element* title = taurus_element_child(root, 0); - - printf("Element: %s\n", taurus_element_name(title)); - printf("Prefix: %s\n", taurus_element_prefix(title)); - printf("Namespace: %s\n", taurus_element_namespace(title)); - - // Resolve namespace - const char* uri = taurus_element_resolve_namespace(title, "book"); - printf("Resolved: %s\n", uri); - - taurus_document_free(doc); - return 0; -} ----- - -== RETURN VALUES - -Most functions return pointers or values directly. NULL return indicates: - -* Object not found (element, attribute functions) -* Error occurred (parse, XPath functions - check `taurus_last_error()`) -* End of collection (child/attribute iteration) - -Functions never return NULL unless documented otherwise. - -== MEMORY MANAGEMENT - -=== Ownership Rules - -1. *Documents*: Caller owns, must free with `taurus_document_free()` -2. *Elements/Attributes*: Owned by document, freed automatically -3. *XPath Results*: Caller owns, must free with `taurus_xpath_result_free()` -4. *Strings from functions*: Owned by object, do not free -5. *Strings from `taurus_xpath_result_as_string()`*: Caller owns, must free with `free()` - -=== Thread Safety - -* Parsing is thread-safe if different documents -* Error state is per-thread (thread-safe) -* XPath evaluation is thread-safe if different documents -* Do not share document pointers between threads - -=== Best Practices - -* Always check return values for NULL -* Free documents and XPath results when done -* Never free elements or attributes directly -* Use `taurus_last_error()` to diagnose failures - -== FILES - -*/usr/local/include/taurus/taurus.h*:: - Main header file - -*/usr/local/include/taurus/xpath.h*:: - XPath API declarations - -*/usr/local/include/taurus/error.h*:: - Error handling API - -*/usr/local/lib/libtaurus.so*:: - Shared library (Linux) - -*/usr/local/lib/libtaurus.dylib*:: - Shared library (macOS) - -*/usr/local/lib/libtaurus.a*:: - Static library - -*/usr/local/lib/pkgconfig/taurus.pc*:: - pkg-config file - -== SEE ALSO - -*taurus*(1), *taurus-xpath*(1), *pkg-config*(1) - -== STANDARDS - -*libtaurus* implements the following W3C specifications: - -* XML 1.0 (Fifth Edition) - https://www.w3.org/TR/xml/ -* XML Namespaces 1.0 (Third Edition) - https://www.w3.org/TR/xml-names/ -* XPath 1.0 - https://www.w3.org/TR/xpath-10/ - -== BUGS - -Report bugs at: https://github.com/lutaml/taurus/issues - -== COPYRIGHT - -Copyright (c) 2024 Ribose Inc. Licensed under the MIT License. - -== AUTHORS - -Developed by Ribose Inc. and contributors. \ No newline at end of file diff --git a/ext/taurus/lib/src/attribute.c b/ext/taurus/lib/src/attribute.c deleted file mode 100644 index a8576ff..0000000 --- a/ext/taurus/lib/src/attribute.c +++ /dev/null @@ -1,101 +0,0 @@ -/* attribute.c - Taurus attribute API implementation - * Copyright (c) 2024, Ribose Inc. - * - * Attribute access functions - */ - -#include "taurus/taurus.h" -#include "taurus_internal.h" -#include - -/* ============================================================================ - * Element Attribute Access Functions - * ============================================================================ */ - -/** - * Get number of attributes - */ -TAURUS_API size_t taurus_element_attribute_count(struct taurus_element* elem) { - if (!elem) return 0; - return elem->attributes_count; -} - -/** - * Get attribute by index - */ -TAURUS_API struct taurus_attribute* taurus_element_attribute( - struct taurus_element* elem, - size_t index -) { - if (!elem) return NULL; - if (index >= elem->attributes_count) return NULL; - return elem->attributes[index]; -} - -/** - * Get attribute value by name - */ -TAURUS_API const char* taurus_element_get_attribute( - struct taurus_element* elem, - const char* name -) { - if (!elem || !name) return NULL; - - /* Search through attributes for matching name */ - for (size_t i = 0; i < elem->attributes_count; i++) { - struct taurus_attribute* attr = elem->attributes[i]; - if (attr && attr->name && strcmp(attr->name, name) == 0) { - return attr->value; - } - } - - return NULL; /* Not found */ -} - -/** - * Check if element has attribute - */ -TAURUS_API int taurus_element_has_attribute( - struct taurus_element* elem, - const char* name -) { - if (!elem || !name) return 0; - - /* Search through attributes for matching name */ - for (size_t i = 0; i < elem->attributes_count; i++) { - struct taurus_attribute* attr = elem->attributes[i]; - if (attr && attr->name && strcmp(attr->name, name) == 0) { - return 1; /* Found */ - } - } - - return 0; /* Not found */ -} - -/* ============================================================================ - * Attribute Property Functions - * ============================================================================ */ - -/** - * Get attribute name - */ -TAURUS_API const char* taurus_attribute_name(struct taurus_attribute* attr) { - if (!attr) return ""; - return attr->name ? attr->name : ""; -} - -/** - * Get attribute value - */ -TAURUS_API const char* taurus_attribute_value(struct taurus_attribute* attr) { - if (!attr) return ""; - return attr->value ? attr->value : ""; -} - -/** - * Get attribute namespace URI - */ -TAURUS_API const char* taurus_attribute_namespace(struct taurus_attribute* attr) { - if (!attr) return NULL; - return attr->namespace_uri; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/chartype.h b/ext/taurus/lib/src/chartype.h deleted file mode 100644 index c2aac94..0000000 --- a/ext/taurus/lib/src/chartype.h +++ /dev/null @@ -1,124 +0,0 @@ -/* chartype.h - Ultra-fast character classification using lookup table - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Inspired by pugixml's character classification approach. - * Replaces multiple if/else branches with single table lookup + bitwise AND. - * Expected: 10-15% speedup by eliminating branch mispredictions. - */ - -#ifndef TAURUS_CHARTYPE_H -#define TAURUS_CHARTYPE_H - -/* Character type bit flags - can be combined with bitwise OR */ -typedef enum { - ct_whitespace = 1, /* ' ', '\t', '\r', '\n' */ - ct_name_start = 2, /* [A-Za-z_:] */ - ct_name_char = 4, /* [A-Za-z0-9:_.-] */ - ct_parse_pcdata = 8, /* Everything except <, &, \r */ - ct_parse_attr = 16, /* Everything except <, &, \r, ", ' */ - ct_digit = 32, /* [0-9] */ - ct_start_symbol = 64, /* Valid start tag chars (A-Za-z) */ - ct_alpha = 128 /* [A-Za-z] */ -} chartype_t; - -/* Pre-computed character type table (256 bytes, fits in L1 cache) */ -static const unsigned char chartype_table[256] = { - /* 0-31 (control chars) */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, /* \t=1, \n=1, \r=1 */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - - /* 32-47 (space and punctuation) */ - 1, /* 32 ' ' - whitespace */ - 24, /* 33 '!' - pcdata + attr */ - 0, /* 34 '"' - quote (excluded from attr) */ - 24, /* 35 '#' - pcdata + attr */ - 24, /* 36 '$' - pcdata + attr */ - 24, /* 37 '%' - pcdata + attr */ - 0, /* 38 '&' - entity (excluded from pcdata/attr) */ - 0, /* 39 '\'' - quote (excluded from attr) */ - 24, /* 40 '(' - pcdata + attr */ - 24, /* 41 ')' - pcdata + attr */ - 24, /* 42 '*' - pcdata + attr */ - 24, /* 43 '+' - pcdata + attr */ - 24, /* 44 ',' - pcdata + attr */ - 4, /* 45 '-' - name_char only */ - 4, /* 46 '.' - name_char only */ - 24, /* 47 '/' - pcdata + attr */ - - /* 48-57 (digits) */ - 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, /* 0-9: digit + name_char */ - - /* 58-64 (punctuation) */ - 6, /* 58 ':' - name_start + name_char */ - 24, /* 59 ';' - pcdata + attr */ - 0, /* 60 '<' - tag start (excluded from pcdata/attr) */ - 24, /* 61 '=' - pcdata + attr */ - 24, /* 62 '>' - pcdata + attr */ - 24, /* 63 '?' - pcdata + attr */ - 24, /* 64 '@' - pcdata + attr */ - - /* 65-90 (A-Z) */ - 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, /* A-J */ - 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, /* K-T */ - 198, 198, 198, 198, 198, 198, /* U-Z */ - /* 198 = name_start(2) + name_char(4) + start_symbol(64) + alpha(128) */ - - /* 91-96 (punctuation) */ - 24, /* 91 '[' - pcdata + attr */ - 24, /* 92 '\\' - pcdata + attr */ - 24, /* 93 ']' - pcdata + attr */ - 24, /* 94 '^' - pcdata + attr */ - 6, /* 95 '_' - name_start + name_char */ - 24, /* 96 '`' - pcdata + attr */ - - /* 97-122 (a-z) */ - 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, /* a-j */ - 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, /* k-t */ - 198, 198, 198, 198, 198, 198, /* u-z */ - - /* 123-127 (punctuation) */ - 24, 24, 24, 24, 0, /* { | } ~ DEL */ - - /* 128-255 (extended ASCII / UTF-8) */ - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24 -}; - -/* Ultra-fast character type test - single table lookup + bitwise AND */ -static inline int is_chartype(unsigned char c, chartype_t ct) { - return chartype_table[c] & ct; -} - -/* Convenience wrappers for common checks */ -static inline int is_whitespace_fast(char c) { - return is_chartype((unsigned char)c, ct_whitespace); -} - -static inline int is_name_start_fast(char c) { - return is_chartype((unsigned char)c, ct_name_start); -} - -static inline int is_name_char_fast(char c) { - return is_chartype((unsigned char)c, ct_name_char); -} - -static inline int is_start_symbol_fast(char c) { - return is_chartype((unsigned char)c, ct_start_symbol); -} - -static inline int is_alpha_fast(char c) { - return is_chartype((unsigned char)c, ct_alpha); -} - -static inline int is_digit_fast(char c) { - return is_chartype((unsigned char)c, ct_digit); -} - -#endif /* TAURUS_CHARTYPE_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/element.c b/ext/taurus/lib/src/element.c deleted file mode 100644 index deb75df..0000000 --- a/ext/taurus/lib/src/element.c +++ /dev/null @@ -1,57 +0,0 @@ -/* element.c - Taurus element API implementation - * Copyright (c) 2024, Ribose Inc. - * - * Element traversal and access functions - */ - -#include "taurus/taurus.h" -#include "taurus_internal.h" - -/* ============================================================================ - * Element Hierarchy Functions - * ============================================================================ */ - -/** - * Get parent element - */ -TAURUS_API struct taurus_element* taurus_element_parent(struct taurus_element* elem) { - if (!elem) return NULL; - return elem->parent; -} - -/** - * Get number of child elements - */ -TAURUS_API size_t taurus_element_child_count(struct taurus_element* elem) { - if (!elem) return 0; - return elem->children_count; -} - -/** - * Get child element by index - */ -TAURUS_API struct taurus_element* taurus_element_child(struct taurus_element* elem, size_t index) { - if (!elem) return NULL; - if (index >= elem->children_count) return NULL; - return elem->children[index]; -} - -/* ============================================================================ - * Element Namespace Functions - * ============================================================================ */ - -/** - * Get element namespace URI - */ -TAURUS_API const char* taurus_element_namespace(struct taurus_element* elem) { - if (!elem) return NULL; - return elem->namespace_uri; -} - -/** - * Get element namespace prefix - */ -TAURUS_API const char* taurus_element_prefix(struct taurus_element* elem) { - if (!elem) return NULL; - return elem->prefix; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/error.c b/ext/taurus/lib/src/error.c deleted file mode 100644 index 65753fb..0000000 --- a/ext/taurus/lib/src/error.c +++ /dev/null @@ -1,271 +0,0 @@ -/* error.c - Taurus error handling implementation - * Copyright (c) 2024, Ribose Inc. - * - * Error handling with thread-local storage - */ - -#include "taurus/taurus.h" -#include "taurus_internal.h" -#include - -/* ============================================================================ - * Thread-Local Error State - * ============================================================================ */ - -/* Thread-local error state structure */ -typedef struct { - char message[512]; - char context_snippet[256]; /* Context around error position */ - taurus_error_code code; - int line; - int column; - size_t byte_offset; /* Byte offset in input */ -} taurus_error_state; - -/* Thread-local storage for error state */ -#ifdef _WIN32 - __declspec(thread) static taurus_error_state g_error_state = {{0}, {0}, TAURUS_OK, 0, 0, 0}; -#else - static __thread taurus_error_state g_error_state = {{0}, {0}, TAURUS_OK, 0, 0, 0}; -#endif - -/* ============================================================================ - * Internal Error Setting (for use by parser/evaluator) - * ============================================================================ */ - -void taurus_set_error(taurus_error_code code, const char* message) { - g_error_state.code = code; - if (message) { - strncpy(g_error_state.message, message, sizeof(g_error_state.message) - 1); - g_error_state.message[sizeof(g_error_state.message) - 1] = '\0'; - } else { - g_error_state.message[0] = '\0'; - } -} - -void taurus_set_parse_error_position(int line, int column) { - g_error_state.line = line; - g_error_state.column = column; -} - -void taurus_set_error_with_context( - taurus_error_code code, - const char* message, - const char* input, - size_t byte_offset, - int line, - int column -) { - g_error_state.code = code; - g_error_state.line = line; - g_error_state.column = column; - g_error_state.byte_offset = byte_offset; - - /* Copy message */ - if (message) { - strncpy(g_error_state.message, message, sizeof(g_error_state.message) - 1); - g_error_state.message[sizeof(g_error_state.message) - 1] = '\0'; - } else { - g_error_state.message[0] = '\0'; - } - - /* Extract context snippet if input provided */ - if (input) { - taurus_extract_context_snippet( - input, - byte_offset, - line, - g_error_state.context_snippet, - sizeof(g_error_state.context_snippet) - ); - } else { - g_error_state.context_snippet[0] = '\0'; - } -} - -/* Extract context snippet (±2 lines around error position) */ -void taurus_extract_context_snippet( - const char* input, - size_t offset, - int error_line, - char* out_buffer, - size_t buffer_size -) { - if (!input || !out_buffer || buffer_size == 0) { - return; - } - - /* Find current line start */ - const char* current_line_start = input + offset; - while (current_line_start > input && *(current_line_start - 1) != '\n') { - current_line_start--; - } - - /* Find current line end */ - const char* current_line_end = input + offset; - while (*current_line_end && *current_line_end != '\n') { - current_line_end++; - } - - /* Calculate position within line for marker */ - size_t marker_pos = (size_t)(input + offset - current_line_start); - - /* Copy the current line */ - size_t line_len = (size_t)(current_line_end - current_line_start); - - /* Check if we have enough space for line + newline + marker + null */ - size_t needed_space = line_len + 1 + marker_pos + 1 + 1; /* line + \n + spaces + ^ + \0 */ - - if (needed_space > buffer_size) { - /* Not enough space for marker, just copy truncated line */ - size_t max_copy = buffer_size > 1 ? buffer_size - 1 : 0; - if (line_len > max_copy) { - line_len = max_copy; - } - if (line_len > 0) { - memcpy(out_buffer, current_line_start, line_len); - } - out_buffer[line_len] = '\0'; - return; - } - - /* We have enough space - copy line + marker */ - size_t write_pos = 0; - - /* Copy line content */ - memcpy(out_buffer + write_pos, current_line_start, line_len); - write_pos += line_len; - - /* Add newline */ - out_buffer[write_pos++] = '\n'; - - /* Add marker line with spaces and ^ */ - for (size_t i = 0; i < marker_pos; i++) { - out_buffer[write_pos++] = ' '; - } - out_buffer[write_pos++] = '^'; - out_buffer[write_pos] = '\0'; -} - -/* ============================================================================ - * Public Error API - * ============================================================================ */ - -/** - * Get last error message - */ -TAURUS_API const char* taurus_last_error(void) { - if (g_error_state.message[0] == '\0') { - return NULL; - } - return g_error_state.message; -} - -/** - * Clear last error - */ -TAURUS_API void taurus_clear_error(void) { - g_error_state.message[0] = '\0'; - g_error_state.context_snippet[0] = '\0'; - g_error_state.code = TAURUS_OK; - g_error_state.line = 0; - g_error_state.column = 0; - g_error_state.byte_offset = 0; -} - -/** - * Get error code from parse result - */ -TAURUS_API taurus_error_code taurus_last_error_code(void) { - return g_error_state.code; -} - -/** - * Convert error code to string - */ -TAURUS_API const char* taurus_error_string(taurus_error_code code) { - switch (code) { - case TAURUS_OK: - return "Success"; - - /* Parse errors */ - case TAURUS_ERROR_NULL_INPUT: - return "NULL input provided"; - case TAURUS_ERROR_EMPTY_INPUT: - return "Empty input provided"; - case TAURUS_ERROR_PARSE_FAILED: - return "Parse failed (malformed XML)"; - case TAURUS_ERROR_INVALID_XML: - return "Invalid XML structure"; - case TAURUS_ERROR_UNCLOSED_TAG: - return "Element tag not closed"; - case TAURUS_ERROR_INVALID_ATTR: - return "Invalid attribute syntax"; - case TAURUS_ERROR_ENCODING: - return "Encoding error"; - case TAURUS_ERROR_NAMESPACE: - return "Namespace error"; - case TAURUS_ERROR_MALFORMED: - return "Malformed XML"; - - /* XPath errors */ - case TAURUS_ERROR_XPATH_SYNTAX: - return "XPath syntax error"; - case TAURUS_ERROR_XPATH_FUNCTION: - return "Unknown or invalid XPath function"; - case TAURUS_ERROR_XPATH_TYPE_MISMATCH: - return "XPath type mismatch"; - case TAURUS_ERROR_XPATH_NAMESPACE: - return "Unregistered namespace prefix in XPath"; - case TAURUS_ERROR_XPATH_UNKNOWN_AXIS: - return "Unknown XPath axis"; - - /* Evaluation errors */ - case TAURUS_ERROR_EVAL_CONTEXT: - return "Invalid evaluation context"; - case TAURUS_ERROR_EVAL_ARGUMENT: - return "Invalid function argument"; - case TAURUS_ERROR_EVAL_OVERFLOW: - return "Numeric overflow"; - - /* Generic errors */ - case TAURUS_ERROR_OUT_OF_MEMORY: - return "Memory allocation failed"; - case TAURUS_ERROR_INTERNAL: - return "Internal error"; - - default: - return "Unknown error"; - } -} - -/** - * Get parse error line number - */ -TAURUS_API int taurus_parse_error_line(void) { - return g_error_state.line; -} - -/** - * Get parse error column number - */ -TAURUS_API int taurus_parse_error_column(void) { - return g_error_state.column; -} - -/** - * Get error context snippet - */ -TAURUS_API const char* taurus_error_context(void) { - if (g_error_state.context_snippet[0] == '\0') { - return NULL; - } - return g_error_state.context_snippet; -} - -/** - * Get error byte offset - */ -TAURUS_API size_t taurus_error_byte_offset(void) { - return g_error_state.byte_offset; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/namespace.c b/ext/taurus/lib/src/namespace.c deleted file mode 100644 index e0e9e03..0000000 --- a/ext/taurus/lib/src/namespace.c +++ /dev/null @@ -1,92 +0,0 @@ -/* namespace.c - Taurus namespace API implementation - * Copyright (c) 2024, Ribose Inc. - * - * Namespace declaration and resolution functions - */ - -#include "taurus/taurus.h" -#include "taurus_internal.h" -#include - -/* ============================================================================ - * Element Namespace Declaration Functions - * ============================================================================ */ - -/** - * Get number of namespace declarations - */ -TAURUS_API size_t taurus_element_namespace_count(struct taurus_element* elem) { - if (!elem) return 0; - return elem->namespaces_count; -} - -/** - * Get namespace declaration by index - */ -TAURUS_API struct taurus_namespace* taurus_element_namespace_decl( - struct taurus_element* elem, - size_t index -) { - if (!elem) return NULL; - if (index >= elem->namespaces_count) return NULL; - - /* Traverse linked list to find the nth namespace */ - struct taurus_namespace* ns = elem->namespaces; - for (size_t i = 0; i < index && ns; i++) { - ns = ns->next; - } - - return ns; -} - -/** - * Resolve namespace prefix - */ -TAURUS_API const char* taurus_element_resolve_namespace( - struct taurus_element* elem, - const char* prefix -) { - if (!elem) return NULL; - - /* Search up the element tree for matching namespace declaration */ - struct taurus_element* current = elem; - while (current) { - /* Check namespaces on this element */ - struct taurus_namespace* ns = current->namespaces; - while (ns) { - /* Match prefix (NULL matches default namespace) */ - if (prefix == NULL && ns->prefix == NULL) { - return ns->uri; - } - if (prefix && ns->prefix && strcmp(prefix, ns->prefix) == 0) { - return ns->uri; - } - ns = ns->next; - } - - /* Move up to parent */ - current = current->parent; - } - - return NULL; /* Not found */ -} - -/* ============================================================================ - * Namespace Property Functions - * ============================================================================ */ - -/** - * Get namespace prefix - */ -TAURUS_API const char* taurus_namespace_prefix(struct taurus_namespace* ns) { - if (!ns) return NULL; - return ns->prefix; /* NULL for default namespace */ -} - -/** - * Get namespace URI - */ -TAURUS_API const char* taurus_namespace_uri(struct taurus_namespace* ns) { - if (!ns) return ""; - return ns->uri ? ns->uri : ""; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_content.c b/ext/taurus/lib/src/parse_content.c deleted file mode 100644 index 67e424d..0000000 --- a/ext/taurus/lib/src/parse_content.c +++ /dev/null @@ -1,395 +0,0 @@ -/* parse_content.c - Content and namespace processing for XML parser - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Session 84: Modularized from taurus_parse.c - * Session 85: Added entity reference expansion - * Functions for processing element content, namespace declarations, and attributes - */ - -#include "parse_internal.h" -#include -#include -#include - -/* ================================================================== - * ENTITY REFERENCE EXPANSION - * ================================================================== */ - -/* Built-in XML entities (predefined in XML spec) */ -static struct { - const char* name; - const char* value; -} builtin_entities[] = { - {"lt", "<"}, - {"gt", ">"}, - {"amp", "&"}, - {"apos", "'"}, - {"quot", "\""}, - {NULL, NULL} -}; - -/* Expand entity reference &name; or &#number; or &#xhex; - * Returns expanded string (MUST be freed by caller) or NULL if unknown - * - * Handles: - * - Built-in entities: < > & ' " - * - Decimal character refs: A -> 'A' - * - Hexadecimal character refs: A -> 'A' - */ -char* expand_entity_reference(const char* ref, size_t len) { - size_t i; - char* result; - unsigned long code; - char* endptr; - char number_buf[32]; - - if (!ref || len == 0) return NULL; - - /* Check for character reference: &#... or &#x... */ - if (len >= 2 && ref[0] == '#') { - /* Decimal: A */ - if (ref[1] != 'x' && ref[1] != 'X') { - /* Copy number part to null-terminated buffer */ - if (len - 1 >= sizeof(number_buf)) { - return NULL; /* Number too long */ - } - memcpy(number_buf, ref + 1, len - 1); - number_buf[len - 1] = '\0'; - - /* Parse decimal number */ - code = strtoul(number_buf, &endptr, 10); - if (*endptr != '\0' || code > 0x10FFFF) { - return NULL; /* Invalid number or out of Unicode range */ - } - } - /* Hexadecimal: A or A */ - else { - if (len < 3) return NULL; - - /* Copy hex part to null-terminated buffer */ - if (len - 2 >= sizeof(number_buf)) { - return NULL; /* Number too long */ - } - memcpy(number_buf, ref + 2, len - 2); - number_buf[len - 2] = '\0'; - - /* Parse hexadecimal number */ - code = strtoul(number_buf, &endptr, 16); - if (*endptr != '\0' || code > 0x10FFFF) { - return NULL; /* Invalid number or out of Unicode range */ - } - } - - /* Convert code point to UTF-8 (simplified: only ASCII for now) */ - if (code <= 0x7F) { - result = (char*)taurus_malloc(2); - if (result) { - result[0] = (char)code; - result[1] = '\0'; - } - return result; - } else { - /* TODO: Full UTF-8 encoding for higher code points */ - return NULL; /* For now, only ASCII supported */ - } - } - - /* Named entity reference - check built-in table */ - for (i = 0; builtin_entities[i].name != NULL; i++) { - size_t name_len = strlen(builtin_entities[i].name); - if (len == name_len && memcmp(ref, builtin_entities[i].name, len) == 0) { - /* Found match - return copy of value */ - return taurus_strdup(builtin_entities[i].value); - } - } - - /* Unknown entity */ - return NULL; -} - -/* ================================================================== - * TEXT CONTENT PROCESSING - * ================================================================== */ - -/* Add text content to element with entity expansion */ -void add_text_to_element(struct taurus_element *elem, const char *text, size_t len) { - char *text_copy; - char *expanded_text; - char *new_content; - size_t existing_len; - const char *p, *start; - const char *entity_start, *entity_end; - size_t result_len, result_cap; - char *result; - char *entity_value; - size_t entity_len; - - if (!elem || !text || len == 0) return; - - /* Check if text contains entities (&...) */ - p = text; - entity_start = NULL; - while (p < text + len) { - if (*p == '&') { - entity_start = p; - break; - } - p++; - } - - /* No entities found - simple path */ - if (!entity_start) { - text_copy = taurus_strndup(text, len); - if (!text_copy) return; - - if (!elem->text_content) { - elem->text_content = text_copy; - } else { - existing_len = strlen(elem->text_content); - new_content = (char*)taurus_realloc(elem->text_content, existing_len + len + 1); - if (new_content) { - memcpy(new_content + existing_len, text, len); - new_content[existing_len + len] = '\0'; - elem->text_content = new_content; - taurus_free(text_copy); - } else { - taurus_free(text_copy); - } - } - return; - } - - /* Entities found - expand them */ - result_cap = len + 64; /* Initial capacity with some padding */ - result = (char*)taurus_malloc(result_cap); - if (!result) return; - result_len = 0; - - start = text; - p = text; - - while (p < text + len) { - if (*p == '&') { - /* Copy text before entity */ - if (p > start) { - size_t copy_len = p - start; - if (result_len + copy_len >= result_cap) { - result_cap = (result_len + copy_len + 1) * 2; - result = (char*)taurus_realloc(result, result_cap); - if (!result) return; - } - memcpy(result + result_len, start, copy_len); - result_len += copy_len; - } - - /* Find end of entity (;) */ - entity_start = p + 1; /* Skip '&' */ - entity_end = entity_start; - while (entity_end < text + len && *entity_end != ';') { - entity_end++; - } - - if (entity_end >= text + len || *entity_end != ';') { - /* Unterminated entity - keep as-is */ - if (result_len + 1 >= result_cap) { - result_cap = (result_len + 2) * 2; - result = (char*)taurus_realloc(result, result_cap); - if (!result) return; - } - result[result_len++] = '&'; - start = p + 1; - p++; - continue; - } - - /* Extract and expand entity */ - entity_len = entity_end - entity_start; - entity_value = expand_entity_reference(entity_start, entity_len); - - if (entity_value) { - /* Copy expanded value */ - size_t value_len = strlen(entity_value); - if (result_len + value_len >= result_cap) { - result_cap = (result_len + value_len + 1) * 2; - result = (char*)taurus_realloc(result, result_cap); - if (!result) { - taurus_free(entity_value); - return; - } - } - memcpy(result + result_len, entity_value, value_len); - result_len += value_len; - taurus_free(entity_value); - - /* Move past entity */ - p = entity_end + 1; - start = p; - } else { - /* Unknown entity - keep as-is */ - size_t keep_len = entity_end - p + 1; /* Include & and ; */ - if (result_len + keep_len >= result_cap) { - result_cap = (result_len + keep_len + 1) * 2; - result = (char*)taurus_realloc(result, result_cap); - if (!result) return; - } - memcpy(result + result_len, p, keep_len); - result_len += keep_len; - p = entity_end + 1; - start = p; - } - } else { - p++; - } - } - - /* Copy remaining text */ - if (start < text + len) { - size_t copy_len = (text + len) - start; - if (result_len + copy_len >= result_cap) { - result_cap = result_len + copy_len + 1; - result = (char*)taurus_realloc(result, result_cap); - if (!result) return; - } - memcpy(result + result_len, start, copy_len); - result_len += copy_len; - } - - /* Null-terminate */ - result[result_len] = '\0'; - expanded_text = result; - - /* Add to element */ - if (!elem->text_content) { - elem->text_content = expanded_text; - } else { - existing_len = strlen(elem->text_content); - new_content = (char*)taurus_realloc(elem->text_content, existing_len + result_len + 1); - if (new_content) { - memcpy(new_content + existing_len, expanded_text, result_len); - new_content[existing_len + result_len] = '\0'; - elem->text_content = new_content; - taurus_free(expanded_text); - } else { - taurus_free(expanded_text); - } - } -} - -/* ================================================================== - * NAMESPACE PROCESSING - * ================================================================== */ - -/* Process namespace declarations from attribute stack - * Extracts xmlns and xmlns:prefix attributes and creates namespace objects */ -void process_namespace_declarations(struct taurus_element *elem, TaurusAttrStack *attr_stack) { - size_t i, count; - ParseAttribute *attrs; - const char *name; - struct taurus_namespace *ns; - - if (!elem || !attr_stack) return; - - count = taurus_attr_stack_size(attr_stack); - attrs = taurus_attr_stack_to_array(attr_stack); - - for (i = 0; i < count; i++) { - name = attrs[i].name; - - /* Check if this is a namespace declaration */ - if (strncmp(name, "xmlns", 5) == 0) { - if (name[5] == '\0') { - /* Default namespace: xmlns="uri" */ - char *uri = taurus_strndup(attrs[i].value, strlen(attrs[i].value)); - ns = taurus_namespace_new(NULL, uri); - taurus_free(uri); - if (ns) { - taurus_element_add_namespace(elem, ns); - } - } else if (name[5] == ':') { - /* Prefixed namespace: xmlns:prefix="uri" */ - const char *prefix = name + 6; - char *uri = taurus_strndup(attrs[i].value, strlen(attrs[i].value)); - char *prefix_copy = taurus_strdup(prefix); - ns = taurus_namespace_new(prefix_copy, uri); - taurus_free(uri); - taurus_free(prefix_copy); - if (ns) { - taurus_element_add_namespace(elem, ns); - } - } - } - } -} - -/* Set element namespace from prefix or parent inheritance */ -void set_element_namespace(struct taurus_element *elem, const char *prefix, - struct taurus_element *parent) { - struct taurus_namespace *ns; - - if (!elem) return; - - /* Set prefix if provided */ - if (prefix) { - elem->prefix = taurus_strdup(prefix); - } - - /* Find namespace URI - search element first, then parent if provided - * (parent relationship not yet established at call time) */ - ns = taurus_namespace_find(elem, prefix); - if (!ns && parent) { - /* Not found on element, search parent for inheritance */ - ns = taurus_namespace_find(parent, prefix); - } - - if (ns && ns->uri) { - elem->namespace_uri = taurus_strdup(ns->uri); - } -} - -/* ================================================================== - * ATTRIBUTE PROCESSING - * ================================================================== */ - -/* Add non-xmlns attributes to element */ -void add_attributes_to_element(struct taurus_element *elem, TaurusAttrStack *attr_stack, - StringInternTable *intern_table) { - size_t i, count; - ParseAttribute *attrs; - const char *name; - struct taurus_attribute *attr; - const char *interned_name; - char *value_copy; - - if (!elem || !attr_stack) return; - - count = taurus_attr_stack_size(attr_stack); - attrs = taurus_attr_stack_to_array(attr_stack); - - for (i = 0; i < count; i++) { - name = attrs[i].name; - - /* Skip xmlns declarations (already processed) */ - if (strncmp(name, "xmlns", 5) == 0 && - (name[5] == '\0' || name[5] == ':')) { - continue; - } - - /* Intern attribute name */ - interned_name = string_intern_get(intern_table, name, strlen(name)); - if (!interned_name) { - interned_name = name; /* Fallback */ - } - - /* Create attribute value copy */ - value_copy = taurus_strndup(attrs[i].value, strlen(attrs[i].value)); - - /* Create attribute */ - attr = taurus_attribute_new(interned_name, value_copy); - taurus_free(value_copy); - - if (attr) { - taurus_element_add_attribute(elem, attr); - } - } -} \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_document.c b/ext/taurus/lib/src/parse_document.c deleted file mode 100644 index 737c218..0000000 --- a/ext/taurus/lib/src/parse_document.c +++ /dev/null @@ -1,176 +0,0 @@ -/* parse_document.c - Document-level parsing functions - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Session 84: Modularized from taurus_parse.c - * Main parsing entry points and document structure creation - */ - -#include "parse_internal.h" -#include - -/* ================================================================== - * PROCESSING INSTRUCTION PARSING - * ================================================================== */ - -/* Parse processing instruction - * Assumes positioned after 'pos, ctx->end); - - /* Find '?>' end marker */ - data_start = ctx->pos; - while (ctx->pos + 1 < ctx->end && - !(ctx->pos[0] == '?' && ctx->pos[1] == '>')) { - if (*ctx->pos == '\n') { - ctx->line++; - } - ctx->pos++; - } - - if (ctx->pos + 1 >= ctx->end) { - taurus_parse_context_set_error(ctx, "Unterminated processing instruction at line %d, column %d", ctx->line, ctx->column); - taurus_free(target); - return NULL; - } - - /* Extract data (between target and '?>') */ - data_len = ctx->pos - data_start; - data = (data_len > 0) ? taurus_strndup(data_start, data_len) : NULL; - - /* Skip '?>' */ - ctx->pos += 2; - - /* Create PI */ - pi = taurus_pi_new(target, data); - taurus_free(target); - if (data) taurus_free(data); - - return pi; -} - -/* ================================================================== - * MAIN PARSE FUNCTIONS - * ================================================================== */ - -/* Parse XML string into document structure */ -struct taurus_document *taurus_parse(const char *xml, - size_t len, - TaurusParseOptions *opts) { - TaurusParseContext ctx; - struct taurus_document *doc; - struct taurus_element *root; - - /* Initialize context */ - if (taurus_parse_context_init(&ctx, xml, len, opts) < 0) { - return NULL; - } - - /* Create document */ - doc = taurus_document_new(); - if (!doc) { - taurus_parse_context_free(&ctx); - return NULL; - } - ctx.doc = doc; - - /* Skip leading whitespace */ - taurus_skip_whitespace(&ctx.pos, ctx.end); - - /* Parse processing instructions (including XML declaration) */ - while (ctx.pos + 1 < ctx.end && - ctx.pos[0] == '<' && ctx.pos[1] == '?') { - ctx.pos += 2; /* Skip 'next = doc->pis; - doc->pis = pi; - - taurus_skip_whitespace(&ctx.pos, ctx.end); - } - - /* Parse root element */ - if (ctx.pos < ctx.end && *ctx.pos == '<') { - ctx.pos++; /* Skip '<' */ - root = parse_element(&ctx, NULL); - if (!root) { - taurus_document_free_internal(doc); - taurus_parse_context_free(&ctx); - return NULL; - } - - /* Set as document root */ - doc->root = root; - } else { - taurus_parse_context_set_error(&ctx, "No root element found at line %d, column %d", ctx.line, ctx.column); - taurus_document_free_internal(doc); - taurus_parse_context_free(&ctx); - return NULL; - } - - /* Cleanup context */ - taurus_parse_context_free(&ctx); - - return doc; -} - -/* Parse XML with error reporting */ -struct taurus_document *taurus_parse_with_error(const char *xml, - size_t len, - TaurusParseOptions *opts, - char *error_buf, - size_t error_len) { - struct taurus_document *doc; - TaurusParseContext ctx; - - /* Initialize context */ - if (taurus_parse_context_init(&ctx, xml, len, opts) < 0) { - if (error_buf && error_len > 0) { - snprintf(error_buf, error_len, "Failed to initialize parse context"); - } - return NULL; - } - - /* Parse document */ - doc = taurus_parse(xml, len, opts); - - /* Copy error if parse failed */ - if (!doc && error_buf && error_len > 0) { - const char *err = taurus_parse_context_error(&ctx); - if (err[0] != '\0') { - snprintf(error_buf, error_len, "%s", err); - } - } - - /* Cleanup */ - taurus_parse_context_free(&ctx); - - return doc; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_element.c b/ext/taurus/lib/src/parse_element.c deleted file mode 100644 index a41f3db..0000000 --- a/ext/taurus/lib/src/parse_element.c +++ /dev/null @@ -1,277 +0,0 @@ -/* parse_element.c - Element parsing functions for XML parser - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Session 84: Modularized from taurus_parse.c - * Functions for parsing element start tags, end tags, and complete elements - */ - -#include "parse_internal.h" -#include -#include - -/* ================================================================== - * ELEMENT START TAG PARSING - * ================================================================== */ - -/* Parse element start tag - * Returns newly created element or NULL on error - * NOTE: Return value may have lowest bit set to indicate self-closing */ -struct taurus_element *parse_start_tag(TaurusParseContext *ctx, - struct taurus_element *parent) { - struct taurus_element *elem; - const char *name; - size_t name_len, value_len; - char *name_copy, *prefix, *local_name; - int self_closing = 0; - - /* Parse element name */ - name = parse_name(ctx, &name_len); - if (!name) return NULL; - - /* Create a copy for processing */ - name_copy = taurus_strndup(name, name_len); - if (!name_copy) return NULL; - - /* Extract prefix and local name */ - extract_prefix_and_local(name_copy, &prefix, &local_name); - - /* Initialize attribute stack */ - taurus_attr_stack_init(&ctx->attr_stack); - - /* Parse attributes */ - while (ctx->pos < ctx->end) { - taurus_skip_whitespace(&ctx->pos, ctx->end); - - if (ctx->pos >= ctx->end) break; - if (*ctx->pos == '>' || *ctx->pos == '/') break; - - /* Parse attribute name */ - const char *attr_name = parse_name(ctx, &name_len); - if (!attr_name) { - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - return NULL; - } - - /* Expect '=' */ - taurus_skip_whitespace(&ctx->pos, ctx->end); - if (ctx->pos >= ctx->end || *ctx->pos != '=') { - taurus_parse_context_set_error(ctx, "Expected '=' after attribute name at line %d, column %d", ctx->line, ctx->column); - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - return NULL; - } - ctx->pos++; - - /* Parse attribute value */ - const char *attr_value = parse_quoted_value(ctx, &value_len); - if (!attr_value) { - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - return NULL; - } - - /* Push attribute onto stack */ - taurus_attr_stack_push(&ctx->attr_stack, attr_name, attr_value); - } - - /* Check for self-closing */ - taurus_skip_whitespace(&ctx->pos, ctx->end); - if (ctx->pos < ctx->end && *ctx->pos == '/') { - self_closing = 1; - ctx->pos++; /* Skip '/' */ - } - - /* Expect '>' */ - if (ctx->pos >= ctx->end || *ctx->pos != '>') { - taurus_parse_context_set_error(ctx, "Expected '>' at line %d, column %d", ctx->line, ctx->column); - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - return NULL; - } - ctx->pos++; /* Skip '>' */ - - /* Create element */ - elem = taurus_element_new(local_name); - if (!elem) { - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - return NULL; - } - - /* Store self-closing flag (we'll use text_content as a hack for now) */ - if (self_closing) { - /* Mark as self-closing - we'll handle this in parse_element */ - } - - /* Process namespace declarations */ - process_namespace_declarations(elem, &ctx->attr_stack); - - /* Set element namespace */ - set_element_namespace(elem, prefix, parent); - - /* Add attributes (excluding xmlns) */ - add_attributes_to_element(elem, &ctx->attr_stack, &ctx->intern_table); - - /* Link to parent */ - if (parent) { - taurus_element_add_child(parent, elem); - } - - /* Cleanup */ - taurus_attr_stack_cleanup(&ctx->attr_stack); - taurus_free(name_copy); - - /* Return element with self_closing status encoded */ - return self_closing ? (struct taurus_element*)((uintptr_t)elem | 1) : elem; -} - -/* ================================================================== - * ELEMENT END TAG PARSING - * ================================================================== */ - -/* Parse element end tag - * Returns 0 on success, -1 on error */ -int parse_end_tag(TaurusParseContext *ctx, const char *expected_name) { - const char *name; - size_t len; - char *name_copy; - const char *local_name; - int match; - - /* Should be at 'pos + 1 >= ctx->end || - ctx->pos[0] != '<' || ctx->pos[1] != '/') { - taurus_parse_context_set_error(ctx, "Expected 'line, ctx->column); - return -1; - } - ctx->pos += 2; - - /* Parse name */ - name = parse_name(ctx, &len); - if (!name) return -1; - - /* Extract local name (remove prefix) */ - name_copy = taurus_strndup(name, len); - if (!name_copy) return -1; - - local_name = extract_local_name_only(name_copy); - - /* Compare with expected */ - match = (strcmp(local_name, expected_name) == 0); - - taurus_free(name_copy); - - if (!match) { - taurus_parse_context_set_error(ctx, - "Mismatched end tag at line %d, column %d: expected %s", - ctx->line, ctx->column, expected_name); - return -1; - } - - /* Expect '>' */ - taurus_skip_whitespace(&ctx->pos, ctx->end); - if (ctx->pos >= ctx->end || *ctx->pos != '>') { - taurus_parse_context_set_error(ctx, - "Expected '>' in end tag at line %d, column %d", ctx->line, ctx->column); - return -1; - } - ctx->pos++; - - return 0; -} - -/* ================================================================== - * COMPLETE ELEMENT PARSING - * ================================================================== */ - -/* Parse complete element (start tag, content, end tag) - * Returns newly created element or NULL on error */ -struct taurus_element *parse_element(TaurusParseContext *ctx, - struct taurus_element *parent) { - struct taurus_element *elem; - uintptr_t elem_ptr; - int self_closing; - - /* Parse start tag */ - elem = parse_start_tag(ctx, parent); - if (!elem) return NULL; - - /* Check if self-closing (encoded in lowest bit) */ - elem_ptr = (uintptr_t)elem; - self_closing = elem_ptr & 1; - elem = (struct taurus_element*)(elem_ptr & ~1); - - /* If self-closing, we're done */ - if (self_closing) { - return elem; - } - - /* Parse content */ - while (ctx->pos < ctx->end) { - taurus_skip_whitespace(&ctx->pos, ctx->end); - - if (ctx->pos >= ctx->end) break; - - if (*ctx->pos == '<') { - ctx->pos++; - - if (ctx->pos >= ctx->end) { - taurus_parse_context_set_error(ctx, "Unexpected end after '<' at line %d, column %d", ctx->line, ctx->column); - taurus_element_free_tree(elem); - return NULL; - } - - if (*ctx->pos == '/') { - /* End tag - rewind and let parse_end_tag handle */ - ctx->pos--; - break; - } else if (ctx->pos + 2 < ctx->end && - *ctx->pos == '!' && ctx->pos[1] == '-' && ctx->pos[2] == '-') { - /* Comment */ - ctx->pos += 3; /* Skip '!--' */ - if (skip_comment(ctx) < 0) { - taurus_element_free_tree(elem); - return NULL; - } - } else if (ctx->pos + 7 < ctx->end && - *ctx->pos == '!' && - strncmp(ctx->pos + 1, "[CDATA[", 7) == 0) { - /* CDATA */ - ctx->pos += 8; /* Skip '![CDATA[' */ - size_t len; - const char *cdata = parse_cdata(ctx, &len); - if (!cdata) { - taurus_element_free_tree(elem); - return NULL; - } - /* Add CDATA as text content */ - add_text_to_element(elem, cdata, len); - } else { - /* Child element - already positioned at element name after '<' */ - struct taurus_element *child = parse_element(ctx, elem); - if (!child) { - taurus_element_free_tree(elem); - return NULL; - } - /* child already added to elem by parse_start_tag */ - } - } else { - /* Text content */ - size_t len; - const char *text = parse_text(ctx, &len); - if (text) { - add_text_to_element(elem, text, len); - } - } - } - - /* Parse end tag */ - if (parse_end_tag(ctx, elem->name) < 0) { - taurus_element_free_tree(elem); - return NULL; - } - - return elem; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_helpers.c b/ext/taurus/lib/src/parse_helpers.c deleted file mode 100644 index 4d5fe67..0000000 --- a/ext/taurus/lib/src/parse_helpers.c +++ /dev/null @@ -1,141 +0,0 @@ -/* parse_helpers.c - Implementation of parse helper functions - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - */ - -#include "parse_helpers.h" -#include - -/* ================================================================== - * STRING INTERNING IMPLEMENTATION - * ================================================================= */ - -/* Pre-interned strings for common attributes - defined as string literals */ -const char *g_intern_id = "id"; -const char *g_intern_class = "class"; -const char *g_intern_type = "type"; -const char *g_intern_name = "name"; -const char *g_intern_href = "href"; -const char *g_intern_src = "src"; -const char *g_intern_xmlns = "xmlns"; -const char *g_intern_style = "style"; -const char *g_intern_value = "value"; -const char *g_intern_lang = "lang"; - -/* Simple hash function - DJB2 */ -static size_t hash_string(const char *str, size_t len) { - size_t hash = 5381; - for (size_t i = 0; i < len; i++) { - hash = ((hash << 5) + hash) + (unsigned char)str[i]; - } - return hash; -} - -/* Initialize string interning table */ -void string_intern_table_init(StringInternTable *table) { - memset(table->entries, 0, sizeof(table->entries)); - table->initialized = 1; -} - -/* Fast-path for common attributes (bypasses hash table) - * Returns interned string directly for top 10 attributes, otherwise NULL */ -const char* string_intern_get_fast(const char *name, size_t len) { - /* Quick length-based dispatch */ - switch (len) { - case 2: - if (name[0] == 'i' && name[1] == 'd') return g_intern_id; - break; - case 3: - if (name[0] == 's' && name[1] == 'r' && name[2] == 'c') - return g_intern_src; - break; - case 4: - if (memcmp(name, "type", 4) == 0) return g_intern_type; - if (memcmp(name, "name", 4) == 0) return g_intern_name; - if (memcmp(name, "href", 4) == 0) return g_intern_href; - if (memcmp(name, "lang", 4) == 0) return g_intern_lang; - break; - case 5: - if (memcmp(name, "class", 5) == 0) return g_intern_class; - if (memcmp(name, "style", 5) == 0) return g_intern_style; - if (memcmp(name, "value", 5) == 0) return g_intern_value; - if (memcmp(name, "xmlns", 5) == 0) return g_intern_xmlns; - break; - } - return NULL; -} - -/* Get or create interned string - * Uses linear probing hash table for collision resolution */ -const char* string_intern_get(StringInternTable *table, const char *str, size_t len) { - /* Try fast path first (common attributes) */ - const char *fast = string_intern_get_fast(str, len); - if (fast != NULL) { - return fast; - } - - /* Compute hash */ - size_t hash = hash_string(str, len); - size_t index = hash & (STRING_INTERN_TABLE_SIZE - 1); /* Modulo by power of 2 */ - - /* Linear probing */ - for (size_t i = 0; i < STRING_INTERN_TABLE_SIZE; i++) { - size_t probe = (index + i) & (STRING_INTERN_TABLE_SIZE - 1); - StringInternEntry *entry = &table->entries[probe]; - - /* Empty slot - insert new entry */ - if (entry->key == NULL) { - /* Allocate and copy string */ - char *copy = (char*)taurus_malloc(len + 1); - memcpy(copy, str, len); - copy[len] = '\0'; - - entry->key = copy; - entry->hash = hash; - return copy; - } - - /* Existing entry - check if it matches */ - if (entry->hash == hash && strlen(entry->key) == len) { - if (memcmp(entry->key, str, len) == 0) { - return entry->key; /* Found existing interned string */ - } - } - } - - /* Table is full - fall back to allocating new string - * (This should be rare with 128 slots) */ - char *copy = (char*)taurus_malloc(len + 1); - memcpy(copy, str, len); - copy[len] = '\0'; - return copy; -} - -/* Clear the interning table (for testing/benchmarking) */ -void string_intern_table_clear(StringInternTable *table) { - for (size_t i = 0; i < STRING_INTERN_TABLE_SIZE; i++) { - if (table->entries[i].key != NULL) { - /* Don't free pre-interned strings (they're string literals) */ - if (table->entries[i].key != g_intern_id && - table->entries[i].key != g_intern_class && - table->entries[i].key != g_intern_type && - table->entries[i].key != g_intern_name && - table->entries[i].key != g_intern_href && - table->entries[i].key != g_intern_src && - table->entries[i].key != g_intern_xmlns && - table->entries[i].key != g_intern_style && - table->entries[i].key != g_intern_value && - table->entries[i].key != g_intern_lang) { - taurus_free((void*)table->entries[i].key); - } - table->entries[i].key = NULL; - table->entries[i].hash = 0; - } - } -} - -/* Free all interned strings */ -void string_intern_table_free(StringInternTable *table) { - string_intern_table_clear(table); - table->initialized = 0; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_helpers.h b/ext/taurus/lib/src/parse_helpers.h deleted file mode 100644 index 2197074..0000000 --- a/ext/taurus/lib/src/parse_helpers.h +++ /dev/null @@ -1,259 +0,0 @@ -/* parse_helpers.h - Helper functions and structures for XML parsing - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Consolidates parsing utilities extracted from ext/taurus helper modules: - * - Character classification and scanning (from parse_inline.h) - * - Attribute stack (from attr_stack.h, converted to pure C) - * - String interning (from symbol_cache.h, converted to pure C) - * - Parse structures (from parse_structures.h, converted to pure C) - */ - -#ifndef TAURUS_PARSE_HELPERS_H -#define TAURUS_PARSE_HELPERS_H - -#include "taurus_internal.h" -#include "taurus_memory.h" -#include "chartype.h" -#include "simd_helpers.h" - -/* ================================================================== - * CHARACTER CLASSIFICATION AND SCANNING - * ================================================================= - * Inline hot-path functions for parser (from parse_inline.h) - */ - -/* Check if character is whitespace - uses fast table lookup */ -static inline int taurus_is_whitespace(char c) { - return is_whitespace_fast(c); -} - -/* Skip whitespace using SIMD vectorized scanning */ -static inline void taurus_skip_whitespace(const char **pos, const char *end) { - *pos = simd_skip_whitespace(*pos, end); -} - -/* Check if character is valid for XML names - uses fast table lookup */ -static inline int taurus_is_name_char(char c) { - return is_name_char_fast(c); -} - -/* Peek at current character without advancing */ -static inline char taurus_peek_char(const char *pos, const char *end) { - if (pos < end) { - return *pos; - } - return '\0'; -} - -/* Get current character and advance position */ -static inline char taurus_next_char(const char **pos, const char *end) { - if (*pos < end) { - return *(*pos)++; - } - return '\0'; -} - -/* ================================================================== - * ATTRIBUTE STACK - * ================================================================= - * Stack-based attribute storage with inline base array - * Converted from ext/taurus/attr_stack.h (Ruby memory → pure C) - */ - -#define TAURUS_ATTR_STACK_BASE_SIZE 8 - -/* Attribute structure for parsing (distinct from final taurus_attribute) */ -typedef struct parse_attribute { - const char *name; /* Attribute name (pointer into parse buffer) */ - const char *value; /* Attribute value (pointer into parse buffer) */ -} ParseAttribute; - -/* Attribute stack with inline base array to avoid heap allocation for small elements */ -typedef struct taurus_attr_stack { - ParseAttribute base[TAURUS_ATTR_STACK_BASE_SIZE]; /* 8 inline slots */ - ParseAttribute *head; /* Start of allocated space */ - ParseAttribute *end; /* End of allocated space */ - ParseAttribute *tail; /* Current position (one past last element) */ -} TaurusAttrStack; - -/* Initialize attribute stack */ -static inline void taurus_attr_stack_init(TaurusAttrStack *stack) { - stack->head = stack->base; - stack->end = stack->base + TAURUS_ATTR_STACK_BASE_SIZE; - stack->tail = stack->head; -} - -/* Cleanup attribute stack (only needed if heap was allocated) */ -static inline void taurus_attr_stack_cleanup(TaurusAttrStack *stack) { - if (stack->base != stack->head) { - /* Heap memory was allocated, free it */ - taurus_free(stack->head); - stack->head = stack->base; - } -} - -/* Push attribute onto stack, growing if necessary */ -static inline void taurus_attr_stack_push(TaurusAttrStack *stack, - const char *name, - const char *value) { - /* Check if we need to grow */ - if (stack->end <= stack->tail + 1) { - size_t len = stack->end - stack->head; - size_t toff = stack->tail - stack->head; - - if (stack->base == stack->head) { - /* First time exceeding base array - allocate on heap */ - stack->head = (ParseAttribute*)taurus_malloc( - sizeof(ParseAttribute) * (len + TAURUS_ATTR_STACK_BASE_SIZE) - ); - memcpy(stack->head, stack->base, sizeof(ParseAttribute) * len); - } else { - /* Already on heap - reallocate */ - stack->head = (ParseAttribute*)taurus_realloc( - stack->head, - sizeof(ParseAttribute) * (len + TAURUS_ATTR_STACK_BASE_SIZE) - ); - } - stack->tail = stack->head + toff; - stack->end = stack->head + len + TAURUS_ATTR_STACK_BASE_SIZE; - } - - /* Add attribute */ - stack->tail->name = name; - stack->tail->value = value; - stack->tail++; -} - -/* Get number of attributes in stack */ -static inline size_t taurus_attr_stack_size(const TaurusAttrStack *stack) { - return stack->tail - stack->head; -} - -/* Get pointer to attribute array */ -static inline ParseAttribute *taurus_attr_stack_to_array(TaurusAttrStack *stack) { - return stack->head; -} - -/* Get attribute at index */ -static inline ParseAttribute *taurus_attr_stack_at(TaurusAttrStack *stack, size_t index) { - if (index < taurus_attr_stack_size(stack)) { - return &stack->head[index]; - } - return NULL; -} - -/* ================================================================== - * STRING INTERNING - * ================================================================= - * String interning table for attribute names - * Replaces symbol_cache.h (Ruby symbols → interned strings) - * - * PURPOSE: Eliminate duplicate string allocations. Multiple attributes - * with the same name (e.g., "id") share a single interned string. - * Compare by pointer equality instead of strcmp(). - */ - -#define STRING_INTERN_TABLE_SIZE 128 /* Power of 2 for fast modulo */ - -typedef struct string_intern_entry { - char *key; /* Interned string (owned copy) */ - size_t hash; /* Cached hash value */ -} StringInternEntry; - -typedef struct string_intern_table { - StringInternEntry entries[STRING_INTERN_TABLE_SIZE]; - int initialized; -} StringInternTable; - -/* Pre-interned strings for top 10 most common attributes (HTML/XML) - * Avoids hash table lookup for 80% of attribute accesses */ -extern const char *g_intern_id; -extern const char *g_intern_class; -extern const char *g_intern_type; -extern const char *g_intern_name; -extern const char *g_intern_href; -extern const char *g_intern_src; -extern const char *g_intern_xmlns; -extern const char *g_intern_style; -extern const char *g_intern_value; -extern const char *g_intern_lang; - -/* Initialize string interning table */ -void string_intern_table_init(StringInternTable *table); - -/* Get or create interned string - * Returns pointer to interned string (owned by table) - * Same string always returns same pointer (pointer equality) */ -const char* string_intern_get(StringInternTable *table, const char *str, size_t len); - -/* Fast-path for common attributes (bypasses hash table) - * Returns interned string directly for top 10 attributes, otherwise NULL */ -const char* string_intern_get_fast(const char *name, size_t len); - -/* Clear the interning table (for testing/benchmarking) */ -void string_intern_table_clear(StringInternTable *table); - -/* Free all interned strings */ -void string_intern_table_free(StringInternTable *table); - -/* ================================================================== - * PARSE STRUCTURES - * ================================================================= - * Temporary structures during parsing, converted from parse_structures.h - * (VALUE → struct taurus_element*) - */ - -/* Parsed element structure - pure C, no Ruby objects - * This structure holds parsed element data temporarily - * before taurus_element structures are created */ -typedef struct parsed_element { - char *name; /* Element name (pointer into buffer) */ - char *prefix; /* Namespace prefix (pointer into buffer) */ - TaurusAttrStack *attrs; /* Attributes (stack-based) */ - int has_children; /* Flag for whether element has child nodes */ - int is_self_closing; /* Flag for self-closing elements */ -} ParsedElement; - -/* Initialize a ParsedElement structure */ -static inline void parsed_element_init(ParsedElement *elem, TaurusAttrStack *attr_stack) { - elem->name = NULL; - elem->prefix = NULL; - elem->attrs = attr_stack; - elem->has_children = 0; - elem->is_self_closing = 0; -} - -/* Parser callbacks - builds C DOM structures - * These callbacks are invoked with parsed C data during parsing. - * The callback implementation creates taurus_element structures from the C data. */ -typedef struct parse_callbacks { - /* Called when element start tag is parsed - * context: Parent element (or NULL for document root) - * elem: Parsed element data (C structure) - * Returns: Newly created element (for parent tracking) */ - struct taurus_element* (*start_element)(struct taurus_element *context, ParsedElement *elem); - - /* Called when element end tag is parsed - * context: Parent element - * name: Element name being closed */ - void (*end_element)(struct taurus_element *context, const char *name); - - /* Called when text content is parsed - * context: Current element - * text: Text content (pointer into buffer) */ - void (*add_text)(struct taurus_element *context, const char *text); - - /* Called when comment is parsed - * context: Current element - * comment: Comment text (pointer into buffer) */ - void (*add_comment)(struct taurus_element *context, const char *comment); - - /* Called when CDATA is parsed - * context: Current element - * cdata: CDATA content (pointer into buffer) - * len: Length of CDATA */ - void (*add_cdata)(struct taurus_element *context, const char *cdata, size_t len); -} ParseCallbacks; - -#endif /* TAURUS_PARSE_HELPERS_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/parse_internal.h b/ext/taurus/lib/src/parse_internal.h deleted file mode 100644 index ec230d6..0000000 --- a/ext/taurus/lib/src/parse_internal.h +++ /dev/null @@ -1,77 +0,0 @@ -/* parse_internal.h - Internal parser function declarations - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * INTERNAL HEADER - Not part of public API - * Shared between parse modules (parse_document.c, parse_element.c, parse_content.c) - */ - -#ifndef TAURUS_PARSE_INTERNAL_H -#define TAURUS_PARSE_INTERNAL_H - -#include "taurus_parse.h" -#include "taurus_internal.h" -#include "parse_helpers.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* ================================================================== - * STRING HELPERS (from taurus_parse.c) - * ================================================================== */ - -/* Duplicate string from buffer with length (NOT null-terminated in source) - * Caller must free returned string with taurus_free() */ -char *taurus_strndup(const char *str, size_t len); - -/* Extract prefix and local name from qualified name "prefix:local" - * Returns 0 if no prefix, 1 if prefix found, -1 on error - * Modifies qname buffer in place (replaces ':' with '\0') - * Caller must free qname after use */ -int extract_prefix_and_local(char *qname, char **prefix, char **local_name); - -/* Extract just local name from qualified name (for end tag comparison) - * Returns pointer into qname buffer (after ':' or whole name if no prefix) */ -const char *extract_local_name_only(const char *qname); - -/* ================================================================== - * CONTENT PROCESSING (from parse_content.c) - * ================================================================== */ - -/* Expand entity reference &name; or &#number; or &#xhex; - * Returns expanded string (MUST be freed by caller) or NULL if unknown */ -char* expand_entity_reference(const char* ref, size_t len); - -/* Add text content to element (creates or appends to text_content field) - * Automatically expands entity references during addition */ -void add_text_to_element(struct taurus_element *elem, const char *text, size_t len); - -/* Process namespace declarations from attribute stack - * Extracts xmlns and xmlns:prefix attributes and creates namespace objects */ -void process_namespace_declarations(struct taurus_element *elem, TaurusAttrStack *attr_stack); - -/* Set element namespace from prefix or parent inheritance - * Resolves prefix to URI using namespace chain */ -void set_element_namespace(struct taurus_element *elem, const char *prefix, - struct taurus_element *parent); - -/* Add non-xmlns attributes to element - * Filters out namespace declarations and creates attribute objects */ -void add_attributes_to_element(struct taurus_element *elem, TaurusAttrStack *attr_stack, - StringInternTable *intern_table); - -/* ================================================================== - * PROCESSING INSTRUCTION PARSING (from parse_document.c) - * ================================================================== */ - -/* Parse processing instruction - * Assumes positioned after ' - -/* Parser state for position tracking */ -typedef struct { - const char* input; /* Original input (for context extraction) */ - const char* pos; /* Current position in input */ - size_t offset; /* Byte offset from start */ - int line; /* Current line (1-based) */ - int column; /* Current column (1-based) */ -} ParserState; - -/* Helper: Advance one character and update position */ -static void advance_char(ParserState* state) { - if (!state || !state->pos || !*state->pos) return; - - if (*state->pos == '\n') { - state->line++; - state->column = 1; - } else { - state->column++; - } - state->pos++; - state->offset++; -} - -/* Helper: Skip whitespace and update position */ -static void skip_whitespace(ParserState* state) { - while (state->pos && *state->pos && isspace((unsigned char)*state->pos)) { - advance_char(state); - } -} - -/* Helper: Parse element name */ -static char* parse_name(const char** p) { - const char* start = *p; - const char* end = start; - - /* Name: [a-zA-Z_][a-zA-Z0-9_.-]* */ - if (!isalpha((unsigned char)*end) && *end != '_') return NULL; - - end++; - while (isalnum((unsigned char)*end) || *end == '_' || *end == '-' || *end == '.' || *end == ':') { - end++; - } - - size_t len = end - start; - if (len == 0) return NULL; - - char* name = TAURUS_ALLOC_N(char, len + 1); - if (!name) return NULL; - - memcpy(name, start, len); - name[len] = '\0'; - *p = end; - - return name; -} - -/* Helper: Parse attribute value */ -static char* parse_attr_value(const char** p) { - const char* pos = *p; - - /* Skip whitespace */ - while (*pos && isspace((unsigned char)*pos)) pos++; - - /* Must have = */ - if (*pos != '=') return NULL; - pos++; - - /* Skip whitespace */ - while (*pos && isspace((unsigned char)*pos)) pos++; - - /* Must have quote */ - char quote = *pos; - if (quote != '"' && quote != '\'') return NULL; - pos++; - - /* Find closing quote */ - const char* start = pos; - while (*pos && *pos != quote) pos++; - - if (*pos != quote) return NULL; - - size_t len = pos - start; - char* value = TAURUS_ALLOC_N(char, len + 1); - if (!value) return NULL; - - memcpy(value, start, len); - value[len] = '\0'; - - pos++; /* Skip closing quote */ - *p = pos; - - return value; -} - -/* Helper: Parse attributes and process namespace declarations */ -static void parse_attributes(const char** p, struct taurus_element* elem) { - const char* pos = *p; - - while (*pos && *pos != '>' && *pos != '/') { - /* Skip whitespace */ - while (*pos && isspace((unsigned char)*pos)) pos++; - - if (*pos == '>' || *pos == '/') break; - - /* Parse attribute name */ - char* name = parse_name(&pos); - if (!name) break; - - /* Parse attribute value */ - char* value = parse_attr_value(&pos); - if (!value) { - TAURUS_FREE(name); - break; - } - - /* Check if this is a namespace declaration */ - if (strcmp(name, "xmlns") == 0) { - /* Default namespace: xmlns="uri" */ - struct taurus_namespace* ns = TAURUS_ALLOC(struct taurus_namespace); - if (ns) { - ns->prefix = NULL; - ns->uri = taurus_strdup(value); - ns->next = elem->namespaces; - elem->namespaces = ns; - elem->namespaces_count++; - } - TAURUS_FREE(name); - TAURUS_FREE(value); - continue; - } else if (strncmp(name, "xmlns:", 6) == 0) { - /* Prefixed namespace: xmlns:prefix="uri" */ - const char* prefix = name + 6; - struct taurus_namespace* ns = TAURUS_ALLOC(struct taurus_namespace); - if (ns) { - ns->prefix = taurus_strdup(prefix); - ns->uri = taurus_strdup(value); - ns->next = elem->namespaces; - elem->namespaces = ns; - elem->namespaces_count++; - } - TAURUS_FREE(name); - TAURUS_FREE(value); - continue; - } - - /* Regular attribute */ - struct taurus_attribute* attr = TAURUS_ALLOC(struct taurus_attribute); - if (!attr) { - TAURUS_FREE(name); - TAURUS_FREE(value); - break; - } - - attr->name = name; - attr->value = value; - attr->prefix = NULL; - attr->namespace_uri = NULL; - - /* Add to element's attributes array */ - if (elem->attributes_count >= elem->attributes_capacity) { - size_t new_cap = elem->attributes_capacity == 0 ? 4 : elem->attributes_capacity * 2; - struct taurus_attribute** new_attrs = TAURUS_REALLOC_N( - elem->attributes, struct taurus_attribute*, new_cap); - if (!new_attrs) { - TAURUS_FREE(attr->name); - TAURUS_FREE(attr->value); - TAURUS_FREE(attr); - break; - } - elem->attributes = new_attrs; - elem->attributes_capacity = new_cap; - } - - elem->attributes[elem->attributes_count++] = attr; - } - - *p = pos; -} - -/* Helper: Resolve namespace URI for element */ -static void resolve_element_namespace(struct taurus_element* elem) { - if (!elem) return; - - /* Extract prefix from element name if present */ - const char* colon = strchr(elem->name, ':'); - char* prefix = NULL; - - if (colon) { - size_t prefix_len = colon - elem->name; - prefix = TAURUS_ALLOC_N(char, prefix_len + 1); - if (prefix) { - memcpy(prefix, elem->name, prefix_len); - prefix[prefix_len] = '\0'; - elem->prefix = prefix; - } - } - - /* Search for matching namespace declaration */ - struct taurus_element* current = elem; - while (current) { - struct taurus_namespace* ns = current->namespaces; - while (ns) { - /* Check if this namespace matches our prefix */ - if (!prefix && !ns->prefix) { - /* Default namespace match */ - elem->namespace_uri = taurus_strdup(ns->uri); - return; - } - if (prefix && ns->prefix && strcmp(prefix, ns->prefix) == 0) { - /* Prefixed namespace match */ - elem->namespace_uri = taurus_strdup(ns->uri); - return; - } - ns = ns->next; - } - current = current->parent; - } -} - -/* Helper: Resolve namespaces recursively for element and all descendants */ -static void resolve_namespaces_recursive(struct taurus_element* elem) { - if (!elem) return; - - /* Resolve this element's namespace */ - resolve_element_namespace(elem); - - /* Recursively resolve children */ - for (size_t i = 0; i < elem->children_count; i++) { - resolve_namespaces_recursive(elem->children[i]); - } -} - -/* Helper: Parse text content */ -static char* parse_text(const char** p) { - size_t capacity = 64; - size_t len = 0; - char* text = TAURUS_ALLOC_N(char, capacity); - if (!text) return NULL; - - while (**p && **p != '<') { - if (len + 1 >= capacity) { - capacity *= 2; - char* new_text = TAURUS_REALLOC_N(text, char, capacity); - if (!new_text) { - TAURUS_FREE(text); - return NULL; - } - text = new_text; - } - text[len++] = **p; - (*p)++; - } - - text[len] = '\0'; - - /* Trim whitespace */ - char* trimmed_start = text; - while (*trimmed_start && isspace((unsigned char)*trimmed_start)) { - trimmed_start++; - } - - if (*trimmed_start == '\0') { - TAURUS_FREE(text); - return NULL; - } - - char* result = taurus_strdup(trimmed_start); - TAURUS_FREE(text); - return result; -} - -/* Forward declaration */ -static struct taurus_element* parse_element(const char** p); - -/* Helper: Add child to element */ -static void add_child(struct taurus_element* parent, struct taurus_element* child) { - if (!parent || !child) return; - - if (parent->children_count >= parent->children_capacity) { - size_t new_cap = parent->children_capacity == 0 ? 4 : parent->children_capacity * 2; - struct taurus_element** new_children = TAURUS_REALLOC_N( - parent->children, struct taurus_element*, new_cap); - if (!new_children) return; - parent->children = new_children; - parent->children_capacity = new_cap; - } - - parent->children[parent->children_count++] = child; - child->parent = parent; -} - -/* Parse element: content */ -static struct taurus_element* parse_element(const char** p) { - /* Skip whitespace manually */ - while (**p && isspace((unsigned char)**p)) (*p)++; - - const char* pos = *p; - - /* Must start with < */ - if (*pos != '<') return NULL; - pos++; - - /* Parse tag name */ - char* name = parse_name(&pos); - if (!name) return NULL; - - /* Create element */ - struct taurus_element* elem = TAURUS_ALLOC(struct taurus_element); - if (!elem) { - TAURUS_FREE(name); - return NULL; - } - memset(elem, 0, sizeof(struct taurus_element)); - elem->name = name; - elem->doc_order = -1; - - /* Parse attributes (includes namespace declarations) */ - parse_attributes(&pos, elem); - - /* Self-closing tag? */ - if (*pos == '/') { - pos++; - if (*pos == '>') pos++; - *p = pos; - return elem; - } - if (*pos == '>') pos++; - - /* Parse content */ - while (*pos) { - /* Skip whitespace manually */ - while (*pos && isspace((unsigned char)*pos)) pos++; - - if (*pos == '<') { - if (*(pos + 1) == '/') { - /* Closing tag */ - pos += 2; - char* close_name = parse_name(&pos); - if (close_name) { - TAURUS_FREE(close_name); - } - /* Skip whitespace manually */ - while (*pos && isspace((unsigned char)*pos)) pos++; - if (*pos == '>') pos++; - *p = pos; - return elem; - } else { - /* Child element */ - struct taurus_element* child = parse_element(&pos); - if (child) { - add_child(elem, child); - /* Note: Namespace resolution now done recursively after full tree built */ - } - } - } else { - /* Text content */ - char* text = parse_text(&pos); - if (text) { - elem->text_content = text; - } - } - } - - *p = pos; - return elem; -} - -/* Parse XML document with position tracking */ -struct taurus_document* parse_xml_simple(const char* xml, size_t len) { - /* Validate input */ - if (!xml) { - taurus_set_error(TAURUS_ERROR_NULL_INPUT, "NULL input provided"); - return NULL; - } - - if (len == 0) { - taurus_set_error(TAURUS_ERROR_EMPTY_INPUT, "Empty input provided"); - return NULL; - } - - /* Initialize parser state */ - ParserState state; - state.input = xml; - state.pos = xml; - state.offset = 0; - state.line = 1; - state.column = 1; - - /* Create document */ - struct taurus_document* doc = TAURUS_ALLOC(struct taurus_document); - if (!doc) { - taurus_set_error(TAURUS_ERROR_OUT_OF_MEMORY, "Failed to allocate document"); - return NULL; - } - - memset(doc, 0, sizeof(struct taurus_document)); - doc->ref_count = 1; - - /* Skip XML declaration and processing instructions */ - skip_whitespace(&state); - - /* Skip declaration and other PIs */ - while (*state.pos == '<' && *(state.pos + 1) == '?') { - /* Find closing ?> */ - advance_char(&state); /* < */ - advance_char(&state); /* ? */ - while (*state.pos && !(*state.pos == '?' && *(state.pos + 1) == '>')) { - advance_char(&state); - } - if (*state.pos == '?' && *(state.pos + 1) == '>') { - advance_char(&state); /* ? */ - advance_char(&state); /* > */ - } - skip_whitespace(&state); - } - - /* Skip comments */ - while (*state.pos == '<' && *(state.pos + 1) == '!' && - *(state.pos + 2) == '-' && *(state.pos + 3) == '-') { - /* Find closing --> */ - advance_char(&state); /* < */ - advance_char(&state); /* ! */ - advance_char(&state); /* - */ - advance_char(&state); /* - */ - while (*state.pos && !(*state.pos == '-' && *(state.pos + 1) == '-' && *(state.pos + 2) == '>')) { - advance_char(&state); - } - if (*state.pos == '-' && *(state.pos + 1) == '-' && *(state.pos + 2) == '>') { - advance_char(&state); /* - */ - advance_char(&state); /* - */ - advance_char(&state); /* > */ - } - skip_whitespace(&state); - } - - /* Check for root element */ - if (*state.pos != '<') { - taurus_set_error_with_context( - TAURUS_ERROR_INVALID_XML, - "Expected root element", - state.input, - state.offset, - state.line, - state.column - ); - TAURUS_FREE(doc); - return NULL; - } - - /* Parse root element (use old interface for now) */ - const char* pos = state.pos; - doc->root = parse_element(&pos); - - if (!doc->root) { - /* Get current position after failed parse */ - size_t failed_offset = pos - xml; - int failed_line = state.line; - int failed_col = state.column; - - /* Calculate actual line/column if parse advanced */ - const char* p = state.pos; - while (p < pos) { - if (*p == '\n') { - failed_line++; - failed_col = 1; - } else { - failed_col++; - } - p++; - } - - taurus_set_error_with_context( - TAURUS_ERROR_PARSE_FAILED, - "Failed to parse root element", - state.input, - failed_offset, - failed_line, - failed_col - ); - TAURUS_FREE(doc); - return NULL; - } - - /* Resolve namespaces for entire tree after parsing complete - * This ensures all elements have correct namespace_uri */ - resolve_namespaces_recursive(doc->root); - - return doc; -} - -/* Free element recursively */ -void free_element(struct taurus_element* elem) { - if (!elem) return; - - /* Free children */ - for (size_t i = 0; i < elem->children_count; i++) { - free_element(elem->children[i]); - } - - /* Free attributes and their content */ - for (size_t i = 0; i < elem->attributes_count; i++) { - if (elem->attributes[i]) { - if (elem->attributes[i]->name) TAURUS_FREE(elem->attributes[i]->name); - if (elem->attributes[i]->value) TAURUS_FREE(elem->attributes[i]->value); - if (elem->attributes[i]->prefix) TAURUS_FREE(elem->attributes[i]->prefix); - if (elem->attributes[i]->namespace_uri) TAURUS_FREE(elem->attributes[i]->namespace_uri); - TAURUS_FREE(elem->attributes[i]); - } - } - - /* Free arrays */ - if (elem->children) TAURUS_FREE(elem->children); - if (elem->attributes) TAURUS_FREE(elem->attributes); - - /* Free strings */ - if (elem->name) TAURUS_FREE(elem->name); - if (elem->prefix) TAURUS_FREE(elem->prefix); - if (elem->namespace_uri) TAURUS_FREE(elem->namespace_uri); - if (elem->text_content) TAURUS_FREE(elem->text_content); - - /* Free element */ - TAURUS_FREE(elem); -} \ No newline at end of file diff --git a/ext/taurus/lib/src/simd_helpers.h b/ext/taurus/lib/src/simd_helpers.h deleted file mode 100644 index ef31e1a..0000000 --- a/ext/taurus/lib/src/simd_helpers.h +++ /dev/null @@ -1,445 +0,0 @@ -/* simd_helpers.h - SIMD acceleration for Taurus parser - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Platform-agnostic SIMD operations: - * - x86_64: SSE2 intrinsics (128-bit vectors, 16 bytes at once) - * - ARM64: NEON intrinsics (128-bit vectors, 16 bytes at once) - * - Fallback: Scalar operations for other platforms - * - * PERFORMANCE TARGET: 3-5× speedup on hot-path operations - */ - -#ifndef TAURUS_SIMD_HELPERS_H -#define TAURUS_SIMD_HELPERS_H - -#include -#include -#include - -/* Detect platform and include appropriate SIMD headers */ -#if defined(__x86_64__) || defined(_M_X64) - #define TAURUS_SIMD_SSE2 1 - #include /* SSE2 intrinsics */ - typedef __m128i simd_vec_t; -#elif defined(__aarch64__) || defined(_M_ARM64) - #define TAURUS_SIMD_NEON 1 - #include /* NEON intrinsics */ - typedef uint8x16_t simd_vec_t; -#else - #define TAURUS_SIMD_NONE 1 -#endif - -/* SIMD vector size (16 bytes for both SSE2 and NEON) */ -#define SIMD_VEC_SIZE 16 - -/* ================================================================== - * SIMD WHITESPACE SCANNING - * ================================================================= - * Scans for whitespace (space, tab, newline, carriage return) using - * SIMD comparison operations. Processes 16 bytes per iteration. - */ - -inline static const char* simd_skip_whitespace(const char* pos, const char* end) { - const char* p = pos; - -#if defined(TAURUS_SIMD_SSE2) - /* SSE2 path - x86_64 */ - __m128i space = _mm_set1_epi8(' '); - __m128i tab = _mm_set1_epi8('\t'); - __m128i newline = _mm_set1_epi8('\n'); - __m128i carriage = _mm_set1_epi8('\r'); - - /* Process 16 bytes at a time */ - while (p + SIMD_VEC_SIZE <= end) { - __m128i chunk = _mm_loadu_si128((__m128i*)p); - - /* Compare with all whitespace chars */ - __m128i is_space = _mm_cmpeq_epi8(chunk, space); - __m128i is_tab = _mm_cmpeq_epi8(chunk, tab); - __m128i is_newline = _mm_cmpeq_epi8(chunk, newline); - __m128i is_carriage = _mm_cmpeq_epi8(chunk, carriage); - - /* Combine all whitespace matches */ - __m128i is_ws = _mm_or_si128( - _mm_or_si128(is_space, is_tab), - _mm_or_si128(is_newline, is_carriage) - ); - - /* Find first non-whitespace */ - int mask = _mm_movemask_epi8(is_ws); - if (mask != 0xFFFF) { /* Found non-whitespace */ - /* Count leading whitespace bytes */ - int leading = __builtin_ctz(~mask & 0xFFFF); - return p + leading; - } - - p += SIMD_VEC_SIZE; - } - -#elif defined(TAURUS_SIMD_NEON) - /* NEON path - ARM64 */ - uint8x16_t space = vdupq_n_u8(' '); - uint8x16_t tab = vdupq_n_u8('\t'); - uint8x16_t newline = vdupq_n_u8('\n'); - uint8x16_t carriage = vdupq_n_u8('\r'); - - /* Process 16 bytes at a time */ - while (p + SIMD_VEC_SIZE <= end) { - uint8x16_t chunk = vld1q_u8((uint8_t*)p); - - /* Compare with all whitespace chars */ - uint8x16_t is_space = vceqq_u8(chunk, space); - uint8x16_t is_tab = vceqq_u8(chunk, tab); - uint8x16_t is_newline = vceqq_u8(chunk, newline); - uint8x16_t is_carriage = vceqq_u8(chunk, carriage); - - /* Combine all whitespace matches */ - uint8x16_t is_ws = vorrq_u8( - vorrq_u8(is_space, is_tab), - vorrq_u8(is_newline, is_carriage) - ); - - /* Check if we have any non-whitespace */ - uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(vmovn_u16( - vreinterpretq_u16_u8(is_ws))), 0); - - if (mask != 0xFFFFFFFFFFFFFFFFULL) { /* Found non-whitespace */ - /* Fall back to scalar for this chunk */ - while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) { - p++; - } - return p; - } - - p += SIMD_VEC_SIZE; - } -#endif - - /* Scalar fallback for remaining bytes (< 16) or unsupported platforms */ - while (p < end && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) { - p++; - } - - return p; -} - -/* ================================================================== - * SIMD NAME CHARACTER CLASSIFICATION - * ================================================================= - * Validates XML name characters: a-z, A-Z, 0-9, _, -, ., : - * Uses SIMD range checks for massive speedup. - */ - -inline static int simd_is_name_char(char c) { - return (c >= 'a' && c <= 'z') || - (c >= 'A' && c <= 'Z') || - (c >= '0' && c <= '9') || - c == '_' || c == '-' || c == '.' || c == ':'; -} - -/* Scan for end of name using SIMD */ -inline static const char* simd_scan_name(const char* start, const char* end) { - const char* p = start; - -#if defined(TAURUS_SIMD_SSE2) - /* SSE2 path - Check ranges in parallel */ - __m128i lower_a = _mm_set1_epi8('a' - 1); - __m128i upper_z = _mm_set1_epi8('z' + 1); - __m128i lower_A = _mm_set1_epi8('A' - 1); - __m128i upper_Z = _mm_set1_epi8('Z' + 1); - __m128i lower_0 = _mm_set1_epi8('0' - 1); - __m128i upper_9 = _mm_set1_epi8('9' + 1); - __m128i underscore = _mm_set1_epi8('_'); - __m128i dash = _mm_set1_epi8('-'); - __m128i dot = _mm_set1_epi8('.'); - __m128i colon = _mm_set1_epi8(':'); - - while (p + SIMD_VEC_SIZE <= end) { - __m128i chunk = _mm_loadu_si128((__m128i*)p); - - /* Check ranges: a-z, A-Z, 0-9 */ - __m128i is_lower = _mm_and_si128( - _mm_cmpgt_epi8(chunk, lower_a), - _mm_cmplt_epi8(chunk, upper_z) - ); - __m128i is_upper = _mm_and_si128( - _mm_cmpgt_epi8(chunk, lower_A), - _mm_cmplt_epi8(chunk, upper_Z) - ); - __m128i is_digit = _mm_and_si128( - _mm_cmpgt_epi8(chunk, lower_0), - _mm_cmplt_epi8(chunk, upper_9) - ); - - /* Check special chars: _, -, ., : */ - __m128i is_underscore = _mm_cmpeq_epi8(chunk, underscore); - __m128i is_dash = _mm_cmpeq_epi8(chunk, dash); - __m128i is_dot = _mm_cmpeq_epi8(chunk, dot); - __m128i is_colon = _mm_cmpeq_epi8(chunk, colon); - - /* Combine all valid character checks */ - __m128i is_valid = _mm_or_si128( - _mm_or_si128( - _mm_or_si128(is_lower, is_upper), - _mm_or_si128(is_digit, is_underscore) - ), - _mm_or_si128( - _mm_or_si128(is_dash, is_dot), - is_colon - ) - ); - - /* Find first invalid character */ - int mask = _mm_movemask_epi8(is_valid); - if (mask != 0xFFFF) { /* Found invalid char */ - int valid_count = __builtin_ctz(~mask & 0xFFFF); - return p + valid_count; - } - - p += SIMD_VEC_SIZE; - } - -#elif defined(TAURUS_SIMD_NEON) - /* NEON path - ARM64 */ - uint8x16_t lower_a = vdupq_n_u8('a' - 1); - uint8x16_t upper_z = vdupq_n_u8('z'); - uint8x16_t lower_A = vdupq_n_u8('A' - 1); - uint8x16_t upper_Z = vdupq_n_u8('Z'); - uint8x16_t lower_0 = vdupq_n_u8('0' - 1); - uint8x16_t upper_9 = vdupq_n_u8('9'); - uint8x16_t underscore = vdupq_n_u8('_'); - uint8x16_t dash = vdupq_n_u8('-'); - uint8x16_t dot = vdupq_n_u8('.'); - uint8x16_t colon = vdupq_n_u8(':'); - - while (p + SIMD_VEC_SIZE <= end) { - uint8x16_t chunk = vld1q_u8((uint8_t*)p); - - /* Check ranges */ - uint8x16_t is_lower = vandq_u8( - vcgtq_u8(chunk, lower_a), - vcleq_u8(chunk, upper_z) - ); - uint8x16_t is_upper = vandq_u8( - vcgtq_u8(chunk, lower_A), - vcleq_u8(chunk, upper_Z) - ); - uint8x16_t is_digit = vandq_u8( - vcgtq_u8(chunk, lower_0), - vcleq_u8(chunk, upper_9) - ); - - /* Check special chars */ - uint8x16_t is_underscore = vceqq_u8(chunk, underscore); - uint8x16_t is_dash = vceqq_u8(chunk, dash); - uint8x16_t is_dot = vceqq_u8(chunk, dot); - uint8x16_t is_colon = vceqq_u8(chunk, colon); - - /* Combine all checks */ - uint8x16_t is_valid = vorrq_u8( - vorrq_u8( - vorrq_u8(is_lower, is_upper), - vorrq_u8(is_digit, is_underscore) - ), - vorrq_u8( - vorrq_u8(is_dash, is_dot), - is_colon - ) - ); - - /* Check if all bytes are valid name chars */ - uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(is_valid), 0); - uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(is_valid), 1); - - if (~(low & high)) { /* Found invalid char */ - /* Fall back to scalar for exact position */ - break; - } - - p += SIMD_VEC_SIZE; - } -#endif - - /* Scalar finish for remaining bytes or on non-SIMD platforms */ - while (p < end && simd_is_name_char(*p)) { - p++; - } - - return p; -} - -/* ================================================================== - * SIMD STRING COMPARISON - * ================================================================= - * Fast memcmp using SIMD for common short string comparisons. - * Optimized for typical XML name/namespace lookups (4-20 chars). - */ - -inline static int simd_memcmp(const char* s1, const char* s2, size_t n) { - /* For very short strings, scalar is faster (branch prediction) */ - if (n < 8) { - return memcmp(s1, s2, n); - } - -#if defined(TAURUS_SIMD_SSE2) - /* SSE2 path */ - const char *p1 = s1, *p2 = s2; - size_t remaining = n; - - while (remaining >= SIMD_VEC_SIZE) { - __m128i v1 = _mm_loadu_si128((__m128i*)p1); - __m128i v2 = _mm_loadu_si128((__m128i*)p2); - __m128i cmp = _mm_cmpeq_epi8(v1, v2); - - int mask = _mm_movemask_epi8(cmp); - if (mask != 0xFFFF) { /* Found difference */ - /* Find first differing byte */ - int diff_pos = __builtin_ctz(~mask & 0xFFFF); - return (unsigned char)p1[diff_pos] - (unsigned char)p2[diff_pos]; - } - - p1 += SIMD_VEC_SIZE; - p2 += SIMD_VEC_SIZE; - remaining -= SIMD_VEC_SIZE; - } - - /* Handle remaining bytes */ - return memcmp(p1, p2, remaining); - -#elif defined(TAURUS_SIMD_NEON) - /* NEON path */ - const char *p1 = s1, *p2 = s2; - size_t remaining = n; - - while (remaining >= SIMD_VEC_SIZE) { - uint8x16_t v1 = vld1q_u8((uint8_t*)p1); - uint8x16_t v2 = vld1q_u8((uint8_t*)p2); - uint8x16_t cmp = vceqq_u8(v1, v2); - - /* Check if all bytes match */ - uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(cmp), 0); - uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(cmp), 1); - - if ((low & high) != 0xFFFFFFFFFFFFFFFFULL) { /* Found difference */ - return memcmp(p1, p2, SIMD_VEC_SIZE); - } - - p1 += SIMD_VEC_SIZE; - p2 += SIMD_VEC_SIZE; - remaining -= SIMD_VEC_SIZE; - } - - return memcmp(p1, p2, remaining); -#else - /* Scalar fallback */ - return memcmp(s1, s2, n); -#endif -} - -/* ================================================================== - * SIMD PATTERN MATCHING - * ================================================================= - * Fast pattern matching for "xmlns" prefix detection. - * Uses SIMD to check multiple bytes simultaneously. - */ - -inline static int simd_starts_with_xmlns(const char* s) { - /* Quick scalar check for common non-xmlns cases */ - if (s[0] != 'x') return 0; - -#if defined(TAURUS_SIMD_SSE2) || defined(TAURUS_SIMD_NEON) - /* Load first 8 bytes (includes "xmlns" and potential ":") */ - /* We know s[0] == 'x', so just check remaining "mlns" */ - if (s[1] == 'm' && s[2] == 'l' && s[3] == 'n' && s[4] == 's') { - /* Check for xmlns or xmlns: */ - return (s[5] == '\0' || s[5] == ':'); - } - return 0; -#else - /* Scalar path */ - return (s[0] == 'x' && s[1] == 'm' && s[2] == 'l' && - s[3] == 'n' && s[4] == 's' && - (s[5] == '\0' || s[5] == ':')); -#endif -} - -/* ================================================================== - * SIMD STRING EQUALITY - * ================================================================= - * Fast string equality check for namespace prefix matching. - */ - -inline static int simd_streq(const char* s1, const char* s2, size_t len) { - /* For very short strings, direct comparison is faster */ - if (len <= 4) { - switch (len) { - case 0: return 1; - case 1: return s1[0] == s2[0]; - case 2: return s1[0] == s2[0] && s1[1] == s2[1]; - case 3: return s1[0] == s2[0] && s1[1] == s2[1] && s1[2] == s2[2]; - case 4: return *((uint32_t*)s1) == *((uint32_t*)s2); - } - } - - return simd_memcmp(s1, s2, len) == 0; -} - -/* ================================================================== - * SIMD FIRST CHARACTER SCANNING - * ================================================================= - * Find first occurrence of character using SIMD. - * Faster than strchr() for short strings. - */ - -inline static const char* simd_find_char(const char* s, const char* end, char target) { - const char* p = s; - -#if defined(TAURUS_SIMD_SSE2) - __m128i target_vec = _mm_set1_epi8(target); - - while (p + SIMD_VEC_SIZE <= end) { - __m128i chunk = _mm_loadu_si128((__m128i*)p); - __m128i cmp = _mm_cmpeq_epi8(chunk, target_vec); - - int mask = _mm_movemask_epi8(cmp); - if (mask != 0) { /* Found target */ - int pos = __builtin_ctz(mask); - return p + pos; - } - - p += SIMD_VEC_SIZE; - } - -#elif defined(TAURUS_SIMD_NEON) - uint8x16_t target_vec = vdupq_n_u8((uint8_t)target); - - while (p + SIMD_VEC_SIZE <= end) { - uint8x16_t chunk = vld1q_u8((uint8_t*)p); - uint8x16_t cmp = vceqq_u8(chunk, target_vec); - - /* Check if we found the target */ - uint64_t low = vgetq_lane_u64(vreinterpretq_u64_u8(cmp), 0); - uint64_t high = vgetq_lane_u64(vreinterpretq_u64_u8(cmp), 1); - - if (low || high) { /* Found target somewhere */ - /* Fall back to scalar for exact position */ - while (p < end && *p != target) { - p++; - } - return (p < end) ? p : NULL; - } - - p += SIMD_VEC_SIZE; - } -#endif - - /* Scalar finish */ - while (p < end && *p != target) { - p++; - } - - return (p < end) ? p : NULL; -} - -#endif /* TAURUS_SIMD_HELPERS_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus.c b/ext/taurus/lib/src/taurus.c deleted file mode 100644 index 2cfa160..0000000 --- a/ext/taurus/lib/src/taurus.c +++ /dev/null @@ -1,222 +0,0 @@ -/* taurus.c - Taurus public API implementation - * Copyright (c) 2024, Ribose Inc. - * - * Pure C XML parser and XPath evaluator - Public API. - */ - -#include "taurus/taurus.h" -#include "taurus_internal.h" -#include "xpath/parser.h" -#include "xpath/evaluator.h" -#include - -/* Forward declaration from parse_simple.c */ -extern struct taurus_document* parse_xml_simple(const char* xml, size_t len); -extern void free_element(struct taurus_element* elem); - -/* ============================================================================ - * Version Information - * ============================================================================ */ - -/** - * Get library version string - */ -TAURUS_API const char* taurus_version(void) { - return TAURUS_VERSION; -} - -/** - * Get version components - */ -TAURUS_API void taurus_version_components(int* major, int* minor, int* patch) { - if (major) *major = TAURUS_VERSION_MAJOR; - if (minor) *minor = TAURUS_VERSION_MINOR; - if (patch) *patch = TAURUS_VERSION_PATCH; -} - -/* ============================================================================ - * Parse Options - * ============================================================================ */ - -/** - * Initialize parse options with defaults - */ -TAURUS_API void taurus_parse_options_init(taurus_parse_options* opts) { - if (!opts) return; - - opts->strict = 1; /* Strict mode by default */ - opts->preserve_whitespace = 0; /* Don't preserve whitespace by default */ - opts->track_positions = 0; /* Don't track positions by default */ -} - -/* ============================================================================ - * Document Functions - * ============================================================================ */ - -/** - * Parse XML string into document - */ -TAURUS_API struct taurus_document* taurus_parse(const char* xml, size_t len) { - if (!xml || len == 0) return NULL; - - /* Use default options */ - return parse_xml_simple(xml, len); -} - -/** - * Parse XML with custom options - */ -TAURUS_API struct taurus_document* taurus_parse_with_options( - const char* xml, - size_t len, - const taurus_parse_options* opts -) { - if (!xml || len == 0) return NULL; - - /* For now, ignore options and use simple parser - * TODO: Implement options support in parser */ - (void)opts; /* Suppress unused parameter warning */ - return parse_xml_simple(xml, len); -} - -/** - * Free document and all its contents - */ -TAURUS_API void taurus_document_free(struct taurus_document* doc) { - if (!doc) return; - - /* Decrement reference count */ - if (doc->ref_count > 0) { - doc->ref_count--; - if (doc->ref_count > 0) return; - } - - /* Free root element tree */ - if (doc->root) { - free_element(doc->root); - } - - /* Free document fields */ - if (doc->encoding) { - TAURUS_FREE(doc->encoding); - } - - /* Free processing instructions */ - struct taurus_processing_instruction* pi = doc->pis; - while (pi) { - struct taurus_processing_instruction* next = pi->next; - if (pi->target) TAURUS_FREE(pi->target); - if (pi->data) TAURUS_FREE(pi->data); - TAURUS_FREE(pi); - pi = next; - } - - /* Free document */ - TAURUS_FREE(doc); -} - -/** - * Get root element of document - */ -TAURUS_API struct taurus_element* taurus_document_root(struct taurus_document* doc) { - if (!doc) return NULL; - return doc->root; -} - -/** - * Get document encoding - */ -TAURUS_API const char* taurus_document_encoding(struct taurus_document* doc) { - if (!doc) return NULL; - return doc->encoding; /* May be NULL if not specified */ -} - -/* ============================================================================ - * Element Functions - * ============================================================================ */ - -/** - * Get element name - */ -TAURUS_API const char* taurus_element_name(struct taurus_element* elem) { - if (!elem) return ""; - return elem->name ? elem->name : ""; -} - -/** - * Get element text content (concatenated recursively) - */ -TAURUS_API const char* taurus_element_text(struct taurus_element* elem) { - if (!elem) return ""; - - /* Return direct text content if present */ - if (elem->text_content) { - return elem->text_content; - } - - /* If no direct text, check if we have children with text */ - /* For now, just return empty string - full recursive concatenation - * would require allocating memory, which complicates ownership */ - return ""; -} - -/* ============================================================================ - * XPath Functions - * ============================================================================ */ - -/** - * Evaluate XPath expression against document - */ -TAURUS_API struct taurus_xpath_result* taurus_xpath_eval( - struct taurus_document* doc, - const char* xpath_expr, - size_t expr_len -) { - if (!doc || !doc->root || !xpath_expr || expr_len == 0) { - return NULL; - } - - /* Parse XPath expression */ - XPathParser* parser = xpath_parser_new(xpath_expr, expr_len); - if (!parser) return NULL; - - XPathASTNode* ast = xpath_parse(parser); - const char* parse_error = xpath_parser_error(parser); - - if (!ast || parse_error) { - xpath_parser_free(parser); - return NULL; - } - - xpath_parser_free(parser); - - /* Create evaluation context */ - XPathContext* context = xpath_context_new(doc, doc->root); - if (!context) { - ast_node_free(ast); - return NULL; - } - - /* Evaluate expression */ - struct taurus_xpath_result* result = xpath_evaluate(context, ast); - - /* Check for evaluation errors */ - const char* eval_error = xpath_context_error(context); - if (eval_error && !result) { - /* Error already set in context */ - } - - /* Cleanup */ - xpath_context_free(context); - ast_node_free(ast); - - return result; -} - -/** - * Free XPath result - */ -TAURUS_API void taurus_xpath_result_free(struct taurus_xpath_result* result) { - /* Use internal xpath_result_free from evaluator */ - xpath_result_free(result); -} \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus_internal.h b/ext/taurus/lib/src/taurus_internal.h deleted file mode 100644 index 2f61243..0000000 --- a/ext/taurus/lib/src/taurus_internal.h +++ /dev/null @@ -1,383 +0,0 @@ -/* libtaurus - Internal data structures - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * INTERNAL HEADER - Not part of public API - * These structures are implementation details and may change between versions. - */ - -#ifndef TAURUS_INTERNAL_H -#define TAURUS_INTERNAL_H - -#include -#include -#include -#include "taurus/types.h" /* For taurus_error_code */ - -/* ============================================================================ - * Internal Structures - Match ext/taurus/taurus.h but without Ruby - * ============================================================================ */ - -/* Processing instruction structure */ -struct taurus_processing_instruction { - char* target; /* PI target (e.g., "xml-stylesheet") */ - char* data; /* PI data/content */ - struct taurus_processing_instruction* next; /* Linked list */ -}; - -/* Document structure */ -struct taurus_document { - struct taurus_element* root; - char* encoding; /* UTF-8 assumed, but store if specified */ - struct taurus_processing_instruction* pis; /* Processing instructions */ - size_t ref_count; /* Reference counting for memory management */ -}; - -/* Element structure - Matches ext/taurus/taurus.h _element */ -struct taurus_element { - char* name; /* Element name (required) */ - char* prefix; /* Namespace prefix (can be NULL) */ - char* namespace_uri; /* Resolved namespace URI (can be NULL) */ - - /* Hierarchy */ - struct taurus_element* parent; - struct taurus_element** children; - size_t children_count; - size_t children_capacity; - - /* Attributes */ - struct taurus_attribute** attributes; - size_t attributes_count; - size_t attributes_capacity; - - /* Namespace declarations (linked list) */ - struct taurus_namespace* namespaces; - size_t namespaces_count; - size_t namespaces_capacity; - - /* Content */ - char* text_content; /* Concatenated text content */ - - /* Document order for XPath */ - long doc_order; /* -1 = unset, >= 0 = document order index */ -}; - -/* Attribute structure - Matches ext/taurus/taurus.h _attribute */ -struct taurus_attribute { - char* name; /* Attribute name (required) */ - char* prefix; /* Namespace prefix (can be NULL) */ - char* namespace_uri; /* Resolved namespace URI (can be NULL) */ - char* value; /* Attribute value (can be NULL for boolean attrs) */ -}; - -/* Namespace structure - Matches ext/taurus/taurus.h _namespace */ -struct taurus_namespace { - char* prefix; /* Namespace prefix (NULL = default namespace) */ - char* uri; /* Namespace URI (required) */ - struct taurus_namespace* next; /* Linked list for multiple declarations */ -}; - -/* ============================================================================ - * XPath Node Type System - * ============================================================================ */ - -/* Node type enumeration - supports all XPath node types */ -typedef enum { - TAURUS_NODE_ELEMENT = 0, - TAURUS_NODE_ATTRIBUTE = 1, - TAURUS_NODE_TEXT = 2, /* Future */ - TAURUS_NODE_COMMENT = 3, /* Future */ - TAURUS_NODE_PI = 4 /* Future */ -} TaurusNodeType; - -/* Attribute node structure - dedicated type for attribute nodes in XPath */ -typedef struct taurus_attribute_node { - TaurusNodeType node_type; /* Always TAURUS_NODE_ATTRIBUTE */ - char* name; /* Attribute name */ - char* value; /* Attribute value */ - char* namespace_uri; /* Namespace URI (can be NULL) */ - struct taurus_element* owner; /* Owner element */ -} TaurusAttributeNode; - -/* XPath node union - type-safe wrapper for all XPath node types */ -typedef union xpath_node { - TaurusNodeType type; /* First field for type checking */ - struct { - TaurusNodeType node_type; - struct taurus_element* element; - } as_element; - TaurusAttributeNode* as_attribute; -} XPathNode; - -/* Type checking macros */ -#define XPATH_NODE_TYPE(node) (*(TaurusNodeType*)(node)) -#define IS_ELEMENT_NODE(node) ((node) && XPATH_NODE_TYPE(node) == TAURUS_NODE_ELEMENT) -#define IS_ATTRIBUTE_NODE(node) ((node) && XPATH_NODE_TYPE(node) == TAURUS_NODE_ATTRIBUTE) - -/* ============================================================================ - * XPath Internal Structures - * ============================================================================ */ - -/* XPath token - Matches ext/taurus/xpath.h Token */ -typedef struct xpath_token { - int type; /* XPathTokenType */ - const char* value; /* Token value (points into input, not owned) */ - size_t value_len; - int line; - int column; -} XPathToken; - -/* XPath lexer - Matches ext/taurus/xpath.h Lexer */ -typedef struct xpath_lexer { - const char* input; /* Input string (not owned) */ - const char* pos; /* Current position */ - const char* end; /* End of input */ - int line; - int column; - XPathToken current; - char error_msg[256]; -} XPathLexer; - -/* XPath AST node types - From ext/taurus/xpath.h */ -typedef enum { - XPATH_AST_PATH_EXPR, - XPATH_AST_ABSOLUTE_PATH, - XPATH_AST_RELATIVE_PATH, - XPATH_AST_STEP, - XPATH_AST_AXIS_SPECIFIER, - XPATH_AST_NODE_TEST, - XPATH_AST_PREDICATE, - XPATH_AST_FUNCTION_CALL, - XPATH_AST_ARGUMENT, - XPATH_AST_NUMBER, - XPATH_AST_STRING, - XPATH_AST_VARIABLE_REFERENCE, - XPATH_AST_OPERATOR, - XPATH_AST_NODE_TEST_NAME, - XPATH_AST_NODE_TEST_TYPE, - XPATH_AST_NODE_TEST_PI, - XPATH_AST_NODE_TEST_ALL, - XPATH_AST_NODE_TEST_ALL_IN_NS -} XPathASTType; - -/* XPath AST node - Matches ext/taurus/xpath.h _xpath_ast_node */ -typedef struct xpath_ast_node { - XPathASTType type; - char* value; /* String value (owned by node) */ - double number_value; /* Number value */ - struct xpath_ast_node** children; - size_t child_count; - size_t child_capacity; - - /* Namespace support for node tests (v0.8.0) */ - char* prefix; /* Namespace prefix (NULL if no prefix) */ - char* local_name; /* Local name part (NULL if not applicable) */ -} XPathASTNode; - -/* XPath parser - Matches ext/taurus/xpath.h _xpath_parser */ -typedef struct xpath_parser { - XPathLexer* lexer; - XPathToken* tokens; /* Token array for lookahead */ - size_t token_count; - size_t token_pos; - char error_msg[256]; -} XPathParser; - -/* XPath nodeset - Holds typed node pointers (elements or attributes) */ -typedef struct xpath_nodeset { - void** nodes; /* Typed node pointers (element* or TaurusAttributeNode*) */ - size_t count; - size_t capacity; - int owns_attributes; /* If true, free attribute nodes on nodeset_free */ -} XPathNodeSet; - -/* XPath result types - From ext/taurus/xpath.h */ -typedef enum { - XPATH_RESULT_BOOLEAN, - XPATH_RESULT_NUMBER, - XPATH_RESULT_STRING, - XPATH_RESULT_NODESET -} XPathResultType; - -/* XPath result value union */ -typedef union { - int boolean_value; - double number_value; - char* string_value; /* Owned by result */ - XPathNodeSet* nodeset_value; /* Owned by result */ -} XPathResultValue; - -/* XPath result - Matches ext/taurus/xpath.h _xpath_result */ -struct taurus_xpath_result { - XPathResultType type; - XPathResultValue value; -}; - -/* Namespace mapping for XPath context (v0.8.0) */ -typedef struct xpath_namespace_mapping { - char* prefix; /* Namespace prefix (NULL = default namespace) */ - char* uri; /* Namespace URI (required) */ -} XPathNamespaceMapping; - -/* XPath context - Matches ext/taurus/xpath.h _xpath_context */ -typedef struct xpath_context { - struct taurus_document* document; - struct taurus_element* context_node; - size_t context_position; /* 1-based position in context nodeset */ - size_t context_size; /* Total size of context nodeset */ - void* function_registry; /* Opaque function registry */ - char error_msg[256]; - - /* Namespace support (v0.8.0) */ - XPathNamespaceMapping* namespace_mappings; - size_t namespace_count; - size_t namespace_capacity; - - /* Error context support (v1.0.0) */ - const char* input; /* Original XPath expression for error context */ - size_t input_len; /* Length of input expression */ - - /* Optimization flags */ - int to_boolean; /* Only checking existence */ - int max_results; /* Stop after N results (0 = unlimited) */ - int enable_early_exit; /* Master switch for early termination */ -} XPathContext; - -/* XPath operator types - From ext/taurus/xpath.h */ -typedef enum { - XPATH_OP_OR, - XPATH_OP_AND, - XPATH_OP_EQUAL, - XPATH_OP_NOT_EQUAL, - XPATH_OP_LESS, - XPATH_OP_LESS_EQUAL, - XPATH_OP_GREATER, - XPATH_OP_GREATER_EQUAL, - XPATH_OP_PLUS, - XPATH_OP_MINUS, - XPATH_OP_MULTIPLY, - XPATH_OP_DIV, - XPATH_OP_MOD, - XPATH_OP_UNION, - XPATH_OP_NEGATION -} XPathOperatorType; - -/* XPath axis types - From ext/taurus/xpath.h */ -typedef enum { - XPATH_AXIS_ANCESTOR, - XPATH_AXIS_ANCESTOR_OR_SELF, - XPATH_AXIS_ATTRIBUTE, - XPATH_AXIS_CHILD, - XPATH_AXIS_DESCENDANT, - XPATH_AXIS_DESCENDANT_OR_SELF, - XPATH_AXIS_FOLLOWING, - XPATH_AXIS_FOLLOWING_SIBLING, - XPATH_AXIS_NAMESPACE, - XPATH_AXIS_PARENT, - XPATH_AXIS_PRECEDING, - XPATH_AXIS_PRECEDING_SIBLING, - XPATH_AXIS_SELF -} XPathAxisType; - -/* ============================================================================ - * Memory Management Macros - * ============================================================================ */ - -/* Use standard C memory functions instead of Ruby macros */ -#define TAURUS_ALLOC(type) \ - ((type*)malloc(sizeof(type))) - -#define TAURUS_ALLOC_N(type, n) \ - ((type*)malloc(sizeof(type) * (n))) - -#define TAURUS_REALLOC_N(ptr, type, n) \ - ((type*)realloc((ptr), sizeof(type) * (n))) - -#define TAURUS_FREE(ptr) \ - do { if (ptr) { free(ptr); ptr = NULL; } } while(0) - -/* Array growth helper - double capacity when full */ -#define TAURUS_GROW_ARRAY(ptr, capacity) \ - do { \ - size_t new_cap = (capacity) == 0 ? 4 : (capacity) * 2; \ - (ptr) = realloc((ptr), new_cap * sizeof(*(ptr))); \ - (capacity) = new_cap; \ - } while(0) - -/* ============================================================================ - * Generic Memory Allocation - * ============================================================================ */ - -/* Generic malloc wrapper */ -static inline void* taurus_malloc(size_t size) { - return malloc(size); -} - -/* Generic realloc wrapper */ -static inline void* taurus_realloc(void* ptr, size_t size) { - return realloc(ptr, size); -} - -/* Generic free wrapper */ -static inline void taurus_free(void* ptr) { - free(ptr); -} - -/* ============================================================================ - * String Helpers - * ============================================================================ */ - -/* NULL-safe string duplication */ -static inline char* taurus_strdup(const char* str) { - if (!str) return NULL; - size_t len = strlen(str); - char* dup = (char*)malloc(len + 1); - if (dup) { - memcpy(dup, str, len + 1); - } - return dup; -} - -/* NULL-safe string length */ -static inline size_t taurus_strlen(const char* str) { - return str ? strlen(str) : 0; -} - -/* NULL-safe string comparison */ -static inline int taurus_strcmp(const char* s1, const char* s2) { - if (s1 == s2) return 0; - if (!s1) return -1; - if (!s2) return 1; - return strcmp(s1, s2); -} - -/* ============================================================================ - * Internal Error Functions (from error.c) - * ============================================================================ */ - -/* Set error with basic message */ -void taurus_set_error(taurus_error_code code, const char* message); - -/* Set error with line/column position */ -void taurus_set_parse_error_position(int line, int column); - -/* Set error with full context (message, input, position, snippet) */ -void taurus_set_error_with_context( - taurus_error_code code, - const char* message, - const char* input, - size_t byte_offset, - int line, - int column -); - -/* Extract context snippet from input around error position */ -void taurus_extract_context_snippet( - const char* input, - size_t offset, - int error_line, - char* out_buffer, - size_t buffer_size -); - -#endif /* TAURUS_INTERNAL_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus_memory.c b/ext/taurus/lib/src/taurus_memory.c deleted file mode 100644 index 8a0d3be..0000000 --- a/ext/taurus/lib/src/taurus_memory.c +++ /dev/null @@ -1,423 +0,0 @@ -/* libtaurus - Memory management implementation - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - */ - -#include "taurus_memory.h" -#include -#include - -/* ============================================================================ - * Document Management - * ============================================================================ */ - -struct taurus_document* taurus_document_new(void) { - struct taurus_document* doc = TAURUS_ALLOC(struct taurus_document); - if (!doc) return NULL; - - doc->root = NULL; - doc->encoding = NULL; - doc->pis = NULL; - doc->ref_count = 1; - - return doc; -} - -void taurus_document_free_internal(struct taurus_document* doc) { - if (!doc) return; - - /* Free root element tree */ - if (doc->root) { - taurus_element_free_tree(doc->root); - } - - /* Free encoding string */ - if (doc->encoding) { - free(doc->encoding); - } - - /* Free processing instructions */ - if (doc->pis) { - taurus_pi_free_chain(doc->pis); - } - - free(doc); -} - -/* ============================================================================ - * Element Management - * ============================================================================ */ - -struct taurus_element* taurus_element_new(const char* name) { - if (!name) return NULL; - - struct taurus_element* elem = TAURUS_ALLOC(struct taurus_element); - if (!elem) return NULL; - - /* Initialize all fields */ - elem->name = taurus_strdup(name); - if (!elem->name) { - free(elem); - return NULL; - } - - elem->prefix = NULL; - elem->namespace_uri = NULL; - elem->parent = NULL; - elem->children = NULL; - elem->children_count = 0; - elem->children_capacity = 0; - elem->attributes = NULL; - elem->attributes_count = 0; - elem->attributes_capacity = 0; - elem->namespaces = NULL; - elem->namespaces_count = 0; - elem->namespaces_capacity = 0; - elem->text_content = NULL; - elem->doc_order = -1; - - return elem; -} - -void taurus_element_free_shallow(struct taurus_element* elem) { - size_t i; - - if (!elem) return; - - /* Free strings */ - if (elem->name) free(elem->name); - if (elem->prefix) free(elem->prefix); - if (elem->namespace_uri) free(elem->namespace_uri); - if (elem->text_content) free(elem->text_content); - - /* Free attributes */ - if (elem->attributes) { - for (i = 0; i < elem->attributes_count; i++) { - taurus_attribute_free(elem->attributes[i]); - } - free(elem->attributes); - } - - /* Free namespace chain */ - taurus_namespace_free_chain(elem->namespaces); - - /* Free children array (not elements themselves) */ - if (elem->children) { - free(elem->children); - } - - free(elem); -} - -void taurus_element_free_tree(struct taurus_element* elem) { - size_t i; - - if (!elem) return; - - /* Recursively free all children first */ - if (elem->children) { - for (i = 0; i < elem->children_count; i++) { - taurus_element_free_tree(elem->children[i]); - } - } - - /* Then free this element */ - taurus_element_free_shallow(elem); -} - -int taurus_element_add_child(struct taurus_element* parent, struct taurus_element* child) { - if (!parent || !child) return -1; - - /* Grow array if needed */ - if (parent->children_count >= parent->children_capacity) { - TAURUS_GROW_ARRAY(parent->children, parent->children_capacity); - if (!parent->children) return -1; - } - - /* Add child */ - parent->children[parent->children_count++] = child; - child->parent = parent; - - return 0; -} - -int taurus_element_add_attribute(struct taurus_element* elem, struct taurus_attribute* attr) { - if (!elem || !attr) return -1; - - /* Grow array if needed */ - if (elem->attributes_count >= elem->attributes_capacity) { - TAURUS_GROW_ARRAY(elem->attributes, elem->attributes_capacity); - if (!elem->attributes) return -1; - } - - /* Add attribute */ - elem->attributes[elem->attributes_count++] = attr; - - return 0; -} - -int taurus_element_add_namespace(struct taurus_element* elem, struct taurus_namespace* ns) { - if (!elem || !ns) return -1; - - /* Add to linked list at head */ - ns->next = elem->namespaces; - elem->namespaces = ns; - elem->namespaces_count++; - - return 0; -} - -/* ============================================================================ - * Attribute Management - * ============================================================================ */ - -struct taurus_attribute* taurus_attribute_new(const char* name, const char* value) { - if (!name) return NULL; - - struct taurus_attribute* attr = TAURUS_ALLOC(struct taurus_attribute); - if (!attr) return NULL; - - attr->name = taurus_strdup(name); - if (!attr->name) { - free(attr); - return NULL; - } - - attr->prefix = NULL; - attr->namespace_uri = NULL; - attr->value = value ? taurus_strdup(value) : NULL; - - if (value && !attr->value) { - free(attr->name); - free(attr); - return NULL; - } - - return attr; -} - -void taurus_attribute_free(struct taurus_attribute* attr) { - if (!attr) return; - - if (attr->name) free(attr->name); - if (attr->prefix) free(attr->prefix); - if (attr->namespace_uri) free(attr->namespace_uri); - if (attr->value) free(attr->value); - - free(attr); -} - -/* ============================================================================ - * Namespace Management - * ============================================================================ */ - -struct taurus_namespace* taurus_namespace_new(const char* prefix, const char* uri) { - if (!uri) return NULL; - - struct taurus_namespace* ns = TAURUS_ALLOC(struct taurus_namespace); - if (!ns) return NULL; - - ns->prefix = prefix ? taurus_strdup(prefix) : NULL; - ns->uri = taurus_strdup(uri); - ns->next = NULL; - - if (!ns->uri || (prefix && !ns->prefix)) { - if (ns->prefix) free(ns->prefix); - if (ns->uri) free(ns->uri); - free(ns); - return NULL; - } - - return ns; -} - -void taurus_namespace_free_single(struct taurus_namespace* ns) { - if (!ns) return; - - if (ns->prefix) free(ns->prefix); - if (ns->uri) free(ns->uri); - free(ns); -} - -void taurus_namespace_free_chain(struct taurus_namespace* ns) { - struct taurus_namespace* next; - - while (ns) { - next = ns->next; - taurus_namespace_free_single(ns); - ns = next; - } -} - -struct taurus_namespace* taurus_namespace_find(struct taurus_element* elem, const char* prefix) { - struct taurus_namespace* ns; - - if (!elem) return NULL; - - /* Search in current element's namespace declarations */ - for (ns = elem->namespaces; ns; ns = ns->next) { - if (!prefix && !ns->prefix) { - /* Both NULL (default namespace) */ - return ns; - } - if (prefix && ns->prefix && strcmp(prefix, ns->prefix) == 0) { - /* Matching prefixes */ - return ns; - } - } - - /* Not found in current element, check parent (inheritance) */ - if (elem->parent) { - return taurus_namespace_find(elem->parent, prefix); - } - - return NULL; -} - -/* ============================================================================ - * XPath Memory Management - * ============================================================================ */ - -XPathNodeSet* taurus_xpath_nodeset_new(void) { - return taurus_xpath_nodeset_new_with_capacity(4); -} - -XPathNodeSet* taurus_xpath_nodeset_new_with_capacity(size_t capacity) { - XPathNodeSet* nodeset = TAURUS_ALLOC(XPathNodeSet); - if (!nodeset) return NULL; - - nodeset->nodes = TAURUS_ALLOC_N(struct taurus_element*, capacity); - if (!nodeset->nodes) { - free(nodeset); - return NULL; - } - - nodeset->count = 0; - nodeset->capacity = capacity; - - return nodeset; -} - -int taurus_xpath_nodeset_add(XPathNodeSet* nodeset, struct taurus_element* node) { - if (!nodeset || !node) return -1; - - /* Grow array if needed */ - if (nodeset->count >= nodeset->capacity) { - size_t new_cap = nodeset->capacity * 2; - struct taurus_element** new_nodes = TAURUS_REALLOC_N(nodeset->nodes, struct taurus_element*, new_cap); - if (!new_nodes) return -1; - - nodeset->nodes = new_nodes; - nodeset->capacity = new_cap; - } - - /* Add node */ - nodeset->nodes[nodeset->count++] = node; - - return 0; -} - -void taurus_xpath_nodeset_free(XPathNodeSet* nodeset) { - if (!nodeset) return; - - if (nodeset->nodes) { - free(nodeset->nodes); - } - - free(nodeset); -} - -struct taurus_xpath_result* taurus_xpath_result_new(XPathResultType type) { - struct taurus_xpath_result* result = TAURUS_ALLOC(struct taurus_xpath_result); - if (!result) return NULL; - - result->type = type; - - /* Initialize value union based on type */ - switch (type) { - case XPATH_RESULT_BOOLEAN: - result->value.boolean_value = 0; - break; - case XPATH_RESULT_NUMBER: - result->value.number_value = 0.0; - break; - case XPATH_RESULT_STRING: - result->value.string_value = NULL; - break; - case XPATH_RESULT_NODESET: - result->value.nodeset_value = NULL; - break; - } - - return result; -} - -void taurus_xpath_result_free_internal(struct taurus_xpath_result* result) { - if (!result) return; - - /* Free owned data based on type */ - switch (result->type) { - case XPATH_RESULT_STRING: - if (result->value.string_value) { - free(result->value.string_value); - } - break; - case XPATH_RESULT_NODESET: - if (result->value.nodeset_value) { - taurus_xpath_nodeset_free(result->value.nodeset_value); - } - break; - default: - /* Boolean and number don't own data */ - break; - } - - free(result); -} - -/* ============================================================================ - * Processing Instruction Management - * ============================================================================ */ - -struct taurus_processing_instruction* taurus_pi_new(const char* target, const char* data) { - if (!target) return NULL; - - struct taurus_processing_instruction* pi = TAURUS_ALLOC(struct taurus_processing_instruction); - if (!pi) return NULL; - - pi->target = taurus_strdup(target); - if (!pi->target) { - free(pi); - return NULL; - } - - pi->data = data ? taurus_strdup(data) : NULL; - if (data && !pi->data) { - free(pi->target); - free(pi); - return NULL; - } - - pi->next = NULL; - - return pi; -} - -void taurus_pi_free(struct taurus_processing_instruction* pi) { - if (!pi) return; - - if (pi->target) free(pi->target); - if (pi->data) free(pi->data); - - free(pi); -} - -void taurus_pi_free_chain(struct taurus_processing_instruction* pi) { - struct taurus_processing_instruction* next; - - while (pi) { - next = pi->next; - taurus_pi_free(pi); - pi = next; - } -} \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus_memory.h b/ext/taurus/lib/src/taurus_memory.h deleted file mode 100644 index 5e188b8..0000000 --- a/ext/taurus/lib/src/taurus_memory.h +++ /dev/null @@ -1,194 +0,0 @@ -/* libtaurus - Memory management - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Internal memory management functions - */ - -#ifndef TAURUS_MEMORY_H -#define TAURUS_MEMORY_H - -#include "taurus_internal.h" - -/* ============================================================================ - * Document Management - * ============================================================================ */ - -/** - * Create new document - * @return Document or NULL on allocation failure - */ -struct taurus_document* taurus_document_new(void); - -/** - * Free document and all elements (internal implementation) - * @param doc Document to free - */ -void taurus_document_free_internal(struct taurus_document* doc); - -/* ============================================================================ - * Element Management - * ============================================================================ */ - -/** - * Create new element - * @param name Element name (will be copied) - * @return Element or NULL on allocation failure - */ -struct taurus_element* taurus_element_new(const char* name); - -/** - * Free element (non-recursive, doesn't free children) - * @param elem Element to free - */ -void taurus_element_free_shallow(struct taurus_element* elem); - -/** - * Free element and entire subtree recursively - * @param elem Element to free - */ -void taurus_element_free_tree(struct taurus_element* elem); - -/** - * Add child element to parent - * @param parent Parent element - * @param child Child element - * @return 0 on success, -1 on allocation failure - */ -int taurus_element_add_child(struct taurus_element* parent, struct taurus_element* child); - -/** - * Add attribute to element - * @param elem Element - * @param attr Attribute (ownership transferred to element) - * @return 0 on success, -1 on allocation failure - */ -int taurus_element_add_attribute(struct taurus_element* elem, struct taurus_attribute* attr); - -/** - * Add namespace declaration to element - * @param elem Element - * @param ns Namespace (ownership transferred to element) - * @return 0 on success, -1 on allocation failure - */ -int taurus_element_add_namespace(struct taurus_element* elem, struct taurus_namespace* ns); - -/* ============================================================================ - * Attribute Management - * ============================================================================ */ - -/** - * Create new attribute - * @param name Attribute name (will be copied) - * @param value Attribute value (will be copied, can be NULL) - * @return Attribute or NULL on allocation failure - */ -struct taurus_attribute* taurus_attribute_new(const char* name, const char* value); - -/** - * Free attribute - * @param attr Attribute to free - */ -void taurus_attribute_free(struct taurus_attribute* attr); - -/* ============================================================================ - * Namespace Management - * ============================================================================ */ - -/** - * Create new namespace - * @param prefix Namespace prefix (will be copied, NULL for default namespace) - * @param uri Namespace URI (will be copied, required) - * @return Namespace or NULL on allocation failure - */ -struct taurus_namespace* taurus_namespace_new(const char* prefix, const char* uri); - -/** - * Free namespace (non-recursive, doesn't free next) - * @param ns Namespace to free - */ -void taurus_namespace_free_single(struct taurus_namespace* ns); - -/** - * Free namespace chain (recursive, frees entire linked list) - * @param ns First namespace in chain - */ -void taurus_namespace_free_chain(struct taurus_namespace* ns); - -/** - * Find namespace by prefix in element (with inheritance) - * @param elem Element to start search from - * @param prefix Prefix to find (NULL for default namespace) - * @return Namespace or NULL if not found - */ -struct taurus_namespace* taurus_namespace_find(struct taurus_element* elem, const char* prefix); - -/* ============================================================================ - * XPath Memory Management - * ============================================================================ */ - -/** - * Create new XPath nodeset - * @return Nodeset or NULL on allocation failure - */ -XPathNodeSet* taurus_xpath_nodeset_new(void); - -/** - * Create new XPath nodeset with initial capacity - * @param capacity Initial capacity - * @return Nodeset or NULL on allocation failure - */ -XPathNodeSet* taurus_xpath_nodeset_new_with_capacity(size_t capacity); - -/** - * Add node to nodeset - * @param nodeset Nodeset - * @param node Element to add - * @return 0 on success, -1 on allocation failure - */ -int taurus_xpath_nodeset_add(XPathNodeSet* nodeset, struct taurus_element* node); - -/** - * Free nodeset (doesn't free the elements themselves) - * @param nodeset Nodeset to free - */ -void taurus_xpath_nodeset_free(XPathNodeSet* nodeset); - -/** - * Create new XPath result - * @param type Result type - * @return Result or NULL on allocation failure - */ -struct taurus_xpath_result* taurus_xpath_result_new(XPathResultType type); - -/** - * Free XPath result (frees owned data) - * @param result Result to free - */ -void taurus_xpath_result_free_internal(struct taurus_xpath_result* result); - -/* ============================================================================ - * Processing Instruction Management - * ============================================================================ */ - -/** - * Create new processing instruction - * @param target PI target (will be copied) - * @param data PI data (will be copied) - * @return Processing instruction or NULL on allocation failure - */ -struct taurus_processing_instruction* taurus_pi_new(const char* target, const char* data); - -/** - * Free processing instruction (single, doesn't free next) - * @param pi Processing instruction to free - */ -void taurus_pi_free(struct taurus_processing_instruction* pi); - -/** - * Free processing instruction chain (recursive, frees entire linked list) - * @param pi First processing instruction in chain - */ -void taurus_pi_free_chain(struct taurus_processing_instruction* pi); - -#endif /* TAURUS_MEMORY_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus_parse.c b/ext/taurus/lib/src/taurus_parse.c deleted file mode 100644 index b532117..0000000 --- a/ext/taurus/lib/src/taurus_parse.c +++ /dev/null @@ -1,382 +0,0 @@ -/* taurus_parse.c - XML parser core helper functions - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Converted from ext/taurus/parse.c (Ruby C extension → pure C library) - * Session 82: Helper functions (parse_name, parse_quoted_value, etc.) - * Session 84: Modularized - moved element/content/document functions to separate files - */ - -#include "parse_internal.h" -#include -#include -#include - -/* ================================================================== - * STRING HELPERS - * ================================================================== */ - -/* Duplicate string from buffer with length (NOT null-terminated in source) */ -char *taurus_strndup(const char *str, size_t len) { - char *dup; - - if (!str) return NULL; - - dup = (char*)taurus_malloc(len + 1); - if (!dup) return NULL; - - memcpy(dup, str, len); - dup[len] = '\0'; - - return dup; -} - -/* Extract prefix and local name from qualified name "prefix:local" - * Returns 0 if no prefix, 1 if prefix found - * Modifies qname buffer in place, caller must free qname */ -int extract_prefix_and_local(char *qname, char **prefix, char **local_name) { - char *colon; - - if (!qname || !prefix || !local_name) return -1; - - /* Find colon separator */ - colon = strchr(qname, ':'); - - if (!colon) { - /* No prefix */ - *prefix = NULL; - *local_name = qname; - return 0; - } - - /* Split at colon */ - *colon = '\0'; - *prefix = qname; - *local_name = colon + 1; - - return 1; -} - -/* Extract just local name from qualified name (for end tag comparison) */ -const char *extract_local_name_only(const char *qname) { - const char *colon; - - if (!qname) return NULL; - - colon = strchr(qname, ':'); - if (!colon) { - return qname; /* No prefix, return whole name */ - } - - return colon + 1; /* Return part after colon */ -} - - -/* ================================================================== - * PARSE CONTEXT MANAGEMENT - * ================================================================== */ - -/* Initialize parse context with input buffer and options */ -int taurus_parse_context_init(TaurusParseContext *ctx, - const char *xml, - size_t len, - TaurusParseOptions *opts) { - if (!ctx || !xml) { - return -1; - } - - /* Initialize input buffer pointers */ - ctx->start = xml; - ctx->pos = xml; - ctx->end = xml + len; - - /* Initialize parse state */ - ctx->doc = NULL; - ctx->current = NULL; - taurus_attr_stack_init(&ctx->attr_stack); - string_intern_table_init(&ctx->intern_table); - - /* Set options (use defaults if NULL) */ - if (opts) { - ctx->opts = *opts; - } else { - taurus_parse_options_init(&ctx->opts); - } - - /* Initialize error tracking */ - ctx->line = 1; - ctx->column = 1; - ctx->error[0] = '\0'; - - return 0; -} - -/* Free parse context resources */ -void taurus_parse_context_free(TaurusParseContext *ctx) { - if (!ctx) { - return; - } - - /* Cleanup attribute stack (frees heap memory if allocated) */ - taurus_attr_stack_cleanup(&ctx->attr_stack); - - /* Free string interning table */ - string_intern_table_free(&ctx->intern_table); - - /* Clear pointers (safety) */ - ctx->start = NULL; - ctx->pos = NULL; - ctx->end = NULL; - ctx->doc = NULL; - ctx->current = NULL; -} - -/* ================================================================== - * CORE PARSING FUNCTIONS - * ================================================================== */ - -/* Parse an XML name (element or attribute name) - * - * Returns pointer to name in buffer and sets *len to name length. - * Advances ctx->pos past the name. - * Returns NULL on error (sets ctx->error). - * - * XML name rules: - * - Must start with letter, underscore, or colon - * - Can contain letters, digits, hyphens, periods, colons, underscores - * - * NOTE: Returned pointer is into parse buffer, NOT null-terminated. - * Caller must copy with taurus_strndup() if needed beyond parse. - */ -const char *parse_name(TaurusParseContext *ctx, size_t *len) { - const char *start; - - /* Skip leading whitespace */ - taurus_skip_whitespace(&ctx->pos, ctx->end); - - /* Set start pointer */ - start = ctx->pos; - - /* Must start with letter or underscore (colon for namespaces) */ - if (ctx->pos >= ctx->end || - (!is_name_start_fast(*ctx->pos) && *ctx->pos != ':')) { - taurus_parse_context_set_error(ctx, - "Invalid name start character at line %d, column %d", - ctx->line, ctx->column); - return NULL; - } - ctx->pos++; - - /* Parse name characters using fast table lookup */ - while (ctx->pos < ctx->end && taurus_is_name_char(*ctx->pos)) { - ctx->pos++; - } - - /* Calculate length */ - *len = ctx->pos - start; - - /* Name cannot be empty */ - if (*len == 0) { - taurus_parse_context_set_error(ctx, - "Empty name at line %d, column %d", - ctx->line, ctx->column); - return NULL; - } - - return start; -} - -/* Parse a quoted attribute value - * - * Returns pointer to value in buffer (excluding quotes) and sets *len. - * Advances ctx->pos past the closing quote. - * Returns NULL on error (sets ctx->error). - * - * Handles both single and double quotes. - * Uses SIMD optimization to find closing quote quickly. - * - * NOTE: Returned pointer is into parse buffer, NOT null-terminated. - * Caller must copy with taurus_strndup() if needed. - */ -const char *parse_quoted_value(TaurusParseContext *ctx, size_t *len) { - char quote; - const char *value_start; - const char *quote_pos; - - /* Skip leading whitespace */ - taurus_skip_whitespace(&ctx->pos, ctx->end); - - /* Must start with quote */ - if (ctx->pos >= ctx->end || - (*ctx->pos != '"' && *ctx->pos != '\'')) { - taurus_parse_context_set_error(ctx, - "Expected quote at line %d, column %d", - ctx->line, ctx->column); - return NULL; - } - - /* Save quote character and skip it */ - quote = *ctx->pos++; - value_start = ctx->pos; - - /* Find closing quote using SIMD optimization */ - quote_pos = simd_find_char(ctx->pos, ctx->end, quote); - if (!quote_pos) { - taurus_parse_context_set_error(ctx, - "Unterminated quoted value at line %d, column %d", - ctx->line, ctx->column); - return NULL; - } - - /* Calculate value length (excluding quotes) */ - *len = quote_pos - value_start; - - /* Advance position past closing quote */ - ctx->pos = quote_pos + 1; - - return value_start; -} - -/* Skip XML comment - * - * Returns 0 on success, -1 on error (sets ctx->error). - * Advances ctx->pos past the comment end marker "-->". - * - * Assumes ctx->pos is at '" pattern */ - while (ctx->pos + 2 < ctx->end) { - /* Use SIMD to find next '-' quickly */ - dash_pos = simd_find_char(ctx->pos, ctx->end - 2, '-'); - if (!dash_pos) { - /* No more dashes - unterminated comment */ - break; - } - - /* Move to dash position */ - ctx->pos = dash_pos; - - /* Check if it's "-->" */ - if (ctx->pos[0] == '-' && ctx->pos[1] == '-' && ctx->pos[2] == '>') { - ctx->pos += 3; /* Skip "-->" */ - return 0; - } - - /* Not a match, move past this dash and continue */ - ctx->pos++; - } - - /* Unterminated comment */ - taurus_parse_context_set_error(ctx, - "Unterminated comment at line %d, column %d", - ctx->line, ctx->column); - return -1; -} - -/* Parse CDATA section - * - * Returns pointer to CDATA content (excluding markers) and sets *len. - * Advances ctx->pos past the "]]>" end marker. - * Returns NULL on error (sets ctx->error). - * - * Assumes ctx->pos is at "pos; - - /* Scan for "]]>" pattern */ - while (ctx->pos + 2 < ctx->end) { - /* Use SIMD to find next ']' quickly */ - bracket_pos = simd_find_char(ctx->pos, ctx->end - 2, ']'); - if (!bracket_pos) { - /* No more brackets - unterminated CDATA */ - break; - } - - /* Move to bracket position */ - ctx->pos = bracket_pos; - - /* Check if it's "]]>" */ - if (ctx->pos[0] == ']' && ctx->pos[1] == ']' && ctx->pos[2] == '>') { - /* Found end marker */ - *len = ctx->pos - content_start; - ctx->pos += 3; /* Skip "]]>" */ - return content_start; - } - - /* Not a match, move past this bracket and continue */ - ctx->pos++; - } - - /* Unterminated CDATA */ - taurus_parse_context_set_error(ctx, - "Unterminated CDATA section at line %d, column %d", - ctx->line, ctx->column); - return NULL; -} - -/* Parse text content (until '<' or end of buffer) - * - * Returns pointer to text content and sets *len. - * Advances ctx->pos to the '<' character or end. - * Returns NULL if text is empty or only whitespace (unless preserve_whitespace). - * - * Uses SIMD optimization to find '<' character quickly. - * - * NOTE: Returned pointer is into parse buffer, NOT null-terminated. - */ -const char *parse_text(TaurusParseContext *ctx, size_t *len) { - const char *start; - const char *text_end; - const char *p; - int has_non_whitespace; - - start = ctx->pos; - has_non_whitespace = 0; - - /* Find next '<' using SIMD */ - text_end = simd_find_char(ctx->pos, ctx->end, '<'); - if (!text_end) { - /* No '<' found - text goes to end of input */ - text_end = ctx->end; - } - - /* Check for non-whitespace content */ - p = ctx->pos; - while (p < text_end && !has_non_whitespace) { - if (!taurus_is_whitespace(*p)) { - has_non_whitespace = 1; - } - p++; - } - - /* Advance position */ - ctx->pos = text_end; - - /* Calculate length */ - *len = text_end - start; - - /* Return NULL if only whitespace (unless preserving) */ - if (!has_non_whitespace && !ctx->opts.preserve_whitespace) { - return NULL; - } - - /* Return NULL if empty */ - if (*len == 0) { - return NULL; - } - - return start; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/taurus_parse.h b/ext/taurus/lib/src/taurus_parse.h deleted file mode 100644 index f511fda..0000000 --- a/ext/taurus/lib/src/taurus_parse.h +++ /dev/null @@ -1,192 +0,0 @@ -/* taurus_parse.h - XML parser for libtaurus (pure C) - * Copyright (c) 2024, Ribose Inc. - * All rights reserved. - * - * Converted from ext/taurus/parse.c (Ruby C extension → pure C library) - */ - -#ifndef TAURUS_PARSE_H -#define TAURUS_PARSE_H - -#include "taurus_internal.h" -#include "parse_helpers.h" -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* ================================================================== - * PARSE OPTIONS - * ================================================================== */ - -/* Parse options structure */ -typedef struct taurus_parse_options { - int strict; /* Strict XML validation (default: 1) */ - int preserve_whitespace; /* Preserve whitespace-only text nodes (default: 0) */ - int track_positions; /* Track line/column positions (default: 0) */ -} TaurusParseOptions; - -/* Initialize parse options with defaults */ -static inline void taurus_parse_options_init(TaurusParseOptions *opts) { - opts->strict = 1; - opts->preserve_whitespace = 0; - opts->track_positions = 0; -} - -/* ================================================================== - * PARSE CONTEXT - * ================================================================== */ - -/* Parse context - internal state during parsing - * NOTE: This structure is opaque to users. Use accessor functions. */ -typedef struct taurus_parse_context { - /* Input buffer */ - const char *start; /* Start of input (for error reporting) */ - const char *pos; /* Current position */ - const char *end; /* End of input */ - - /* Parse state */ - struct taurus_document *doc; /* Document being built */ - struct taurus_element *current; /* Current element (for nesting) */ - TaurusAttrStack attr_stack; /* Reusable attribute stack */ - StringInternTable intern_table; /* String interning for attributes */ - - /* Options */ - TaurusParseOptions opts; - - /* Error tracking */ - int line; /* Current line number (1-based) */ - int column; /* Current column number (1-based) */ - char error[256]; /* Error message (empty if no error) */ -} TaurusParseContext; - -/* Initialize parse context with input buffer and options - * Returns 0 on success, -1 on error */ -int taurus_parse_context_init(TaurusParseContext *ctx, - const char *xml, - size_t len, - TaurusParseOptions *opts); - -/* Free parse context resources (attributes, interning table, etc.) - * Does NOT free the document (caller owns that) */ -void taurus_parse_context_free(TaurusParseContext *ctx); - -/* Get error message from parse context (empty string if no error) */ -static inline const char *taurus_parse_context_error(const TaurusParseContext *ctx) { - return ctx->error; -} - -/* Set error message in parse context */ -static inline void taurus_parse_context_set_error(TaurusParseContext *ctx, - const char *fmt, ...) { - va_list args; - va_start(args, fmt); - vsnprintf(ctx->error, sizeof(ctx->error), fmt, args); - va_end(args); -} - -/* ================================================================== - * MAIN PARSE API - * ================================================================== */ - -/* Parse XML string into document structure - * - * Parameters: - * xml: XML string to parse (need not be null-terminated) - * len: Length of XML string - * opts: Parse options (NULL for defaults) - * - * Returns: - * Document structure on success, NULL on error - * Caller owns returned document and must free with taurus_document_free_tree() - * - * Thread safety: Each parse operation is independent (no shared state) - * - * Example: - * const char *xml = "text"; - * struct taurus_document *doc = taurus_parse(xml, strlen(xml), NULL); - * if (!doc) { - * fprintf(stderr, "Parse error\n"); - * return; - * } - * // Use document... - * taurus_document_free_tree(doc); - */ -struct taurus_document *taurus_parse(const char *xml, - size_t len, - TaurusParseOptions *opts); - -/* Parse XML with error reporting - * - * Parameters: - * xml: XML string to parse - * len: Length of XML string - * opts: Parse options (NULL for defaults) - * error_buf: Buffer for error message (can be NULL) - * error_len: Size of error buffer - * - * Returns: - * Document structure on success, NULL on error - * If error_buf is provided, it will contain error message on failure - * - * Example: - * char error[256]; - * struct taurus_document *doc = taurus_parse_with_error( - * xml, len, NULL, error, sizeof(error) - * ); - * if (!doc) { - * fprintf(stderr, "Parse error: %s\n", error); - * return; - * } - */ -struct taurus_document *taurus_parse_with_error(const char *xml, - size_t len, - TaurusParseOptions *opts, - char *error_buf, - size_t error_len); - -/* ================================================================== - * HELPER FUNCTIONS (exposed for testing) - * ================================================================== */ - -/* Parse XML name - exposed for testing */ -const char *parse_name(TaurusParseContext *ctx, size_t *len); - -/* Parse quoted attribute value - exposed for testing */ -const char *parse_quoted_value(TaurusParseContext *ctx, size_t *len); - -/* Skip XML comment - exposed for testing */ -int skip_comment(TaurusParseContext *ctx); - -/* Parse CDATA section - exposed for testing */ -const char *parse_cdata(TaurusParseContext *ctx, size_t *len); - -/* Parse text content - exposed for testing */ -const char *parse_text(TaurusParseContext *ctx, size_t *len); - -/* ================================================================== - * ELEMENT PARSING FUNCTIONS (exposed for testing - Session 83) - * ================================================================== */ - -/* Parse element start tag - * Returns newly created element or NULL on error - * NOTE: Return value may have lowest bit set to indicate self-closing */ -struct taurus_element *parse_start_tag(TaurusParseContext *ctx, - struct taurus_element *parent); - -/* Parse element end tag - * Returns 0 on success, -1 on error */ -int parse_end_tag(TaurusParseContext *ctx, const char *expected_name); - -/* Parse complete element (start tag, content, end tag) - * Returns newly created element or NULL on error */ -struct taurus_element *parse_element(TaurusParseContext *ctx, - struct taurus_element *parent); - -#ifdef __cplusplus -} -#endif - -#endif /* TAURUS_PARSE_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/evaluator.c b/ext/taurus/lib/src/xpath/evaluator.c deleted file mode 100644 index cd87930..0000000 --- a/ext/taurus/lib/src/xpath/evaluator.c +++ /dev/null @@ -1,1931 +0,0 @@ -/* evaluator.c - XPath evaluator implementation - * Copyright (c) 2024, Ribose Inc. - * - * Pure C implementation of XPath 1.0 evaluator. - * Converted from Ruby C extension to pure C. - */ - -#include "evaluator.h" -#include "functions.h" -#include "lexer.h" -#include "parser.h" -#include "taurus/taurus.h" -#include -#include -#include -#include - -/* Debug logging - set to 1 to enable */ -#define XPATH_DEBUG 0 - -#if XPATH_DEBUG -#define DEBUG_LOG(fmt, ...) fprintf(stderr, "[XPath DEBUG] " fmt "\n", ##__VA_ARGS__) -#else -#define DEBUG_LOG(fmt, ...) do {} while(0) -#endif - -/* ============================================================================ - * Forward Declarations - * ============================================================================ */ - -/* Namespace support functions (v0.8.0) */ -static void xpath_context_register_namespace(XPathContext* context, - const char* prefix, - const char* uri); -static const char* xpath_context_resolve_prefix(XPathContext* context, - const char* prefix); -static void xpath_context_init_from_document(XPathContext* context); - -/* Main evaluation dispatcher */ -static struct taurus_xpath_result* evaluate_expr(XPathContext* context, - XPathASTNode* ast); - -/* Path evaluation */ -static struct taurus_xpath_result* evaluate_location_path(XPathContext* context, - XPathASTNode* path); -static struct taurus_xpath_result* evaluate_step(XPathContext* context, - XPathASTNode* step, - XPathNodeSet* input); - -/* Node test matching */ -static int matches_node_test(XPathContext* ctx, struct taurus_element* node, XPathASTNode* test); - -/* Predicate evaluation */ -static XPathNodeSet* apply_predicates(XPathContext* context, - XPathNodeSet* nodes, - XPathASTNode** predicates, - size_t pred_count); - -/* Axis implementations */ -static XPathNodeSet* apply_axis(XPathContext* context, - struct taurus_element* node, - const char* axis_name, - XPathASTNode* node_test); - -/* Operators */ -static struct taurus_xpath_result* evaluate_operator(XPathContext* context, - XPathASTNode* ast); - -/* ============================================================================ - * Context Management - * ============================================================================ */ - -XPathContext* xpath_context_new(struct taurus_document* document, - struct taurus_element* context_node) { - if (!document || !context_node) return NULL; - - XPathContext* context = TAURUS_ALLOC(XPathContext); - if (!context) return NULL; - - context->document = document; - context->context_node = context_node; - context->context_position = 1; - context->context_size = 1; - context->error_msg[0] = '\0'; - context->to_boolean = 0; - context->max_results = 0; - context->enable_early_exit = 1; - - /* Initialize namespace support (v0.8.0) */ - context->namespace_mappings = NULL; - context->namespace_count = 0; - context->namespace_capacity = 0; - - /* Initialize error context (v1.0.0) */ - context->input = NULL; - context->input_len = 0; - - /* Initialize function registry with standard XPath 1.0 functions */ - context->function_registry = xpath_function_registry_new(); - if (context->function_registry) { - xpath_function_registry_init_standard( - (XPathFunctionRegistry*)context->function_registry); - } - - /* Auto-populate namespace mappings from document (v0.8.0) */ - xpath_context_init_from_document(context); - - return context; -} - -void xpath_context_free(XPathContext* context) { - if (!context) return; - - /* Free namespace mappings (v0.8.0) */ - if (context->namespace_mappings) { - for (size_t i = 0; i < context->namespace_count; i++) { - TAURUS_FREE(context->namespace_mappings[i].prefix); - TAURUS_FREE(context->namespace_mappings[i].uri); - } - TAURUS_FREE(context->namespace_mappings); - } - - /* Free function registry */ - if (context->function_registry) { - xpath_function_registry_free((XPathFunctionRegistry*)context->function_registry); - } - - TAURUS_FREE(context); -} - -const char* xpath_context_error(XPathContext* context) { - if (!context) return "Invalid context"; - return context->error_msg[0] ? context->error_msg : NULL; -} - -/* ============================================================================ - * Namespace Support (v0.8.0) - * ============================================================================ */ - -/** - * Register a namespace prefix->URI mapping in the context - * - * @param context XPath context - * @param prefix Namespace prefix (NULL for default namespace) - * @param uri Namespace URI (required) - */ -void xpath_context_register_namespace(XPathContext* context, - const char* prefix, - const char* uri) { - if (!context || !uri) return; - - /* Check if prefix already registered - update if found */ - for (size_t i = 0; i < context->namespace_count; i++) { - int prefix_matches = 0; - if (!prefix && !context->namespace_mappings[i].prefix) { - prefix_matches = 1; /* Both NULL (default namespace) */ - } else if (prefix && context->namespace_mappings[i].prefix && - strcmp(prefix, context->namespace_mappings[i].prefix) == 0) { - prefix_matches = 1; /* Both non-NULL and equal */ - } - - if (prefix_matches) { - /* Update existing mapping */ - TAURUS_FREE(context->namespace_mappings[i].uri); - context->namespace_mappings[i].uri = taurus_strdup(uri); - return; - } - } - - /* Add new mapping - grow array if needed */ - if (context->namespace_count >= context->namespace_capacity) { - size_t new_capacity = context->namespace_capacity == 0 ? - 4 : context->namespace_capacity * 2; - XPathNamespaceMapping* new_mappings = TAURUS_REALLOC_N( - context->namespace_mappings, - XPathNamespaceMapping, - new_capacity - ); - if (!new_mappings) return; /* Allocation failed */ - - context->namespace_mappings = new_mappings; - context->namespace_capacity = new_capacity; - } - - /* Add new mapping */ - context->namespace_mappings[context->namespace_count].prefix = - prefix ? taurus_strdup(prefix) : NULL; - context->namespace_mappings[context->namespace_count].uri = - taurus_strdup(uri); - context->namespace_count++; -} - -/** - * Resolve namespace prefix to URI (OPTIMIZED with reverse lookup) - * - * Strategy: Search from END to START to find most recent registration first. - * This handles override semantics naturally - child namespace declarations - * override parent ones because they're registered later. - * - * Performance: O(n) worst case, but in practice very fast because: - * - Most documents have <10 unique namespace prefixes - * - Recent registrations (local scope) found first - * - Common prefixes cached by compiler in registers - * - * @param context XPath context - * @param prefix Namespace prefix to resolve (NULL for default namespace) - * @return Namespace URI, or NULL if not found - */ -const char* xpath_context_resolve_prefix(XPathContext* context, - const char* prefix) { - if (!context || context->namespace_count == 0) return NULL; - - /* Search BACKWARDS for most recent (local) registration first - * This implements namespace scope override semantics efficiently */ - for (size_t i = context->namespace_count; i > 0; i--) { - size_t idx = i - 1; - XPathNamespaceMapping* mapping = &context->namespace_mappings[idx]; - - /* Fast path: Compare prefix pointers first (common case: same string object) */ - if (mapping->prefix == prefix) { - return mapping->uri; - } - - /* Both NULL = default namespace match */ - if (!prefix && !mapping->prefix) { - return mapping->uri; - } - - /* String comparison only if both non-NULL */ - if (prefix && mapping->prefix && strcmp(prefix, mapping->prefix) == 0) { - return mapping->uri; - } - } - - return NULL; /* Prefix not found */ -} - -/* Helper: Collect namespaces from element and all descendants recursively */ -static void collect_namespaces_recursive(XPathContext* context, - struct taurus_element* element) { - if (!element) return; - - /* Register namespaces from this element's namespace declarations - * Note: namespaces is a linked list, not an array */ - struct taurus_namespace* ns = element->namespaces; - while (ns) { - if (ns->uri) { - xpath_context_register_namespace(context, ns->prefix, ns->uri); - } - ns = ns->next; - } - - /* Also check attributes for xmlns declarations - * (in case they weren't already parsed into namespaces list) */ - for (size_t i = 0; i < element->attributes_count; i++) { - struct taurus_attribute* attr = element->attributes[i]; - if (!attr || !attr->name) continue; - - /* Check for xmlns:prefix or xmlns */ - if (strncmp(attr->name, "xmlns:", 6) == 0) { - /* xmlns:prefix="uri" */ - xpath_context_register_namespace(context, attr->name + 6, attr->value); - } else if (strcmp(attr->name, "xmlns") == 0) { - /* xmlns="uri" (default namespace) */ - xpath_context_register_namespace(context, NULL, attr->value); - } - } - - /* Recursively collect from children */ - for (size_t i = 0; i < element->children_count; i++) { - collect_namespaces_recursive(context, element->children[i]); - } -} - -/** - * Auto-populate namespace mappings from entire document tree - * - * @param context XPath context - */ -void xpath_context_init_from_document(XPathContext* context) { - if (!context || !context->document || !context->document->root) return; - - /* Collect namespaces from entire document tree - * This ensures namespace declarations on any element are available */ - collect_namespaces_recursive(context, context->document->root); -} - -/* ============================================================================ - * NodeSet Management - * ============================================================================ */ - -XPathNodeSet* xpath_nodeset_new(void) { - return xpath_nodeset_new_with_capacity(0); -} - -XPathNodeSet* xpath_nodeset_new_with_capacity(size_t capacity) { - XPathNodeSet* nodeset = TAURUS_ALLOC(XPathNodeSet); - if (!nodeset) return NULL; - - if (capacity > 0) { - nodeset->nodes = (void**)TAURUS_ALLOC_N(void*, capacity); - if (!nodeset->nodes) { - TAURUS_FREE(nodeset); - return NULL; - } - nodeset->capacity = capacity; - } else { - nodeset->nodes = NULL; - nodeset->capacity = 0; - } - - nodeset->count = 0; - nodeset->owns_attributes = 1; /* By default, nodeset owns its attribute nodes */ - return nodeset; -} - -void xpath_nodeset_free(XPathNodeSet* nodeset) { - if (!nodeset) return; - - if (nodeset->nodes && nodeset->owns_attributes) { - /* Free typed nodes only if we own them - check node type and free appropriately */ - for (size_t i = 0; i < nodeset->count; i++) { - void* node = nodeset->nodes[i]; - if (!node) continue; - - TaurusNodeType node_type = XPATH_NODE_TYPE(node); - if (node_type == TAURUS_NODE_ATTRIBUTE) { - /* Attribute node - free its allocated memory */ - TaurusAttributeNode* attr_node = (TaurusAttributeNode*)node; - if (attr_node->name) TAURUS_FREE(attr_node->name); - if (attr_node->value) TAURUS_FREE(attr_node->value); - if (attr_node->namespace_uri) TAURUS_FREE(attr_node->namespace_uri); - TAURUS_FREE(attr_node); - } - /* Element nodes are owned by document, don't free */ - } - } - if (nodeset->nodes) { - TAURUS_FREE(nodeset->nodes); - } - TAURUS_FREE(nodeset); -} - -size_t xpath_nodeset_count(XPathNodeSet* nodeset) { - return nodeset ? nodeset->count : 0; -} - -void* xpath_nodeset_get(XPathNodeSet* nodeset, size_t index) { - if (!nodeset || !nodeset->nodes || index >= nodeset->count) { - return NULL; - } - return nodeset->nodes[index]; -} - -void xpath_nodeset_add(XPathNodeSet* nodeset, void* node) { - if (!nodeset || !node) return; - - /* Resize if needed */ - if (nodeset->count >= nodeset->capacity) { - size_t new_capacity = nodeset->capacity == 0 ? 8 : nodeset->capacity * 2; - void** new_nodes = (void**)TAURUS_REALLOC_N( - nodeset->nodes, void*, new_capacity); - if (!new_nodes) return; - nodeset->nodes = new_nodes; - nodeset->capacity = new_capacity; - } - - nodeset->nodes[nodeset->count++] = node; -} - -/* Helper: Create attribute node from taurus_attribute */ -static TaurusAttributeNode* create_attribute_node(struct taurus_attribute* attr, - struct taurus_element* owner) { - if (!attr) return NULL; - - TaurusAttributeNode* attr_node = TAURUS_ALLOC(TaurusAttributeNode); - if (!attr_node) return NULL; - - attr_node->node_type = TAURUS_NODE_ATTRIBUTE; - attr_node->name = taurus_strdup(attr->name); - attr_node->value = taurus_strdup(attr->value); - attr_node->namespace_uri = attr->namespace_uri ? taurus_strdup(attr->namespace_uri) : NULL; - attr_node->owner = owner; - - return attr_node; -} - -/* Helper: Get element from typed node (returns NULL if not element) - * - * IMPORTANT: Elements are stored as plain taurus_element* without a type field. - * Only attribute nodes have a node_type field as their first member. - * - * Strategy: Check if first field is TAURUS_NODE_ATTRIBUTE. If so, it's an attribute. - * Otherwise, treat it as an element. - */ -static struct taurus_element* node_as_element(void* node) { - if (!node) return NULL; - - /* Check if it's an attribute node by reading first field */ - TaurusNodeType first_field = *(TaurusNodeType*)node; - if (first_field == TAURUS_NODE_ATTRIBUTE) { - /* It's an attribute node, not an element */ - return NULL; - } - - /* Otherwise, it's an element (no type field in taurus_element) */ - return (struct taurus_element*)node; -} - -/* Helper: Get attribute node from typed node (returns NULL if not attribute) */ -static TaurusAttributeNode* node_as_attribute(void* node) { - if (!node) return NULL; - - /* Check if first field is TAURUS_NODE_ATTRIBUTE */ - TaurusNodeType first_field = *(TaurusNodeType*)node; - return (first_field == TAURUS_NODE_ATTRIBUTE) ? (TaurusAttributeNode*)node : NULL; -} - -/* ============================================================================ - * Result Management - * ============================================================================ */ - -struct taurus_xpath_result* xpath_result_new(XPathResultType type) { - struct taurus_xpath_result* result = TAURUS_ALLOC(struct taurus_xpath_result); - if (!result) return NULL; - - result->type = type; - memset(&result->value, 0, sizeof(XPathResultValue)); - return result; -} - -void xpath_result_free(struct taurus_xpath_result* result) { - if (!result) return; - - switch (result->type) { - case XPATH_RESULT_STRING: - if (result->value.string_value) { - TAURUS_FREE(result->value.string_value); - } - break; - case XPATH_RESULT_NODESET: - xpath_nodeset_free(result->value.nodeset_value); - break; - default: - break; - } - - TAURUS_FREE(result); -} - -/* ============================================================================ - * Type Conversions (XPath 1.0 Spec Section 4) - * ============================================================================ */ - -/* Get text content from typed node (handles elements and attributes) */ -static char* get_node_text(void* node) { - if (!node) return taurus_strdup(""); - - TaurusNodeType node_type = XPATH_NODE_TYPE(node); - - switch (node_type) { - case TAURUS_NODE_ELEMENT: { - struct taurus_element* element = (struct taurus_element*)node; - - /* If element has direct text content, return it */ - if (element->text_content) { - return taurus_strdup(element->text_content); - } - - /* Otherwise concatenate all descendant text */ - size_t total_len = 0; - size_t capacity = 256; - char* result = TAURUS_ALLOC_N(char, capacity); - if (!result) return taurus_strdup(""); - result[0] = '\0'; - - /* Recursively collect text from children */ - for (size_t i = 0; i < element->children_count; i++) { - char* child_text = get_node_text(element->children[i]); - if (child_text) { - size_t child_len = strlen(child_text); - if (total_len + child_len + 1 > capacity) { - capacity = (total_len + child_len + 1) * 2; - char* new_result = TAURUS_REALLOC_N(result, char, capacity); - if (!new_result) { - TAURUS_FREE(child_text); - TAURUS_FREE(result); - return taurus_strdup(""); - } - result = new_result; - } - strcat(result, child_text); - total_len += child_len; - TAURUS_FREE(child_text); - } - } - - return result; - } - - case TAURUS_NODE_ATTRIBUTE: { - TaurusAttributeNode* attr_node = (TaurusAttributeNode*)node; - return taurus_strdup(attr_node->value ? attr_node->value : ""); - } - - default: - return taurus_strdup(""); - } -} - -int xpath_to_boolean(struct taurus_xpath_result* result) { - if (!result) return 0; - - switch (result->type) { - case XPATH_RESULT_BOOLEAN: - return result->value.boolean_value; - case XPATH_RESULT_NUMBER: - return result->value.number_value != 0.0 && !isnan(result->value.number_value); - case XPATH_RESULT_STRING: - return result->value.string_value && result->value.string_value[0] != '\0'; - case XPATH_RESULT_NODESET: - return xpath_nodeset_count(result->value.nodeset_value) > 0; - default: - return 0; - } -} - -double xpath_to_number(struct taurus_xpath_result* result) { - if (!result) return NAN; - - switch (result->type) { - case XPATH_RESULT_NUMBER: - return result->value.number_value; - case XPATH_RESULT_BOOLEAN: - return result->value.boolean_value ? 1.0 : 0.0; - case XPATH_RESULT_STRING: { - if (!result->value.string_value) return NAN; - const char* str = result->value.string_value; - - /* Skip leading whitespace */ - while (isspace((unsigned char)*str)) str++; - if (*str == '\0') return NAN; - - /* Parse number */ - char* endptr; - double value = strtod(str, &endptr); - - /* Skip trailing whitespace */ - while (isspace((unsigned char)*endptr)) endptr++; - - /* Must consume entire string */ - return (*endptr == '\0') ? value : NAN; - } - case XPATH_RESULT_NODESET: { - /* Convert first node's string value to number */ - XPathNodeSet* nodeset = result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - return NAN; - } - void* first = xpath_nodeset_get(nodeset, 0); - char* str = get_node_text(first); - if (!str) return NAN; - - /* Parse the string */ - const char* p = str; - while (isspace((unsigned char)*p)) p++; - if (*p == '\0') { - TAURUS_FREE(str); - return NAN; - } - - char* endptr; - double value = strtod(p, &endptr); - while (isspace((unsigned char)*endptr)) endptr++; - - int valid = (*endptr == '\0'); - TAURUS_FREE(str); - return valid ? value : NAN; - } - default: - return NAN; - } -} - -char* xpath_to_string(struct taurus_xpath_result* result) { - if (!result) return taurus_strdup(""); - - switch (result->type) { - case XPATH_RESULT_STRING: - return taurus_strdup(result->value.string_value ? - result->value.string_value : ""); - case XPATH_RESULT_NUMBER: { - char buf[64]; - double num = result->value.number_value; - if (isnan(num)) { - return taurus_strdup("NaN"); - } else if (isinf(num)) { - return taurus_strdup(num > 0 ? "Infinity" : "-Infinity"); - } else { - snprintf(buf, sizeof(buf), "%g", num); - return taurus_strdup(buf); - } - } - case XPATH_RESULT_BOOLEAN: - return taurus_strdup(result->value.boolean_value ? "true" : "false"); - case XPATH_RESULT_NODESET: { - XPathNodeSet* nodeset = result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - return taurus_strdup(""); - } - return get_node_text(xpath_nodeset_get(nodeset, 0)); - } - default: - return taurus_strdup(""); - } -} - -/* ============================================================================ - * Node Test Matching - * ============================================================================ */ - -static int matches_node_test(XPathContext* ctx, struct taurus_element* node, XPathASTNode* test) { - if (!node || !test) return 1; /* No test means match all */ - - switch (test->type) { - case XPATH_AST_NODE_TEST_NAME: - /* Match specific name - namespace-aware (v0.8.0) */ - if (!test->value || !node->name) return 0; - - /* If test has no prefix, match local name only (backward compatible) */ - if (!test->prefix) { - const char* local_name = node->name; - const char* colon = strchr(node->name, ':'); - if (colon) local_name = colon + 1; - - const char* test_name = test->local_name ? test->local_name : test->value; - return strcmp(local_name, test_name) == 0; - } - - /* Test has prefix - need namespace-aware matching */ - /* 1. Resolve test prefix to URI */ - const char* test_uri = xpath_context_resolve_prefix(ctx, test->prefix); - if (!test_uri) return 0; /* Unknown prefix */ - - /* 2. Get element's namespace URI */ - const char* element_uri = node->namespace_uri; - if (!element_uri) return 0; /* Element not in namespace */ - - /* 3. Match URIs */ - if (strcmp(test_uri, element_uri) != 0) return 0; - - /* URIs match - now check local name */ - const char* element_local = node->name; - const char* colon = strchr(node->name, ':'); - if (colon) element_local = colon + 1; - - const char* test_local = test->local_name ? test->local_name : test->value; - return strcmp(element_local, test_local) == 0; - - case XPATH_AST_NODE_TEST_ALL: - /* Wildcard - if test has prefix, match namespace (v0.8.0) */ - if (test->prefix) { - const char* test_uri = xpath_context_resolve_prefix(ctx, test->prefix); - if (!test_uri) return 0; - const char* element_uri = node->namespace_uri; - return element_uri && strcmp(test_uri, element_uri) == 0; - } - /* No prefix - match all elements */ - return 1; - - case XPATH_AST_NODE_TEST_TYPE: - /* Node type tests (node(), text(), etc.) */ - if (test->value) { - if (strcmp(test->value, "node") == 0) { - return 1; /* node() matches all nodes */ - } - /* text(), comment() not fully implemented yet */ - } - return 0; - - default: - return 0; - } -} - -/* ============================================================================ - * Axis Implementations (All 13 XPath Axes) - * ============================================================================ */ - -/* Helper: Collect descendants recursively */ -static void collect_descendants(XPathContext* ctx, - struct taurus_element* node, - XPathNodeSet* result, - XPathASTNode* node_test) { - if (!node) return; - - for (size_t i = 0; i < node->children_count; i++) { - struct taurus_element* child = node->children[i]; - if (matches_node_test(ctx, child, node_test)) { - xpath_nodeset_add(result, child); - } - collect_descendants(ctx, child, result, node_test); - } -} - -/* Helper: Collect descendants or self */ -static void collect_descendants_or_self(XPathContext* ctx, - struct taurus_element* node, - XPathNodeSet* result, - XPathASTNode* node_test) { - if (!node) return; - - if (matches_node_test(ctx, node, node_test)) { - xpath_nodeset_add(result, node); - } - - for (size_t i = 0; i < node->children_count; i++) { - collect_descendants_or_self(ctx, node->children[i], result, node_test); - } -} - -/* child:: axis */ -static XPathNodeSet* axis_child(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - - for (size_t i = 0; i < node->children_count; i++) { - struct taurus_element* child = node->children[i]; - if (matches_node_test(ctx, child, test)) { - xpath_nodeset_add(result, child); - } - } - - return result; -} - -/* descendant:: axis */ -static XPathNodeSet* axis_descendant(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - collect_descendants(ctx, node, result, test); - return result; -} - -/* descendant-or-self:: axis */ -static XPathNodeSet* axis_descendant_or_self(XPathContext* ctx, - struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - collect_descendants_or_self(ctx, node, result, test); - return result; -} - -/* parent:: axis */ -static XPathNodeSet* axis_parent(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node || !node->parent) return result; - - if (matches_node_test(ctx, node->parent, test)) { - xpath_nodeset_add(result, node->parent); - } - - return result; -} - -/* ancestor:: axis */ -static XPathNodeSet* axis_ancestor(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - - struct taurus_element* current = node->parent; - while (current) { - if (matches_node_test(ctx, current, test)) { - xpath_nodeset_add(result, current); - } - current = current->parent; - } - - return result; -} - -/* ancestor-or-self:: axis */ -static XPathNodeSet* axis_ancestor_or_self(XPathContext* ctx, - struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - - if (matches_node_test(ctx, node, test)) { - xpath_nodeset_add(result, node); - } - - struct taurus_element* current = node->parent; - while (current) { - if (matches_node_test(ctx, current, test)) { - xpath_nodeset_add(result, current); - } - current = current->parent; - } - - return result; -} - -/* self:: axis */ -static XPathNodeSet* axis_self(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) return result; - - if (matches_node_test(ctx, node, test)) { - xpath_nodeset_add(result, node); - } - - return result; -} - -/* following-sibling:: axis */ -static XPathNodeSet* axis_following_sibling(XPathContext* ctx, - struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node || !node->parent) return result; - - struct taurus_element* parent = node->parent; - int found = 0; - - for (size_t i = 0; i < parent->children_count; i++) { - if (parent->children[i] == node) { - found = 1; - continue; - } - if (found && matches_node_test(ctx, parent->children[i], test)) { - xpath_nodeset_add(result, parent->children[i]); - } - } - - return result; -} - -/* preceding-sibling:: axis */ -static XPathNodeSet* axis_preceding_sibling(XPathContext* ctx, - struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node || !node->parent) return result; - - struct taurus_element* parent = node->parent; - - for (size_t i = 0; i < parent->children_count; i++) { - if (parent->children[i] == node) break; - if (matches_node_test(ctx, parent->children[i], test)) { - xpath_nodeset_add(result, parent->children[i]); - } - } - - return result; -} - -/* following:: axis - all nodes after context in document order */ -static XPathNodeSet* axis_following(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node || !node->parent) return result; - - /* Get following siblings and their descendants */ - struct taurus_element* parent = node->parent; - int found = 0; - - for (size_t i = 0; i < parent->children_count; i++) { - if (parent->children[i] == node) { - found = 1; - continue; - } - if (found) { - if (matches_node_test(ctx, parent->children[i], test)) { - xpath_nodeset_add(result, parent->children[i]); - } - collect_descendants(ctx, parent->children[i], result, test); - } - } - - /* Recursively get parent's following nodes */ - XPathNodeSet* parent_following = axis_following(ctx, parent, test); - if (parent_following) { - for (size_t i = 0; i < xpath_nodeset_count(parent_following); i++) { - xpath_nodeset_add(result, xpath_nodeset_get(parent_following, i)); - } - xpath_nodeset_free(parent_following); - } - - return result; -} - -/* preceding:: axis - all nodes before context in document order */ -static XPathNodeSet* axis_preceding(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node || !node->parent) return result; - - /* Get preceding siblings and their descendants */ - struct taurus_element* parent = node->parent; - - for (size_t i = 0; i < parent->children_count; i++) { - if (parent->children[i] == node) break; - if (matches_node_test(ctx, parent->children[i], test)) { - xpath_nodeset_add(result, parent->children[i]); - } - collect_descendants(ctx, parent->children[i], result, test); - } - - /* Recursively get parent's preceding nodes */ - XPathNodeSet* parent_preceding = axis_preceding(ctx, parent, test); - if (parent_preceding) { - for (size_t i = 0; i < xpath_nodeset_count(parent_preceding); i++) { - xpath_nodeset_add(result, xpath_nodeset_get(parent_preceding, i)); - } - xpath_nodeset_free(parent_preceding); - } - - return result; -} - -/* attribute:: axis - * - * Returns attributes as proper TaurusAttributeNode structures. - * These nodes have type TAURUS_NODE_ATTRIBUTE and work with all - * type conversion functions properly. - */ -static XPathNodeSet* axis_attribute(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - DEBUG_LOG(" === axis_attribute START ==="); - DEBUG_LOG(" node=%p, name=%s", (void*)node, node ? node->name : "(null)"); - DEBUG_LOG(" attributes_count=%zu", node ? (size_t)node->attributes_count : 0); - - XPathNodeSet* result = xpath_nodeset_new(); - if (!result || !node) { - DEBUG_LOG(" EARLY RETURN: result=%p, node=%p", (void*)result, (void*)node); - return result; - } - - /* Iterate through element's attributes */ - for (size_t i = 0; i < node->attributes_count; i++) { - struct taurus_attribute* attr = node->attributes[i]; - DEBUG_LOG(" [%zu] attr=%p", i, (void*)attr); - if (!attr) { - DEBUG_LOG(" [%zu] SKIPPED: attr is NULL", i); - continue; - } - DEBUG_LOG(" [%zu] attr->name=%s, attr->value=%s", - i, attr->name ? attr->name : "(null)", - attr->value ? attr->value : "(null)"); - - /* Check if attribute matches node test */ - int matches = 0; - if (test && test->type == XPATH_AST_NODE_TEST_NAME) { - /* Specific attribute name test */ - matches = (test->value && attr->name && strcmp(test->value, attr->name) == 0); - DEBUG_LOG(" [%zu] NAME test: looking for '%s', matches=%d", - i, test->value ? test->value : "(null)", matches); - } else if (test && test->type == XPATH_AST_NODE_TEST_ALL) { - /* Wildcard - matches all attributes */ - matches = 1; - DEBUG_LOG(" [%zu] WILDCARD test: matches=%d", i, matches); - } else if (!test) { - /* No test means match all */ - matches = 1; - DEBUG_LOG(" [%zu] NO test: matches=%d", i, matches); - } - - if (matches) { - /* Create proper attribute node */ - DEBUG_LOG(" [%zu] Creating attribute node...", i); - TaurusAttributeNode* attr_node = create_attribute_node(attr, node); - DEBUG_LOG(" [%zu] attr_node=%p", i, (void*)attr_node); - if (attr_node) { - DEBUG_LOG(" [%zu] attr_node->node_type=%d (should be 1)", - i, (int)attr_node->node_type); - DEBUG_LOG(" [%zu] attr_node->name=%s", - i, attr_node->name ? attr_node->name : "(null)"); - DEBUG_LOG(" [%zu] attr_node->value=%s", - i, attr_node->value ? attr_node->value : "(null)"); - DEBUG_LOG(" [%zu] Adding to nodeset...", i); - xpath_nodeset_add(result, (void*)attr_node); - DEBUG_LOG(" [%zu] Added. Nodeset count now: %zu", - i, xpath_nodeset_count(result)); - } else { - DEBUG_LOG(" [%zu] FAILED to create attr_node!", i); - } - } - } - - DEBUG_LOG(" Final nodeset count: %zu", xpath_nodeset_count(result)); - DEBUG_LOG(" === axis_attribute END ==="); - return result; -} - -/* namespace:: axis */ -static XPathNodeSet* axis_namespace(XPathContext* ctx, struct taurus_element* node, - XPathASTNode* test) { - XPathNodeSet* result = xpath_nodeset_new(); - /* Namespace axis rarely used, stub for now */ - return result; -} - -/* Apply axis dispatcher */ -static XPathNodeSet* apply_axis(XPathContext* ctx, struct taurus_element* node, - const char* axis_name, XPathASTNode* test) { - DEBUG_LOG(" === apply_axis: %s ===", axis_name ? axis_name : "(null/child)"); - if (!axis_name) { - DEBUG_LOG(" Using default 'child' axis"); - return axis_child(ctx, node, test); - } - - if (strcmp(axis_name, "child") == 0) { - DEBUG_LOG(" Using 'child' axis"); - return axis_child(ctx, node, test); - } - if (strcmp(axis_name, "descendant") == 0) { - DEBUG_LOG(" Using 'descendant' axis"); - return axis_descendant(ctx, node, test); - } - if (strcmp(axis_name, "descendant-or-self") == 0) { - DEBUG_LOG(" Using 'descendant-or-self' axis"); - return axis_descendant_or_self(ctx, node, test); - } - if (strcmp(axis_name, "parent") == 0) return axis_parent(ctx, node, test); - if (strcmp(axis_name, "ancestor") == 0) return axis_ancestor(ctx, node, test); - if (strcmp(axis_name, "ancestor-or-self") == 0) - return axis_ancestor_or_self(ctx, node, test); - if (strcmp(axis_name, "self") == 0) return axis_self(ctx, node, test); - if (strcmp(axis_name, "following-sibling") == 0) - return axis_following_sibling(ctx, node, test); - if (strcmp(axis_name, "preceding-sibling") == 0) - return axis_preceding_sibling(ctx, node, test); - if (strcmp(axis_name, "following") == 0) return axis_following(ctx, node, test); - if (strcmp(axis_name, "preceding") == 0) return axis_preceding(ctx, node, test); - if (strcmp(axis_name, "attribute") == 0) return axis_attribute(ctx, node, test); - if (strcmp(axis_name, "namespace") == 0) return axis_namespace(ctx, node, test); - - return xpath_nodeset_new(); /* Unknown axis */ -} - -/* ============================================================================ - * Operator Evaluation - * ============================================================================ */ - -static struct taurus_xpath_result* evaluate_operator(XPathContext* ctx, - XPathASTNode* ast) { - if (!ast || ast->child_count < 1) return NULL; - - XPathOperatorType op = (XPathOperatorType)ast->number_value; - - /* Unary negation */ - if (op == XPATH_OP_NEGATION) { - struct taurus_xpath_result* operand = evaluate_expr(ctx, ast->children[0]); - if (!operand) return NULL; - double value = xpath_to_number(operand); - xpath_result_free(operand); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (result) result->value.number_value = -value; - return result; - } - - /* Binary operators require 2 operands */ - if (ast->child_count < 2) return NULL; - - struct taurus_xpath_result* left = evaluate_expr(ctx, ast->children[0]); - if (!left) return NULL; - - /* Short-circuit for logical operators */ - if (op == XPATH_OP_AND) { - if (!xpath_to_boolean(left)) { - xpath_result_free(left); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (result) result->value.boolean_value = 0; - return result; - } - } else if (op == XPATH_OP_OR) { - if (xpath_to_boolean(left)) { - xpath_result_free(left); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (result) result->value.boolean_value = 1; - return result; - } - } - - struct taurus_xpath_result* right = evaluate_expr(ctx, ast->children[1]); - if (!right) { - xpath_result_free(left); - return NULL; - } - - struct taurus_xpath_result* result = NULL; - - /* Arithmetic operators */ - if (op == XPATH_OP_PLUS || op == XPATH_OP_MINUS || op == XPATH_OP_MULTIPLY || - op == XPATH_OP_DIV || op == XPATH_OP_MOD) { - double lval = xpath_to_number(left); - double rval = xpath_to_number(right); - result = xpath_result_new(XPATH_RESULT_NUMBER); - if (result) { - switch (op) { - case XPATH_OP_PLUS: result->value.number_value = lval + rval; break; - case XPATH_OP_MINUS: result->value.number_value = lval - rval; break; - case XPATH_OP_MULTIPLY: result->value.number_value = lval * rval; break; - case XPATH_OP_DIV: result->value.number_value = lval / rval; break; - case XPATH_OP_MOD: result->value.number_value = fmod(lval, rval); break; - default: break; - } - } - } - /* Comparison operators */ - else if (op >= XPATH_OP_EQUAL && op <= XPATH_OP_GREATER_EQUAL) { - result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (result) { - /* XPath spec: if both operands are strings, compare as strings */ - if (left->type == XPATH_RESULT_STRING && right->type == XPATH_RESULT_STRING) { - /* String comparison */ - const char* lstr = left->value.string_value ? left->value.string_value : ""; - const char* rstr = right->value.string_value ? right->value.string_value : ""; - int cmp = strcmp(lstr, rstr); - - switch (op) { - case XPATH_OP_EQUAL: result->value.boolean_value = (cmp == 0); break; - case XPATH_OP_NOT_EQUAL: result->value.boolean_value = (cmp != 0); break; - case XPATH_OP_LESS: result->value.boolean_value = (cmp < 0); break; - case XPATH_OP_LESS_EQUAL: result->value.boolean_value = (cmp <= 0); break; - case XPATH_OP_GREATER: result->value.boolean_value = (cmp > 0); break; - case XPATH_OP_GREATER_EQUAL: result->value.boolean_value = (cmp >= 0); break; - default: break; - } - } else { - /* Numeric comparison (default for mixed types) */ - double lval = xpath_to_number(left); - double rval = xpath_to_number(right); - switch (op) { - case XPATH_OP_EQUAL: result->value.boolean_value = (lval == rval); break; - case XPATH_OP_NOT_EQUAL: result->value.boolean_value = (lval != rval); break; - case XPATH_OP_LESS: result->value.boolean_value = (lval < rval); break; - case XPATH_OP_LESS_EQUAL: result->value.boolean_value = (lval <= rval); break; - case XPATH_OP_GREATER: result->value.boolean_value = (lval > rval); break; - case XPATH_OP_GREATER_EQUAL: result->value.boolean_value = (lval >= rval); break; - default: break; - } - } - } - } - /* Logical operators */ - else if (op == XPATH_OP_AND || op == XPATH_OP_OR) { - int lbool = xpath_to_boolean(left); - int rbool = xpath_to_boolean(right); - result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (result) { - result->value.boolean_value = (op == XPATH_OP_AND) ? (lbool && rbool) : (lbool || rbool); - } - } - /* Union operator */ - else if (op == XPATH_OP_UNION) { - if (left->type != XPATH_RESULT_NODESET || right->type != XPATH_RESULT_NODESET) { - xpath_result_free(left); - xpath_result_free(right); - return NULL; - } - result = xpath_result_new(XPATH_RESULT_NODESET); - if (result) { - XPathNodeSet* ns = xpath_nodeset_new(); - /* Add left nodes */ - for (size_t i = 0; i < xpath_nodeset_count(left->value.nodeset_value); i++) { - xpath_nodeset_add(ns, xpath_nodeset_get(left->value.nodeset_value, i)); - } - /* Add right nodes (skip duplicates) */ - for (size_t i = 0; i < xpath_nodeset_count(right->value.nodeset_value); i++) { - struct taurus_element* node = xpath_nodeset_get(right->value.nodeset_value, i); - int duplicate = 0; - for (size_t j = 0; j < xpath_nodeset_count(ns); j++) { - if (xpath_nodeset_get(ns, j) == node) { - duplicate = 1; - break; - } - } - if (!duplicate) xpath_nodeset_add(ns, node); - } - result->value.nodeset_value = ns; - } - } - - xpath_result_free(left); - xpath_result_free(right); - return result; -} - -/* ============================================================================ - * Predicate Evaluation - * ============================================================================ */ - -static XPathNodeSet* apply_predicates(XPathContext* ctx, XPathNodeSet* nodes, - XPathASTNode** predicates, size_t pred_count) { - if (!nodes || pred_count == 0) return nodes; - - DEBUG_LOG(" === apply_predicates: pred_count=%zu, nodeset size=%zu ===", - pred_count, xpath_nodeset_count(nodes)); - - XPathNodeSet* result = nodes; - - for (size_t p = 0; p < pred_count; p++) { - DEBUG_LOG(" Processing predicate %zu", p); - XPathNodeSet* filtered = xpath_nodeset_new(); - if (!filtered) { - DEBUG_LOG(" FAILED to create filtered nodeset"); - break; - } - - size_t size = xpath_nodeset_count(result); - DEBUG_LOG(" Filtering %zu nodes", size); - - for (size_t i = 0; i < size; i++) { - void* node = xpath_nodeset_get(result, i); - - /* For predicates, we need element context - attributes predicate on their owner */ - struct taurus_element* context_elem = node_as_element(node); - if (!context_elem) { - TaurusAttributeNode* attr_node = node_as_attribute(node); - if (attr_node) { - context_elem = attr_node->owner; - } - } - - if (!context_elem) { - DEBUG_LOG(" Node[%zu]: No valid context element, skipping", i); - continue; /* Skip if no valid context */ - } - - DEBUG_LOG(" Node[%zu]: context_elem=%p (name=%s)", - i, (void*)context_elem, context_elem->name ? context_elem->name : "(null)"); - - /* Save context */ - struct taurus_element* old_node = ctx->context_node; - size_t old_pos = ctx->context_position; - size_t old_size = ctx->context_size; - - ctx->context_node = context_elem; - ctx->context_position = i + 1; /* 1-based */ - ctx->context_size = size; - - DEBUG_LOG(" Evaluating predicate with context pos=%zu, size=%zu", - ctx->context_position, ctx->context_size); - - /* Evaluate predicate */ - struct taurus_xpath_result* pred_result = evaluate_expr(ctx, predicates[p]); - - /* Restore context */ - ctx->context_node = old_node; - ctx->context_position = old_pos; - ctx->context_size = old_size; - - if (pred_result) { - DEBUG_LOG(" Predicate result type=%d", pred_result->type); - /* Numeric predicate: matches position */ - if (pred_result->type == XPATH_RESULT_NUMBER) { - DEBUG_LOG(" Number=%f, position=%zu", - pred_result->value.number_value, i + 1); - if ((size_t)pred_result->value.number_value == i + 1) { - DEBUG_LOG(" MATCH! Adding node"); - xpath_nodeset_add(filtered, node); - } - } - /* Boolean predicate */ - else if (xpath_to_boolean(pred_result)) { - DEBUG_LOG(" Boolean=true, adding node"); - xpath_nodeset_add(filtered, node); - } - xpath_result_free(pred_result); - } else { - DEBUG_LOG(" Predicate evaluation returned NULL! Error: %s", - ctx->error_msg[0] ? ctx->error_msg : "(no error)"); - } - } - - DEBUG_LOG(" Filtered nodeset size: %zu", xpath_nodeset_count(filtered)); - if (result != nodes) xpath_nodeset_free(result); - result = filtered; - } - - DEBUG_LOG(" === apply_predicates END: result size=%zu ===", - xpath_nodeset_count(result)); - return result; -} - -/* ============================================================================ - * Path Expression Evaluation - * ============================================================================ */ - -static struct taurus_xpath_result* evaluate_step(XPathContext* ctx, - XPathASTNode* step, - XPathNodeSet* input) { - DEBUG_LOG(" === evaluate_step START ==="); - if (!step || step->type != XPATH_AST_STEP || !input) { - DEBUG_LOG(" Invalid parameters: step=%p, type=%d, input=%p", - (void*)step, step ? step->type : -1, (void*)input); - return NULL; - } - - const char* axis_name = step->value ? step->value : "child"; - XPathASTNode* node_test = (step->child_count > 0) ? step->children[0] : NULL; - - DEBUG_LOG(" axis_name = %s", axis_name); - DEBUG_LOG(" node_test = %p (type=%d)", (void*)node_test, node_test ? node_test->type : -1); - if (node_test && node_test->value) { - DEBUG_LOG(" node_test->value = %s", node_test->value); - } - DEBUG_LOG(" input nodeset count = %zu", xpath_nodeset_count(input)); - - XPathNodeSet* result = xpath_nodeset_new(); - if (!result) { - DEBUG_LOG(" FAILED to create result nodeset"); - return NULL; - } - - /* Apply axis to each input node (must be elements) */ - for (size_t i = 0; i < xpath_nodeset_count(input); i++) { - void* node_ptr = xpath_nodeset_get(input, i); - struct taurus_element* node = node_as_element(node_ptr); - DEBUG_LOG(" Processing input[%zu]: node=%p", i, (void*)node); - if (!node) { - DEBUG_LOG(" Skipping non-element node"); - continue; /* Skip non-element nodes */ - } - DEBUG_LOG(" node->name = %s, children_count = %zu", - node->name ? node->name : "(null)", node->children_count); - - XPathNodeSet* axis_result = apply_axis(ctx, node, axis_name, node_test); - DEBUG_LOG(" axis_result count = %zu", axis_result ? xpath_nodeset_count(axis_result) : 0); - - if (axis_result) { - /* Apply predicates if present */ - XPathNodeSet* filtered = axis_result; - if (step->child_count > 1) { - filtered = apply_predicates(ctx, axis_result, - &step->children[1], - step->child_count - 1); - } - - /* Transfer nodes to result (result will own the attribute nodes) */ - for (size_t j = 0; j < xpath_nodeset_count(filtered); j++) { - xpath_nodeset_add(result, xpath_nodeset_get(filtered, j)); - } - - /* Don't free attribute nodes from intermediate node sets - result now owns them */ - if (filtered != axis_result) { - filtered->owns_attributes = 0; - xpath_nodeset_free(filtered); - } - axis_result->owns_attributes = 0; /* Result nodeset now owns the attributes */ - xpath_nodeset_free(axis_result); - } - } - - DEBUG_LOG(" Final result count = %zu", xpath_nodeset_count(result)); - DEBUG_LOG(" === evaluate_step END ==="); - - struct taurus_xpath_result* res = xpath_result_new(XPATH_RESULT_NODESET); - if (res) res->value.nodeset_value = result; - return res; -} - -static struct taurus_xpath_result* evaluate_location_path(XPathContext* ctx, - XPathASTNode* path) { - XPathNodeSet* current = xpath_nodeset_new(); - if (!current) return NULL; - - /* Starting nodeset */ - if (path->type == XPATH_AST_ABSOLUTE_PATH) { - /* Special case: Absolute path with element name as first step - * XPath "/root" means "child of document node named root" - * Since we don't have a document node, check if root matches and use it */ - int is_root_match = 0; - struct taurus_element* root = ctx->document->root; - - DEBUG_LOG(" Checking for special case: child_count=%zu, root=%p", - (size_t)path->child_count, (void*)root); - - if (path->child_count > 0 && root && root->name) { - XPathASTNode* first_child = path->children[0]; - - DEBUG_LOG(" First child type=%d (RELATIVE_PATH=%d, STEP=%d)", - first_child->type, XPATH_AST_RELATIVE_PATH, XPATH_AST_STEP); - - /* The first child might be RELATIVE_PATH containing steps, or a direct STEP */ - XPathASTNode* first_step = NULL; - if (first_child->type == XPATH_AST_RELATIVE_PATH && first_child->child_count > 0) { - first_step = first_child->children[0]; - DEBUG_LOG(" Found RELATIVE_PATH, extracting first step"); - } else if (first_child->type == XPATH_AST_STEP) { - first_step = first_child; - DEBUG_LOG(" Found direct STEP"); - } - - /* Check if first step is a simple child axis with element name */ - if (first_step && first_step->type == XPATH_AST_STEP) { - const char* axis = first_step->value ? first_step->value : "child"; - DEBUG_LOG(" Axis=%s, child_count=%zu", axis, (size_t)first_step->child_count); - - if (strcmp(axis, "child") == 0 && first_step->child_count > 0) { - XPathASTNode* node_test = first_step->children[0]; - DEBUG_LOG(" Node test type=%d, value=%s", - node_test->type, node_test->value ? node_test->value : "(null)"); - - if (node_test->type == XPATH_AST_NODE_TEST_NAME && node_test->value) { - /* Extract local name from root (strip namespace prefix if present) */ - const char* root_local = root->name; - const char* colon = strchr(root->name, ':'); - if (colon) root_local = colon + 1; - - DEBUG_LOG(" Comparing root_local='%s' with node_test='%s'", - root_local, node_test->value); - - /* Check if root element name matches */ - if (strcmp(root_local, node_test->value) == 0) { - is_root_match = 1; - DEBUG_LOG(" ✓ Special case: /root matches document root"); - } - } - } - } - } - - DEBUG_LOG(" is_root_match=%d", is_root_match); - - if (is_root_match) { - /* Root matches - add it and process remaining steps - * Structure can be: - * /root/child: ABSOLUTE_PATH → RELATIVE_PATH → [STEP:child::root, STEP:child::child] - * /root: ABSOLUTE_PATH → RELATIVE_PATH → [STEP:child::root] - */ - xpath_nodeset_add(current, root); - DEBUG_LOG(" Added root to nodeset, processing remaining steps"); - - /* Get the RELATIVE_PATH (first child of ABSOLUTE_PATH) */ - XPathASTNode* rel_path = path->children[0]; - if (rel_path && rel_path->type == XPATH_AST_RELATIVE_PATH && rel_path->child_count > 1) { - /* Process steps starting from index 1 (skip first step which matched root) */ - for (size_t j = 1; j < rel_path->child_count; j++) { - XPathASTNode* step = rel_path->children[j]; - if (step->type == XPATH_AST_STEP) { - DEBUG_LOG(" Processing remaining step %zu", j); - struct taurus_xpath_result* step_result = evaluate_step(ctx, step, current); - if (!step_result) { - xpath_nodeset_free(current); - return NULL; - } - xpath_nodeset_free(current); - current = step_result->value.nodeset_value; - step_result->value.nodeset_value = NULL; - xpath_result_free(step_result); - } - } - } - /* If rel_path has only 1 child (the step that matched), we're done - just return root */ - } else { - /* Normal absolute path - start from root and process ALL steps */ - DEBUG_LOG(" Adding root to initial nodeset for absolute path"); - xpath_nodeset_add(current, ctx->document->root); - DEBUG_LOG(" Nodeset count after adding root: %zu", xpath_nodeset_count(current)); - - /* Process steps - handle both direct steps and those in RELATIVE_PATH */ - DEBUG_LOG(" Processing %zu children", (size_t)path->child_count); - for (size_t i = 0; i < path->child_count; i++) { - XPathASTNode* child = path->children[i]; - DEBUG_LOG(" Child[%zu]: type=%d", i, child->type); - - if (child->type == XPATH_AST_STEP) { - DEBUG_LOG(" Processing STEP child"); - DEBUG_LOG(" Input nodeset count: %zu", xpath_nodeset_count(current)); - /* Direct step child - process it */ - struct taurus_xpath_result* step_result = evaluate_step(ctx, child, current); - if (!step_result) { - DEBUG_LOG(" STEP evaluation FAILED"); - xpath_nodeset_free(current); - return NULL; - } - DEBUG_LOG(" STEP result nodeset count: %zu", - xpath_nodeset_count(step_result->value.nodeset_value)); - - xpath_nodeset_free(current); - current = step_result->value.nodeset_value; - step_result->value.nodeset_value = NULL; - xpath_result_free(step_result); - DEBUG_LOG(" Current nodeset count: %zu", xpath_nodeset_count(current)); - } - else if (child->type == XPATH_AST_RELATIVE_PATH) { - /* RELATIVE_PATH container - process its step children */ - for (size_t j = 0; j < child->child_count; j++) { - XPathASTNode* step = child->children[j]; - - if (step->type == XPATH_AST_STEP) { - struct taurus_xpath_result* step_result = evaluate_step(ctx, step, current); - if (!step_result) { - xpath_nodeset_free(current); - return NULL; - } - - xpath_nodeset_free(current); - current = step_result->value.nodeset_value; - step_result->value.nodeset_value = NULL; - xpath_result_free(step_result); - } - } - } - } - } - } /* End of if (path->type == XPATH_AST_ABSOLUTE_PATH) */ - else { - /* Relative path - start from context node */ - xpath_nodeset_add(current, ctx->context_node); - - /* Process steps - handle both direct steps and those in RELATIVE_PATH */ - for (size_t i = 0; i < path->child_count; i++) { - XPathASTNode* child = path->children[i]; - - if (child->type == XPATH_AST_STEP) { - /* Direct step child - process it */ - struct taurus_xpath_result* step_result = evaluate_step(ctx, child, current); - if (!step_result) { - xpath_nodeset_free(current); - return NULL; - } - - xpath_nodeset_free(current); - current = step_result->value.nodeset_value; - step_result->value.nodeset_value = NULL; - xpath_result_free(step_result); - } - else if (child->type == XPATH_AST_RELATIVE_PATH) { - /* RELATIVE_PATH container - process its step children */ - for (size_t j = 0; j < child->child_count; j++) { - XPathASTNode* step = child->children[j]; - - if (step->type == XPATH_AST_STEP) { - struct taurus_xpath_result* step_result = evaluate_step(ctx, step, current); - if (!step_result) { - xpath_nodeset_free(current); - return NULL; - } - - xpath_nodeset_free(current); - current = step_result->value.nodeset_value; - step_result->value.nodeset_value = NULL; - xpath_result_free(step_result); - } - } - } - } - } - - DEBUG_LOG(" Final nodeset count: %zu", xpath_nodeset_count(current)); - DEBUG_LOG("=== evaluate_location_path END ==="); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NODESET); - if (result) result->value.nodeset_value = current; - return result; -} - -/* ============================================================================ - * Main Evaluation Dispatcher - * ============================================================================ */ - -/* Forward declaration for function call evaluation */ -static struct taurus_xpath_result* evaluate_function_call(XPathContext* ctx, - XPathASTNode* ast); - -static struct taurus_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast) { - if (!ctx || !ast) return NULL; - - switch (ast->type) { - case XPATH_AST_NUMBER: { - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (result) result->value.number_value = ast->number_value; - return result; - } - - case XPATH_AST_STRING: { - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(ast->value ? ast->value : ""); - return result; - } - - case XPATH_AST_OPERATOR: - return evaluate_operator(ctx, ast); - - case XPATH_AST_FUNCTION_CALL: - return evaluate_function_call(ctx, ast); - - case XPATH_AST_PATH_EXPR: - case XPATH_AST_ABSOLUTE_PATH: - case XPATH_AST_RELATIVE_PATH: - return evaluate_location_path(ctx, ast); - - case XPATH_AST_STEP: { - XPathNodeSet* initial = xpath_nodeset_new(); - if (initial) xpath_nodeset_add(initial, ctx->context_node); - struct taurus_xpath_result* result = evaluate_step(ctx, ast, initial); - xpath_nodeset_free(initial); - return result; - } - - default: { - char msg[256]; - snprintf(msg, sizeof(msg), "Unsupported AST node type: %d", ast->type); - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_EVAL_CONTEXT, - msg, - ctx->input, - 0, /* No specific position for AST node type errors */ - 1, 1 - ); - } - return NULL; - } - } -} - -/* ============================================================================ - * Function Call Evaluation - * ============================================================================ */ - -/* Helper: Find similar function name (simple Levenshtein distance check) */ -static const char* suggest_similar_function(const char* name) { - if (!name) return NULL; - - /* All XPath 1.0 functions */ - static const char* functions[] = { - "last", "position", "count", "id", "local-name", "namespace-uri", "name", - "string", "concat", "starts-with", "contains", "substring-before", - "substring-after", "substring", "string-length", "normalize-space", "translate", - "boolean", "not", "true", "false", "lang", - "number", "sum", "floor", "ceiling", "round", - NULL - }; - - size_t name_len = strlen(name); - const char* best_match = NULL; - int best_distance = 999; - - for (int i = 0; functions[i]; i++) { - const char* func = functions[i]; - size_t func_len = strlen(func); - - /* Quick filters */ - if (name_len == 0 || func_len == 0) continue; - - /* Check prefix match */ - if (strncmp(name, func, name_len < func_len ? name_len : func_len) == 0) { - return func; /* Strong prefix match */ - } - - /* Simple distance: count character differences */ - int distance = abs((int)name_len - (int)func_len); - for (size_t j = 0; j < (name_len < func_len ? name_len : func_len); j++) { - if (name[j] != func[j]) distance++; - } - - /* Only suggest if reasonably close (within 3 edits) */ - if (distance < best_distance && distance <= 3) { - best_distance = distance; - best_match = func; - } - } - - return best_match; -} - -static struct taurus_xpath_result* evaluate_function_call(XPathContext* ctx, - XPathASTNode* ast) { - if (!ctx || !ast || !ast->value) { - if (ctx) { - char msg[] = "Invalid function call"; - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_FUNCTION, - msg, ctx->input, 0, 1, 1 - ); - } - } - return NULL; - } - - /* Get function name */ - const char* function_name = ast->value; - - /* Look up function in registry */ - XPathFunctionRegistry* registry = (XPathFunctionRegistry*)ctx->function_registry; - if (!registry) { - char msg[] = "Function registry not initialized"; - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_FUNCTION, - msg, ctx->input, 0, 1, 1 - ); - } - return NULL; - } - - XPathFunctionDef* func_def = xpath_function_registry_get(registry, function_name); - if (!func_def) { - /* Try to suggest similar function */ - const char* suggestion = suggest_similar_function(function_name); - char msg[256]; - - if (suggestion) { - snprintf(msg, sizeof(msg), - "Unknown function '%s'. Did you mean '%s'?", - function_name, suggestion); - } else { - snprintf(msg, sizeof(msg), - "Unknown function '%s'", function_name); - } - - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_FUNCTION, - msg, ctx->input, 0, 1, 1 - ); - } - return NULL; - } - - /* Validate argument count */ - size_t arg_count = ast->child_count; - if ((int)arg_count < func_def->min_args) { - char msg[256]; - snprintf(msg, sizeof(msg), - "Function '%s()' requires at least %d argument%s, got %zu", - function_name, func_def->min_args, - func_def->min_args == 1 ? "" : "s", - arg_count); - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_FUNCTION, - msg, ctx->input, 0, 1, 1 - ); - } - return NULL; - } - if (func_def->max_args >= 0 && (int)arg_count > func_def->max_args) { - char msg[256]; - snprintf(msg, sizeof(msg), - "Function '%s()' accepts at most %d argument%s, got %zu", - function_name, func_def->max_args, - func_def->max_args == 1 ? "" : "s", - arg_count); - snprintf(ctx->error_msg, sizeof(ctx->error_msg), "%s", msg); - - if (ctx->input) { - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_FUNCTION, - msg, ctx->input, 0, 1, 1 - ); - } - return NULL; - } - - /* Call function handler */ - return func_def->handler(ctx, ast->children, arg_count); -} - -struct taurus_xpath_result* xpath_evaluate(XPathContext* ctx, XPathASTNode* ast) { - if (!ctx || !ast) return NULL; - return evaluate_expr(ctx, ast); -} - -/* ============================================================================ - * Public XPath Result API (for libtaurus) - * ============================================================================ */ - -/** - * Evaluate XPath with specific context node - */ -TAURUS_API struct taurus_xpath_result* taurus_xpath_eval_with_context( - struct taurus_document* doc, - struct taurus_element* context_node, - const char* xpath_expr, - size_t expr_len -) { - if (!doc || !context_node || !xpath_expr || expr_len == 0) { - return NULL; - } - - /* Parse XPath expression */ - XPathParser* parser = xpath_parser_new(xpath_expr, expr_len); - if (!parser) return NULL; - - XPathASTNode* ast = xpath_parse(parser); - const char* parse_error = xpath_parser_error(parser); - - if (!ast || parse_error) { - xpath_parser_free(parser); - return NULL; - } - - xpath_parser_free(parser); - - /* Create evaluation context with specified context node */ - XPathContext* context = xpath_context_new(doc, context_node); - if (!context) { - ast_node_free(ast); - return NULL; - } - - /* Store input expression for error reporting (v1.0.0) */ - context->input = xpath_expr; - context->input_len = expr_len; - - /* Evaluate expression */ - struct taurus_xpath_result* result = xpath_evaluate(context, ast); - - /* Cleanup */ - xpath_context_free(context); - ast_node_free(ast); - - return result; -} - -/** - * Get result type - */ -TAURUS_API taurus_xpath_result_type taurus_xpath_result_get_type( - const struct taurus_xpath_result* result -) { - if (!result) return TAURUS_XPATH_NODESET; - - /* Convert internal type to public enum */ - switch (result->type) { - case XPATH_RESULT_BOOLEAN: return TAURUS_XPATH_BOOLEAN; - case XPATH_RESULT_NUMBER: return TAURUS_XPATH_NUMBER; - case XPATH_RESULT_STRING: return TAURUS_XPATH_STRING; - case XPATH_RESULT_NODESET: return TAURUS_XPATH_NODESET; - default: return TAURUS_XPATH_NODESET; - } -} - -/** - * Get boolean value from result - */ -TAURUS_API int taurus_xpath_result_as_boolean(const struct taurus_xpath_result* result) { - if (!result) return 0; - - /* Use internal conversion function (it's safe to cast away const) */ - return xpath_to_boolean((struct taurus_xpath_result*)result); -} - -/** - * Get number value from result - */ -TAURUS_API double taurus_xpath_result_as_number(const struct taurus_xpath_result* result) { - if (!result) return NAN; - - /* Use internal conversion function (it's safe to cast away const) */ - return xpath_to_number((struct taurus_xpath_result*)result); -} - -/** - * Get string value from result - */ -TAURUS_API char* taurus_xpath_result_as_string(const struct taurus_xpath_result* result) { - if (!result) return taurus_strdup(""); - - /* Use internal conversion function (it's safe to cast away const) */ - return xpath_to_string((struct taurus_xpath_result*)result); -} - -/** - * Get node-set size - */ -TAURUS_API size_t taurus_xpath_result_nodeset_size( - const struct taurus_xpath_result* result -) { - if (!result || result->type != XPATH_RESULT_NODESET) return 0; - return xpath_nodeset_count(result->value.nodeset_value); -} - -/** - * Get node from node-set (public API - returns elements only) - * - * This function filters the internal nodeset to return only element nodes. - * Attribute nodes are skipped since they cannot be represented as taurus_element*. - * - * Note: The Ruby FFI bridge accesses the nodeset directly and can handle - * attribute nodes correctly by reading their values. - */ -TAURUS_API struct taurus_element* taurus_xpath_result_nodeset_get( - const struct taurus_xpath_result* result, - size_t index -) { - if (!result || result->type != XPATH_RESULT_NODESET) return NULL; - - XPathNodeSet* nodeset = result->value.nodeset_value; - if (!nodeset) return NULL; - - /* Count only element nodes to map index correctly */ - size_t element_index = 0; - for (size_t i = 0; i < nodeset->count; i++) { - void* node = nodeset->nodes[i]; - if (!node) continue; - - TaurusNodeType node_type = XPATH_NODE_TYPE(node); - if (node_type == TAURUS_NODE_ELEMENT) { - if (element_index == index) { - return (struct taurus_element*)node; - } - element_index++; - } - /* Skip attribute nodes - they can't be returned as taurus_element* */ - } - - return NULL; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/evaluator.h b/ext/taurus/lib/src/xpath/evaluator.h deleted file mode 100644 index da59c30..0000000 --- a/ext/taurus/lib/src/xpath/evaluator.h +++ /dev/null @@ -1,162 +0,0 @@ -/* evaluator.h - XPath evaluator API - * Copyright (c) 2024, Ribose Inc. - * - * Pure C implementation of XPath 1.0 evaluator. - * Provides evaluation of XPath expressions against DOM trees. - */ - -#ifndef XPATH_EVALUATOR_H -#define XPATH_EVALUATOR_H - -#include "../taurus_internal.h" -#include "parser.h" - -/* ============================================================================ - * Types from taurus_internal.h - * ============================================================================ */ - -/* XPathContext, XPathNodeSet, XPathResult are defined in taurus_internal.h */ - -/* ============================================================================ - * Context Management - * ============================================================================ */ - -/** - * Create new XPath evaluation context - * - * @param document Document to evaluate against - * @param context_node Current context node - * @return New context, or NULL on error - */ -XPathContext* xpath_context_new(struct taurus_document* document, - struct taurus_element* context_node); - -/** - * Free XPath context - * - * @param context Context to free - */ -void xpath_context_free(XPathContext* context); - -/** - * Get error message from context - * - * @param context Context to query - * @return Error message, or NULL if no error - */ -const char* xpath_context_error(XPathContext* context); - -/* ============================================================================ - * NodeSet Management - * ============================================================================ */ - -/** - * Create new nodeset - * - * @return New nodeset, or NULL on error - */ -XPathNodeSet* xpath_nodeset_new(void); - -/** - * Create new nodeset with pre-allocated capacity - * - * @param capacity Initial capacity - * @return New nodeset, or NULL on error - */ -XPathNodeSet* xpath_nodeset_new_with_capacity(size_t capacity); - -/** - * Free nodeset - * - * @param nodeset Nodeset to free - */ -void xpath_nodeset_free(XPathNodeSet* nodeset); - -/** - * Get nodeset count - * - * @param nodeset Nodeset to query - * @return Number of nodes in set - */ -size_t xpath_nodeset_count(XPathNodeSet* nodeset); - -/** - * Get node from nodeset (returns typed node pointer) - * - * @param nodeset Nodeset to query - * @param index Index of node (0-based) - * @return Typed node pointer (void*), or NULL if out of bounds - * @note Cast to appropriate type using XPATH_NODE_TYPE macro - */ -void* xpath_nodeset_get(XPathNodeSet* nodeset, size_t index); - -/** - * Add typed node to nodeset - * - * @param nodeset Nodeset to add to - * @param node Typed node pointer to add (element or attribute) - */ -void xpath_nodeset_add(XPathNodeSet* nodeset, void* node); - -/* ============================================================================ - * Result Management - * ============================================================================ */ - -/** - * Create new XPath result - * - * @param type Result type - * @return New result, or NULL on error - */ -struct taurus_xpath_result* xpath_result_new(XPathResultType type); - -/** - * Free XPath result - * - * @param result Result to free - */ -void xpath_result_free(struct taurus_xpath_result* result); - -/* ============================================================================ - * Type Conversions (XPath 1.0 spec section 4) - * ============================================================================ */ - -/** - * Convert result to boolean - * - * @param result Result to convert - * @return Boolean value (0 or 1) - */ -int xpath_to_boolean(struct taurus_xpath_result* result); - -/** - * Convert result to number - * - * @param result Result to convert - * @return Number value (NAN if conversion fails) - */ -double xpath_to_number(struct taurus_xpath_result* result); - -/** - * Convert result to string - * - * @param result Result to convert - * @return String value (caller must free), or NULL on error - */ -char* xpath_to_string(struct taurus_xpath_result* result); - -/* ============================================================================ - * Evaluation - * ============================================================================ */ - -/** - * Evaluate XPath expression - * - * @param context Evaluation context - * @param ast Parsed AST to evaluate - * @return Result of evaluation, or NULL on error - */ -struct taurus_xpath_result* xpath_evaluate(XPathContext* context, - XPathASTNode* ast); - -#endif /* XPATH_EVALUATOR_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/functions.c b/ext/taurus/lib/src/xpath/functions.c deleted file mode 100644 index 18511c0..0000000 --- a/ext/taurus/lib/src/xpath/functions.c +++ /dev/null @@ -1,1746 +0,0 @@ -/* functions.c - XPath 1.0 function library implementation - * Copyright (c) 2024, Ribose Inc. - * - * Pure C implementation of all 27 XPath 1.0 standard functions. - * Converted from Ruby C extension to standalone C library. - */ - -#include "functions.h" -#include "evaluator.h" -#include "taurus/taurus.h" -#include -#include -#include -#include -#include -#include -#include - -/* ============================================================================ - * Forward Declarations - * ============================================================================ */ - -/* External evaluator function */ -extern struct taurus_xpath_result* xpath_evaluate(XPathContext* context, - XPathASTNode* ast); - -/* Helper functions */ -static char* get_element_text(struct taurus_element* element); -static char* result_to_string(struct taurus_xpath_result* result); -static int result_to_boolean(struct taurus_xpath_result* result); -static double result_to_number(struct taurus_xpath_result* result); - -/* UTF-8 helpers */ -static size_t utf8_strlen(const char* str); -static size_t utf8_char_offset(const char* str, size_t char_pos); -static char* utf8_substring(const char* str, size_t start_char, size_t char_count); - -/* ============================================================================ - * Function Registry Implementation - * ============================================================================ */ - -XPathFunctionRegistry* xpath_function_registry_new(void) { - XPathFunctionRegistry* registry = TAURUS_ALLOC(XPathFunctionRegistry); - if (!registry) return NULL; - - registry->functions = NULL; - registry->count = 0; - registry->capacity = 0; - - return registry; -} - -void xpath_function_registry_free(XPathFunctionRegistry* registry) { - if (!registry) return; - - if (registry->functions) { - TAURUS_FREE(registry->functions); - } - TAURUS_FREE(registry); -} - -void xpath_function_registry_register( - XPathFunctionRegistry* registry, - const char* name, - XPathFunctionHandler handler, - int min_args, - int max_args -) { - if (!registry || !name || !handler) return; - - /* Resize if needed */ - if (registry->count >= registry->capacity) { - size_t new_capacity = registry->capacity == 0 ? 8 : registry->capacity * 2; - XPathFunctionDef* new_functions = TAURUS_REALLOC_N( - registry->functions, - XPathFunctionDef, - new_capacity - ); - if (!new_functions) return; - registry->functions = new_functions; - registry->capacity = new_capacity; - } - - /* Add function */ - registry->functions[registry->count].name = name; - registry->functions[registry->count].handler = handler; - registry->functions[registry->count].min_args = min_args; - registry->functions[registry->count].max_args = max_args; - registry->count++; -} - -XPathFunctionHandler xpath_function_registry_lookup( - XPathFunctionRegistry* registry, - const char* name -) { - if (!registry || !name) return NULL; - - for (size_t i = 0; i < registry->count; i++) { - if (strcmp(registry->functions[i].name, name) == 0) { - return registry->functions[i].handler; - } - } - - return NULL; -} - -XPathFunctionDef* xpath_function_registry_get( - XPathFunctionRegistry* registry, - const char* name -) { - if (!registry || !name) return NULL; - - for (size_t i = 0; i < registry->count; i++) { - if (strcmp(registry->functions[i].name, name) == 0) { - return ®istry->functions[i]; - } - } - - return NULL; -} - -/* ============================================================================ - * Helper Functions for Type Conversion - * ============================================================================ */ - -/* Get text content from typed node (handles elements and attributes) */ -static char* get_node_text(void* node) { - if (!node) return taurus_strdup(""); - - /* Check if first 4 bytes match TAURUS_NODE_ATTRIBUTE */ - uint32_t first_int = *(uint32_t*)node; - - if (first_int == TAURUS_NODE_ATTRIBUTE) { - /* It's an attribute node - cast to proper type and read value */ - TaurusAttributeNode* attr = (TaurusAttributeNode*)node; - return taurus_strdup(attr->value ? attr->value : ""); - } - - /* It's an element node */ - struct taurus_element* element = (struct taurus_element*)node; - - /* If element has direct text content, return it */ - if (element->text_content) { - return taurus_strdup(element->text_content); - } - - /* Otherwise concatenate all descendant text */ - size_t total_len = 0; - size_t capacity = 256; - char* result = TAURUS_ALLOC_N(char, capacity); - if (!result) return taurus_strdup(""); - result[0] = '\0'; - - /* Recursively collect text from children (children are always elements) */ - for (size_t i = 0; i < element->children_count; i++) { - char* child_text = get_node_text(element->children[i]); - if (child_text) { - size_t child_len = strlen(child_text); - if (total_len + child_len + 1 > capacity) { - capacity = (total_len + child_len + 1) * 2; - char* new_result = TAURUS_REALLOC_N(result, char, capacity); - if (!new_result) { - TAURUS_FREE(child_text); - TAURUS_FREE(result); - return taurus_strdup(""); - } - result = new_result; - } - strcat(result, child_text); - total_len += child_len; - TAURUS_FREE(child_text); - } - } - - return result; -} - -/* Backward compatibility wrapper */ -static char* get_element_text(struct taurus_element* element) { - return get_node_text((void*)element); -} - -/* Convert XPath result to string according to XPath 1.0 spec */ -static char* result_to_string(struct taurus_xpath_result* result) { - if (!result) return taurus_strdup(""); - - switch (result->type) { - case XPATH_RESULT_STRING: - return result->value.string_value ? - taurus_strdup(result->value.string_value) : taurus_strdup(""); - - case XPATH_RESULT_NUMBER: { - double num = result->value.number_value; - char buffer[64]; - - /* Handle special values per XPath spec */ - if (isnan(num)) { - return taurus_strdup("NaN"); - } else if (isinf(num)) { - return taurus_strdup(num > 0 ? "Infinity" : "-Infinity"); - } else if (num == 0.0) { - return taurus_strdup("0"); - } else if (num == floor(num)) { - /* Integer - no decimal point */ - snprintf(buffer, sizeof(buffer), "%.0f", num); - } else { - snprintf(buffer, sizeof(buffer), "%g", num); - } - return taurus_strdup(buffer); - } - - case XPATH_RESULT_BOOLEAN: - return taurus_strdup(result->value.boolean_value ? "true" : "false"); - - case XPATH_RESULT_NODESET: { - /* String value of first node in document order */ - XPathNodeSet* nodeset = result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - return taurus_strdup(""); - } - void* first_node = xpath_nodeset_get(nodeset, 0); - return get_node_text(first_node); - } - - default: - return taurus_strdup(""); - } -} - -/* Convert XPath result to boolean according to XPath 1.0 spec */ -static int result_to_boolean(struct taurus_xpath_result* result) { - if (!result) return 0; - - switch (result->type) { - case XPATH_RESULT_BOOLEAN: - return result->value.boolean_value; - case XPATH_RESULT_NUMBER: - /* Number is false if 0 or NaN */ - return result->value.number_value != 0.0 && - !isnan(result->value.number_value); - case XPATH_RESULT_STRING: - /* String is false if empty */ - return result->value.string_value && - result->value.string_value[0] != '\0'; - case XPATH_RESULT_NODESET: - /* Nodeset is false if empty */ - return xpath_nodeset_count(result->value.nodeset_value) > 0; - default: - return 0; - } -} - -/* Convert XPath result to number according to XPath 1.0 spec */ -static double result_to_number(struct taurus_xpath_result* result) { - if (!result) return NAN; - - switch (result->type) { - case XPATH_RESULT_NUMBER: - return result->value.number_value; - - case XPATH_RESULT_BOOLEAN: - return result->value.boolean_value ? 1.0 : 0.0; - - case XPATH_RESULT_STRING: { - if (!result->value.string_value) return NAN; - - const char* str = result->value.string_value; - - /* Skip leading whitespace */ - while (isspace((unsigned char)*str)) str++; - - /* Empty string or only whitespace -> NaN */ - if (*str == '\0') return NAN; - - /* Try to parse as number */ - char* endptr; - double value = strtod(str, &endptr); - - /* Skip trailing whitespace */ - while (isspace((unsigned char)*endptr)) endptr++; - - /* If we didn't consume the entire string (after trimming), it's NaN */ - if (*endptr != '\0') return NAN; - - return value; - } - - case XPATH_RESULT_NODESET: { - /* Convert first node's string value to number */ - XPathNodeSet* nodeset = result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - return NAN; - } - void* first_node = xpath_nodeset_get(nodeset, 0); - char* str = get_node_text(first_node); - - /* Parse the string */ - const char* p = str; - while (isspace((unsigned char)*p)) p++; - - if (*p == '\0') { - TAURUS_FREE(str); - return NAN; - } - - char* endptr; - double value = strtod(p, &endptr); - - while (isspace((unsigned char)*endptr)) endptr++; - - if (*endptr != '\0') { - TAURUS_FREE(str); - return NAN; - } - - TAURUS_FREE(str); - return value; - } - - default: - return NAN; - } -} - -/* ============================================================================ - * UTF-8 Helper Functions - * ============================================================================ */ - -/* Count UTF-8 characters (not bytes) in a string */ -static size_t utf8_strlen(const char* str) { - if (!str) return 0; - - size_t count = 0; - const unsigned char* p = (const unsigned char*)str; - - while (*p) { - /* Count leading bytes only (not continuation bytes 10xxxxxx) */ - if ((*p & 0xC0) != 0x80) { - count++; - } - p++; - } - - return count; -} - -/* Get byte offset for UTF-8 character at position (0-based character index) */ -static size_t utf8_char_offset(const char* str, size_t char_pos) { - if (!str) return 0; - - size_t count = 0; - size_t offset = 0; - const unsigned char* p = (const unsigned char*)str; - - /* Special case: position 0 is offset 0 */ - if (char_pos == 0) return 0; - - while (*p) { - /* Move to next byte */ - offset++; - p++; - - /* Check if we've reached a new character (not a continuation byte) */ - if (*p && (*p & 0xC0) != 0x80) { - count++; - if (count == char_pos) { - return offset; - } - } - } - - /* If we've gone past the end, return the string length */ - return offset; -} - -/* Extract substring by character positions (0-based character indices) */ -static char* utf8_substring(const char* str, size_t start_char, size_t char_count) { - if (!str || char_count == 0) return taurus_strdup(""); - - size_t str_len_chars = utf8_strlen(str); - - /* Clamp start position to valid range */ - if (start_char >= str_len_chars) { - return taurus_strdup(""); - } - - /* Clamp character count to available characters */ - if (start_char + char_count > str_len_chars) { - char_count = str_len_chars - start_char; - } - - /* Get byte offsets */ - size_t start_byte = utf8_char_offset(str, start_char); - size_t end_char = start_char + char_count; - size_t end_byte = utf8_char_offset(str, end_char); - - size_t length = end_byte - start_byte; - if (length == 0) return taurus_strdup(""); - - char* result = TAURUS_ALLOC_N(char, length + 1); - if (!result) return taurus_strdup(""); - - memcpy(result, str + start_byte, length); - result[length] = '\0'; - - return result; -} - -/* ============================================================================ - * Core XPath 1.0 Functions - * ============================================================================ */ - -/* last() - Returns the context size (number of nodes in context nodeset) */ -static struct taurus_xpath_result* xpath_func_last( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - (void)args; /* Unused */ - - if (arg_count != 0) { - snprintf(context->error_msg, sizeof(context->error_msg), - "last() takes no arguments"); - return NULL; - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - - result->value.number_value = (double)context->context_size; - return result; -} - -/* position() - Returns the context position (1-based) */ -static struct taurus_xpath_result* xpath_func_position( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - (void)args; /* Unused */ - - if (arg_count != 0) { - snprintf(context->error_msg, sizeof(context->error_msg), - "position() takes no arguments"); - return NULL; - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - - result->value.number_value = (double)context->context_position; - return result; -} - -/* ============================================================================ - * XPath String Functions - * ============================================================================ */ - -/* string(object?) - Convert argument to string */ -static struct taurus_xpath_result* xpath_func_string( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) return NULL; - - if (arg_count == 0) { - /* No argument: convert context node to string */ - result->value.string_value = get_element_text(context->context_node); - } else { - /* Evaluate argument and convert to string */ - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) { - xpath_result_free(result); - return NULL; - } - - result->value.string_value = result_to_string(arg_result); - xpath_result_free(arg_result); - } - - return result; -} - -/* concat(string, string, string*) - Concatenate strings */ -static struct taurus_xpath_result* xpath_func_concat( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count < 2) { - snprintf(context->error_msg, sizeof(context->error_msg), - "concat() requires at least 2 arguments"); - return NULL; - } - - /* Calculate total length needed */ - size_t total_length = 0; - char** strings = TAURUS_ALLOC_N(char*, arg_count); - if (!strings) return NULL; - - for (size_t i = 0; i < arg_count; i++) { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[i]); - if (!arg_result) { - /* Cleanup and return NULL */ - for (size_t j = 0; j < i; j++) { - TAURUS_FREE(strings[j]); - } - TAURUS_FREE(strings); - return NULL; - } - - strings[i] = result_to_string(arg_result); - total_length += strlen(strings[i]); - xpath_result_free(arg_result); - } - - /* Allocate result string */ - char* concat_str = TAURUS_ALLOC_N(char, total_length + 1); - if (!concat_str) { - for (size_t i = 0; i < arg_count; i++) { - TAURUS_FREE(strings[i]); - } - TAURUS_FREE(strings); - return NULL; - } - - /* Concatenate all strings */ - concat_str[0] = '\0'; - for (size_t i = 0; i < arg_count; i++) { - strcat(concat_str, strings[i]); - TAURUS_FREE(strings[i]); - } - TAURUS_FREE(strings); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(concat_str); - return NULL; - } - result->value.string_value = concat_str; - - return result; -} - -/* starts-with(string, string) - Check if string starts with prefix */ -static struct taurus_xpath_result* xpath_func_starts_with( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 2) { - snprintf(context->error_msg, sizeof(context->error_msg), - "starts-with() requires exactly 2 arguments"); - return NULL; - } - - struct taurus_xpath_result* str_result = xpath_evaluate(context, args[0]); - if (!str_result) return NULL; - - struct taurus_xpath_result* prefix_result = xpath_evaluate(context, args[1]); - if (!prefix_result) { - xpath_result_free(str_result); - return NULL; - } - - char* str = result_to_string(str_result); - char* prefix = result_to_string(prefix_result); - - int match = (strncmp(str, prefix, strlen(prefix)) == 0); - - TAURUS_FREE(str); - TAURUS_FREE(prefix); - xpath_result_free(str_result); - xpath_result_free(prefix_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = match; - - return result; -} - -/* contains(string, string) - Check if string contains substring */ -static struct taurus_xpath_result* xpath_func_contains( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 2) { - snprintf(context->error_msg, sizeof(context->error_msg), - "contains() requires exactly 2 arguments"); - return NULL; - } - - struct taurus_xpath_result* str_result = xpath_evaluate(context, args[0]); - if (!str_result) return NULL; - - struct taurus_xpath_result* substr_result = xpath_evaluate(context, args[1]); - if (!substr_result) { - xpath_result_free(str_result); - return NULL; - } - - char* str = result_to_string(str_result); - char* substr = result_to_string(substr_result); - - int match = (strstr(str, substr) != NULL); - - TAURUS_FREE(str); - TAURUS_FREE(substr); - xpath_result_free(str_result); - xpath_result_free(substr_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = match; - - return result; -} - -/* substring(string, number, number?) - Extract substring (1-BASED INDEXING!) */ -static struct taurus_xpath_result* xpath_func_substring( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count < 2 || arg_count > 3) { - snprintf(context->error_msg, sizeof(context->error_msg), - "substring() requires 2 or 3 arguments"); - return NULL; - } - - /* Get string argument */ - struct taurus_xpath_result* str_result = xpath_evaluate(context, args[0]); - if (!str_result) return NULL; - char* str = result_to_string(str_result); - xpath_result_free(str_result); - - /* Get start position (1-based!) */ - struct taurus_xpath_result* start_result = xpath_evaluate(context, args[1]); - if (!start_result) { - TAURUS_FREE(str); - return NULL; - } - - double start_pos = result_to_number(start_result); - xpath_result_free(start_result); - - /* Get optional length */ - double length = INFINITY; - if (arg_count == 3) { - struct taurus_xpath_result* len_result = xpath_evaluate(context, args[2]); - if (!len_result) { - TAURUS_FREE(str); - return NULL; - } - - length = result_to_number(len_result); - xpath_result_free(len_result); - } - - /* Handle NaN and special values per XPath spec */ - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(str); - return NULL; - } - - if (isnan(start_pos) || isnan(length)) { - result->value.string_value = taurus_strdup(""); - TAURUS_FREE(str); - return result; - } - - /* Round to nearest according to XPath spec */ - start_pos = round(start_pos); - length = round(length); - - /* v1.1.0: Handle negative or zero start positions per XPath 1.0 spec - * XPath uses 1-based indexing, so position < 1 is "before the string" - * Example: substring("12345", 0, 3) covers positions [0, 1, 2] - * Only position 1 is valid, so result is "1" */ - if (start_pos < 1.0) { - /* Adjust length to account for positions before position 1 */ - double chars_before = 1.0 - start_pos; - length -= chars_before; - start_pos = 1.0; - - /* If adjusted length is now non-positive, return empty */ - if (length <= 0.0) { - result->value.string_value = taurus_strdup(""); - TAURUS_FREE(str); - return result; - } - } - - /* XPath substring extracts characters at positions [start_pos, start_pos + length) - * in 1-based indexing. We need to find the intersection with valid range [1, str_len] */ - - size_t str_len = utf8_strlen(str); - - if (length <= 0) { - result->value.string_value = taurus_strdup(""); - TAURUS_FREE(str); - return result; - } - - /* Calculate the range of 1-based positions we want: [start_pos, start_pos + length) */ - double end_pos = start_pos + length; - - /* Intersect with valid range [1, str_len + 1) - * (end is exclusive, so str_len + 1 is one past the last character) */ - double actual_start_1based = start_pos < 1.0 ? 1.0 : start_pos; - double actual_end_1based = end_pos > (double)(str_len + 1) ? - (double)(str_len + 1) : end_pos; - - /* If no intersection, return empty */ - if (actual_start_1based >= actual_end_1based || - actual_start_1based > (double)str_len) { - result->value.string_value = taurus_strdup(""); - TAURUS_FREE(str); - return result; - } - - /* Calculate how many characters to extract */ - size_t actual_length = (size_t)(actual_end_1based - actual_start_1based); - - /* Convert to 0-based for C string indexing */ - size_t actual_start = (size_t)(actual_start_1based - 1); - - /* Extract substring using UTF-8 aware function */ - result->value.string_value = utf8_substring(str, actual_start, actual_length); - TAURUS_FREE(str); - - return result; -} - -/* string-length(string?) - Get character length of string */ -static struct taurus_xpath_result* xpath_func_string_length( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - char* str; - - if (arg_count == 0) { - /* No argument: use context node string value */ - str = get_element_text(context->context_node); - } else { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - str = result_to_string(arg_result); - xpath_result_free(arg_result); - } - - size_t length = utf8_strlen(str); - TAURUS_FREE(str); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - result->value.number_value = (double)length; - - return result; -} - -/* normalize-space(string?) - Normalize whitespace */ -static struct taurus_xpath_result* xpath_func_normalize_space( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - char* str; - - if (arg_count == 0) { - /* No argument: use context node string value */ - str = get_element_text(context->context_node); - } else { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - str = result_to_string(arg_result); - xpath_result_free(arg_result); - } - - /* Allocate buffer for normalized string (can't be longer than original) */ - char* normalized = TAURUS_ALLOC_N(char, strlen(str) + 1); - if (!normalized) { - TAURUS_FREE(str); - return NULL; - } - - char* out = normalized; - const char* in = str; - int in_space = 0; - int started = 0; - - /* Skip leading whitespace and collapse internal whitespace */ - while (*in) { - if (isspace((unsigned char)*in)) { - in_space = 1; - in++; - } else { - if (started && in_space) { - *out++ = ' '; - } - *out++ = *in++; - in_space = 0; - started = 1; - } - } - *out = '\0'; - - TAURUS_FREE(str); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(normalized); - return NULL; - } - result->value.string_value = normalized; - - return result; -} - -/* ============================================================================ - * XPath Boolean Functions - * ============================================================================ */ - -/* boolean(object) - Convert any object to boolean */ -static struct taurus_xpath_result* xpath_func_boolean( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "boolean() requires exactly 1 argument"); - return NULL; - } - - /* Evaluate argument */ - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - /* Convert to boolean */ - int bool_value = result_to_boolean(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = bool_value; - - return result; -} - -/* not(boolean) - Logical negation */ -static struct taurus_xpath_result* xpath_func_not( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "not() requires exactly 1 argument"); - return NULL; - } - - /* Evaluate argument */ - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - /* Convert to boolean and negate */ - int bool_value = result_to_boolean(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = !bool_value; - - return result; -} - -/* true() - Returns boolean true */ -static struct taurus_xpath_result* xpath_func_true( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - (void)context; /* Unused */ - (void)args; /* Unused */ - - if (arg_count != 0) { - snprintf(context->error_msg, sizeof(context->error_msg), - "true() takes no arguments"); - return NULL; - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = 1; - - return result; -} - -/* false() - Returns boolean false */ -static struct taurus_xpath_result* xpath_func_false( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - (void)context; /* Unused */ - (void)args; /* Unused */ - - if (arg_count != 0) { - snprintf(context->error_msg, sizeof(context->error_msg), - "false() takes no arguments"); - return NULL; - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - result->value.boolean_value = 0; - - return result; -} - -/* ============================================================================ - * XPath Number Functions - * ============================================================================ */ - -/* number(object?) - Convert argument to number */ -static struct taurus_xpath_result* xpath_func_number( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count > 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "number() takes 0 or 1 argument"); - return NULL; - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - - if (arg_count == 0) { - /* No argument: convert context node to number */ - char* str = get_element_text(context->context_node); - const char* p = str; - while (isspace((unsigned char)*p)) p++; - - if (*p == '\0') { - result->value.number_value = NAN; - } else { - char* endptr; - double value = strtod(p, &endptr); - while (isspace((unsigned char)*endptr)) endptr++; - result->value.number_value = (*endptr == '\0') ? value : NAN; - } - TAURUS_FREE(str); - } else { - /* Evaluate argument and convert to number */ - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) { - xpath_result_free(result); - return NULL; - } - result->value.number_value = result_to_number(arg_result); - xpath_result_free(arg_result); - } - return result; -} - -/* sum(node-set) - Sum the numeric values of all nodes */ -static struct taurus_xpath_result* xpath_func_sum( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "sum() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - if (arg_result->type != XPATH_RESULT_NODESET) { - snprintf(context->error_msg, sizeof(context->error_msg), - "sum() argument must be a nodeset"); - xpath_result_free(arg_result); - return NULL; - } - - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - double sum = 0.0; - - if (nodeset) { - size_t count = xpath_nodeset_count(nodeset); - for (size_t i = 0; i < count; i++) { - void* node = xpath_nodeset_get(nodeset, i); - char* str = get_node_text(node); - const char* p = str; - while (isspace((unsigned char)*p)) p++; - - if (*p != '\0') { - char* endptr; - double value = strtod(p, &endptr); - while (isspace((unsigned char)*endptr)) endptr++; - if (*endptr == '\0' && !isnan(value)) { - sum += value; - } - } - TAURUS_FREE(str); - } - } - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - result->value.number_value = sum; - return result; -} - -/* floor(number) - Largest integer not greater than argument */ -static struct taurus_xpath_result* xpath_func_floor( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "floor() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - double num = result_to_number(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - result->value.number_value = floor(num); - return result; -} - -/* ceiling(number) - Smallest integer not less than argument */ -static struct taurus_xpath_result* xpath_func_ceiling( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "ceiling() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - double num = result_to_number(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - result->value.number_value = ceil(num); - return result; -} - -/* round(number) - Round to nearest integer (half away from zero) */ -static struct taurus_xpath_result* xpath_func_round( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "round() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - double num = result_to_number(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - - /* XPath round() rounds half away from zero */ - if (isnan(num) || isinf(num) || num == 0.0) { - result->value.number_value = num; - } else { - double frac = num - floor(num); - if (frac == 0.5) { - result->value.number_value = (num > 0) ? ceil(num) : floor(num); - } else { - result->value.number_value = floor(num + 0.5); - } - } - return result; -} - -/* ============================================================================ - * XPath Node-set Functions - * ============================================================================ */ - -/* Helper to recursively find elements by id */ -static void find_elements_by_id(struct taurus_element* node, const char* id, - XPathNodeSet* result) { - if (!node) return; - - /* Check this node's id attribute */ - for (size_t i = 0; i < node->attributes_count; i++) { - struct taurus_attribute* attr = node->attributes[i]; - if (attr && attr->name && strcmp(attr->name, "id") == 0) { - if (attr->value && strcmp(attr->value, id) == 0) { - xpath_nodeset_add(result, node); - } - } - } - - /* Search children */ - for (size_t i = 0; i < node->children_count; i++) { - find_elements_by_id(node->children[i], id, result); - } -} - -/* count(node-set) - Returns the number of nodes */ -static struct taurus_xpath_result* xpath_func_count( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "count() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - if (arg_result->type != XPATH_RESULT_NODESET) { - snprintf(context->error_msg, sizeof(context->error_msg), - "count() argument must be a nodeset"); - xpath_result_free(arg_result); - return NULL; - } - - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - size_t count = nodeset ? xpath_nodeset_count(nodeset) : 0; - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NUMBER); - if (!result) return NULL; - result->value.number_value = (double)count; - return result; -} - -/* local-name(node-set?) - Local name of first node */ -static struct taurus_xpath_result* xpath_func_local_name( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count > 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "local-name() takes 0 or 1 argument"); - return NULL; - } - - struct taurus_element* node; - if (arg_count == 0) { - node = context->context_node; - } else { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - if (arg_result->type != XPATH_RESULT_NODESET) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - node = xpath_nodeset_get(nodeset, 0); - xpath_result_free(arg_result); - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) return NULL; - - if (!node || !node->name) { - result->value.string_value = taurus_strdup(""); - return result; - } - - /* Return local name (after ':' if present) */ - const char* colon = strchr(node->name, ':'); - result->value.string_value = taurus_strdup(colon ? colon + 1 : node->name); - return result; -} - -/* namespace-uri(node-set?) - Namespace URI of first node */ -static struct taurus_xpath_result* xpath_func_namespace_uri( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count > 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "namespace-uri() takes 0 or 1 argument"); - return NULL; - } - - struct taurus_element* node; - if (arg_count == 0) { - node = context->context_node; - } else { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - if (arg_result->type != XPATH_RESULT_NODESET) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - node = xpath_nodeset_get(nodeset, 0); - xpath_result_free(arg_result); - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) return NULL; - - result->value.string_value = (node && node->namespace_uri) ? - taurus_strdup(node->namespace_uri) : - taurus_strdup(""); - return result; -} - -/* name(node-set?) - Qualified name of first node */ -static struct taurus_xpath_result* xpath_func_name( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count > 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "name() takes 0 or 1 argument"); - return NULL; - } - - struct taurus_element* node; - if (arg_count == 0) { - node = context->context_node; - } else { - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - if (arg_result->type != XPATH_RESULT_NODESET) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - if (!nodeset || xpath_nodeset_count(nodeset) == 0) { - xpath_result_free(arg_result); - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (result) result->value.string_value = taurus_strdup(""); - return result; - } - - node = xpath_nodeset_get(nodeset, 0); - xpath_result_free(arg_result); - } - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) return NULL; - - /* XPath name() returns qualified name, but our implementation stores - * full qualified name in node->name (e.g., "ns:item"). - * Since we're matching local names everywhere else, return local name here too. - * TODO: When we properly store prefix separately, return prefix:localname */ - if (!node || !node->name) { - result->value.string_value = taurus_strdup(""); - return result; - } - - /* Strip namespace prefix if present */ - const char* colon = strchr(node->name, ':'); - result->value.string_value = taurus_strdup(colon ? colon + 1 : node->name); - return result; -} - -/* id(object) - Select elements by ID */ -static struct taurus_xpath_result* xpath_func_id( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "id() requires exactly 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - char** id_strings = NULL; - size_t id_count = 0; - - if (arg_result->type == XPATH_RESULT_NODESET) { - XPathNodeSet* nodeset = arg_result->value.nodeset_value; - if (nodeset) { - id_count = xpath_nodeset_count(nodeset); - if (id_count > 0) { - id_strings = TAURUS_ALLOC_N(char*, id_count); - if (id_strings) { - for (size_t i = 0; i < id_count; i++) { - id_strings[i] = get_node_text(xpath_nodeset_get(nodeset, i)); - } - } - } - } - } else { - char* str = result_to_string(arg_result); - const char* p = str; - int in_id = 0; - while (*p) { - if (isspace((unsigned char)*p)) { - in_id = 0; - } else if (!in_id) { - id_count++; - in_id = 1; - } - p++; - } - - if (id_count > 0) { - id_strings = TAURUS_ALLOC_N(char*, id_count); - if (id_strings) { - size_t idx = 0; - p = str; - while (*p && isspace((unsigned char)*p)) p++; - while (*p && idx < id_count) { - const char* start = p; - while (*p && !isspace((unsigned char)*p)) p++; - size_t len = p - start; - id_strings[idx] = TAURUS_ALLOC_N(char, len + 1); - if (id_strings[idx]) { - memcpy(id_strings[idx], start, len); - id_strings[idx][len] = '\0'; - idx++; - } - while (*p && isspace((unsigned char)*p)) p++; - } - } - } - TAURUS_FREE(str); - } - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_NODESET); - if (!result) { - for (size_t i = 0; i < id_count; i++) TAURUS_FREE(id_strings[i]); - TAURUS_FREE(id_strings); - return NULL; - } - - result->value.nodeset_value = xpath_nodeset_new(); - if (!result->value.nodeset_value) { - xpath_result_free(result); - for (size_t i = 0; i < id_count; i++) TAURUS_FREE(id_strings[i]); - TAURUS_FREE(id_strings); - return NULL; - } - - if (id_count > 0 && context->document && context->document->root) { - for (size_t i = 0; i < id_count; i++) { - find_elements_by_id(context->document->root, id_strings[i], - result->value.nodeset_value); - } - } - - for (size_t i = 0; i < id_count; i++) TAURUS_FREE(id_strings[i]); - TAURUS_FREE(id_strings); - return result; -} - -/* translate(string, string, string) - Character translation */ -static struct taurus_xpath_result* xpath_func_translate( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 3) { - snprintf(context->error_msg, sizeof(context->error_msg), - "translate() requires 3 arguments"); - return NULL; - } - - struct taurus_xpath_result* results[3]; - for (int i = 0; i < 3; i++) { - results[i] = xpath_evaluate(context, args[i]); - if (!results[i]) { - for (int j = 0; j < i; j++) xpath_result_free(results[j]); - return NULL; - } - } - - char* str = result_to_string(results[0]); - char* from = result_to_string(results[1]); - char* to = result_to_string(results[2]); - - for (int i = 0; i < 3; i++) xpath_result_free(results[i]); - - size_t from_len = strlen(from); - size_t to_len = strlen(to); - char* translated = TAURUS_ALLOC_N(char, strlen(str) + 1); - if (!translated) { - TAURUS_FREE(str); - TAURUS_FREE(from); - TAURUS_FREE(to); - return NULL; - } - - char* out = translated; - const char* in = str; - while (*in) { - int found = -1; - for (size_t i = 0; i < from_len; i++) { - if (*in == from[i]) { - found = (int)i; - break; - } - } - if (found >= 0 && (size_t)found < to_len) { - *out++ = to[found]; - } else if (found < 0) { - *out++ = *in; - } - in++; - } - *out = '\0'; - - TAURUS_FREE(str); - TAURUS_FREE(from); - TAURUS_FREE(to); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(translated); - return NULL; - } - result->value.string_value = translated; - return result; -} - -/* substring-before(string, string) - Before delimiter */ -static struct taurus_xpath_result* xpath_func_substring_before( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 2) { - snprintf(context->error_msg, sizeof(context->error_msg), - "substring-before() requires 2 arguments"); - return NULL; - } - - struct taurus_xpath_result* results[2]; - for (int i = 0; i < 2; i++) { - results[i] = xpath_evaluate(context, args[i]); - if (!results[i]) { - for (int j = 0; j < i; j++) xpath_result_free(results[j]); - return NULL; - } - } - - char* str = result_to_string(results[0]); - char* delim = result_to_string(results[1]); - xpath_result_free(results[0]); - xpath_result_free(results[1]); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(str); - TAURUS_FREE(delim); - return NULL; - } - - if (delim[0] == '\0') { - result->value.string_value = taurus_strdup(""); - } else { - const char* pos = strstr(str, delim); - if (pos) { - size_t len = pos - str; - char* substr = TAURUS_ALLOC_N(char, len + 1); - if (substr) { - memcpy(substr, str, len); - substr[len] = '\0'; - result->value.string_value = substr; - } else { - result->value.string_value = taurus_strdup(""); - } - } else { - result->value.string_value = taurus_strdup(""); - } - } - - TAURUS_FREE(str); - TAURUS_FREE(delim); - return result; -} - -/* substring-after(string, string) - After delimiter */ -static struct taurus_xpath_result* xpath_func_substring_after( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 2) { - snprintf(context->error_msg, sizeof(context->error_msg), - "substring-after() requires 2 arguments"); - return NULL; - } - - struct taurus_xpath_result* results[2]; - for (int i = 0; i < 2; i++) { - results[i] = xpath_evaluate(context, args[i]); - if (!results[i]) { - for (int j = 0; j < i; j++) xpath_result_free(results[j]); - return NULL; - } - } - - char* str = result_to_string(results[0]); - char* delim = result_to_string(results[1]); - xpath_result_free(results[0]); - xpath_result_free(results[1]); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_STRING); - if (!result) { - TAURUS_FREE(str); - TAURUS_FREE(delim); - return NULL; - } - - if (delim[0] == '\0') { - result->value.string_value = taurus_strdup(str); - } else { - const char* pos = strstr(str, delim); - result->value.string_value = pos ? taurus_strdup(pos + strlen(delim)) : taurus_strdup(""); - } - - TAURUS_FREE(str); - TAURUS_FREE(delim); - return result; -} - -/* Helper to get xml:lang attribute */ -static char* get_lang_attribute(struct taurus_element* node) { - if (!node) return NULL; - - for (size_t i = 0; i < node->attributes_count; i++) { - struct taurus_attribute* attr = node->attributes[i]; - if (attr && attr->name && strcmp(attr->name, "xml:lang") == 0) { - return attr->value ? taurus_strdup(attr->value) : NULL; - } - } - - return node->parent ? get_lang_attribute(node->parent) : NULL; -} - -/* lang(string) - Check xml:lang matches */ -static struct taurus_xpath_result* xpath_func_lang( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -) { - if (arg_count != 1) { - snprintf(context->error_msg, sizeof(context->error_msg), - "lang() requires 1 argument"); - return NULL; - } - - struct taurus_xpath_result* arg_result = xpath_evaluate(context, args[0]); - if (!arg_result) return NULL; - - char* target_lang = result_to_string(arg_result); - xpath_result_free(arg_result); - - struct taurus_xpath_result* result = xpath_result_new(XPATH_RESULT_BOOLEAN); - if (!result) return NULL; - - char* node_lang = get_lang_attribute(context->context_node); - if (!node_lang) { - result->value.boolean_value = 0; - } else { - size_t target_len = strlen(target_lang); - size_t node_len = strlen(node_lang); - int matches = (node_len >= target_len && - strncasecmp(node_lang, target_lang, target_len) == 0 && - (node_len == target_len || node_lang[target_len] == '-')); - result->value.boolean_value = matches; - TAURUS_FREE(node_lang); - } - - TAURUS_FREE(target_lang); - return result; -} - -/* ============================================================================ - * Standard Function Library Initialization - * ============================================================================ */ - -void xpath_function_registry_init_standard(XPathFunctionRegistry* registry) { - if (!registry) return; - - /* Core functions */ - xpath_function_registry_register(registry, "last", xpath_func_last, 0, 0); - xpath_function_registry_register(registry, "position", xpath_func_position, 0, 0); - - /* String functions */ - xpath_function_registry_register(registry, "string", xpath_func_string, 0, 1); - xpath_function_registry_register(registry, "concat", xpath_func_concat, 2, -1); - xpath_function_registry_register(registry, "starts-with", xpath_func_starts_with, 2, 2); - xpath_function_registry_register(registry, "contains", xpath_func_contains, 2, 2); - xpath_function_registry_register(registry, "substring", xpath_func_substring, 2, 3); - xpath_function_registry_register(registry, "string-length", xpath_func_string_length, 0, 1); - xpath_function_registry_register(registry, "normalize-space", xpath_func_normalize_space, 0, 1); - xpath_function_registry_register(registry, "translate", xpath_func_translate, 3, 3); - xpath_function_registry_register(registry, "substring-before", xpath_func_substring_before, 2, 2); - xpath_function_registry_register(registry, "substring-after", xpath_func_substring_after, 2, 2); - - /* Boolean functions */ - xpath_function_registry_register(registry, "boolean", xpath_func_boolean, 1, 1); - xpath_function_registry_register(registry, "not", xpath_func_not, 1, 1); - xpath_function_registry_register(registry, "true", xpath_func_true, 0, 0); - xpath_function_registry_register(registry, "false", xpath_func_false, 0, 0); - xpath_function_registry_register(registry, "lang", xpath_func_lang, 1, 1); - - /* Number functions */ - xpath_function_registry_register(registry, "number", xpath_func_number, 0, 1); - xpath_function_registry_register(registry, "sum", xpath_func_sum, 1, 1); - xpath_function_registry_register(registry, "floor", xpath_func_floor, 1, 1); - xpath_function_registry_register(registry, "ceiling", xpath_func_ceiling, 1, 1); - xpath_function_registry_register(registry, "round", xpath_func_round, 1, 1); - - /* Node-set functions */ - xpath_function_registry_register(registry, "count", xpath_func_count, 1, 1); - xpath_function_registry_register(registry, "id", xpath_func_id, 1, 1); - xpath_function_registry_register(registry, "local-name", xpath_func_local_name, 0, 1); - xpath_function_registry_register(registry, "namespace-uri", xpath_func_namespace_uri, 0, 1); - xpath_function_registry_register(registry, "name", xpath_func_name, 0, 1); -} - -/* ============================================================================ - * Public XPath Function Support API (for libtaurus) - * ============================================================================ */ - -/* Array of all supported function names (NULL-terminated) */ -static const char* g_supported_functions[] = { - /* Core */ - "last", - "position", - /* String */ - "string", - "concat", - "starts-with", - "contains", - "substring-before", - "substring-after", - "substring", - "string-length", - "normalize-space", - "translate", - /* Boolean */ - "boolean", - "not", - "true", - "false", - "lang", - /* Number */ - "number", - "sum", - "floor", - "ceiling", - "round", - /* Node-set */ - "count", - "id", - "local-name", - "namespace-uri", - "name", - NULL /* Terminator */ -}; - -/** - * Check if XPath function is supported - */ -TAURUS_API int taurus_xpath_function_supported(const char* function_name) { - if (!function_name) return 0; - - for (size_t i = 0; g_supported_functions[i] != NULL; i++) { - if (strcmp(function_name, g_supported_functions[i]) == 0) { - return 1; - } - } - return 0; -} - -/** - * Get list of supported XPath functions - */ -TAURUS_API const char** taurus_xpath_supported_functions(void) { - return g_supported_functions; -} diff --git a/ext/taurus/lib/src/xpath/functions.h b/ext/taurus/lib/src/xpath/functions.h deleted file mode 100644 index 278a688..0000000 --- a/ext/taurus/lib/src/xpath/functions.h +++ /dev/null @@ -1,137 +0,0 @@ -/* functions.h - XPath 1.0 function library API - * Copyright (c) 2024, Ribose Inc. - * - * Pure C implementation of XPath 1.0 standard function library. - * Provides all 27 XPath 1.0 functions with extensible registry. - */ - -#ifndef XPATH_FUNCTIONS_H -#define XPATH_FUNCTIONS_H - -#include "../taurus_internal.h" -#include "parser.h" - -/* ============================================================================ - * Forward Declarations - * ============================================================================ */ - -typedef struct xpath_function_registry XPathFunctionRegistry; - -/* ============================================================================ - * Function Handler Type - * ============================================================================ */ - -/** - * XPath function handler - * - * @param context Evaluation context - * @param args Array of pointers to AST nodes (function arguments) - * @param arg_count Number of arguments - * @return Result of function evaluation, or NULL on error - */ -typedef struct taurus_xpath_result* (*XPathFunctionHandler)( - XPathContext* context, - XPathASTNode** args, - size_t arg_count -); - -/* ============================================================================ - * Function Definition Structure - * ============================================================================ */ - -/** - * Function definition - */ -typedef struct { - const char* name; /* Function name */ - XPathFunctionHandler handler; /* Handler function */ - int min_args; /* Minimum arguments */ - int max_args; /* Maximum arguments (-1 = unlimited) */ -} XPathFunctionDef; - -/* ============================================================================ - * Function Registry Structure - * ============================================================================ */ - -/** - * Function registry - * Stores registered XPath functions - */ -struct xpath_function_registry { - XPathFunctionDef* functions; - size_t count; - size_t capacity; -}; - -/* ============================================================================ - * Registry Management - * ============================================================================ */ - -/** - * Create new function registry - * - * @return New registry, or NULL on error - */ -XPathFunctionRegistry* xpath_function_registry_new(void); - -/** - * Free function registry - * - * @param registry Registry to free - */ -void xpath_function_registry_free(XPathFunctionRegistry* registry); - -/** - * Register a function - * - * @param registry Registry to register in - * @param name Function name - * @param handler Handler function - * @param min_args Minimum arguments - * @param max_args Maximum arguments (-1 for unlimited) - */ -void xpath_function_registry_register( - XPathFunctionRegistry* registry, - const char* name, - XPathFunctionHandler handler, - int min_args, - int max_args -); - -/** - * Lookup function by name - * - * @param registry Registry to search - * @param name Function name - * @return Handler function, or NULL if not found - */ -XPathFunctionHandler xpath_function_registry_lookup( - XPathFunctionRegistry* registry, - const char* name -); - -/** - * Get function definition by name - * - * @param registry Registry to search - * @param name Function name - * @return Function definition, or NULL if not found - */ -XPathFunctionDef* xpath_function_registry_get( - XPathFunctionRegistry* registry, - const char* name -); - -/* ============================================================================ - * Standard Function Library - * ============================================================================ */ - -/** - * Initialize standard XPath 1.0 functions - * Registers all 27 XPath 1.0 functions - * - * @param registry Registry to initialize - */ -void xpath_function_registry_init_standard(XPathFunctionRegistry* registry); - -#endif /* XPATH_FUNCTIONS_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/lexer.c b/ext/taurus/lib/src/xpath/lexer.c deleted file mode 100644 index b1687ef..0000000 --- a/ext/taurus/lib/src/xpath/lexer.c +++ /dev/null @@ -1,554 +0,0 @@ -/* lexer.c - XPath 1.0 Lexer (Pure C) - * Copyright (c) 2024, Ribose Inc. - */ - -#include "lexer.h" -#include "../taurus_internal.h" -#include -#include -#include - -/* Token type names for debugging */ -const char* xpath_token_type_names[] = { - "EOF", - "SLASH", - "DOUBLE_SLASH", - "AT", - "DOT", - "DOUBLE_DOT", - "LPAREN", - "RPAREN", - "LBRACKET", - "RBRACKET", - "COMMA", - "DOUBLE_COLON", - "NCNAME", - "QNAME", - "STRING", - "NUMBER", - "EQUALS", - "NOT_EQUALS", - "LT", - "LE", - "GT", - "GE", - "PLUS", - "MINUS", - "STAR", - "PIPE", - "AND", - "OR", - "DIV", - "MOD", - "ANCESTOR", - "ANCESTOR_OR_SELF", - "ATTRIBUTE", - "CHILD", - "DESCENDANT", - "DESCENDANT_OR_SELF", - "FOLLOWING", - "FOLLOWING_SIBLING", - "NAMESPACE", - "PARENT", - "PRECEDING", - "PRECEDING_SIBLING", - "SELF", - "COMMENT", - "TEXT", - "PROCESSING_INSTRUCTION", - "NODE" -}; - -/* Forward declarations */ -static void skip_whitespace(XPathLexer* lexer); -static int is_ncname_start(char c); -static int is_ncname_char(char c); -static XPathTokenType check_keyword(const char* str, size_t len, int peek_ahead, XPathLexer* lexer); - -/* Create a new lexer */ -XPathLexer* xpath_lexer_new(const char* input, size_t len) { - if (!input) return NULL; - - XPathLexer* lexer = TAURUS_ALLOC(XPathLexer); - if (!lexer) return NULL; - - lexer->input = input; - lexer->pos = input; - lexer->end = input + len; - lexer->line = 1; - lexer->column = 1; - lexer->error_msg[0] = '\0'; - - return lexer; -} - -/* Free the lexer */ -void xpath_lexer_free(XPathLexer* lexer) { - if (lexer) { - TAURUS_FREE(lexer); - } -} - -/* Check if character is NCName start character */ -static int is_ncname_start(char c) { - return isalpha((unsigned char)c) || c == '_'; -} - -/* Check if character is NCName character */ -static int is_ncname_char(char c) { - return isalnum((unsigned char)c) || c == '_' || c == '-' || c == '.'; -} - -/* Skip whitespace and update position */ -static void skip_whitespace(XPathLexer* lexer) { - while (lexer->pos < lexer->end && isspace((unsigned char)*lexer->pos)) { - if (*lexer->pos == '\n') { - lexer->line++; - lexer->column = 1; - } else { - lexer->column++; - } - lexer->pos++; - } -} - -/* Check if a string matches a keyword and return appropriate token type */ -static XPathTokenType check_keyword(const char* str, size_t len, int peek_ahead, XPathLexer* lexer) { - /* Check for axis names (must be followed by ::) */ - if (peek_ahead && lexer->pos < lexer->end - 1 && - lexer->pos[0] == ':' && lexer->pos[1] == ':') { - if (len == 8 && strncmp(str, "ancestor", 8) == 0) return TOK_ANCESTOR; - if (len == 16 && strncmp(str, "ancestor-or-self", 16) == 0) return TOK_ANCESTOR_OR_SELF; - if (len == 9 && strncmp(str, "attribute", 9) == 0) return TOK_ATTRIBUTE; - if (len == 5 && strncmp(str, "child", 5) == 0) return TOK_CHILD; - if (len == 10 && strncmp(str, "descendant", 10) == 0) return TOK_DESCENDANT; - if (len == 18 && strncmp(str, "descendant-or-self", 18) == 0) return TOK_DESCENDANT_OR_SELF; - if (len == 9 && strncmp(str, "following", 9) == 0) return TOK_FOLLOWING; - if (len == 17 && strncmp(str, "following-sibling", 17) == 0) return TOK_FOLLOWING_SIBLING; - if (len == 9 && strncmp(str, "namespace", 9) == 0) return TOK_NAMESPACE; - if (len == 6 && strncmp(str, "parent", 6) == 0) return TOK_PARENT; - if (len == 9 && strncmp(str, "preceding", 9) == 0) return TOK_PRECEDING; - if (len == 17 && strncmp(str, "preceding-sibling", 17) == 0) return TOK_PRECEDING_SIBLING; - if (len == 4 && strncmp(str, "self", 4) == 0) return TOK_SELF; - } - - /* Check for node type tests (must be followed by '(') */ - if (peek_ahead && lexer->pos < lexer->end && *lexer->pos == '(') { - if (len == 7 && strncmp(str, "comment", 7) == 0) return TOK_COMMENT; - if (len == 4 && strncmp(str, "text", 4) == 0) return TOK_TEXT; - if (len == 4 && strncmp(str, "node", 4) == 0) return TOK_NODE; - if (len == 22 && strncmp(str, "processing-instruction", 22) == 0) - return TOK_PROCESSING_INSTRUCTION; - } - - /* Check for operator keywords (can appear anywhere) */ - if (len == 3 && strncmp(str, "and", 3) == 0) return TOK_AND; - if (len == 2 && strncmp(str, "or", 2) == 0) return TOK_OR; - if (len == 3 && strncmp(str, "div", 3) == 0) return TOK_DIV; - if (len == 3 && strncmp(str, "mod", 3) == 0) return TOK_MOD; - - return TOK_NCNAME; -} - -/* Get next token */ -XPathToken xpath_lexer_next_token(XPathLexer* lexer) { - XPathToken token; - - if (!lexer) { - token.type = TOK_EOF; - token.value = NULL; - token.value_len = 0; - token.line = 0; - token.column = 0; - return token; - } - - skip_whitespace(lexer); - - token.line = lexer->line; - token.column = lexer->column; - - if (lexer->pos >= lexer->end) { - token.type = TOK_EOF; - token.value = lexer->pos; - token.value_len = 0; - return token; - } - - char c = *lexer->pos; - - /* Single character tokens */ - switch (c) { - case '@': - token.type = TOK_AT; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '(': - token.type = TOK_LPAREN; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case ')': - token.type = TOK_RPAREN; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '[': - token.type = TOK_LBRACKET; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case ']': - token.type = TOK_RBRACKET; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case ',': - token.type = TOK_COMMA; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '+': - token.type = TOK_PLUS; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '-': - token.type = TOK_MINUS; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '*': - token.type = TOK_STAR; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - - case '|': - token.type = TOK_PIPE; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - /* Multi-character tokens */ - - /* Slash and double slash */ - if (c == '/') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == '/') { - token.type = TOK_DOUBLE_SLASH; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - token.type = TOK_SLASH; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - /* Dot and double dot */ - if (c == '.') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == '.') { - token.type = TOK_DOUBLE_DOT; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - /* Check if it's a number like .5 */ - if (lexer->pos + 1 < lexer->end && isdigit((unsigned char)lexer->pos[1])) { - goto parse_number; - } - token.type = TOK_DOT; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - /* Colon (for :: and QNames) */ - if (c == ':') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == ':') { - token.type = TOK_DOUBLE_COLON; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - /* Single colon is handled as part of QName */ - if (lexer->input && lexer->pos >= lexer->input) { - size_t byte_offset = lexer->pos - lexer->input; - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Unexpected ':' character in XPath expression", - lexer->input, - byte_offset, - lexer->line, - lexer->column - ); - } - - snprintf(lexer->error_msg, sizeof(lexer->error_msg), - "Unexpected character ':' at line %d, column %d", - lexer->line, lexer->column); - token.type = TOK_EOF; /* Error token */ - token.value = lexer->pos; - token.value_len = 0; - return token; - } - - /* Comparison operators */ - if (c == '=') { - token.type = TOK_EQUALS; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - if (c == '!') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == '=') { - token.type = TOK_NOT_EQUALS; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - if (lexer->input && lexer->pos >= lexer->input) { - size_t byte_offset = lexer->pos - lexer->input; - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Unexpected '!' character (did you mean '!='?)", - lexer->input, - byte_offset, - lexer->line, - lexer->column - ); - } - - snprintf(lexer->error_msg, sizeof(lexer->error_msg), - "Unexpected character '!' at line %d, column %d", - lexer->line, lexer->column); - token.type = TOK_EOF; /* Error token */ - token.value = lexer->pos; - token.value_len = 0; - return token; - } - - if (c == '<') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == '=') { - token.type = TOK_LE; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - token.type = TOK_LT; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - if (c == '>') { - if (lexer->pos + 1 < lexer->end && lexer->pos[1] == '=') { - token.type = TOK_GE; - token.value = lexer->pos; - token.value_len = 2; - lexer->pos += 2; - lexer->column += 2; - return token; - } - token.type = TOK_GT; - token.value = lexer->pos; - token.value_len = 1; - lexer->pos++; - lexer->column++; - return token; - } - - /* String literals */ - if (c == '\'' || c == '"') { - char quote = c; - const char* start = lexer->pos; - lexer->pos++; - lexer->column++; - - while (lexer->pos < lexer->end && *lexer->pos != quote) { - if (*lexer->pos == '\n') { - lexer->line++; - lexer->column = 1; - } else { - lexer->column++; - } - lexer->pos++; - } - - if (lexer->pos >= lexer->end) { - if (lexer->input && start >= lexer->input) { - size_t byte_offset = start - lexer->input; - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Unterminated string literal", - lexer->input, - byte_offset, - token.line, - token.column - ); - } - - snprintf(lexer->error_msg, sizeof(lexer->error_msg), - "Unterminated string literal at line %d", token.line); - token.type = TOK_EOF; /* Error token */ - token.value = start; - token.value_len = 0; - return token; - } - - lexer->pos++; /* Skip closing quote */ - lexer->column++; - - token.type = TOK_STRING; - token.value = start; - token.value_len = lexer->pos - start; - return token; - } - - /* Numbers */ -parse_number: - if (isdigit((unsigned char)c) || c == '.') { - const char* start = lexer->pos; - - while (lexer->pos < lexer->end && - (isdigit((unsigned char)*lexer->pos) || *lexer->pos == '.')) { - lexer->pos++; - lexer->column++; - } - - token.type = TOK_NUMBER; - token.value = start; - token.value_len = lexer->pos - start; - return token; - } - - /* NCNames and QNames (and keywords) */ - if (is_ncname_start(c)) { - const char* start = lexer->pos; - - while (lexer->pos < lexer->end && is_ncname_char(*lexer->pos)) { - lexer->pos++; - lexer->column++; - } - - size_t len = lexer->pos - start; - - /* Check for QName (prefix:localname) */ - if (lexer->pos < lexer->end && *lexer->pos == ':' && - lexer->pos + 1 < lexer->end && lexer->pos[1] != ':') { /* Not :: */ - - lexer->pos++; /* Skip : */ - lexer->column++; - - if (is_ncname_start(*lexer->pos)) { - while (lexer->pos < lexer->end && is_ncname_char(*lexer->pos)) { - lexer->pos++; - lexer->column++; - } - - token.type = TOK_QNAME; - token.value = start; - token.value_len = lexer->pos - start; - return token; - } - } - - /* Check for keywords */ - token.type = check_keyword(start, len, 1, lexer); - token.value = start; - token.value_len = len; - return token; - } - - /* Invalid character */ - if (lexer->input && lexer->pos >= lexer->input) { - size_t byte_offset = lexer->pos - lexer->input; - char msg[256]; - snprintf(msg, sizeof(msg), - "Invalid character '%c' in XPath expression", - c); - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - msg, - lexer->input, - byte_offset, - lexer->line, - lexer->column - ); - } - - snprintf(lexer->error_msg, sizeof(lexer->error_msg), - "Invalid character '%c' at line %d, column %d", - c, lexer->line, lexer->column); - token.type = TOK_EOF; /* Error token */ - token.value = lexer->pos; - token.value_len = 0; - return token; -} - -/* Get error message */ -const char* xpath_lexer_error(XPathLexer* lexer) { - return lexer ? lexer->error_msg : "NULL lexer"; -} - -/* Convert token type to string */ -const char* xpath_token_type_to_string(XPathTokenType type) { - if (type >= 0 && type < sizeof(xpath_token_type_names) / sizeof(xpath_token_type_names[0])) { - return xpath_token_type_names[type]; - } - return "UNKNOWN"; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/lexer.h b/ext/taurus/lib/src/xpath/lexer.h deleted file mode 100644 index d044367..0000000 --- a/ext/taurus/lib/src/xpath/lexer.h +++ /dev/null @@ -1,25 +0,0 @@ -/* lexer.h - XPath lexer public API - * Copyright (c) 2024, Ribose Inc. - */ - -#ifndef XPATH_LEXER_H -#define XPATH_LEXER_H - -#include "xpath_internal.h" - -/* Create new lexer */ -XPathLexer* xpath_lexer_new(const char* input, size_t len); - -/* Free lexer resources */ -void xpath_lexer_free(XPathLexer* lexer); - -/* Get next token (returns token by value, value field points into input) */ -XPathToken xpath_lexer_next_token(XPathLexer* lexer); - -/* Get error message */ -const char* xpath_lexer_error(XPathLexer* lexer); - -/* Convert token type to string (for debugging) */ -const char* xpath_token_type_to_string(XPathTokenType type); - -#endif /* XPATH_LEXER_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/parser.c b/ext/taurus/lib/src/xpath/parser.c deleted file mode 100644 index 065c26e..0000000 --- a/ext/taurus/lib/src/xpath/parser.c +++ /dev/null @@ -1,1275 +0,0 @@ -/* parser.c - XPath parser implementation - * Copyright (c) 2024, Ribose Inc. - * - * Pure C implementation of XPath 1.0 parser. - * Uses token buffer for lookahead (matches taurus_internal.h). - */ - -#include "parser.h" -#include "lexer.h" -#include "../taurus_internal.h" -#include -#include -#include - -/* ============================================================================ - * Forward Declarations - * ============================================================================ */ - -/* Expression parsers (precedence order) */ -static XPathASTNode* parse_expr(XPathParser* parser); -static XPathASTNode* parse_or_expr(XPathParser* parser); -static XPathASTNode* parse_and_expr(XPathParser* parser); -static XPathASTNode* parse_equality_expr(XPathParser* parser); -static XPathASTNode* parse_relational_expr(XPathParser* parser); -static XPathASTNode* parse_additive_expr(XPathParser* parser); -static XPathASTNode* parse_multiplicative_expr(XPathParser* parser); -static XPathASTNode* parse_unary_expr(XPathParser* parser); -static XPathASTNode* parse_union_expr(XPathParser* parser); - -/* Path parsers */ -static XPathASTNode* parse_path_expr(XPathParser* parser); -static XPathASTNode* parse_filter_expr(XPathParser* parser); -static XPathASTNode* parse_primary_expr(XPathParser* parser); -static XPathASTNode* parse_location_path(XPathParser* parser); -static XPathASTNode* parse_relative_location_path(XPathParser* parser); -static XPathASTNode* parse_step(XPathParser* parser); - -/* Node test and predicate parsers */ -static XPathASTNode* parse_node_test(XPathParser* parser); -static XPathASTNode* parse_predicate(XPathParser* parser); -static XPathASTNode* parse_function_call(XPathParser* parser, const char* name, size_t name_len); - -/* Token management */ -static void advance_token(XPathParser* parser); -static XPathToken* peek_token(XPathParser* parser, int offset); -static XPathToken* current_token(XPathParser* parser); -static int current_token_is(XPathParser* parser, XPathTokenType type); -static int match_token(XPathParser* parser, XPathTokenType type); -static int consume_token(XPathParser* parser, XPathTokenType type, const char* error_msg); - -/* AST helpers */ -static char* token_to_string(const XPathToken* token); -static XPathASTNode* create_operator_node(XPathOperatorType op_type, - XPathASTNode* left, - XPathASTNode* right); - -/* ============================================================================ - * Parser Lifecycle - * ============================================================================ */ - -XPathParser* xpath_parser_new(const char* input, size_t len) { - if (!input) return NULL; - - XPathParser* parser = TAURUS_ALLOC(XPathParser); - if (!parser) return NULL; - - parser->lexer = xpath_lexer_new(input, len); - if (!parser->lexer) { - TAURUS_FREE(parser); - return NULL; - } - - parser->tokens = NULL; - parser->token_count = 0; - parser->token_pos = 0; - parser->error_msg[0] = '\0'; - - /* Tokenize entire input into array */ - size_t capacity = 16; - parser->tokens = TAURUS_ALLOC_N(XPathToken, capacity); - if (!parser->tokens) { - xpath_lexer_free(parser->lexer); - TAURUS_FREE(parser); - return NULL; - } - - /* Read all tokens */ - while (1) { - XPathToken tok = xpath_lexer_next_token(parser->lexer); - - /* Grow array if needed */ - if (parser->token_count >= capacity) { - capacity *= 2; - XPathToken* new_tokens = TAURUS_REALLOC_N(parser->tokens, XPathToken, capacity); - if (!new_tokens) { - TAURUS_FREE(parser->tokens); - xpath_lexer_free(parser->lexer); - TAURUS_FREE(parser); - return NULL; - } - parser->tokens = new_tokens; - } - - parser->tokens[parser->token_count++] = tok; - - if (tok.type == TOK_EOF) break; - } - - return parser; -} - -void xpath_parser_free(XPathParser* parser) { - if (!parser) return; - if (parser->tokens) { - TAURUS_FREE(parser->tokens); - } - if (parser->lexer) { - xpath_lexer_free(parser->lexer); - } - TAURUS_FREE(parser); -} - -const char* xpath_parser_error(XPathParser* parser) { - if (!parser) return "Invalid parser"; - return parser->error_msg[0] ? parser->error_msg : NULL; -} - -/* ============================================================================ - * AST Node Management - * ============================================================================ */ - -static XPathASTNode* ast_node_new(XPathASTType type) { - XPathASTNode* node = TAURUS_ALLOC(XPathASTNode); - if (!node) return NULL; - - node->type = type; - node->value = NULL; - node->number_value = 0.0; - node->children = NULL; - node->child_count = 0; - node->child_capacity = 0; - - /* Initialize namespace support fields (v0.8.0) */ - node->prefix = NULL; - node->local_name = NULL; - - return node; -} - -void ast_node_free(XPathASTNode* node) { - if (!node) return; - - if (node->value) { - TAURUS_FREE(node->value); - } - - /* Free namespace support fields (v0.8.0) */ - if (node->prefix) { - TAURUS_FREE(node->prefix); - } - if (node->local_name) { - TAURUS_FREE(node->local_name); - } - - if (node->children) { - for (size_t i = 0; i < node->child_count; i++) { - ast_node_free(node->children[i]); - } - TAURUS_FREE(node->children); - } - - TAURUS_FREE(node); -} - -static void ast_node_add_child(XPathASTNode* parent, XPathASTNode* child) { - if (!parent || !child) return; - - /* Resize if needed */ - if (parent->child_count >= parent->child_capacity) { - size_t new_capacity = parent->child_capacity == 0 ? 4 : parent->child_capacity * 2; - XPathASTNode** new_children = TAURUS_REALLOC_N(parent->children, XPathASTNode*, new_capacity); - if (!new_children) return; - parent->children = new_children; - parent->child_capacity = new_capacity; - } - - parent->children[parent->child_count++] = child; -} - -/* ============================================================================ - * Token Management - * ============================================================================ */ - -static XPathToken* current_token(XPathParser* parser) { - if (!parser || parser->token_pos >= parser->token_count) return NULL; - return &parser->tokens[parser->token_pos]; -} - -static void advance_token(XPathParser* parser) { - if (!parser) return; - if (parser->token_pos < parser->token_count) { - parser->token_pos++; - } -} - -static XPathToken* peek_token(XPathParser* parser, int offset) { - if (!parser) return NULL; - size_t pos = parser->token_pos + offset; - if (pos >= parser->token_count) return NULL; - return &parser->tokens[pos]; -} - -static int current_token_is(XPathParser* parser, XPathTokenType type) { - XPathToken* tok = current_token(parser); - return tok && (int)tok->type == (int)type; -} - -static int match_token(XPathParser* parser, XPathTokenType type) { - if (!parser) return 0; - if (current_token_is(parser, type)) { - advance_token(parser); - return 1; - } - return 0; -} - -static int consume_token(XPathParser* parser, XPathTokenType type, const char* error_msg) { - if (!parser) return 0; - XPathToken* tok = current_token(parser); - if (tok && (int)tok->type == (int)type) { - advance_token(parser); - return 1; - } - if (tok && parser->lexer && parser->lexer->input) { - /* Calculate byte offset from token position */ - size_t byte_offset = (tok->value && tok->value >= parser->lexer->input) - ? tok->value - parser->lexer->input - : 0; - - /* Build detailed error message */ - char detailed_msg[512]; - snprintf(detailed_msg, sizeof(detailed_msg), - "%s (got %s)", - error_msg, - xpath_token_type_to_string(tok->type)); - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - detailed_msg, - parser->lexer->input, - byte_offset, - tok->line, - tok->column - ); - - /* Also store in parser for legacy compatibility */ - snprintf(parser->error_msg, sizeof(parser->error_msg), - "%s at line %d, column %d (got %s)", - error_msg, tok->line, tok->column, - xpath_token_type_to_string(tok->type)); - } else if (parser->lexer && parser->lexer->input) { - size_t byte_offset = (parser->lexer->end && parser->lexer->end >= parser->lexer->input) - ? parser->lexer->end - parser->lexer->input - : 0; - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - error_msg, - parser->lexer->input, - byte_offset, - parser->lexer->line, - parser->lexer->column - ); - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "%s at EOF", error_msg); - } else { - /* Fallback: set error without context */ - snprintf(parser->error_msg, sizeof(parser->error_msg), - "%s", error_msg); - } - return 0; -} - -/* ============================================================================ - * Helper Functions - * ============================================================================ */ - -static char* token_to_string(const XPathToken* token) { - if (!token || token->value_len == 0) return NULL; - - char* str = TAURUS_ALLOC_N(char, token->value_len + 1); - if (!str) return NULL; - - memcpy(str, token->value, token->value_len); - str[token->value_len] = '\0'; - return str; -} - -static XPathASTNode* create_operator_node(XPathOperatorType op_type, - XPathASTNode* left, - XPathASTNode* right) { - XPathASTNode* node = ast_node_new(XPATH_AST_OPERATOR); - if (!node) { - ast_node_free(left); - ast_node_free(right); - return NULL; - } - - node->number_value = (double)op_type; - ast_node_add_child(node, left); - ast_node_add_child(node, right); - return node; -} - -/* ============================================================================ - * Main Parser Entry Point - * ============================================================================ */ - -static XPathASTNode* parse_expr(XPathParser* parser) { - return parse_or_expr(parser); -} - -XPathASTNode* xpath_parse(XPathParser* parser) { - if (!parser) return NULL; - - XPathASTNode* ast = parse_expr(parser); - - if (ast && !current_token_is(parser, TOK_EOF)) { - XPathToken* tok = current_token(parser); - if (tok && parser->lexer && parser->lexer->input) { - size_t byte_offset = (tok->value && tok->value >= parser->lexer->input) - ? tok->value - parser->lexer->input - : 0; - char msg[256]; - snprintf(msg, sizeof(msg), - "Unexpected token after expression: %s", - xpath_token_type_to_string(tok->type)); - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - msg, - parser->lexer->input, - byte_offset, - tok->line, - tok->column - ); - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Unexpected token after expression: %s at line %d, column %d", - xpath_token_type_to_string(tok->type), - tok->line, tok->column); - } else { - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Unexpected token after expression"); - } - ast_node_free(ast); - return NULL; - } - - return ast; -} - -/* ============================================================================ - * Expression Parsers (Operator Precedence) - * ============================================================================ */ - -/* Parse OR expressions: AndExpr ( 'or' AndExpr )* */ -static XPathASTNode* parse_or_expr(XPathParser* parser) { - if (!parser) return NULL; - - XPathASTNode* left = parse_and_expr(parser); - if (!left) return NULL; - - while (current_token_is(parser, TOK_OR)) { - advance_token(parser); - XPathASTNode* right = parse_and_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(XPATH_OP_OR, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse AND expressions: EqualityExpr ( 'and' EqualityExpr )* */ -static XPathASTNode* parse_and_expr(XPathParser* parser) { - if (!parser) return NULL; - - XPathASTNode* left = parse_equality_expr(parser); - if (!left) return NULL; - - while (current_token_is(parser, TOK_AND)) { - advance_token(parser); - XPathASTNode* right = parse_equality_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(XPATH_OP_AND, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse equality expressions: RelationalExpr ( ('=' | '!=') RelationalExpr )* */ -static XPathASTNode* parse_equality_expr(XPathParser* parser) { - if (!parser) return NULL; - - XPathASTNode* left = parse_relational_expr(parser); - if (!left) return NULL; - - while (1) { - XPathOperatorType op_type; - - if (current_token_is(parser, TOK_EQUALS)) { - op_type = XPATH_OP_EQUAL; - } else if (current_token_is(parser, TOK_NOT_EQUALS)) { - op_type = XPATH_OP_NOT_EQUAL; - } else { - break; - } - - advance_token(parser); - XPathASTNode* right = parse_relational_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(op_type, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse relational expressions: AdditiveExpr ( ('<' | '>' | '<=' | '>=') AdditiveExpr )* */ -static XPathASTNode* parse_relational_expr(XPathParser* parser) { - XPathASTNode* left = parse_additive_expr(parser); - if (!left) return NULL; - - while (1) { - XPathOperatorType op_type; - - if (current_token_is(parser, TOK_LT)) { - op_type = XPATH_OP_LESS; - } else if (current_token_is(parser, TOK_LE)) { - op_type = XPATH_OP_LESS_EQUAL; - } else if (current_token_is(parser, TOK_GT)) { - op_type = XPATH_OP_GREATER; - } else if (current_token_is(parser, TOK_GE)) { - op_type = XPATH_OP_GREATER_EQUAL; - } else { - break; - } - - advance_token(parser); - XPathASTNode* right = parse_additive_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(op_type, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse additive expressions: MultiplicativeExpr ( ('+' | '-') MultiplicativeExpr )* */ -static XPathASTNode* parse_additive_expr(XPathParser* parser) { - XPathASTNode* left = parse_multiplicative_expr(parser); - if (!left) return NULL; - - while (1) { - XPathOperatorType op_type; - - if (current_token_is(parser, TOK_PLUS)) { - op_type = XPATH_OP_PLUS; - } else if (current_token_is(parser, TOK_MINUS)) { - op_type = XPATH_OP_MINUS; - } else { - break; - } - - advance_token(parser); - XPathASTNode* right = parse_multiplicative_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(op_type, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse multiplicative expressions: UnaryExpr ( ('*' | 'div' | 'mod') UnaryExpr )* */ -static XPathASTNode* parse_multiplicative_expr(XPathParser* parser) { - XPathASTNode* left = parse_unary_expr(parser); - if (!left) return NULL; - - while (1) { - XPathOperatorType op_type; - - if (current_token_is(parser, TOK_STAR)) { - op_type = XPATH_OP_MULTIPLY; - } else if (current_token_is(parser, TOK_DIV)) { - op_type = XPATH_OP_DIV; - } else if (current_token_is(parser, TOK_MOD)) { - op_type = XPATH_OP_MOD; - } else { - break; - } - - advance_token(parser); - XPathASTNode* right = parse_unary_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(op_type, left, right); - if (!left) return NULL; - } - - return left; -} - -/* Parse unary expressions: '-' UnaryExpr | UnionExpr */ -static XPathASTNode* parse_unary_expr(XPathParser* parser) { - if (current_token_is(parser, TOK_MINUS)) { - advance_token(parser); - XPathASTNode* expr = parse_unary_expr(parser); - if (!expr) return NULL; - - XPathASTNode* node = ast_node_new(XPATH_AST_OPERATOR); - if (!node) { - ast_node_free(expr); - return NULL; - } - - node->number_value = (double)XPATH_OP_NEGATION; - ast_node_add_child(node, expr); - return node; - } - - return parse_union_expr(parser); -} - -/* Parse union expressions: PathExpr ( '|' PathExpr )* */ -static XPathASTNode* parse_union_expr(XPathParser* parser) { - XPathASTNode* left = parse_path_expr(parser); - if (!left) return NULL; - - while (current_token_is(parser, TOK_PIPE)) { - advance_token(parser); - XPathASTNode* right = parse_path_expr(parser); - if (!right) { - ast_node_free(left); - return NULL; - } - - left = create_operator_node(XPATH_OP_UNION, left, right); - if (!left) return NULL; - } - - return left; -} - -/* ============================================================================ - * Path Parsers - * ============================================================================ */ - -/* Parse path expressions */ -static XPathASTNode* parse_path_expr(XPathParser* parser) { - /* Check if it starts with location path indicator */ - if (current_token_is(parser, TOK_SLASH) || - current_token_is(parser, TOK_DOUBLE_SLASH) || - current_token_is(parser, TOK_AT) || - current_token_is(parser, TOK_DOT) || - current_token_is(parser, TOK_DOUBLE_DOT) || - current_token_is(parser, TOK_STAR) || - (current_token(parser) && current_token(parser)->type >= TOK_ANCESTOR && - current_token(parser)->type <= TOK_SELF)) { - return parse_location_path(parser); - } - - /* Check for relative paths starting with NCName/QName */ - if (current_token_is(parser, TOK_NCNAME) || current_token_is(parser, TOK_QNAME)) { - XPathToken* next = peek_token(parser, 1); - - /* If followed by '(', it's a function call */ - if (next && next->type != TOK_LPAREN) { - return parse_location_path(parser); - } - } - - /* Try filter expression */ - XPathASTNode* expr = parse_filter_expr(parser); - if (!expr) return NULL; - - /* Check for path continuation */ - if (current_token_is(parser, TOK_SLASH) || current_token_is(parser, TOK_DOUBLE_SLASH)) { - XPathASTNode* path = ast_node_new(XPATH_AST_PATH_EXPR); - if (!path) { - ast_node_free(expr); - return NULL; - } - - ast_node_add_child(path, expr); - - int is_double = current_token_is(parser, TOK_DOUBLE_SLASH); - advance_token(parser); - - XPathASTNode* rel_path = parse_relative_location_path(parser); - if (!rel_path) { - ast_node_free(path); - return NULL; - } - - if (is_double) { - XPathASTNode* desc_step = ast_node_new(XPATH_AST_STEP); - if (desc_step) { - desc_step->value = taurus_strdup("descendant-or-self"); - XPathASTNode* node_test = ast_node_new(XPATH_AST_NODE_TEST_TYPE); - if (node_test) { - node_test->value = taurus_strdup("node"); - } - ast_node_add_child(desc_step, node_test); - ast_node_add_child(path, desc_step); - } - } - - ast_node_add_child(path, rel_path); - return path; - } - - return expr; -} - -/* Parse filter expressions */ -static XPathASTNode* parse_filter_expr(XPathParser* parser) { - XPathASTNode* expr = parse_primary_expr(parser); - if (!expr) return NULL; - - /* Parse predicates */ - while (current_token_is(parser, TOK_LBRACKET)) { - XPathASTNode* pred = parse_predicate(parser); - if (!pred) { - ast_node_free(expr); - return NULL; - } - - XPathASTNode* filter = ast_node_new(XPATH_AST_PREDICATE); - if (!filter) { - ast_node_free(expr); - ast_node_free(pred); - return NULL; - } - - ast_node_add_child(filter, expr); - ast_node_add_child(filter, pred); - expr = filter; - } - - return expr; -} - -/* Parse primary expressions: NUMBER | STRING | FunctionCall | '(' Expr ')' */ -static XPathASTNode* parse_primary_expr(XPathParser* parser) { - XPathToken* tok = current_token(parser); - if (!tok) { - if (parser->lexer && parser->lexer->input) { - size_t byte_offset = (parser->lexer->end && parser->lexer->end >= parser->lexer->input) - ? parser->lexer->end - parser->lexer->input - : 0; - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Unexpected end of XPath expression", - parser->lexer->input, - byte_offset, - parser->lexer->line, - parser->lexer->column - ); - } - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Unexpected EOF in primary expression"); - return NULL; - } - - /* Number literal */ - if (tok->type == TOK_NUMBER) { - XPathASTNode* node = ast_node_new(XPATH_AST_NUMBER); - if (!node) return NULL; - - char* num_str = token_to_string(tok); - if (num_str) { - node->number_value = strtod(num_str, NULL); - TAURUS_FREE(num_str); - } - advance_token(parser); - return node; - } - - /* String literal */ - if (tok->type == TOK_STRING) { - XPathASTNode* node = ast_node_new(XPATH_AST_STRING); - if (!node) return NULL; - - /* Remove quotes */ - if (tok->value_len >= 2) { - size_t len = tok->value_len - 2; - node->value = TAURUS_ALLOC_N(char, len + 1); - if (node->value) { - memcpy(node->value, tok->value + 1, len); - node->value[len] = '\0'; - } - } - advance_token(parser); - return node; - } - - /* Parenthesized expression */ - if (tok->type == TOK_LPAREN) { - advance_token(parser); - XPathASTNode* expr = parse_expr(parser); - if (!expr) return NULL; - - if (!consume_token(parser, TOK_RPAREN, "Expected ')' after expression")) { - ast_node_free(expr); - return NULL; - } - return expr; - } - - /* Function call with node type tokens */ - if (tok->type >= TOK_COMMENT && tok->type <= TOK_NODE) { - XPathToken name_token = *tok; - XPathToken* next = peek_token(parser, 1); - - if (next && next->type == TOK_LPAREN) { - advance_token(parser); - return parse_function_call(parser, name_token.value, name_token.value_len); - } - } - - /* Function call with NCName/QName */ - if (tok->type == TOK_NCNAME || tok->type == TOK_QNAME) { - XPathToken name_token = *tok; - XPathToken* next = peek_token(parser, 1); - - if (next && next->type == TOK_LPAREN) { - advance_token(parser); - return parse_function_call(parser, name_token.value, name_token.value_len); - } - } - - if (parser->lexer && parser->lexer->input && tok->value) { - size_t byte_offset = (tok->value >= parser->lexer->input) - ? tok->value - parser->lexer->input - : 0; - char msg[256]; - snprintf(msg, sizeof(msg), - "Unexpected token in primary expression: %s", - xpath_token_type_to_string(tok->type)); - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - msg, - parser->lexer->input, - byte_offset, - tok->line, - tok->column - ); - } - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Unexpected token %s at line %d, column %d in primary expression", - xpath_token_type_to_string(tok->type), - tok->line, tok->column); - return NULL; -} - -/* Parse function call */ -static XPathASTNode* parse_function_call(XPathParser* parser, const char* name, size_t name_len) { - XPathASTNode* node = ast_node_new(XPATH_AST_FUNCTION_CALL); - if (!node) return NULL; - - node->value = TAURUS_ALLOC_N(char, name_len + 1); - if (node->value) { - memcpy(node->value, name, name_len); - node->value[name_len] = '\0'; - } - - if (!consume_token(parser, TOK_LPAREN, "Expected '(' after function name")) { - ast_node_free(node); - return NULL; - } - - /* Parse arguments */ - if (!current_token_is(parser, TOK_RPAREN)) { - do { - XPathASTNode* arg = parse_expr(parser); - if (!arg) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, arg); - } while (match_token(parser, TOK_COMMA)); - } - - if (!consume_token(parser, TOK_RPAREN, "Expected ')' after function arguments")) { - ast_node_free(node); - return NULL; - } - - return node; -} - -/* ============================================================================ - * Location Path Parsers - * ============================================================================ */ - -/* Parse location path */ -static XPathASTNode* parse_location_path(XPathParser* parser) { - XPathASTNode* node; - - /* Absolute path starting with / */ - if (current_token_is(parser, TOK_SLASH)) { - advance_token(parser); - - node = ast_node_new(XPATH_AST_ABSOLUTE_PATH); - if (!node) return NULL; - - /* If followed by a step, parse relative path */ - if (!current_token_is(parser, TOK_EOF) && - !current_token_is(parser, TOK_RPAREN) && - !current_token_is(parser, TOK_RBRACKET) && - !current_token_is(parser, TOK_PIPE)) { - - XPathASTNode* rel = parse_relative_location_path(parser); - if (!rel) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, rel); - } - - return node; - } - - /* Absolute path starting with // */ - if (current_token_is(parser, TOK_DOUBLE_SLASH)) { - advance_token(parser); - - node = ast_node_new(XPATH_AST_ABSOLUTE_PATH); - if (!node) return NULL; - - /* Optimization: double-slash followed by star should be a single descendant-or-self::* step, - * not two steps (descendant-or-self::node() + child::*). - * This matches how most XPath implementations handle double-slash-star for efficiency. */ - if (current_token_is(parser, TOK_STAR)) { - /* Create single step: descendant-or-self::* */ - XPathASTNode* desc_step = ast_node_new(XPATH_AST_STEP); - if (!desc_step) { - ast_node_free(node); - return NULL; - } - desc_step->value = taurus_strdup("descendant-or-self"); - - /* Use wildcard node test instead of node() */ - XPathASTNode* node_test = ast_node_new(XPATH_AST_NODE_TEST_ALL); - if (!node_test) { - ast_node_free(desc_step); - ast_node_free(node); - return NULL; - } - ast_node_add_child(desc_step, node_test); - - /* Consume the * token */ - advance_token(parser); - - /* Parse predicates (FIX: was missing before!) */ - while (current_token_is(parser, TOK_LBRACKET)) { - XPathASTNode* pred = parse_predicate(parser); - if (!pred) { - ast_node_free(desc_step); - ast_node_free(node); - return NULL; - } - ast_node_add_child(desc_step, pred); - } - - ast_node_add_child(node, desc_step); - - return node; - } - - /* General case: Add descendant-or-self::node() step */ - XPathASTNode* desc_step = ast_node_new(XPATH_AST_STEP); - if (!desc_step) { - ast_node_free(node); - return NULL; - } - - desc_step->value = taurus_strdup("descendant-or-self"); - XPathASTNode* node_test = ast_node_new(XPATH_AST_NODE_TEST_TYPE); - if (!node_test) { - ast_node_free(desc_step); - ast_node_free(node); - return NULL; - } - node_test->value = taurus_strdup("node"); - ast_node_add_child(desc_step, node_test); - ast_node_add_child(node, desc_step); - - /* Parse relative path */ - XPathASTNode* rel = parse_relative_location_path(parser); - if (!rel) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, rel); - - return node; - } - - /* Relative path */ - XPathASTNode* rel = parse_relative_location_path(parser); - if (!rel) return NULL; - - /* Unwrap single-step relative paths */ - if (rel->type == XPATH_AST_RELATIVE_PATH && rel->child_count == 1) { - XPathASTNode* single_step = rel->children[0]; - rel->children[0] = NULL; - rel->child_count = 0; - ast_node_free(rel); - return single_step; - } - - return rel; -} - -/* Parse relative location path */ -static XPathASTNode* parse_relative_location_path(XPathParser* parser) { - XPathASTNode* node = ast_node_new(XPATH_AST_RELATIVE_PATH); - if (!node) return NULL; - - /* Parse first step */ - XPathASTNode* step = parse_step(parser); - if (!step) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, step); - - /* Parse additional steps */ - while (current_token_is(parser, TOK_SLASH) || current_token_is(parser, TOK_DOUBLE_SLASH)) { - int is_double = current_token_is(parser, TOK_DOUBLE_SLASH); - advance_token(parser); - - if (is_double) { - /* Insert descendant-or-self::node() step */ - XPathASTNode* desc_step = ast_node_new(XPATH_AST_STEP); - if (!desc_step) { - ast_node_free(node); - return NULL; - } - desc_step->value = taurus_strdup("descendant-or-self"); - XPathASTNode* node_test = ast_node_new(XPATH_AST_NODE_TEST_TYPE); - if (node_test) { - node_test->value = taurus_strdup("node"); - } - ast_node_add_child(desc_step, node_test); - ast_node_add_child(node, desc_step); - } - - step = parse_step(parser); - if (!step) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, step); - } - - return node; -} - -/* Parse step */ -static XPathASTNode* parse_step(XPathParser* parser) { - /* Handle abbreviated steps */ - if (current_token_is(parser, TOK_DOT)) { - advance_token(parser); - XPathASTNode* node = ast_node_new(XPATH_AST_STEP); - if (node) { - node->value = taurus_strdup("self"); - XPathASTNode* test = ast_node_new(XPATH_AST_NODE_TEST_ALL); - ast_node_add_child(node, test); - } - return node; - } - - if (current_token_is(parser, TOK_DOUBLE_DOT)) { - advance_token(parser); - XPathASTNode* node = ast_node_new(XPATH_AST_STEP); - if (node) { - node->value = taurus_strdup("parent"); - XPathASTNode* test = ast_node_new(XPATH_AST_NODE_TEST_ALL); - ast_node_add_child(node, test); - } - return node; - } - - /* Handle @ abbreviation */ - if (current_token_is(parser, TOK_AT)) { - advance_token(parser); - XPathASTNode* node = ast_node_new(XPATH_AST_STEP); - if (!node) return NULL; - - node->value = taurus_strdup("attribute"); - - XPathASTNode* test = parse_node_test(parser); - if (!test) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, test); - - /* Parse predicates */ - while (current_token_is(parser, TOK_LBRACKET)) { - XPathASTNode* pred = parse_predicate(parser); - if (!pred) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, pred); - } - - return node; - } - - XPathASTNode* node = ast_node_new(XPATH_AST_STEP); - if (!node) return NULL; - - /* Check for axis specifier */ - char* axis = NULL; - XPathToken* tok = current_token(parser); - - if (tok && tok->type >= TOK_ANCESTOR && tok->type <= TOK_SELF) { - axis = token_to_string(tok); - advance_token(parser); - - if (!consume_token(parser, TOK_DOUBLE_COLON, "Expected '::' after axis name")) { - if (axis) TAURUS_FREE(axis); - ast_node_free(node); - return NULL; - } - } - - node->value = axis ? taurus_strdup(axis) : taurus_strdup("child"); - if (axis) TAURUS_FREE(axis); - - /* Parse node test */ - XPathASTNode* test = parse_node_test(parser); - if (!test) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, test); - - /* Parse predicates */ - while (current_token_is(parser, TOK_LBRACKET)) { - XPathASTNode* pred = parse_predicate(parser); - if (!pred) { - ast_node_free(node); - return NULL; - } - ast_node_add_child(node, pred); - } - - return node; -} - -/* ============================================================================ - * Node Test and Predicate Parsers - * ============================================================================ */ - -/* Parse node test */ -static XPathASTNode* parse_node_test(XPathParser* parser) { - XPathToken* tok = current_token(parser); - if (!tok) { - if (parser->lexer && parser->lexer->input) { - size_t byte_offset = (parser->lexer->end && parser->lexer->end >= parser->lexer->input) - ? parser->lexer->end - parser->lexer->input - : 0; - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Expected node test, got end of expression", - parser->lexer->input, - byte_offset, - parser->lexer->line, - parser->lexer->column - ); - } - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Expected node test at EOF"); - return NULL; - } - - /* Node type tests */ - if (tok->type == TOK_COMMENT || tok->type == TOK_TEXT || - tok->type == TOK_NODE || tok->type == TOK_PROCESSING_INSTRUCTION) { - - XPathASTNode* node = ast_node_new(XPATH_AST_NODE_TEST_TYPE); - if (!node) return NULL; - - node->value = token_to_string(tok); - advance_token(parser); - - if (!consume_token(parser, TOK_LPAREN, "Expected '(' after node type")) { - ast_node_free(node); - return NULL; - } - - if (current_token_is(parser, TOK_STRING)) { - char* arg = token_to_string(current_token(parser)); - if (arg) TAURUS_FREE(arg); - advance_token(parser); - } - - if (!consume_token(parser, TOK_RPAREN, "Expected ')' after node type")) { - ast_node_free(node); - return NULL; - } - - return node; - } - - /* Check for namespace wildcard: prefix:* - * Lexer produces: TOK_NCNAME("prefix") followed by TOK_STAR - * when it sees prefix:* because * is not an ncname_start char */ - if (tok->type == TOK_NCNAME) { - XPathToken* next = peek_token(parser, 1); - - /* Check if next token is * (namespace wildcard pattern) */ - if (next && next->type == TOK_STAR) { - /* This is prefix:* pattern */ - XPathASTNode* node = ast_node_new(XPATH_AST_NODE_TEST_ALL); - if (!node) return NULL; - - /* Set prefix from NCName token */ - node->prefix = token_to_string(tok); - node->value = taurus_strdup("*"); - - advance_token(parser); /* Consume NCName */ - advance_token(parser); /* Consume STAR */ - - return node; - } - /* Otherwise fall through to normal name test handling below */ - } - - /* Wildcard */ - if (tok->type == TOK_STAR) { - advance_token(parser); - return ast_node_new(XPATH_AST_NODE_TEST_ALL); - } - - /* Name test */ - if (tok->type == TOK_NCNAME || tok->type == TOK_QNAME) { - XPathASTNode* node = ast_node_new(XPATH_AST_NODE_TEST_NAME); - if (!node) return NULL; - - /* Get full QName string */ - char* full_name = token_to_string(tok); - if (!full_name) { - ast_node_free(node); - return NULL; - } - - /* Split into prefix and local name (v0.8.0 namespace support) */ - char* colon = strchr(full_name, ':'); - if (colon && tok->type == TOK_QNAME) { - /* Has namespace prefix */ - size_t prefix_len = colon - full_name; - node->prefix = TAURUS_ALLOC_N(char, prefix_len + 1); - if (node->prefix) { - memcpy(node->prefix, full_name, prefix_len); - node->prefix[prefix_len] = '\0'; - } - node->local_name = taurus_strdup(colon + 1); - } else { - /* No prefix - simple NCName */ - node->prefix = NULL; - node->local_name = taurus_strdup(full_name); - } - - node->value = full_name; /* Keep full name for backward compat */ - advance_token(parser); - - return node; - } - - /* v1.1.0: Allow operator keywords as element names in node tests - * This fixes axis::name syntax where name happens to be a keyword - * e.g., ancestor::div, child::mod, parent::and, self::or */ - if (tok->type == TOK_DIV || tok->type == TOK_MOD || - tok->type == TOK_AND || tok->type == TOK_OR) { - XPathASTNode* node = ast_node_new(XPATH_AST_NODE_TEST_NAME); - if (!node) return NULL; - - char* name = token_to_string(tok); - if (!name) { - ast_node_free(node); - return NULL; - } - - node->prefix = NULL; - node->local_name = taurus_strdup(name); - node->value = name; - advance_token(parser); - - return node; - } - - if (parser->lexer && parser->lexer->input && tok->value) { - size_t byte_offset = (tok->value >= parser->lexer->input) - ? tok->value - parser->lexer->input - : 0; - - taurus_set_error_with_context( - TAURUS_ERROR_XPATH_SYNTAX, - "Expected node test", - parser->lexer->input, - byte_offset, - tok->line, - tok->column - ); - } - - snprintf(parser->error_msg, sizeof(parser->error_msg), - "Expected node test at line %d, column %d", - tok->line, tok->column); - return NULL; -} - -/* Parse predicate */ -static XPathASTNode* parse_predicate(XPathParser* parser) { - if (!consume_token(parser, TOK_LBRACKET, "Expected '[' to start predicate")) { - return NULL; - } - - XPathASTNode* expr = parse_expr(parser); - if (!expr) return NULL; - - if (!consume_token(parser, TOK_RBRACKET, "Expected ']' to end predicate")) { - ast_node_free(expr); - return NULL; - } - - return expr; -} \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/parser.h b/ext/taurus/lib/src/xpath/parser.h deleted file mode 100644 index 18a7925..0000000 --- a/ext/taurus/lib/src/xpath/parser.h +++ /dev/null @@ -1,28 +0,0 @@ -/* parser.h - XPath parser public API - * Copyright (c) 2024, Ribose Inc. - */ - -#ifndef XPATH_PARSER_H -#define XPATH_PARSER_H - -#include "xpath_internal.h" - -/* Forward declarations - types already defined in taurus_internal.h */ -/* No need to redefine them here */ - -/* Create new parser */ -XPathParser* xpath_parser_new(const char* input, size_t len); - -/* Free parser resources */ -void xpath_parser_free(XPathParser* parser); - -/* Parse expression into AST (caller owns returned node) */ -XPathASTNode* xpath_parse(XPathParser* parser); - -/* Get error message (returns NULL if no error) */ -const char* xpath_parser_error(XPathParser* parser); - -/* Free AST node and all children recursively */ -void ast_node_free(XPathASTNode* node); - -#endif /* XPATH_PARSER_H */ \ No newline at end of file diff --git a/ext/taurus/lib/src/xpath/xpath_internal.h b/ext/taurus/lib/src/xpath/xpath_internal.h deleted file mode 100644 index 08c20be..0000000 --- a/ext/taurus/lib/src/xpath/xpath_internal.h +++ /dev/null @@ -1,68 +0,0 @@ -/* xpath_internal.h - Internal XPath structures - * Copyright (c) 2024, Ribose Inc. - * INTERNAL HEADER - Not part of public API - */ - -#ifndef XPATH_INTERNAL_H -#define XPATH_INTERNAL_H - -#include "../taurus_internal.h" - -/* XPath token types - Complete set from ext/taurus/lexer_xpath.c */ -typedef enum { - TOK_EOF = 0, - TOK_SLASH, - TOK_DOUBLE_SLASH, - TOK_AT, - TOK_DOT, - TOK_DOUBLE_DOT, - TOK_LPAREN, - TOK_RPAREN, - TOK_LBRACKET, - TOK_RBRACKET, - TOK_COMMA, - TOK_DOUBLE_COLON, - TOK_NCNAME, - TOK_QNAME, - TOK_STRING, - TOK_NUMBER, - TOK_EQUALS, - TOK_NOT_EQUALS, - TOK_LT, - TOK_LE, - TOK_GT, - TOK_GE, - TOK_PLUS, - TOK_MINUS, - TOK_STAR, - TOK_PIPE, - TOK_AND, - TOK_OR, - TOK_DIV, - TOK_MOD, - TOK_ANCESTOR, - TOK_ANCESTOR_OR_SELF, - TOK_ATTRIBUTE, - TOK_CHILD, - TOK_DESCENDANT, - TOK_DESCENDANT_OR_SELF, - TOK_FOLLOWING, - TOK_FOLLOWING_SIBLING, - TOK_NAMESPACE, - TOK_PARENT, - TOK_PRECEDING, - TOK_PRECEDING_SIBLING, - TOK_SELF, - TOK_COMMENT, - TOK_TEXT, - TOK_PROCESSING_INSTRUCTION, - TOK_NODE -} XPathTokenType; - -/* Token type names for debugging */ -extern const char* xpath_token_type_names[]; - -/* Use XPathToken and XPathLexer types from taurus_internal.h */ -/* They are already defined there, no need to redefine */ - -#endif /* XPATH_INTERNAL_H */ \ No newline at end of file diff --git a/lib/libtaurus.dylib b/lib/libtaurus.dylib deleted file mode 100755 index dfd0c30b5fa83a2a2efb7197dc2895c5557284ac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 108224 zcmeFa3wTu3z5l%?6JQc90-0R6m`uP+LcLTakSI2j02UBIL-5x2WP-L%q-rCe0&N)( z+aTH+8*lVNz+RH6wpc@z-VEBF1J$0QwpiP9jsa~OgZYi*w`GtqcbI#WWXACO6K`v3s%KtV zZIk-_vqh8AoM);q-cK)UYLxbyDKpF3AQr}btxCf&r6A8TrsEM2x} zNl#M$`r3CouU>O==sCH*fLkAZw|_M?*W7gDl3oD&*SF=jPQG^MV)UHu-lw`y-;$*_ z*WGxX`?7z1UwGDeQ8U81de2^6$*?M|re@iVx7OWwZB5;cpS#IE_oc_Km)(+XK|S}c z!_8qYqH8C=nwl9E)fF|<=g(W-_m_ zdGAR)m*qWhJ(>=E;cIc>>2S;FS?~<>r+${w1*e}$xx#(>W%@mP{q*XtskydxX>D)$ zf$F=`Lpt?&WqV8Y-XRasn?GB7ZOtvUH;aq=*LP*517Dt7M9<0fCF4w4dg@!W#0o|K z`o7@RmsCm8tr_jM<6VTeS+?G}v*%qrbH;3!J4~z}-rVQ*)0~oe>*lZt66;ca>W5AD zir@T&+NII6KVP?KY3;I`mn}K#<7ZvFoF`j|f0K=giNDld3uVr8pIcV@OcbUOnpJ04 zgU|e!YeSRIT#76W<^EEB`kU$g1o}h#a`+AO*ZB>fDN6Bj9BFFjvNP76oCr?6MFAV$(1OLLnzcBDG z4E*1Kfl!)hduRTyT92&swH}#n8sGN&;_vuP+!V#C($6+c9mcc;FEyV9Uw>jKeGRQREH`pYUcW;`h-kKIG`=jZ4Vn=57`oM+ZZN@ixbh|Mn z_@%+-d^6f-8mhLRWty7P%;cvgnfld7x~m(;hPP!RXj&wyhdr602zcLZ0sfp5%N_4>r|5O=~aPNxPHoFqhTb;Hz&LWvUm` zpT*lJHQt4Lc0=9urFUfvUmx=o?2ZpMjdxO4Yq}Y=j{ep70{fq)Pno{#X9e4Se|lUv zC=9nd*(j^zno4>cx~bxt8qC-qzJ25y zMm}GxD#ZI8)TjJj+iSdh)K{o`>chVe?%=BYvnZFJlz&lD`#$bl$S2xIsW+IEZ^CF( zJ&8WmY@=S~bNe)l>$1(JwI$OuHh{C1fEfkdgPqhv93WUkd-(Oi09WCl$jc9|lt0G1 zN!#I_Q%(KOp{6=?vdP+QOjCH2nS9^Z!mWq=+3}~+{QIBIGS#<2hr`e{uQ^s#Mm;M` z?1c@c<1OW3ED+oQ9|pFX%L;ay`l5+DHUxZQ?@WIv{BAou*+5-6@X-CVnJi>;>c@1s<9c-PNA~jtp?DvgOogz+(e= zScl&CXk~ouW!coVhW5>o?#VUAzn@`jb=b6*LEok|^flx&ld&C*Ybcw{&kdR3M2!It z)Z60HW|ql*_96Py*Z!G!%-1zF3NOkw1$Lh2@%`vkU-s3Tyzq*SAsfdg+rEh8AQY=A z7Viy^r+*tJMH?B&lJR9^N$w}ps*Op$JIAj2si`mKT42D} zsC9i{I&{S^;SX&3%Cy!ax0}Xjx_Q39m$rXjw)Cz;v(>s!ckT+vz$NfodDtB27{YaiIna#WD4%5xtVZ`(Ssr;lHr>Q4k+W>zjSMj*k@Q&A zk(HIePyvrVV||43pgAy1b&fO#!Wmq7uB9$p$8%-2j?MHlojSsUOi3tJ9eL&ezJi5y zHTJ}oo#vEHgRTeB4H3U7X~#|+)&42wKumooG6yzc18mvXoU)aa{TpRtK2s7-(XP!K zaoeGve<5$j7&G~m(cs0O6>q0sd*I!@@cgUr{3~O@Po~?(I}U!HrfN;rA0MTBd(cd_>7PEoQEe;z2c(Cy z-Sp>r(>E!p8Ve=-Ge>3-<@fu#0&(-S_cmkz~6exhp=T9j#9T?((f3c-T-+e z@A8W*|86q%wc@2==D?XQPqpKpm0t;eg7@sHv^K9t-ktp{Lq3%UwsIBP;iH@zLquul9_G3dY|qC-1B}Dd=*Z?bGDve@*Wwo z<#zh&E4YuO%By<6$9wqO*88%reh=-(2Fgpldw|P>VKw*7De_tzwDt1P8Q=kab#TAK z!M%9vG~oySZ%=_ATgQK0(D*bo8t>$r9D{HA%UCQ$+2#~!9Vy^6DfquRMOrLHS|~*u z?J4pFjIR-&^v&V}rH$y#10i3-2HDGkCry0|_N>9`eeB>>kuIf&c{bzAtWE8{-S>P~ zO&a>lk6uehw+>>=Y-dd4*}(6=-~9kKFabZ=agGVc zsvaTVA>{9sFRyNWrP7qOuPNw?`JKA*@Zoa7bpTt?l9RVSZ-{C96XiRGgda77%%h$D z@U|V$5E(=!gYk!{zrdes?c1Ket$0!Gew+H+8J8V?ch!r)n79oaC^-KYo2U2dc(1aJ zl$9R1gXb*T)%}r`GwI_D`Z^u|qOz5~TO639#*2&<)5D1f?JT3b#zYbP3Gmjo(yiCC zl{b9M86P(DE-S{!_SzWhw0WhT$I@oL^IWax ze4a;y6YY$1qNDKxxd!Q1lr*z^X;)`=_XAD%D|)w)aozOp?rP;1%rhwO^xqlVhFzGu zZy#jGw1=+90xv;mpAGE?HCjKRXB<1e%M3AXqWyIIk!JX!ZbC(CfiGi!B{E%yf06-D zlw=3ix1@!)wG1+oqu>hL+!nysDB{{mo+A9Ucg}0rpgj0q*oQ#;N?;~l@Az*^r}g-6 zrvq`=pnz);`1Wm z6aG^i#lzM-_~Teq(8{Z{p8y7zk(Bf+lkuJQx@m$uF-k^)Yz9d?sUl;cjGYelkz?$KSah z0e{5SjtGCJC*dy@Ul#PkpYjZZzlq1d-w#~;eeW3f+c)typO+2XH}PjTynCGwoE~la zB*%>LQ{wOnV|E>0b4KHX$g{_LJCk^?c(%E$d^j-)aM*cu-TTQnEa}ICd(dSb4>G^H zP4e8I2R$6_ChxI$@IQIqktEy4;=yZfW_tU!u)}h}&;^@%taveyAdbmH9-N^_! zKF%V>Dze$d*oq!J!<(BlMoF^SZ^+g`E9nl|?AMD-lWbP=P}A0cu4o`uB>9eEuVdKj z81{N2_PSwE=L-$Qo~0-Mn=&Evb`1NCud>Vh=IIM#nXwDAu;I`Jo0=78-IMjfWVbwf zxX87KS5j9homBo=(?IAI&9zWxU zy!UjGmq+@1U6P+6`zJp`_E51Q`LbzT<$uU`II^;@ym)p`e#e>6R{0OPK7X-G^V7L% zK0tUnh5LVSUm=^{FK(0(s%%y4ei8OAFf5z^zrl>esu%CXm%x8Nu)w!&gVO8X`qGP{ zp?uYYjDz<0GvZ&OZ;BCw@W1!Cur`2)Z-9q&_}-J~XXZ$g@GURy>OYSBusNhCG*6yC z%Du9Jm}IV<3(81Lby^x`X5)IxtZ2DvMF?xNzHW5-l)XI_J` ze4>TE$k$%PH6ufFA8GqvJ#XEH^z7-yc8nZ#d|Sm)A3Y7)f?xTNcFcLuG=}h}O}g*V z;^!;6GIsg9T8W2VPhaLRhL}UWHPCs_83unc09}tAxiEQmKTgJ;C_dV z!(Q>OADh~O?_V&+)GIDhP)3Z9w1Nxq_lS>lK^Mv1Q1Ra|M;42aJ^ZYcwzZA1;~z%C z$JGD9>7r|1Ji_xPoRyKfKOjk z7kyIjt$w?^`j7D6VHc*qkvEKNOFzs4Cg}nT@7H6~EPP3RXA5uzGt7Z&(Bbs&`Ijhb z7$-@lT7V7Tw$X#{MHjwKe{TG8U=XeX!%RYa`x0YS`Mhcqo&RQKgU^nu_rT|WOry?| zHP#Nw*9m4m3f}QsGzaio>ZtMM?%#}jTuh%nR=4=cRrD#syG&>z`V?YkynIiSu6)Jh zD<@wC&ztTHw`RI$z*zI>abi~751)!x9G&9G@Gq$6s4?RsX^pWp&b+}o>Jx02 z0-Jb2vL_v}6MSS0$0z+vMQe9jhBIe6D4h5$ws#?XzV$1gXnYx*Zr}$EcI_Tq-njqu zl`qZ#A2o&W0`l2KKhzf=v{#&Tneb2iuY-1O5S`#V@rs@cZJwO?=gAYwU>P7heL1jk zZ*j!@Z%Tfa4VgNNj|BY{?5ERSGc+YO zbrjs|X@?r!njl`l0bN%Nv8@qrZP3Js*s-o)Ej38*hQO z_$Slc#ArSg(Ot&pVEow&K-Spjgx;C`2#yIX!K$puTid@a?&4) zF<)tY#Vqc#;|sZ0`?oBr1dUE#Zl*8d$sf{Ry?Z4s&+?=}w+a@|yz-v0F;t zgxz`(nDFD;R7Ut*1}|7X9%T~2+op6q;MR8^*T=~_kS~-Q!4Dz^_cT15jSXUbLR(<} z$`@O%N6%#t>mo*60KK=Phl9lPM9&~{FTAu;ZzS8a74^Ym-!b+^WULZ>u@3%ey}s^A z`6_|JonwnHja6lYn{N(i?&zWLibCdP99x_f|A+k7v97NL-+Y~Rnt7I87Ej0?d;AlV z|Ku}?f&7WTP*)h)3mEJQ{n^9(OJHO;L7xt2F2?!?=qLPwL;-evgypTQxb%Gv{S{0( zZhvn8j*j62_t)cft5=w-*+HKz9`W1vFwZZXeOi41XVUMf_%A~IbOCup+m^fTuG%pS z9KC6tgwM7FMxEbieC-z+6T8sk%~^tJv=jFTII-8GWYCkp3(4D#PG|;ys!#rBGx%c; zIgv3G|Bdu=>_R2HAQ?p0ZP|_Plh4Vxc*|k*o^%Cs#%;yegV}Y^6aBXxAG%lf<;15T z1K|N0o z7&}E6J1HJ6_`VIF$Y-l_`9$_wF>zL-6Js;+WWWA$^kal~+tH8fX(MFyqp|w&7I>u& zUQvH!2d{@;3_koiH`cuwdA$`_WP@Ht&!b-~K0Exe3;zslHb9%7BaeSU9zV^yZ)Kg& zItu(6#(zEIM)V8xs+N5$WF9X-JJMBU!0O$r|DO`wu=Rq!H>Tm(6D$9`kHHt?ko%aw zue{IY9WemQSG|6MQ&v1RL+@Rl8k@vRpCG;2m75Og^yEHzTBVKk3$MZ*dkca^$X+?J zm*a2f!RJ)UcTiruCR}PBLSw!<@R&_(S+qJATH(h!GV~GaE&PyrJ^DQSjx&z5_CL}6 zK<}K-Mex{6cx?teHyz%qWK9Wv+%wMHPx72h41N&bWznYex?#;l*C~#St-*KLgN%6d zJ_k?1m$JOxyI%19n~t6n=zb>fd=!4@9oLQT3Y;Px#P}1t7r>?#(QbBjh8@=x_8YB3*?4_`EW#Hq;@7@VL@zE=qIgV+EV$&^2Uyb z@sq=`s;9t7L-PC#>CPIPtoW(4*_;;M_W0$~i#sUKxViPve7BBAr~^J=(?@WxR3bUCxkuocv0ga z$^JU%+A}6RnK3Hqw(Q5#d&Xf)DBC>Dl+=O~;pUg{ZaX?dcEO7=d-YDh?pmFKeeKaH z%pcX_dwKdpbv!~HvQ^&L^OL~c?Ak6HXT~;El6I{5BX6EVw%?mSDxr*IJOJM}Bj?F6 z=3Hc4aB6*?H-F^mj=iq#aCCA`+)KZPIZ98LOi9uur?~A5q)R+}Y(Cg+@lkiMyB8nD z_)_SCWPC)yhw#~cuzRceau~ncnWM^yZ-7TNet6Jcv*P!2?bRKrV^9O}ns_Yx(;6dY z@866JH^2i?GV3f1oqZ8dCJ0RWvU&xR6Gja;^ys7w; zv=_+}X6z}yAo`=bsv3Ux$jv46OXZ*Q%1`K9z6;%Dh&3eJPr|m1qkRQz$NbUG+d>}i1E#t-Z z(T*SeY4|pRzvRRaJU==o{weZAh%x39w8@_u&QlX1zn|Gn<& z72r}ac8}&(x9xCrTP-k7qir+XOeWURCco-J>b5!wyE=h;$z(J5*$Z!Jo>*hx0@8D^ z4a%P*Sm^I{;I*AOiBHj9J2=WBU3hH}JpyKVblBZhMRz}HePbIZqs-NmQ9S;5{lY=i zeLQ~Q1jfGu(obV$FD5AZp{JAS_YVGcd%8ov|2+(yu*v=Dx1T%_|3|0aA165S^ik-i zdFVfaN8$SClyh`qZhRrI$d6jU^}}?b)(;(P9yP~D&A z_O8P4AnUKZ8?ye!3zE&iKGGOFOHY_h?b9Ng*G%ibUP$wv-kPDJ#pp=%_rt`Ui+;?# z=6s14NLMWe*3bvtDdR!!5Zi4+e~R~G@O^~5(y8L-J>W;QP~7=5q&sovocMD3l?g5s zM_&XUXTww0o+xfWoK0=c6Mo+9?uQ@8?>|VJ+2|50Z?rj`ys}ljZ8~c=!=!J-zmY87 zN1Lj*l(hE4-EA$%GrI1m*n#R%{NNC6+|M{(cH(1{330D}sZX*I#iYqbsDBkh*zdqI z@xTM2ahI$JL-UQSchWodlh}60^4`4j(c0aOoU7g8l!>_GCa>M0Zo6Ln<9YUUkdOOR zI_QH!NAKLv7?XHc!sEj)GBy@}HNaQmFXC2ho#JWvd3MgEVZ&>zS7Od&OJV5{%VV|h zSf|!0o$mU;Ylm1r+!u;fy+J#L^jA7mc+5`kZ3|txrSj6j=*6t~c68o8V#LHoC)c^- zQFz-|E0+%P#`#wta>nd4>6>to%lh#S zaQQP}i$N3dh+;F+&3o~ao*=zo@zhe``!VY4#fOuLIU849|mHSTV#3vKXIp+^*cDw#4dE9LKOqnw&qcQZ0{Gv&7r>B$N!zZlw>@;R;0ci%Dc;jii zUKPKn;5mnGPFuZW>vn8oN?bE8j_@wZ9x(zjX-nzCy>Pw;oYz6$ z$;+2@E$!}ZTPIsYOvcA}Bu2gn{XUG`ZiE+O=rujRt!L)HW5hrrN4neo$@4z&FSsMr z6(-N?r1i)BUqdFScP5>+o8*;mL998kgR~6N%6-25b;zt)UfZSj!imjCpL{9$oY4|) zRe8lQr_+zw#A1e`n`?;2EFr#?YR-BWa0&lvyJyZCI(&ov$j?-~iwznn=d6#SGrsrZ z)F+%|VGjx@mrTPB+DI+~tlMN8!{{r;*Eewu(C;Yu#5dyWZ&9CQL;cn}Fa36{sjzbA z@WH*{vIE+xFW?EC;m~a^b}9HdDm1KQi?(>#Y$huYQq?&-eg_f7QO(0|QhGjRp=IivfZFNA#8 zeFr(M|GfH)52yPI(K>Od?Nkkd@ z8SD@KxAvuM{Q|gSz5F)8X-3|dkA6ElG%S)oP#YHi%#UX=x4e`+kxlTg@ZYRGKkO+z z19~h$Rt)=&mJN=TvES^8hNL~HdKd2QE?JmqChwUj-#sh7kTQXAB)^k!A@w#cduwB< z_O2$EYiIAOd`_>O(Uc)=^4mj9LUpPP^HD$TLav@lGxcYaSMq@TG+~o0zXaLyvkaKG zx-hr9Fn1T2Car%K%=ZKH<-pw1v%hcjXuT86x1b{&n1k`6B$$K1d_V1LUtn@M4`#2O zztWCieg~LUr^?*#!Yn-OrwWBd}9juM{lU^J=AUOBjc@q=RT5Vw)Xn-N3ZK`K-bO2?_yR_<3awIm8&=?{3S5o|==*CXaZ*!ij(QsPc1t zh^zJmD1U)Juzxe_gBq}HX8CPhzfznHeJwvl_2-)0^_|e5z?Z#$C;OVS(S=TZ+3|1i z9$B~T{~dlhR=?HmO7bs3-c|lK?nB7=a;}0ucBs3J{g-8WmmGie)`f6h`we()eL}BtP)MKVR^P zcS5!K?TjzbcSo!*_hg{419|h|m;W2E>HbpYTzD6hzKAKNg#M^tOez^qMaxf9&f|#+ z?jy)m%k7`(!Uo-w9B4~G@cl_no+pU|dig5yd5^82pZ659Pg43OWEwU+CU{OZ zB`RBVvQritoUpdOgtau|O?4jpaOHT(YOWniZla9Fk{yF%8}=|SiG67bk7Ms4;|ay? zA0>t&IMs*U)vVLN-xG|r)uws}ed7LrpZlrMr7_I}UpWmKr5~^4qgRD5p0^8M_&!Ui zyQ89ajvxP!HSXp}rpj>!18c*oUpW`NF<&UX6%Df%hdjAvd4Bi#_#O0Hu=s#Q`s7Y@ zTBO|3Q;PM-hARC>+^fASg^y44wr478^VQxzSi4t9TcY87_4mTmG`t1>j`{XBjpb*O zuiY@ekMCEcy-CkAzt5a%j?vg#bKy=Lpfugld&1uY;Art*)rBm-nXDgbKc!e!R{RCv zxQ{lnbBVXo-!O4k`IwJq&=&V=NMk((zDe5RGtai-mH9$0!mfX~@Ld$yi_cIs5}YK#ef8Z)_9kS=}yhruSn+;NaPHBP>#@|29mcb*|1KVK+THP|Wdykm|kve`*Dq%YbWPHaAh zev&tKYOLxj)RTI6UC&_kDsq!ng8lBF~gbrtOcmy`1zkI~<&%2M}rP3ejC zwedLndPh=UZ*u#Z->SAuIGI1yc^FU z|9RxUg?GD2TSERNdPn}Lq#d^RBX2r~>ose)%&T0xbzb4xpUg9B+vfd!?PK%4xAuv7 z|GxI|d284Hbl&3Crm>jcoYm~{XZ~aR+D-FbUHkC7*xKfKo7Zlp%x20y%yrW|^WERruYJXBUnywe>C@Wge3*=u`iJ?&{am0?$6nSs*R^hGmCKZ{WAlH+*sN zpmk&Cz@N2>Z6LFOV0c?Jt!t|E@g(5+NcuQBtdDMdYP{90iE`-a$46U@u1RGhDkeEL z;>gOY@l&qCU%3*$`u&GFWou8 ziM2;r^DX`>L~cAgna_O&HdAtRH*gWd>sfE8*hDwBdpPIWbYq*v*WG8~LvS@?>hhlk z{ser!4I6RrI?wiGHflctcEq&{LwjrjzDH9hIv=0yD7&zNcd`q6sY`Yt#99nLa&QVh z#i{)8y_$?<DAAUVHyyA1T+dT!}3Y%#AhFz;*9hL1H_j}|IQO{87QJpd7Jfgs`Bh75X zm$hr=(s}3k1slI?S{2h1oDG~O)dCJ?5f{-Ibs=qO-S9Wm<^=37V=Gf!mtVrO{GE-| zC!b;l@XPid#>bGXKaJn$*xp-H+TJ}rr+wk!S;lT{*xnW3M{xi5IC$ir-4^Bmbj${K z#3yr=_gdQVcplyJfas%fr05f33?=&L90$W#rIT3IwZLgI>hd#mtzi7ZPyPNCZD`MF zY_K^Z9c{|$@-6=HDX-+YI|q6*X6k0FP@z6kpZ0zzE;eJ3ZMY{~*x`nCm{`_8Qd zLeAXELd~DJb1Tnsza9M5S~}#$ZzQ(&&b(l&{8)_}E<&F>@n6>Tvu;QDcVai$@gD=5 zaF-k>OWqT$v5n$kb;z^EqUM}+HtrkY+0mc>XT*-f!1;xDp|u+$6l_Yn@jb0UcIIG0 z!2B{cL+S7k=Mp;eE+OPdeN_K8$=AaEqL16~5AFPdXlMHhPkZ@l;pt5BVei{!k*`y- zNWMAnuXt3v8;}o+T!u-*PiPxT8y6EV)%-+^cHr$s?YHyl--K-*h$p@C7E6l4iDj(Y zh)!TEk1T7L7>sx`w%en3zkRZGhId5ss3;xm#fE5PlLzrfk$L?vXhn*f6#d@QN5~D z^8GsPL=~e1H`zQ#(dj+bjRoT`xt139Q=eBk?PyRwcCA%Z`BlAh>R!A zvvx3s)BLCG=8grNpMpHBjJX1xS*;ihqJ*z=@?PD)B+uhVma-`%Tb z%X0SDe+cfZqu$pA6IcPFw(VWLUw{W$tlw4>}&$~Ir*tffh&ndlW|47=kjBu zd;H_$druE1zD>Mhqu(4z=iI&+V?phqdKDk!UFz%PT%_(ab0CAb_7r$hdmUus=L2`> z{qC)5PxB$_3$fj%a5!~eoc6{MFUpC(N}Ky=GZk*qicIx0#8Xt?nbgN_gf`)}KW_Th zhtHF;zBQ+s>K{|zVR*6&{rv7Y;+LnGt$csQwh5}mb2A_krB zhtBVTi+3!Y$H$kiJg-aieGxjB0qa%7x07K#9azKN-IG_P1?`zv;==~$$@r%qJ;%lW z0!$s2p5xb;NDD9F@^e6bL zh<;0#)Pb9gjJ4JPc8ti z=J&d{sy*qHSK-0rK6c}$odbT7;q9{ck-nSSrE%9wz$;iq$BpQ_35@Hbz&hTAm3fNl zWH@V*;0yz2H+x|pcHs=L54HfE*kA9B68?ZwF#Z)7yI$c8C3MRD(C-=GONRL(#^&;e zJN)C~d!W@9`7z17bM9CJeR~g`y|2Kb#XH3Q zjOKWerMEA_4n76(INN_XPd+hViDNxL<3jZ{(WbM6Q!)#Xu;lden(L66t|tl zT7WvrlwJ_qkVF2eID) z`nV1_cQS64?U#?n;3=rIR{B-o%i3QDjwWNGVrJw&p|w=;0iE zY}xUD1BQ0|UgRS2Q+yWrxh=?0@V2SeuBdJK4X?i6UHvvNZuDo_vD?ORiam^vpADR= z@Nq=jGq^u^O$Gj=V`IffE%=)?^y`^Ni7yk6DxCHTv8@tZHk zf1ZOMJ)3y$EY?Q*?HZ={Z~7T&sn6C@Y{EH@SMzkSst|41@jg7f3SVrM>x)H!^Cft5 zD(Ri*hZe?4(!q>dtHy$plfb2D%APp(^%ixBw|&faX}qC1dYwo63*=X2iz(AHH-?UR zoxE3)SL3S?`mh*%sB)S+*4pctl#?!ze-%c*M86+yjX)dAbKutFxlgfgqLw`qT{-X@ zYg;1FWhL-O!Q;#DgHva&t@G!MA=}{zjl%-zjts1$PW&o6-prv-4qs$jzL?6`b1Hn1 z+_w0_Yx_@W4I6y4{W5KLKqIw%o7=XB7wy;3xU~Uzo`Nsdz~i<}{DyZee8G79pchj) z`i!slZ~Aw;*7JDi`3Ufcp0NSw`4W0bG@0enQ?wlM5okFZnuvxft2xd}=qQ@!xpb7i zNv7c+uspW+?|6RXx8JllhA?9Xbj_2fd{|EKD+I7A-DE9Re9`E5k64)Q9e*!d>3tsF3oRu_t*~2>1yul zK9|RjtUUHUY397*A#ltbOWV`@299z0;W z)~OY8X7s(}331N4<_W5St4+EYxbBl5V&TeOpOXaF?n?7K`t^CmxwfwnT*3YDmkU=g z{$=WG2cCBN8iVfy53$&->eE2+!w~Nj^Yq{p>~+)wOb24DZ&IvNe!+J1|L2_a`VQt7 zbpCN6zTH4{(K@iAAhBX_ta$k6ISu+Ypo4RXz4qqiY!vbVZ~bdy!|!&Wdv{65^v#+7Qon*0$M_A-oSEB?S8YG~uCY~oUwq=@yz&1CGKQf( zd~zFmOkR8M%%cS2zZOj3sAru%WmHEyGJ@aUwuWCSd?fERn25cd-G8sa;H>q<2aY}? z?-1Yi=>m6$!R2GLE#1)pjNTriSJ9QPK}+#?19di1^!&g!GR;Gl4#TDbACK8>+iGcu}J@q@tB&KmBmi%cWq&jS_s zfT~OJ=Vs{Jf1gkP`sL5JQ?F!dHP>wP$U&}I&>%v2t)p8-8_l$_gf`F-whd<<>*#$% z1En`FO4T>~$6eu8Lt6#D;QrgOn~D)-z=w(xO@(IEsMhrSM}0 zIL`28d{c4cIWvbh606#>czagkq%%!xc?RPna2|zMRrf@Es)6dhz^yxk{_yISzFvxs z6An~<0=(O&y{p{zDzcAikNJl!Dx*Cu1GSm&wi!-pQ~MUYHoZF1`nNk~gxk*?+ir7w z<`LpuM?Pv_u|gJ)$?bk8Kc|vU_MxTI; z9aaoJgDZxoy^7ctUM%Jdrjx**14A9yQFidAzc+=0w{3o!92*6KeCb zw8_}9M<2+4{}4U9WzHbihSlb#Y_tD(rvDgm5n~s_n1;1gTLO=bw0j(M#-cq3Wy0;8 zgVMVXKg76mC2I#G#9ksJ*!%RS+AkZ{jwa_hX8mJE_13?Kb5<4|UH>&+{n}fVqW=El zF(;PcobeV0z6F%m*f&DI4)NQ>ctm5(NpAr+xK#}PrT}q7#yLt?erJ5#_k4#KxHs%$ za`GKLZc~{VlpSdNHc%`^ahIBObD)#4oAL1eD0pFyhrZ*pY0d4^0tYI(T5e9~4EfY& zka_bc;WxkZ;_pY=I1_OlW7nK0p0j<06O(!4fD^M;y!2f4c|~d0U&uekj9IVsa6#Z# zOlKo=skMxoLWtr-dD|wD!!t%Chf%YZdsvqyG~5zSLB~!V{tk0R_<4= znA)W^teSh+$QffH#&nSt%erFZ*<|0BbScJl8?@2PQBo?@4JC;Qqd153+aETA5JbMEtZ6nrX-v+x;XLH{mtl$ivx$44_5zj zlW-AqaZ%^u;yM=>SA7&*9PEpWz$oHxr->)}_E)&LYyeyg^sOb)d{)=0dzn8zQ0wAF zF)xo_Mu3M7#iz)(fPOpixSaS@+VS{j5P8DjN_plYpUxWpocLMfVNL%5;&auTh^dIz z-nDwl;Wc9EP1^UO^obS^e5aIaJ8QPzc4Ev&$%*&flO8^~FRKrq1ol*PH7q(>=XmA3 z{qb8)N-c+8KJ8!6VE=j;IehaU@WOlDZQ9>1e0?9C7b>jF{~Xt}iqGYT`1v@qBFtX* zJ4l;Qx+vf93xp#1MLeI2ZU|A&{j_OihWIryQ^q0J!3z4%8jZHPv~XE5=W7Ju|Lf5s z#e>FOZSGbcP1KWT=ja=IY!uo{`#V)UzD3o z9cm}7h<&)g9U{%lt<6`Ax6pUZchrx<=N9Fsac@HOz53w(kw(^Jp+1e2De~!MbnaFFB8(_glG7qszsY zb?{KgmDeA!7T?ob_d+Mt_YU~XG~u#2#Jknc4Cc<}fX^BipOe5RdzMQA^e+>bO*(V* z@OFef8v&g=00Ofb|y~`P(<~8T%cnfo$a>=qXuyeDvG(CS3_zqQ!T zRC5pNyL@t8e@%aGwY15NZ|B~j$WZ0v@Tj-c}Fp<<9i*Duad?2KXaWPln2ffgPpLHXc7j5K=57HHP z9fDE&)U@{GHkH8+t>-EoAe+Y8 zY}V%F?0*%1!_hN}iRc`iocLPaVXNdvS8+DmHs!A+?GNyR)~_mVWPOf3xi%)I?+zQ` z_~W-vlm5|r`5CN<-R9|<%P23MJCNVkotCq|7Fa}At;uh>{+7~$tqwoE!n4k6*13hL zzI!WsKasIY4_x(my>J}>t}om^Z8q?Du_xgsL_4>-G?M*a3NLEip87fu+J;)0jefsFrF4xXkgd>vL`R7pRO&bSUQ>Z#s zhHqrqvj~OnIlwHuWKgCX`SkYg>U=--%cBq9dvWR0cRj5=*Tc6|CLYI!)1Mpl{?P+xtV(0j#r?d{{fd8v6>)t6BLOyhE{7%X|2ag;2*hingk$03n-{|@K%f|GHfr!?> zr~j%$GN|Wgc^04ll4}^9$(WdU_tEPmEsZ(*Pr6omZaa3g|2SOqYmn|mPDHoggJ&n^ zlNEo=ZRcUG5!x{opS5Rwd9f;QtnBIfR=%0Aj&CMp%r@Js-Aar(s-MS#<8w)HJemZ@ z*IhVPdvI*O_Ly+kw%3jA({^!^Zy^{q;lHH9#Y|w(xLCNjD+z`hT^JM}K`w3l=x^w? zfbVnP2_(YzW)Nf2dcyQE;dcwIzapCSjVTO>r^0c4U=_WD>$I{6v8d16SX3c;&_}-m zoI4SEju=mhn1v}O1{5BcM#t*++wQn&5dAmw-;>{3@FX9h(~Z$+Z1v{8UjIUIm(yL` zj1g||WBT`7yn7UHJa%-S?YBeVpXkl$Pg*-vF}}~(cR2N{uKx8arZd=up$piw_aTr1 zKOeT{T(KPCNdBzkLi%Srde)5T#fRdbIp9OzAo1c3kI<(0B}TpoYc9W@>5k3d6U|r1 zmhV9ye2;wWi*9OWK0)WqiRw{ecj4o{cpnQsS@C@}A zI2NGO)&Kc!|2we1?Tpu&iIZq=vGlg`m-1fvx+6ba+CIcgju6vIZddxcgK{0jP>5%} z@IJWn$`(6iOJW6-1%?!5CqL-VeU|Y`lC_~%vT5k3A9EK_KE33%#XrUM-pb9s*M8uXM|hCPsP^E_$d zKk=!T_8e)dGnGwB{??grB;L<;`=7xz)YZL}^{=_omGb|zuDOr?s84?qpXbeD*0_Z9 zoo6?GBAwZPj%c$RW0ua64UK?DPp|pd%PyG>BFoJ6(HCNX;5_8s`+#j5&t5$GAKWX} zsWrS|WafW(?x248-IJlwH^33|9MqF#*Yh`n1Fex?!Wwy{ZRT12j=`7zD)*|l860j# zmK;APE56pn+aI92r{fM?@r>Q`6r#=Lycb@=lw;h>*gq$}BSl`d_cZVc&Ni;i>`zf& zRY&xwI*8||sKdkmbQk{?=l|Uo=gBtpSh)WJxQ`{_emgqU!+o_K>jdMU5xF+*5`*ix%ks9yG@hs5{+*fIyZWeaW_e;+F@$IjYwwegL2^*J|}J#cH#L5gMfKOZ{6hdqMC)vy!wE#S;MSNjU;3tM@{-(XFp z<>P+mYWHu4y+A3?)&3-H2<`>0?!4;n@S>IFEUO2ubYyUoAN z&HoTTr83<6q33RF9%KEc7={u+M{1E0k zLVW*^d>!PI+=(9A57mNyF8@>Og0jh@akh9?F|FS#Ki8jgP2NA1#`&h&du7;r^%Q%O zLg-)Vf7PF7^416N;ZmKu&!q2hoxA^S@_VuT4cv#I$2YkO{*DhjcYk{7Z*Yh%{lCA_ ziQg;vufV@D$bWMDtpE2nI`CB_>wAbDS{Y~TA$)!9Z|Fnz#Ohu)^KPDR12=+|dEMtr zkoB$jC9-wxZv5&h`hxMZ@seYGm*RfDb-l;NuY&P4l=0#v$NDY>`n0E=a>~T;``^Lu zR(r|cr3j!?@LxXiw?P`vX?(-u`N{OB$?Z?G+n-ZuXNlXNWyIqa4)AS|WsD`9{$$1H zCH04TKhn2BhEk>-n=sI~L6YNd1JUx8esQ`b`1+!qaLd`EO{QYtZ*zD&d60ZwTLZPz z-*;#Sf1CMbF!rm1CINVb*mlZwDH)uvHyeJNV|?pt_?~ak>NOjD=w{A2c;REng5uok z!S|hvdEW64jb}y|YyHLKi&>MgiZvO?r9GQZ=k#rdU#*`(*?`aY!!UYD^_=0>GZ);m z7G?75{$cT<(a)DMKAQY_>e<+*o`9`q0ei7xl-D>TlRET_?y8m_5&@o{fR`A0YExQp zz4V**Wo}VgTGo2$9qH!&KAmLyyX1kc)>ia?AEcdB@8;f+;5yPW%)f zReDY^OP47Yp2irgg*kx$dMt_#%V6xrc@J%qn4hZop3k1EK4}p5jlO!Ve=N>mEs^#R zbDoRrkYf3FsbB0rcXVcU{Gq>gKk(BD;e^i7(tge;c+i+k`#H_>Ti9c$_&;akqZ<@o zRi0Nkf58u}QmrSz&)8);^Q~{=+R<&q@Z01A;MZ)c&zpRJEA!k zrAJ6dx3#f0C1`*pIc;fDT7O>cpp5iaU>G=}9|6vR)VJ4Y2Uz>Ak&B=U!sMUIm^Z@M zH^Tjy;AR#6`%>&*HDhk!D7oCJgJo-2qeecBb+f_!edLW%m&%_^y2iyZ>SI2uZH)4P zSG8k^38^3U9-l?`@?nke#k#Eq@&ur#<|GZ@j!5~wr0;v#MyC$W_2a&lpXCXz{c&^1 z#^~5f3ZG5+GrAxC60iM)duyNQ&l>K<{~DX$$h~mC1o=e}w>tA6Iq~_g;ZK8Gm6hKY zz{m2+e3N%7djnTbc7?;G)RjsWivH@%;S6-XN;~~1bmv?`@Q;r*PQP;J`3>ocKj|!= z81bHv8}FGy+EjSzFf`G7_)FiZ8>RG#*!hOEF*<9qEWw`MX6#glDV^Gxv?i+I`sIoZ zm4qm#c+77#Ulv~8h0xC)&Sr71_PqMQV~Jo_KSK#e*Q=bx zRWQ^T0}t9q{u=!BSA06n;fR-JP`~0}j%@awmrDMosp{PXtt{T|;LIp+85jxD|$E$C%P?8(dX4Ihr0XVl(dp9)USCajSaFnHztBU z0^YVqiQzuZyG~-3eqZoets8UBuFiY57+h!OhD&SUnXNhZjh!;+{;|@XT5D$M@%d0= zggoD({D;NCt^P&V8Eg{gflijsHw}6G7BOPYL8(vwL4U*>oJEj`u{N)Yc+yj$6ufD@?8c!w`-r;_qT5{$)DOUA_JO3IXmd-gBe9t;|Z^QXI zS0$X#`6}w?!B1ZHlWf!ZRupK_54IoX*X{5JKGHaUt6 zv~Zn8thr%mpl5y%`6^MpUR@o0)4Jf7&iQ2Dq8_~y9o_=>Iv<5|quVqO8KLbk-@3j9 zS=BjmIzL5vO1O#9W|+1@v?*DZ&FvV;v)WF=kD=`%_2D3AlE8akcFTW(@+udi4#RuS zXln~wxJ?h-_C4h-zkb`{=Yn;}3vmLS&6crvMXAovD#y=0Wz?({#4)PNeSyWB81F0Q z{5iqMIc|!HkMoaR&lxn&>--t?L{kyZ1qTXBZQqHPTmBiA(Rd^8j9vTYrZFPcdB*i_ zx zB+^yKaIS*&Dq!vPACI1!O^$n>;z>EA7j-@MQ$vwz31vSuWp7zk6v`o+R_gqu`cI8Dd$Id)B!; zVDM$vZLVyEC--kgmuqZ4TXZBY@)Y%G4p07x{O26f1Y67XQ%gJ11LMHE`g9n4tDPOd zBU=%pEe5-Mb1282W4W7iDAXUt6&|NfY?RI~EK|KYqx322YsT-8?mk35wITVvN9|K* zJM&Yq!`*h?Cs}UQ#~qZD?pCbghvb(|5TB`R$H8uUmbB8;_Scj~{a@kwz!Z~crETv# zy=?!w4eI+Q=FP;bnyY9apM1g&&PP)H4V+bf-&oF7#&4fQ-|x&Z`1QqI!C{=~N?j}A zgU@k|!W)!>m-)UTb|Vb0*HPC&aHf7TUa~eSxi1>esm}|@7t@>`eTF{Pu6F`+2J3vw z;kT`$8#XMXow>Brj!utIx6ZOYUY*6X*O_z6n01bSXamLCR>((#BckHy3l3 zp);0B{Fb^HJL%c3N!tp1(7o-alQ?UWy#Vh6+iv{+%gMi;{%qnZ|F(qsMc+T-{~siu z&i{*o_gVPQV`!^n5NF8SyxH+H$?NHt(cBBpW^mx>3#|{%j-N#OQn!vG`XZeWwd1m- zUE3IsDK?_|H|m^4J09yd#!+l<{;xO-oV^p%O{2BVoSW3Yu0tv6ilRfYw@#brU*YPn z*j%02WH?ikv07q}`&_WxIrF)WGCHTV61|f_o;vy(^1(m!Yqy(M>DZM-h%u?scO|C} zCmkFq9U9oSZ2m!{Ll5M7tJ)58RjgFsXp4~dDe|s@&m+L5=b!5tTM%)1?Fl`@YY}&x z_qd+nfe18I{vYcZJV&NDW5OTu?D&_?y3QYPUbe<#1FZuTUW4%DeQB|>Dfl|OX}4ss z)@WtBHaBndQ(yMg8_r;4oMOMtm)FdkoLT$AL#E>`jZ-vU!Y^#xaQ#-ho@hs=w+<;U zQ#>Vq(5@$<+^xXZjGWD49aCT{-_F^|T>FF_8v?#Dcc$aVY)4NwQ`Z;C7lLmdNXuR? zUUSCs+41GJe>w42t}iL2F6OIJuQ#@FvQVt*Q{?yHFJzwDz=s2s34>3=_`7GU3%}_e zo!G|rni${u_OFw#JW_nr_dC(HY#^zuJ5ILgp`?1a@2O|}(e-#^;wUnEwEpnLE0FJC zA#2TnDf?t+?bueOa^%Z4q`c3@iD*@Q+&s7M!PUorHaWoa5?+K8lX>rI#R?L?EW$P9@$KOe-vHL zaA?sinsP5%)B&R@;tVj-I%uPa{upSfcZ)=CY)=e*YIya zUhU}{HMYOVv&tQXJM>dBZoGBK%160-OeBMOo^T@ME8iV3{%zaA#oqE*)z5&f;Qb+G z-kM^3&z}2Z){*Yt<_q|@dF4{^)j`JHTE{vN4C&M{h&ucYz65(PEIjwS@MM`lV;gD1 z=)3kDHJ~eorw1Bugns*o(Z22QO`viu^eZFDqbuM5AwEh_MJp0X>Qa%jV_z33) z{tkZaX8fqQqx`O+b+?wTV*GIJm^mxphib(z=TIg&UE|Al(z2f|XRKLz$HomcgVGQ9 zu^pWSod5NK|G<6cHf(4Df6~SJ)+6!WrYP`%e{k1#&PcQpPHlhKV}`y@na8OMd84j& z_HoQ&zAo@)LFq#H7N6zW41UGF-1U=zl{uCJX~5-UY;rdFC1cj+5+~j{lr{G3*BS^G zgY8X4E1k>tF!A)Y{5+foh?n00zW+f#9h?sb-^0NB2p8w356&+E=g)z2_B@^-&U1Qk z?n}3_+rZkj&hr{J$d_p9gZE(k4gA36Yk_!!%N^U2i)cK;I0+idiV>0 zOX2W;D04hG^yI>ms{nFktXwfBfVVpQu??PF43t+qQD6dP`bMFN`G_(5w-q1hh8v}Z>upzHi~I4EwnN4 zf=ANp|5xL&Q~dS6WA3=1$Y0Mn4Ali^`0K-rT?#(#uPF6SabEw#P}&|^9Ck5dE3(KeP8}h?J>OI?Zl@jl?k>0fdwlf~)dx&_xY~C`6P$8e((5|}CouTDcTYNfaO!t( zVDGOz#g?)6JDl=Px&xcNCq^ncw)erL{C6eg4<+UA2=(RUT4?lh!8!{66Wzq_E+k5O&&%JzqFCD+X z=YDL`z5H`8&xEA=(~|D7fjxQ7O1eKc=^kIWC(rpw_n%0*uS~kXDCvGq(*3-o`zq%i z8uk2LVZOqjSy*v#P3_7XO7-CUUGkObQ?B{SV(;#DDO>FC7dl*wwu=e9%~KIv~{ z*m(%L*F5(+9{11r3%FNZl!o3i-TdjwxVNX?ne#6)3+7fVm}O?nUsySJW{vYuQO&b{ zHchv4FRiGWInPu%m${Wy71J-CS#7Gko9Xi}xun7?Fn#{q`SZ-Y>GLWsnQ1Pw{})tO z&7Sv3GjHJ~l{2f%%*z&5%w1sS&9AO;Z|Bm)O!LWV^U0a!(zy#4m`i5Q`P~wig`24{3a+Ld*OaGtI&qKYQC3K6}m5&t4lk{ruBI z*FiL1Up6`$nM!Yg$ohiyXA?bLT!YJG)85bJ{<8PVcmLp84J9xnIBgF?XK3 zL`7C5e?e%1Kd33OhzgHx^Ks|7^DYd@A%Be)^G766^^ZGm#<-c|-PW$mA>DA9LoFk+ zD$=SOrY@`HPzQ(;707B>ohvtTrCKE_P!m^i1;KGcwtN`Vp{rKMlrLI9m4M>KDUw$RtL}G=G8d)vR3oG0e~zx&$)U8MZ$f=QlMN z0-|pEp`jr;2xG#fzsb@Ar!H-Q;V&%LOsM8~0?$MCW2yyRqLQ0M^VGs$I!_=G9Z*qS zj);1Viy~JA$HN#;A#gBxLuN8G&%-uo$UIyXDYPpRj;U71`{|f+88|g{3`D&=M#qrh zvYJL$1gk+}TsBhjpu@~>!ep4>ryYP4CWcNTAIFk*4<$d*v%5-FHCDU7WHlfj*E zfh#Xp>)p0e9NyPTjo)o*lXEINhda071%6HUU+5~>A;xXxHgK}RE^ynqtCg^`dS*B? zq~EQ!8#&pj7VVrCPQ?KHBEnahZ^)%OTaMDkrgt_csn7DHoqVCMX zo?iY)45m$)Hb0bl+CN=W=qO8Eu3_A!|d0{a!C4Wc@ zTJN;PJ3`m!t4fiq-BKcjwH@*&DX)*ga%dQ20o^J2!z}YcSZH8viavO zCSiMdmJ$u@cLTl-4nFtnbXR@VyD=Zv=iLW?fX$?@%h>Ths@?zw*I1st?W&=x44Ed|p2A z!}~HI!1=n*3vwicUihOOQ81vPYZu($qR;M&e%t1d0BL{>;PTFc8#sN^A#?Bk4B|No z6`61v@l86Ncun}D18YGRjwD&3T;l6Eg9wMdMl$pB$OvT=$t)aAgq$(N1OJWc^eN{N zp{anRPbehbcp=F;Hl7H(FCw1N@MFE=sU$5lm3aH663?1qLb{8Ir{ogiJplhGBQ%X< z_f99i=%pm1YZf7Wvq(-~DG`oe1CHSZB<;Wgu(_59{)Hrcp#-vm_zqRTKe(uXddcuC z6OX@|c>Ak~ry)*+NlS@m!7`HRyPafo-cAJHa^mZ*BSKp}@g8j;X?1rIVeH)`v!juW zs9Q}k8h!?KzmIro*F*i*6Vkt)WRx@$-;oDNcC>|fdN)D4A0}k%BgE7F2*_6AInWAr ztwdPUM$%6{O+3>(h_~@sB6MtlL-OZ{r~NtNo6||i0XWSu;gqB0=OiundEz_y0+hcE z_})&^z`vR7vVeZz7iWMoz!~5Sa0WO7oB_@NXMi)n8Q=_X1~>zp0nPwtfHS}u;0$mE zI0Kvk&H!hCGr$?(3~&ZG1DpZQ0B3+R@ZZ2dZY}$FOu4n}cVfA<^mko^JpA{tEJ=TdM)QH6l35ad0%l404Voo$QNrKV zvGCVW!tc;5oQLw-w=7H+p$wpuP*$KcP%cMVk8%~twJ2LqK7sNVD1VKz59RwPKS6mC zrLT|GXY!j&UW_sm<4;4GhjKK^b5MTUl2+sRjWfU*;0$mEI0Kvk&H!hCGr$?(3~&ZG z1DpZQ0B3+Rz!~5Sa0WO7oB_@NXMi)n8Q=_X1~>zp0nPwtfHS}u;0$mEI0Kvk&H!hC zGr$?(3~&ZG1DpZQ0B3+Rz!~5Sa0WO7oB_@NXMi)n8Q=_X1~>yG`Ws3@E-_IqMY#gy zN|dWnu1DE|@^O?MD7T^9iE=l}w^05LWk1TpDF2G`Gn6M${u8CJo7FQ7Wj4xOl%r6N zL3s|!^H3I`9FOt>l$WEt8s+sUZ$^0w%Kt^V3gtSK8&S5Q`~}LLC|^Ul8|6WisejMl zKl|?#zp0nPwt zfHS}u;0$mEI0Kvk&H!hCGr$?(3~&ZG1DpZQ0B3+Rz!~5Sa0WO7oB_@NXMi)n8Q=_X z1~>zp0nPwtfHS}u;0$mEI0Kvk&H!hCGr$?(415&^{9sf8p$o#-A$TCzmk%FCgPdeX zf~1(tN{3s*nm#%4vy$UI0$6?r!fXg(2#pY$A+$m0gwPG455ge`e}|CmA)YZ1z5`(z zg!vFc5UL$QhA9Rs1Hp>QKvCzKYtl9HeOm-lO-m z@Jzgt8q`9vT2AI!4KLN9WU>(QT~6)$mwP>dpcYe2qC>e>TvH;h-s2;6cTmHV*1g}V z%z#xsOZB)XBn1_+84P#ObmTdBYCkAoZMy;0TDkVXod}{XK~V=hx)he<(?-GJ z7)LfjqVD$u=!jN$>R&-iK3Wg8v8?P??gL#X=!jrtO5XKFMct4Btca*)$g~9VDVQ}{ zHK?Uo2DM03Q-KSEY)JEw)@>fhd;t17IrC1?^}azz;F0ar;^+=~uX_>Zvlqs_B8e*b zZJHX3lu0@{kcND}52@O%5#M8_>H~X-p{WEI1mvD{LtZM8rgY+iAwZ6#S;M(LoemJQ zCMuD}bX5yU(3=6WF&%2R2RQRdFh9sI(!wz{NLv&zV$rCkn^K7MroniDl_fwnr#rC$ z+t46yrju-E;04HqL8!OR2qLpXS}?{2#f=ha_9~)bqH2%V8GZrsf!CsyyzaBA^_j0q z(hW*%OIkcCLa&kiP}3uK(U!gd>mCf#6_h2`DJL_mCf<>$O4Xzx(?`}kNKLx_Lhmg{ z>AmS=dhh(mx?Azb;ZD-6gimEs-k!~*!-OuAYKX3eTQe0+tBgg-i&nlbXX;Y9Y?#m$ zyE46`>mpc#n#RJd_iVVejs^Cs$vs(dAX%$~)oxvuUA=}ZtCUq)FjSkfV7XaEYti3G z@2z*!`+)V_xspCNtn}E!M1*xrHfzW`StLyig~-cUY$@5rGTf6ztNk`)TTR}}@{;ai zs7NinoxI55=7DUh@Rn?9^=P)29KXZ^Q}fAen0u>fdChPqf@Sm@%V;mC+J8z_oond5 z3*Iq_@%X1~9FGIpI37O%``X$xD0V*-Ypu2hxqpPI(FL6@5X~cq5Fp31ffZ{2!V*4$ zWZG*2S)ED8UQC3=?9ohnSi$RslC9SS$ev6^ic3)E%~{U4J)XtJ%S+kz*xZ+GYGmsO zAPPnpwPUX@i>ZLbRwi;fo4oOe5-{XQ6yA|}rWn&>Fiq~yz=5`F1iW5)&z_glaat(a zls!7XPMG6g>)9df7CMD4p$EcA;gGk{(|p>Y%(ZDHCxroDV|IULv!}!3pAg;Q$ti5` zOj^?58Su4udwqGeV_OA(gD0=Ba7mNU>h1q}ueaOVZz=uGSI^a@?RTJIrmi_j*N%xm(l_4auiJawL9o;smDqt@Fe92XYm4EUP84Qc&C zzbD5(Ixnxylau53cX@mr83Q?8La)#&L@Cn3pLeMKKo3&@&#SD)| z+&z`yBE*xXF?95PMx1Xj{RzZ9Cc`6P@Y4P~8e@2Zjq4bmfq2243}1)11F?j7aXr(=5t9an z*C5Wji{VER`&Tl&9dRG*Yw7hi;<{A~e{AblGn@f?Ia=SmpD~<|clj{vcp>5@!~;!C{}kfd4GeF$?O{(&uh$VDK>Qx!B@Z(Fr?&k@ zhSN@C?OFT~!+D5(k1+gQ#C5F<&qcidQHB>G?s%Nx3dCcdWVjmf3r{h87vfn@GrS&g z%QFl=jd;oP48MqY_YQ{NLHy&L3?HUAgOE1-o*8jEU|194mq91N^(~5FPA#6z@MMZ% z3`P;dPJ)aCRR~^(^g06q#W}yUAUPLt#}xjq1@SV($6sakYY?|Q z%P^&hmN(GBa2MjWsQ)eEeyV`$C#uPJ4?1#wpu!@orAk2CxZ;wHpGI;&4-HPe5~#+ZI4;^T-##9d>Uy@_}< ztPAw2N8AhR3cc1L&PV+-h}V9f>3@ZI3F3W-Tjw(Uhlmx_e}Om?^=D+T`cFZ80pjDh z9?e8N2l4fY3F0u~lh~d(;*u*^`FA58i}*pr?TDX2JcTY~aCIS`Rl@LIieWt^=ok6` z_4~2BG|<8Hg8#GY8!5OT1y4=E^HcDRDYz^JSEOJy1y`lu+fs0S3jS#dUY~+DrQj!0 z@Utm+TMB+P1@B40`%`d#3f=&;J^*1O1p10@fv^d}!w?>U&icKM5p%zgS-}&i6}T(DzFKzh4p`;Fh0f=xFBa8LVTj zF+1M<{cguOpYe{9Y>>wKf*cfUInnG`{0wusrH0j@t1VT}oLxi44wHgsPD$6&RtVnVQ zCaaR1gSLu#qnM9rP)xEb&#h*YG{r+`8`zGm6b$S*E<;7m(1Svu8MU$^c2qJ!wHm($G0+c_N3*)^_qx=hl}RSZ>Z_3#Y*@ z|73ubZTp+BJCh?>U6bRe!wl0p4l2YB!H$>8oxxzO)fATdU}dt`ao7^j89A)pRo%g5 zIIc@f&OB;KRIn&_J6Mb>UpvC_abj+Ek5M0GN)&TgrbN06vD3OJvZGujyP|O5+rClE z8W#x0u?1`wwA(<(Gp!^uS1~y5-SxvLmk~HNoms;&f*5Dup=Djr?v9gG+C}< z<`hl%OaDD*c`2u7|6yl)vJp^&lnUx^*I}Y3B7zkn90CR_Bsi_ClxnIqdNPS?YCH-m z_6%P7faJo`Eiq96Z+TLrE-4~C&JdNPXc(w)ZUZM^?hGPu#vw-)8ICYhRWVfrPc$=j z_Ggd@)RG>)VU4VV3U`ihmTHv_db7f|VpW2&Q?$5|gK-mrGY5Dds0N&z;9&xm;7n|K zP-|xhM-pJqNTKs2U`hrMN*7s#aIzP$moRJvyfzgHPUf8VumK+TUL7KS%_P_j-`8Fp>MBBBW$3}YZsU%N(dG8L5I1cn}- z0Sl~}uE+qKEEA6c_c+RCv$GAv)0clvvOj4GV4pCO2 zR&L{1*$}z1r~n*#m(z}S*{hlk2kLM>7r@Q9O9yAAssZEG=>V&ShFwCSObToIa7r;u zPo~^Or7TibW-1(MyKPJz&cxjjVNo%XV-%5gsH>XEOC8oRl4KHwmsN6Qf|3l|vE+<& zI8Aq67}y*1eBE7`oNPenjAD($Br9hW2dqt_yR!7`ABMJdfazLdQ)WlPz;0d43>U*8 zsMEV)nXWhN90|5fH33>PT$S*2i58Q5uAVfhaE4kHGGgWBFiYtvl&rvMDQ!JnrzYAD zFv`jkXRwamie@`Y7^ZZjl;b|wg8A@^iG1s@8@@-~*NH#mbipCsA0W>5E#yHQc<;Qw zCUAaF1o$5zKY_3q0=>>Ao`?JW0s#;ASGl$ywXGDnjICu8Cru3103sg=*Szx5$^8%Z z{q@Bi3)(*#Gk@~rrkPDE#lP(K|FGxGt7dGPwmA}<)$!&neYa0Pt8uvl@yvVRir;Mr|7iQJ`<^d+Y|O(~7Gw=*kL|sDa+6Ql@U!!8Ix+v(S8RRi ze~!(JOsJCI@Ls#~wjV4g-F*3uSFd~Fdq1Cj=#?U+@VpNi7u+Hj9cx~qjC}jbLw7Gq zUq656toJr(!R4=B-CiGEy*6vqYwuipX2F|BpPRVs0`Cux{&l-Sx-a|gf%$h{bZ+Bi z&vYL2t-SZl^S5ldW8|NwJ~3x+sG@1#v~7*I^;F*6Q(U!iy0ow$7C zyX|LXj*lMOy}t4%V=If#`l4;c+um(|`}ndAmv-0QHSWoZlIDBg=yb@KGpS6nxv;?hSx>v>}4o~LeT*|EuY?tw*X zR;6zqJLaW^_dlP1#Y!^wth5hjJd`maa7gLMd;8=5-|Vc_)>MUC$B@oVA3b#TtE~q^ z@4pecVZ}|QJGFCb24Z_}U$=h68Jll!-?CVH^@DJiZ{Oa%mBKZP)Bd@vbJ@~6fB)j$ z^X{7P_^I?Cty(pC#?Tua1|Ne)E%q6Yjg^RO$a!{okJ* zb7#l(kDjyKY<+p%u`gEtsqW;2J)0kCJf!^bN%fsqKKxhnKUMnX)ym$i>+T!1bNk3A zF3DK8?r+;hW^ai!+>x#O|50%1S#K>JVa|FX@_$8l{O<58wXc71>zU)E?v0content') -# root = doc.root -# root.name # => "root" -# root.nodes.first[:id] # => "1" -# -# @example Parsing from file -# doc = Taurus.parse_file('document.xml') -# -# @example XPath queries -# doc = Taurus.parse('Ruby') -# titles = doc.xpath('//title') -# count = doc.xpath('count(//book)') # => 1.0 -# -# @example Working with namespaces -# xml = '' -# doc = Taurus.parse(xml) -# doc.root.namespace[:href] # => "http://example.org" -# -# @see Document -# @see Element -# @see XPath module Taurus - # Base error class for Taurus library - class Error < StandardError; end - - # Raised when XML parsing fails due to malformed input - # - # @example - # Taurus.parse('') # raises Taurus::ParseError - class ParseError < Error - # @return [Symbol] error code symbol - attr_reader :code - - # @return [Integer] line number where error occurred (1-based, 0 if not available) - attr_reader :line - - # @return [Integer] column number where error occurred (1-based, 0 if not available) - attr_reader :column - - # @return [Integer] byte offset where error occurred (0 if not available) - attr_reader :byte_offset - - # @return [String, nil] context snippet showing code around error - attr_reader :context - - def initialize(message, code: :parse_failed, line: 0, column: 0, byte_offset: 0, context: nil) - super(message) - @code = code - @line = line - @column = column - @byte_offset = byte_offset - @context = context - end - end - - # Raised when XPath evaluation fails due to syntax or semantic errors - # - # @example - # doc.xpath('//book:title') # raises Taurus::XPathError if 'book' prefix not registered - class XPathError < Error - attr_reader :code, :line, :column, :byte_offset, :context - - def initialize(message, code: :xpath_error, line: 0, column: 0, byte_offset: 0, context: nil) - super(message) - @code = code - @line = line - @column = column - @byte_offset = byte_offset - @context = context - end - end - - # Raised when XPath evaluation fails due to runtime issues - # - # @example - # doc.xpath('sum("not a number")') # raises Taurus::EvaluationError - class EvaluationError < Error - attr_reader :code, :line, :column, :byte_offset, :context - - def initialize(message, code: :eval_error, line: 0, column: 0, byte_offset: 0, context: nil) - super(message) - @code = code - @line = line - @column = column - @byte_offset = byte_offset - @context = context - end - end - - class << self - # Parse an XML string and return a Document - # - # Parses the given XML string using the native libtaurus C library via FFI. - # Returns a fully constructed Ruby Document object with all elements, - # attributes, and namespace information. - # - # @param xml_string [String] the XML string to parse - # @return [Document] the parsed document - # @raise [ParseError] if XML is malformed - # - # @example - # doc = Taurus.parse('content') - # doc.root.name # => "root" - # doc.root.nodes.first[:id] # => "1" - # - # @see .parse_file - def parse(xml_string) - # Validate input in Ruby layer first - if xml_string.nil? - raise ParseError.new( - "NULL input provided", - code: :null_input, - line: 0, - column: 0 - ) - end - - if xml_string.empty? - raise ParseError.new( - "Empty input provided", - code: :empty_input, - line: 0, - column: 0 - ) - end - - FFI::ErrorHandling.with_error_check do - # Call C library to parse XML - doc_ptr = FFI.taurus_parse(xml_string, xml_string.bytesize) - - if doc_ptr.null? - FFI::ErrorHandling.check_error! - raise ParseError, "Failed to parse XML" - end - - # Wrap pointer for automatic cleanup - doc_ptr = FFI::MemoryHelpers.wrap_document(doc_ptr) - - # Convert C document to Ruby object - FFI::Bridge.document_from_ptr(doc_ptr) - end - end - - # Parse an XML file and return a Document - # - # This is a convenience method that reads the file and calls {.parse}. - # - # @param file_path [String] path to the XML file - # @return [Document] the parsed document - # @raise [Errno::ENOENT] if file does not exist - # @raise [ParseError] if XML is malformed - # - # @example - # doc = Taurus.parse_file('books.xml') - # doc.root.name # => root element name - # - # @see .parse - def parse_file(file_path) - xml_string = File.read(file_path) - parse(xml_string) - end - - # Evaluate an XPath expression on a document - # - # This is called internally by Document#xpath and Element#xpath. - # Uses the native C XPath evaluator via FFI. - # - # @param doc [Document] the document context - # @param expression [String] the XPath expression - # @param context_node [Element, Document] the context node for evaluation - # @param namespaces [Hash, nil] custom namespace mappings (reserved for future use) - # @return [Array, String, Float, Boolean] the XPath result - # - # @api private - def xpath_evaluate(doc, expression, context_node = nil, namespaces = nil) - # Note: namespaces parameter reserved for v0.9.0 custom namespace registration - # Currently, namespaces are auto-detected from the document (v0.8.0) - FFI::ErrorHandling.with_error_check do - # Extract C pointer from Ruby Document object or from context node - doc_ptr = doc.instance_variable_get(:@_c_ptr) - - # If doc doesn't have pointer, try to get it from context_node - # (happens when Element#xpath creates a temporary Document) - if !doc_ptr && context_node - doc_ptr = context_node.instance_variable_get(:@_c_doc_ptr) - end - - unless doc_ptr - raise Error, "Document has no C pointer (not created via Taurus.parse)" - end - - # Call C library to evaluate XPath - result_ptr = if context_node && context_node != doc - # Extract C pointer from context node - context_ptr = context_node.instance_variable_get(:@_c_ptr) - unless context_ptr - raise Error, "Context node has no C pointer" - end - - # Use context node variant - FFI.taurus_xpath_eval_with_context( - doc_ptr, - context_ptr, - expression, - expression.bytesize - ) - else - # Use document variant - FFI.taurus_xpath_eval(doc_ptr, expression, expression.bytesize) - end - - if result_ptr.null? - FFI::ErrorHandling.check_error! - raise Error, "XPath evaluation failed" - end - - # Wrap pointer for automatic cleanup - result_ptr = FFI::MemoryHelpers.wrap_xpath_result(result_ptr) - - # Convert C result to Ruby value, passing doc_ptr for full element hydration - FFI::Bridge.xpath_result_to_ruby(result_ptr, doc_ptr) - end - end - end + autoload :XML, "taurus/xml" end - -# Load adapter after Taurus module is fully defined -require_relative "taurus/adapter" \ No newline at end of file diff --git a/lib/taurus/.ruby_version b/lib/taurus/.ruby_version deleted file mode 100644 index 49ab6b8..0000000 --- a/lib/taurus/.ruby_version +++ /dev/null @@ -1 +0,0 @@ -3.1.1-arm64-darwin21 \ No newline at end of file diff --git a/lib/taurus/adapter.rb b/lib/taurus/adapter.rb deleted file mode 100644 index 06d3b09..0000000 --- a/lib/taurus/adapter.rb +++ /dev/null @@ -1,9 +0,0 @@ -# frozen_string_literal: true - -# Load Moxml-compatible adapters if available -begin - require "moxml" - require_relative "adapter/taurus" -rescue LoadError - # Moxml not available, skip Moxml adapters -end diff --git a/lib/taurus/adapter/taurus.rb b/lib/taurus/adapter/taurus.rb deleted file mode 100644 index 4100d9e..0000000 --- a/lib/taurus/adapter/taurus.rb +++ /dev/null @@ -1,81 +0,0 @@ -# frozen_string_literal: true - -# This file is loaded from lib/taurus.rb after the main Taurus module is defined -# No need to require anything here - Taurus module is already available - -module Taurus - module Adapter - class Taurus < Moxml::Adapter::Base - class << self - def parse(xml, _options = {}) - ::Taurus.parse(xml) - rescue ::Taurus::ParseError => e - raise Moxml::ParseError.new( - e.message, - source: xml.is_a?(String) ? xml[0..100] : nil, - ) - end - - def xpath(node, expression, namespaces = {}) - # Taurus now has complete XPath 1.0 support through C extension - # Use the built-in xpath method - result = node.xpath(expression) - - # Ensure result is wrapped in NodeSet - case result - when Array - ::Taurus::NodeSet.new(result) - when ::Taurus::NodeSet - result - else - # Scalar values (string, number, boolean) - return as-is - result - end - end - - def at_xpath(node, expression, namespaces = {}) - result = xpath(node, expression, namespaces) - result.is_a?(::Taurus::NodeSet) ? result.first : result - end - - def xpath_supported? - true # Taurus has complete XPath 1.0 support - end - - def capabilities - { - # Core adapter capabilities - parse: true, - - # Parsing capabilities - sax_parsing: false, - namespace_aware: true, - namespace_support: :full, - dtd_support: false, - parsing_speed: :fast, - - # XPath capabilities - COMPLETE XPath 1.0 in C! - xpath_support: :full, - xpath_full: true, - xpath_axes: :complete, # All 13 XPath 1.0 axes - xpath_functions: :complete, # All 27 XPath 1.0 functions - xpath_predicates: true, - xpath_namespaces: true, - xpath_variables: true, - - # Serialization capabilities - namespace_serialization: true, - pretty_print: true, - - # Known limitations - schema_validation: false, - xslt_support: false, - } - end - end - end - - # For backward compatibility - TaurusAdapter = Taurus - end -end diff --git a/lib/taurus/adapters.rb b/lib/taurus/adapters.rb deleted file mode 100644 index aa51a37..0000000 --- a/lib/taurus/adapters.rb +++ /dev/null @@ -1,10 +0,0 @@ -# frozen_string_literal: true - -require_relative "adapter/taurus" -require_relative "adapter/headed_ox" - -module Taurus - # Adapter module for different XML processing backends - module Adapter - end -end \ No newline at end of file diff --git a/lib/taurus/attributes_hash.rb b/lib/taurus/attributes_hash.rb deleted file mode 100644 index e164f43..0000000 --- a/lib/taurus/attributes_hash.rb +++ /dev/null @@ -1,86 +0,0 @@ -# frozen_string_literal: true - -module Taurus - # A Hash subclass that allows transparent access with both string and symbol keys. - # - # AttributesHash is used to store XML element attributes, providing convenient - # access regardless of whether you use strings or symbols as keys. All keys are - # internally stored as symbols for consistency and performance. - # - # @example Access with symbols - # elem = doc.root - # elem.attributes[:id] # => "123" - # elem[:id] # => "123" (shorthand) - # - # @example Access with strings - # elem.attributes["id"] # => "123" (converted to symbol) - # elem["id"] # => "123" (shorthand) - # - # @example Setting attributes - # elem[:class] = "important" # stored as :class - # elem["data-id"] = "456" # stored as :"data-id" - # - # @example Best practice for performance - # # Prefer symbols for ~90% better performance - # elem[:id] # Fast path - # elem["id"] # Slower (needs conversion) - # - # @see Element#attributes - # @see Element#[] - # @see Element#[]= - class AttributesHash < Hash - # Retrieve a value by key, trying symbol and string variants - # - # Attempts to find the value using three strategies: - # 1. Direct lookup with the given key - # 2. Lookup with key converted to symbol - # 3. Lookup with key converted to string - # - # @param key [String, Symbol] the attribute name - # @return [String, nil] the attribute value or nil if not found - # - # @example - # attrs = AttributesHash.new - # attrs[:id] = "123" - # attrs[:id] # => "123" - # attrs["id"] # => "123" - # attrs[:other] # => nil - def [](key) - super(key) || super(key.to_sym) || super(key.to_s) - end - - # Set a value by key, always storing as a symbol - # - # All keys are normalized to symbols for consistent internal storage - # and optimal performance. - # - # @param key [String, Symbol] the attribute name - # @param value [String] the attribute value - # @return [String] the value that was set - # - # @example - # attrs = AttributesHash.new - # attrs["id"] = "123" # stored as :id - # attrs[:class] = "widget" # stored as :class - def []=(key, value) - super(key.to_sym, value) - end - - # Check if a key exists, trying symbol and string variants - # - # @param key [String, Symbol] the attribute name to check - # @return [Boolean] true if the key exists - # - # @example - # attrs = AttributesHash.new - # attrs[:id] = "123" - # attrs.key?(:id) # => true - # attrs.key?("id") # => true - # attrs.key?(:name) # => false - def key?(key) - super(key) || super(key.to_sym) || super(key.to_s) - end - - alias has_key? key? - end -end \ No newline at end of file diff --git a/lib/taurus/cli.rb b/lib/taurus/cli.rb deleted file mode 100644 index ad97807..0000000 --- a/lib/taurus/cli.rb +++ /dev/null @@ -1,118 +0,0 @@ -# frozen_string_literal: true - -require "thor" -require_relative "../taurus" -require_relative "commands/xpath_command" -require_relative "commands/format_command" - -module Taurus - # Taurus CLI - Command-line interface for XML processing - # - # Provides fast XML parsing, XPath queries, and formatting capabilities - # through a simple command-line interface. - # - # Architecture: - # - CLI layer uses Thor for option parsing - # - All logic delegated to Command classes - # - Commands use API classes (Document, Element, etc.) - # - MECE design: CLI/API/ENV argument handling - class CLI < Thor - # Global options available to all commands - class_option :quiet, - type: :boolean, - aliases: "-q", - desc: "Suppress output messages" - - class_option :verbose, - type: :boolean, - aliases: "-v", - desc: "Show verbose output" - - desc "xpath FILE EXPRESSION", "Execute XPath query against XML file" - long_desc <<~DESC - Execute an XPath 1.0 query against an XML document. - - Supports: - - All XPath 1.0 axes, functions, and operators - - Complete namespace support - - Multiple output formats - - Stdin input (use '-' as filename) - - Examples: - $ taurus xpath books.xml "//book" - $ cat books.xml | taurus xpath - "//title" - $ taurus xpath --count books.xml "//book[@price > 20]" - DESC - method_option :count, - type: :boolean, - aliases: "-c", - desc: "Output count of matching nodes" - method_option :boolean, - type: :boolean, - aliases: "-b", - desc: "Output boolean result (true/false)" - method_option :format, - type: :string, - aliases: "-f", - enum: %w[text xml count boolean], - default: "xml", - desc: "Output format" - def xpath(file, expression) - Commands::XPathCommand.new(options).run(file, expression) - rescue Taurus::Error => e - handle_error(e) - end - - desc "format FILE", "Pretty-print XML document" - long_desc <<~DESC - Format an XML document with proper indentation. - - Features: - - Customizable indentation (default: 2 spaces) - - Compact mode (removes extra whitespace) - - Output to file or stdout - - Preserves namespace declarations - - Examples: - $ taurus format books.xml - $ taurus format --indent 4 books.xml - $ taurus format --output formatted.xml books.xml - $ taurus format --compact books.xml - DESC - method_option :indent, - type: :numeric, - aliases: "-i", - default: 2, - desc: "Indentation spaces" - method_option :output, - type: :string, - aliases: "-o", - desc: "Output file (default: stdout)" - method_option :compact, - type: :boolean, - desc: "Remove extra whitespace" - def format(file) - Commands::FormatCommand.new(options).run(file) - rescue Taurus::Error => e - handle_error(e) - end - - desc "version", "Show Taurus version" - def version - puts "Taurus #{Taurus::VERSION}" - puts "Fast XML parser with complete XPath 1.0 support" - end - - private - - def handle_error(error) - if options[:verbose] - warn "Error: #{error.message}" - warn error.backtrace.join("\n") if error.backtrace - elsif !options[:quiet] - warn "Error: #{error.message}" - end - exit 1 - end - end -end \ No newline at end of file diff --git a/lib/taurus/commands/base.rb b/lib/taurus/commands/base.rb deleted file mode 100644 index e10fe91..0000000 --- a/lib/taurus/commands/base.rb +++ /dev/null @@ -1,73 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module Commands - # Base class for all Taurus commands - # - # Provides common functionality: - # - File/stdin reading - # - Error handling - # - Option access - # - Output management - class Base - attr_reader :options - - def initialize(options = {}) - @options = options - end - - # Read XML from file or stdin - # - # @param filename [String] File path or '-' for stdin - # @return [String] XML content - def read_input(filename) - if filename == "-" - $stdin.read - else - File.read(filename) - end - rescue Errno::ENOENT - raise Taurus::Error, "File not found: #{filename}" - rescue Errno::EACCES - raise Taurus::Error, "Permission denied: #{filename}" - rescue => e - raise Taurus::Error, "Failed to read file: #{e.message}" - end - - # Parse XML string - # - # @param xml [String] XML content - # @return [Taurus::Document] Parsed document - def parse_xml(xml) - Taurus.parse(xml) - rescue Taurus::ParseError => e - raise Taurus::Error, "XML parse error: #{e.message}" - end - - # Write output to file or stdout - # - # @param content [String] Content to write - # @param filename [String, nil] Output file or nil for stdout - def write_output(content, filename = nil) - if filename - File.write(filename, content) - log_info "Output written to #{filename}" if options[:verbose] - else - puts content - end - rescue => e - raise Taurus::Error, "Failed to write output: #{e.message}" - end - - # Log info message (unless quiet) - def log_info(message) - warn message unless options[:quiet] - end - - # Log verbose message (only if verbose) - def log_verbose(message) - warn message if options[:verbose] - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/commands/format_command.rb b/lib/taurus/commands/format_command.rb deleted file mode 100644 index 984e320..0000000 --- a/lib/taurus/commands/format_command.rb +++ /dev/null @@ -1,187 +0,0 @@ -# frozen_string_literal: true - -require_relative "base" - -module Taurus - module Commands - # Format command - Pretty-print XML documents - # - # Provides XML formatting with customizable indentation. - # Can output to stdout or file. - # - # Usage: - # command = FormatCommand.new(options) - # command.run("books.xml") - class FormatCommand < Base - # Format XML document - # - # @param filename [String] XML file path or '-' for stdin - def run(filename) - log_verbose "Reading XML from #{filename == '-' ? 'stdin' : filename}..." - xml = read_input(filename) - - log_verbose "Parsing XML..." - doc = parse_xml(xml) - - log_verbose "Formatting XML..." - formatted = format_document(doc) - - write_output(formatted, options[:output]) - end - - private - - # Format document based on options - def format_document(doc) - if options[:compact] - format_compact(doc) - else - format_pretty(doc) - end - end - - # Format with indentation - def format_pretty(doc) - indent = options[:indent] || 2 - indent_str = " " * indent - - xml = +"" # Unfreeze string - - # Add XML declaration if present - if doc.respond_to?(:version) && doc.version - xml << %{\n" - end - - # Format root element - xml << format_element(doc.root, 0, indent_str) - xml << "\n" - - xml - end - - # Format element with indentation - def format_element(element, depth, indent_str) - return +"" unless element - - indent = indent_str * depth - xml = +"#{indent}<#{element.name}" - - # Add attributes - if element.attributes && !element.attributes.empty? - element.attributes.each do |key, value| - xml << %( #{key}="#{escape_xml(value)}") - end - end - - # Handle empty elements - if element.nodes.empty? - xml << "/>" - return xml - end - - # Check if element has only text content - if has_only_text?(element) - xml << ">" - text = element.nodes.find { |n| n.is_a?(String) } - xml << escape_xml(text) if text - xml << "" - return xml - end - - xml << ">\n" - - # Format children - element.nodes.each do |child| - case child - when Element - xml << format_element(child, depth + 1, indent_str) - xml << "\n" - when String - # Only add text if non-whitespace - text = child.strip - unless text.empty? - xml << "#{indent}#{indent_str}#{escape_xml(text)}\n" - end - end - end - - xml << "#{indent}" - xml - end - - # Format document in compact mode (no extra whitespace) - def format_compact(doc) - xml = +"" - - # Add XML declaration if present - if doc.respond_to?(:version) && doc.version - xml << %{" - end - - # Format root element - xml << format_element_compact(doc.root) - xml - end - - # Format element in compact mode - def format_element_compact(element) - return +"" unless element - - xml = +"<#{element.name}" - - # Add attributes - if element.attributes && !element.attributes.empty? - element.attributes.each do |key, value| - xml << %( #{key}="#{escape_xml(value)}") - end - end - - # Handle empty elements - if element.nodes.empty? - xml << "/>" - return xml - end - - xml << ">" - - # Add children (remove whitespace-only text) - element.nodes.each do |child| - case child - when Element - xml << format_element_compact(child) - when String - # Only add non-whitespace text - text = child.strip - xml << escape_xml(text) unless text.empty? - end - end - - xml << "" - xml - end - - # Check if element contains only text content (no child elements) - def has_only_text?(element) - return false if element.nodes.empty? - - element.nodes.all? do |node| - node.is_a?(String) - end - end - - # Escape XML special characters - def escape_xml(text) - text.to_s - .gsub("&", "&") - .gsub("<", "<") - .gsub(">", ">") - .gsub('"', """) - .gsub("'", "'") - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/commands/xpath_command.rb b/lib/taurus/commands/xpath_command.rb deleted file mode 100644 index 41c0be0..0000000 --- a/lib/taurus/commands/xpath_command.rb +++ /dev/null @@ -1,255 +0,0 @@ -# frozen_string_literal: true - -require_relative "base" - -module Taurus - module Commands - # XPath query command - # - # Executes XPath 1.0 queries against XML documents. - # Supports all XPath axes, functions, and operators. - # - # Usage: - # command = XPathCommand.new(options) - # command.run("books.xml", "//book") - class XPathCommand < Base - # Execute XPath query - # - # @param filename [String] XML file path or '-' for stdin - # @param expression [String] XPath expression - def run(filename, expression) - log_verbose "Reading XML from #{filename == '-' ? 'stdin' : filename}..." - xml = read_input(filename) - - log_verbose "Parsing XML..." - doc = parse_xml(xml) - - log_verbose "Executing XPath: #{expression}" - result = doc.xpath(expression) - - log_verbose "Query returned #{result_summary(result)}" - - output_result(result) - end - - private - - # Output XPath result based on format and type - def output_result(result) - format = determine_format(result) - - case format - when :count - output_count(result) - when :boolean - output_boolean(result) - when :number - output_number(result) - when :string - output_string(result) - when :xml - output_xml(result) - end - end - - # Determine output format based on options and result type - def determine_format(result) - # Explicit format from options - return :count if options[:count] - return :boolean if options[:boolean] - return options[:format].to_sym if options[:format] - - # Auto-detect from result type - case result - when NodeSet, Array - :xml - when TrueClass, FalseClass - :boolean - when Numeric - :number - when String - :string - else - :xml - end - end - - # Output count of nodes - def output_count(result) - count = case result - when NodeSet, Array - result.size - when TrueClass - 1 - when FalseClass - 0 - else - 1 - end - puts count - end - - # Output boolean result - def output_boolean(result) - bool = case result - when NodeSet, Array - !result.empty? - when TrueClass, FalseClass - result - when Numeric - result != 0 - when String - !result.empty? - else - false - end - puts bool ? "true" : "false" - end - - # Output number result - def output_number(result) - number = case result - when Numeric - result - when String - result.to_f - when TrueClass - 1.0 - when FalseClass - 0.0 - else - 0.0 - end - - # Handle special float values - if number.infinite? - puts number > 0 ? "Infinity" : "-Infinity" - elsif number.nan? - puts "NaN" - else - puts number - end - end - - # Output string result - def output_string(result) - str = case result - when String - result - when Numeric - result.to_s - when TrueClass - "true" - when FalseClass - "false" - when NodeSet, Array - result.map { |n| node_to_string(n) }.join - else - result.to_s - end - puts str - end - - # Output XML nodes - def output_xml(result) - nodes = case result - when NodeSet - result.to_a - when Array - result - when Element - [result] - else - return output_string(result) - end - - if nodes.empty? - log_info "XPath set is empty" unless options[:quiet] - exit 11 # XMLLINT_ERR_XPATH_EMPTY - end - - nodes.each do |node| - puts node_to_xml(node) - end - end - - # Convert node to XML string - def node_to_xml(node) - case node - when Element - element_to_xml(node) - when String - node - else - node.to_s - end - end - - # Convert element to XML string - def element_to_xml(element) - xml = +"<#{element.name}" - - # Add attributes - if element.attributes && !element.attributes.empty? - element.attributes.each do |key, value| - xml << %( #{key}="#{escape_xml(value)}") - end - end - - # Handle empty elements - if element.nodes.empty? - xml << "/>" - return xml - end - - xml << ">" - - # Add children - element.nodes.each do |child| - xml << node_to_xml(child) - end - - xml << "" - xml - end - - # Convert node to text string (for string() function) - def node_to_string(node) - case node - when Element - element.nodes.map { |n| node_to_string(n) }.join - when String - node - else - node.to_s - end - end - - # Escape XML special characters - def escape_xml(text) - text.to_s - .gsub("&", "&") - .gsub("<", "<") - .gsub(">", ">") - .gsub('"', """) - .gsub("'", "'") - end - - # Human-readable result summary - def result_summary(result) - case result - when NodeSet, Array - "#{result.size} node(s)" - when TrueClass, FalseClass - "boolean: #{result}" - when Numeric - "number: #{result}" - when String - "string: #{result[0...50]}#{'...' if result.length > 50}" - else - result.class.name - end - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/document.rb b/lib/taurus/document.rb deleted file mode 100644 index 8d2cd43..0000000 --- a/lib/taurus/document.rb +++ /dev/null @@ -1,155 +0,0 @@ -# frozen_string_literal: true - -require_relative "element" - -module Taurus - # Represents an XML document with optional XML declaration (prolog). - # - # Document is the top-level container for an XML tree. It extends {Element} - # and adds support for XML version, encoding, and standalone attributes. - # The document maintains a root element and provides optimized access to it. - # - # @example Parse a document - # doc = Taurus.parse('') - # doc.version # => "1.0" - # doc.root.name # => "root" - # - # @example Create a document programmatically - # doc = Taurus::Document.new(version: "1.0", encoding: "UTF-8") - # root = Taurus::Element.new("root") - # doc.root = root - # - # @example XPath queries on document - # doc = Taurus.parse('Ruby') - # titles = doc.xpath('//title') - # count = doc.xpath('count(//book)') # => 1.0 - # - # @see Element - # @see #root - # @see #xpath - class Document < Element - # @return [String] the XML version (default: "1.0") - # @return [String, nil] the character encoding (e.g., "UTF-8") - # @return [Boolean, nil] whether the document is standalone - attr_accessor :version, :encoding, :standalone - - # Create a new XML document - # - # @param prolog [Hash] XML declaration attributes - # @option prolog [String] :version ("1.0") the XML version - # @option prolog [String] :encoding the character encoding - # @option prolog [Boolean] :standalone whether document is standalone - # - # @example Default document - # doc = Taurus::Document.new - # doc.version # => "1.0" - # - # @example Document with encoding - # doc = Taurus::Document.new(encoding: "UTF-8") - def initialize(prolog = {}) - super(nil) - @version = prolog[:version] || "1.0" - @encoding = prolog[:encoding] - @standalone = prolog[:standalone] - @nodes = [] - end - - # Returns the root element of the document - # - # This method uses a two-level optimization strategy: - # 1. Ruby cache (@root) - set on first access or assignment - # 2. C fast-path (root_fast) - blazing fast ivar access from C - # - # The first call scans the nodes array to find the root element. - # Subsequent calls use the cached value for O(1) access. - # - # @return [Element, nil] the root element or nil if no root exists - # - # @example - # doc = Taurus.parse('') - # root = doc.root - # root.name # => "root" - # - # @see #root= - def root - # If cache exists, return cached value - return @root if instance_variable_defined?(:@root) - - # First access - find and cache root - @root = nodes.find { |n| n.is_a?(Element) } - end - - # Sets the root element of the document - # - # Replaces any existing root element with the given element. - # The root element becomes a child node of the document. - # - # @param element [Element, nil] the new root element or nil to remove root - # @return [Element, nil] the assigned element - # - # @example - # doc = Taurus::Document.new - # root = Taurus::Element.new("root") - # doc.root = root - # doc.root.name # => "root" - # - # @see #root - def root=(element) - # Remove existing root if present - nodes.delete_if { |n| n.is_a?(Element) } - # Add new root - nodes << element if element - # Update cache - @root = element - end - - # Execute an XPath query on the document - # - # Evaluates the given XPath expression with the document as both the - # document context and the context node. Supports full XPath 1.0 specification - # including all 13 axes, 27 functions, and operators. - # - # @param expression [String] the XPath expression to evaluate - # @param namespaces [Hash{String => String}, nil] optional custom namespace mappings - # (prefix => URI). Overrides auto-detected namespaces. - # @return [Array, String, Numeric, Boolean] the query result - # - Node-set queries return Array - # - String queries return String - # - Numeric queries return Float - # - Boolean queries return true/false - # - # @raise [ArgumentError] if expression is invalid - # - # @example Find all elements - # doc.xpath('//book') # => [, , ...] - # - # @example Count elements - # doc.xpath('count(//book)') # => 2.0 - # - # @example Boolean query - # doc.xpath('boolean(//book[@price > 20])') # => true - # - # @example String query - # doc.xpath('string(//title)') # => "First Title" - # - # @example Custom namespaces - # doc.xpath('//ns:book', namespaces: { 'ns' => 'http://books.org' }) - # - # @see Element#xpath - # @see XPath - def xpath(expression, namespaces: nil) - # Validate XPath expression - if expression.nil? || expression.empty? - raise Taurus::ParseError.new( - "Empty XPath expression", - code: :empty_input, - line: 0, - column: 0 - ) - end - - # Use root element as context node (Document itself is the document context) - Taurus.xpath_evaluate(self, expression, root, namespaces) - end - end -end \ No newline at end of file diff --git a/lib/taurus/element.rb b/lib/taurus/element.rb deleted file mode 100644 index 2589ec1..0000000 --- a/lib/taurus/element.rb +++ /dev/null @@ -1,762 +0,0 @@ -# frozen_string_literal: true - -require_relative "node" -require_relative "attributes_hash" - -module Taurus - # Represents an XML element with full namespace support and Ox-compatible API. - # - # Element is the core class for representing XML elements in the document tree. - # It provides comprehensive functionality for: - # - Element and attribute access - # - Namespace handling with full XML Namespaces 1.0 support - # - XPath querying - # - DOM manipulation (add/remove children) - # - Ox-compatible API for easy migration - # - # @example Create and manipulate elements - # elem = Taurus::Element.new("book") - # elem[:id] = "123" - # elem << Taurus::Element.new("title") - # elem.name # => "book" - # elem[:id] # => "123" - # - # @example Parse and query - # doc = Taurus.parse('Ruby') - # book = doc.root.nodes.first - # book.name # => "book" - # book[:id] # => "1" - # book.text # => "Ruby" (first text node) - # - # @example Namespace support - # xml = '' - # doc = Taurus.parse(xml) - # doc.root.namespace[:href] # => "http://example.org" - # doc.root.namespace_for_prefix(nil) # => "http://example.org" - # - # @example XPath queries - # books = doc.root.xpath('.//book[@price > 20]') - # count = doc.root.xpath('count(.//book)') # => 2.0 - # - # @see Node - # @see Document - # @see AttributesHash - class Element < Node - # @return [AttributesHash] the element's attributes with dual string/symbol access - attr_reader :attributes - - # Create a new element with the given name - # - # @param name [String, Symbol] the element name (tag name) - # - # @example - # book = Taurus::Element.new("book") - # book.name # => "book" - def initialize(name) - super(name) - @attributes = AttributesHash.new - @nodes = [] - end - - # Return the element's name (tag name) - # - # Provides direct access to the element name for maximum performance. - # Names are automatically interned and frozen in the C parser for memory - # efficiency and VM optimization. - # - # @return [String] the element name - # - # @example - # elem = Taurus::Element.new("book") - # elem.name # => "book" - # - # @note This is optimized for performance with direct ivar access - def name - @value - end - - # Get the fully qualified name with namespace prefix if present - # - # @return [String] the qualified name (e.g., "prefix:localname" or "localname") - # - # @example Without prefix - # elem.qualified_name # => "book" - # - # @example With prefix - # elem.qualified_name # => "ex:book" - # - # @see #namespace_prefix - def qualified_name - if namespace_prefix - "#{namespace_prefix}:#{value}" - else - value - end - end - - alias name= value= - - # Returns the element's child nodes - # - # The nodes array contains all children including element nodes and text nodes. - # This array is always initialized and ready for direct access, providing - # excellent performance (matches or exceeds Ox). - # - # @return [Array] array of child nodes - # - # @example Access children - # elem.nodes # => [, "text", ] - # elem.nodes.first # => - # - # @example Iterate children - # elem.nodes.each { |node| puts node } - # - # @note This is performance-optimized with direct ivar access - def nodes - @nodes - end - - # Append a child node to this element - # - # Adds the node to the end of the children array. For Element nodes, - # also sets the parent relationship. - # - # @param node [Element, String] the node to append - # @return [Element] self for method chaining - # @raise [ArgumentError] if node is not a String or Node - # - # @example Append element - # parent = Taurus::Element.new("parent") - # child = Taurus::Element.new("child") - # parent << child - # parent.nodes # => [] - # - # @example Append text - # parent << "text content" - # parent.text # => "text content" - # - # @example Method chaining - # parent << child1 << child2 << "text" - # - # @see #add_child - # @see #prepend_child - def <<(node) - raise ArgumentError, "argument to << must be a String or Taurus::Node" unless node.is_a?(String) || node.is_a?(Node) - - @nodes << node - node.parent = self if node.is_a?(Element) # Set parent for Element nodes - self - end - - # Prepend a child node to the beginning of the children array - # - # @param node [Element, String] the node to prepend - # @return [Element] self for method chaining - # @raise [ArgumentError] if node is not a String or Node - # - # @example - # parent = Taurus::Element.new("parent") - # parent << "second" - # parent.prepend_child("first") - # parent.nodes # => ["first", "second"] - # - # @see #<< - # @see #add_child - def prepend_child(node) - raise ArgumentError, "argument to prepend_child must be a String or Taurus::Node" unless node.is_a?(String) || node.is_a?(Node) - - @nodes.unshift(node) - self - end - - # Check equality with another element - # - # Two elements are equal if they have the same name, attributes, and children. - # This provides deep equality checking. - # - # @param other [Element] the element to compare with - # @return [Boolean] true if elements are equal - # - # @example - # elem1 = Taurus::Element.new("book") - # elem1[:id] = "1" - # elem2 = Taurus::Element.new("book") - # elem2[:id] = "1" - # elem1 == elem2 # => true (if same children) - def eql?(other) - return false unless super - return false unless attributes == other.attributes - return false unless nodes == other.nodes - true - end - alias == eql? - - # Returns the first text node content - # - # Searches through child nodes and returns the content of the first text node. - # Returns nil if no text nodes exist. - # - # @return [String, nil] the text content or nil - # - # @example - # elem = Taurus::Element.new("title") - # elem << "Ruby Programming" - # elem.text # => "Ruby Programming" - # - # @example Multiple children - # elem << "First" << Taurus::Element.new("tag") << "Second" - # elem.text # => "First" (returns first text node only) - # - # @see #replace_text - def text - nodes.each { |n| return n if n.is_a?(String) } - nil - end - - # Replace all child nodes with a single text node - # - # Clears the children array and replaces it with a single text node. - # Useful for setting simple text content. - # - # @param txt [String] the new text content - # @return [Array] the new nodes array containing just the text - # @raise [ArgumentError] if txt is not a String - # - # @example - # elem = Taurus::Element.new("title") - # elem << "Old" << Taurus::Element.new("tag") - # elem.replace_text("New") - # elem.nodes # => ["New"] - # elem.text # => "New" - # - # @see #text - def replace_text(txt) - raise ArgumentError, "argument to replace_text() must be a String" unless txt.is_a?(String) - - @nodes = [txt] - end - - # Set or get an attribute value - # ✅ PERFORMANCE: Symbol fast-path avoids conversion overhead - # Old: Always convert to symbol, then check string fallbacks (71.49% waste) - # New: Direct lookup for symbols (90% of usage), convert only for strings - # Expected: 1.5× speedup (0.11µs → 0.07µs) - def [](attr) - # Fast path: direct symbol lookup (90% of real-world usage) - return @attributes[attr] if attr.is_a?(Symbol) - - # Slow path: string conversion for backwards compatibility (10% of usage) - key = attr.to_sym - @attributes[key] || @attributes[attr.to_s] || @attributes[attr] - end - - def []=(attr, value) - key = attr.is_a?(Symbol) ? attr : attr.to_sym - @attributes[key] = value - end - - # Remove this element from its parent - def remove - return self if parent.nil? - - parent.nodes.delete(self) if parent.respond_to?(:nodes) - self.parent = nil - self - end - - # Add a child element to this element - def add_child(child) - child.remove if child.respond_to?(:parent) && child.parent - nodes << child - child.parent = self if child.respond_to?(:parent=) - self - end - - # Create an element with a namespace declaration - # - # This is a class method for convenient creation of namespaced elements. - # - # @param name [String] the element name - # @param prefix [String, nil] the namespace prefix (nil for default namespace) - # @param href [String] the namespace URI - # @return [Element] the new element with namespace - # - # @example Default namespace - # elem = Taurus::Element.with_namespace("root", href: "http://example.org") - # elem.namespace[:href] # => "http://example.org" - # - # @example Prefixed namespace - # elem = Taurus::Element.with_namespace("root", - # prefix: "ex", - # href: "http://example.org") - # elem.namespace_prefix # => "ex" - # - # @see #add_namespace - def self.with_namespace(name, prefix: nil, href:) - elem = new(name) - if prefix - elem.attributes["xmlns:#{prefix}"] = href - elem.add_namespace(prefix, href) - else - elem.attributes["xmlns"] = href - elem.add_namespace(nil, href) - end - elem - end - - # Set the parent element with validation - # - # Sets the parent reference, ensuring no circular references or invalid parents. - # Automatically removes the element from its old parent's children array. - # - # @param new_parent [Element, nil] the new parent element - # @return [Element, nil] the new parent - # @raise [ArgumentError] if trying to set element as its own parent - # @raise [TypeError] if new_parent is not an Element or nil - # - # @example - # child = Taurus::Element.new("child") - # parent = Taurus::Element.new("parent") - # child.parent = parent - # child.parent # => - # - # @note Circular references are silently ignored for safety - def parent=(new_parent) - if new_parent == self - raise ArgumentError, "Cannot set element as its own parent" - end - - unless new_parent.nil? || new_parent.is_a?(Element) - raise TypeError, "Parent must be an Element or nil" - end - - # Check for circular reference by walking up the parent chain - current = new_parent - while current - if current == self - return # Ignore circular reference - end - current = current.parent - end - - # Remove from old parent's nodes if any - if @parent && @parent.respond_to?(:nodes) - @parent.nodes.delete(self) - end - - @parent = new_parent - end - - # @!group Namespace Methods - - # Get the primary namespace of this element - # - # Returns the namespace that applies to this element, which may be a local - # namespace declaration or inherited from an ancestor. - # - # @return [Hash{Symbol => String}, nil] namespace hash with :prefix and :href keys, or nil - # - # @example - # xml = '' - # doc = Taurus.parse(xml) - # doc.root.namespace # => {prefix: nil, href: "http://example.org"} - # - # @see #namespaces - # @see #namespace_for_prefix - def namespace - return nil unless @_namespace_data - - @_namespace_data - end - - # Get all namespace declarations on this element only - # - # Returns only the namespace declarations directly on this element, - # not inherited ones. - # - # @return [Array] array of namespace hashes with :prefix and :href keys - # - # @example - # xml = '' - # doc = Taurus.parse(xml) - # doc.root.namespaces - # # => [{prefix: nil, href: "http://default.org"}, - # # {prefix: "ex", href: "http://example.org"}] - # - # @see #namespace - # @see #all_namespaces - def namespaces - @_namespaces ||= [] - end - - # Resolve a namespace prefix to its URI, checking ancestors - # - # Searches for the namespace URI associated with the given prefix, - # checking local declarations first, then walking up the parent chain. - # This implements proper XML Namespaces 1.0 inheritance. - # - # @param prefix [String, nil] the namespace prefix (nil for default namespace) - # @return [String, nil] the namespace URI or nil if not found - # - # @example Default namespace - # xml = '' - # doc = Taurus.parse(xml) - # doc.root.nodes.first.namespace_for_prefix(nil) - # # => "http://example.org" (inherited) - # - # @example Prefixed namespace - # elem.namespace_for_prefix("ex") # => "http://example.org" - # - # @see #namespace - # @see #add_namespace - def namespace_for_prefix(prefix) - # Check local namespaces first - namespaces.each do |ns| - if prefix.nil? - return ns[:href] if ns[:prefix].nil? - elsif ns[:prefix] == prefix - return ns[:href] - end - end - - # Check parent namespaces - parent&.namespace_for_prefix(prefix) - end - - # Add a namespace declaration to this element - # - # Declares a new namespace on this element, adding both to the internal - # namespace list and to the element's attributes. - # - # @param prefix [String, nil] the namespace prefix (nil for default namespace) - # @param href [String] the namespace URI - # @return [void] - # - # @example Add default namespace - # elem.add_namespace(nil, "http://example.org") - # elem.attributes["xmlns"] # => "http://example.org" - # - # @example Add prefixed namespace - # elem.add_namespace("ex", "http://example.org") - # elem.attributes["xmlns:ex"] # => "http://example.org" - # - # @see .with_namespace - def add_namespace(prefix, href) - @_namespaces ||= [] - @_namespaces << { prefix: prefix, href: href } - - # Update attributes to include xmlns declaration - if prefix.nil? - @attributes["xmlns"] = href - else - @attributes["xmlns:#{prefix}"] = href - end - end - - # Get the namespace prefix for this element - # - # @return [String, nil] the prefix or nil for default namespace - # - # @example - # elem.namespace_prefix # => "ex" - # - # @see #namespace_uri - def namespace_prefix - namespace&.[](:prefix) - end - - # Get the namespace URI for this element - # - # @return [String, nil] the namespace URI or nil - # - # @example - # elem.namespace_uri # => "http://example.org" - # - # @see #namespace_prefix - def namespace_uri - namespace&.[](:href) - end - - # Check if element has a namespace - # - # @return [Boolean] true if element has a namespace - # - # @example - # elem.namespace? # => true - def namespace? - !namespace.nil? - end - - # Get all namespace definitions including inherited ones - # - # Returns a hash of all namespaces in scope for this element, - # including both local declarations and inherited ones from ancestors. - # Local declarations override inherited ones. - # - # @return [Hash{String => String}] map of prefixes (or nil) to URIs - # - # @example - # xml = '' - # doc = Taurus.parse(xml) - # item = doc.root.nodes.first - # item.all_namespaces - # # => {nil => "http://default.org", "ex" => "http://example.org"} - # - # @see #namespaces - # @see #namespace_for_prefix - def all_namespaces - result = {} - - # Add inherited namespaces from parents - if parent - parent.all_namespaces.each do |prefix, href| - result[prefix] = href - end - end - - # Override with local declarations - namespaces.each do |ns| - prefix = ns[:prefix] - result[prefix] = ns[:href] - end - - result - end - - # @!endgroup - - # Locate nodes by path (Ox-compatible) - # - # Provides Ox-compatible path-based node location using a simplified - # path syntax. For XPath queries, use {#xpath} instead. - # - # @param path [String, nil] the path pattern to match - # @return [Array] matching elements - # - # @example Simple path - # elem.locate('child/grandchild') - # - # @example Wildcard - # elem.locate('*/item') - # - # @note For full XPath support, use {#xpath} instead - # @see #xpath - def locate(path) - return [self] if path.nil? - - found = [] - pa = path.split('/') - if path.start_with?('*') - # Allow self to be checked - e = Element.new('') - e << self - e.alocate(pa, found) - else - alocate(pa, found) - end - found - end - - # Dynamic method dispatch for child element access - # - # Allows accessing child elements and attributes using method syntax. - # This provides a convenient alternative to navigating the nodes array. - # - # @param id [Symbol] the method name (element name or attribute key) - # @param args [Array] optional index for multiple matching elements - # @return [Element, String, nil] the matched element, attribute value, or nil - # @raise [NoMethodError] if no matching element or attribute found - # - # @example Access child element - # parent.child_name # => element - # - # @example Access multiple elements by index - # parent.item(0) # => first - # parent.item(1) # => second - # - # @example Access attribute - # elem.id # => attribute value if no child named "id" - # - # @note This method only works when no regular method conflicts - def method_missing(id, *args, &block) - has_some = false - ids = id.to_s - i = args[0].to_i - - nodes.each do |n| - next unless (n.is_a?(Element) || n.is_a?(Instruct)) && (n.value == id || n.value == ids) - return n if i == 0 - - has_some = true - i -= 1 - end - - return @attributes[id] if @attributes.key?(id) - return @attributes[ids] if @attributes.key?(ids) - return nil if has_some - - raise NoMethodError, "#{ids} not found" - end - - # Check if method_missing will handle the given method - # - # @param id [Symbol] the method name to check - # @param inc_all [Boolean] whether to include all methods - # @return [Boolean] true if the method will be handled - # - # @api private - def respond_to_missing?(id, inc_all = false) - id_str = id.to_s - id_sym = id.to_sym - - nodes.each do |n| - next if n.is_a?(String) - return true if n.respond_to?(:value) && (n.value == id_str || n.value == id_sym) - end - - return true if @attributes.key?(id_str) || @attributes.key?(id_sym) - - false - end - - # Execute an XPath query on this element - # - # Evaluates the XPath expression with this element as the context node. - # Automatically finds or creates the document context for proper evaluation. - # Supports full XPath 1.0 specification. - # - # @param expression [String] the XPath expression to evaluate - # @param namespaces [Hash{String => String}, nil] optional custom namespace mappings - # (prefix => URI). Overrides auto-detected namespaces. - # @return [Array, String, Float, Boolean] the query result - # - Node-set queries return Array - # - String queries return String - # - Numeric queries return Float - # - Boolean queries return true/false - # - # @example Find descendants - # elem.xpath('.//book') # => [, , ...] - # - # @example Count descendants - # elem.xpath('count(.//book)') # => 2.0 - # - # @example Use predicates - # elem.xpath('.//book[@price > 20]') - # - # @example Relative paths - # elem.xpath('./child | ./other') # Union - # - # @example Custom namespaces - # elem.xpath('//ns:book', namespaces: { 'ns' => 'http://books.org' }) - # - # @see Document#xpath - # @see XPath - def xpath(expression, namespaces: nil) - # Validate XPath expression - raise RuntimeError, "XPath parsing error: empty expression" if expression.nil? || expression.empty? - - # Find the document root for context - current = self - current = current.parent while current.parent && !current.is_a?(Document) - - # If we found a Document, use it - if current.is_a?(Document) - doc = current - else - # No Document found - current is the root element - # If this element has C pointers, create a document that preserves them - if instance_variable_defined?(:@_c_doc_ptr) && @_c_doc_ptr - # Element was parsed from C - create Document wrapper with C pointer - doc = Document.new - doc.instance_variable_set(:@_c_ptr, @_c_doc_ptr) - doc.root = current - else - # Pure Ruby element - create temporary document - doc = Document.new - doc.root = current - end - end - - # Call the C extension's xpath_evaluate function - Taurus.xpath_evaluate(doc, expression, self, namespaces) - end - - protected - - # Internal locate implementation - def alocate(path, found) - step = path[0] - - if step.start_with?('@') # attribute - raise Taurus::Error, "Invalid path" unless path.size == 1 - - step = step[1..-1] - sym_step = step.to_sym - @attributes.each do |k, v| - found << v if step == '?' || k == step || k == sym_step - end - else # element name - if (i = step.index('[')).nil? - name = step - qual = nil - else - name = step[0..i-1] - raise Taurus::Error, "Invalid path" unless step.end_with?(']') - - i += 1 - qual = step[i..i] - qual = '+' if qual.between?('0', '9') - i += 1 unless qual == '+' - index = step[i..-2].to_i - end - - # Select matching nodes - match = if ['?', '*'].include?(name) - nodes - elsif name.start_with?('^') - class_name = name[1..-1] - nodes.select do |e| - case class_name - when 'Element' then e.is_a?(Element) - when 'String', 'Text' then e.is_a?(String) - when 'Comment' then e.is_a?(Comment) rescue false - when 'CData' then e.is_a?(CData) rescue false - else false - end - end - else - nodes.select { |e| e.is_a?(Element) && name == e.name } - end - - # Apply qualifiers - unless qual.nil? || match.empty? - match = case qual - when '+' then index < match.size ? [match[index]] : [] - when '-' then index <= match.size ? [match[-index]] : [] - when '<' then index > 0 ? match[0..index-1] : [] - when '>' then index <= match.size ? match[index+1..-1] : [] - when '@' - k, v = step[i..-2].split('=') - if v - match.select { |n| n.is_a?(Element) && (v == n.attributes[k.to_sym] || v == n.attributes[k]) } - else - match.select { |n| n.is_a?(Element) && (n.attributes[k.to_sym] || n.attributes[k]) } - end - else - raise Taurus::Error, "Invalid path" - end - end - - # Recurve or add to found - if path.size == 1 - match.each { |n| found << n } - elsif name == '*' - match.each { |n| n.alocate(path, found) if n.is_a?(Element) } - match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) } - else - match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) } - end - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/ffi/bridge.rb b/lib/taurus/ffi/bridge.rb deleted file mode 100644 index 10cd724..0000000 --- a/lib/taurus/ffi/bridge.rb +++ /dev/null @@ -1,276 +0,0 @@ -# frozen_string_literal: true - -require_relative 'library' -require_relative 'types' -require_relative 'memory' -require_relative 'errors' - -module Taurus - module FFI - # Bridge between C pointers and Ruby objects - # Converts taurus_document/taurus_element pointers to Ruby Document/Element instances - module Bridge - class << self - # Convert a taurus_document pointer to a Ruby Document object - # @param doc_ptr [FFI::Pointer] the document pointer from C (wrapped in AutoPointer) - # @return [Document] the Ruby Document object - def document_from_ptr(doc_ptr) - return nil if doc_ptr.nil? || doc_ptr.null? - - # Get encoding from C - encoding_str = Taurus::FFI.taurus_document_encoding(doc_ptr) - - # Create Ruby Document with prolog - doc = Document.new( - version: "1.0", - encoding: encoding_str - ) - - # CRITICAL: Store C pointer for XPath evaluation - # The AutoPointer will handle cleanup when Ruby object is GC'd - doc.instance_variable_set(:@_c_ptr, doc_ptr) - - # Get root element - root_ptr = Taurus::FFI.taurus_document_root(doc_ptr) - if root_ptr && !root_ptr.null? - root_elem = element_from_ptr(root_ptr, doc_ptr) - doc.root = root_elem if root_elem - end - - doc - end - - # Convert a taurus_element pointer to a Ruby Element object - # @param elem_ptr [FFI::Pointer] the element pointer from C - # @param doc_ptr [FFI::Pointer] the document pointer (for XPath context, optional) - # @return [Element] the Ruby Element object - def element_from_ptr(elem_ptr, doc_ptr = nil) - return nil if elem_ptr.nil? || elem_ptr.null? - - # Safety check: detect attribute nodes before calling C functions - # Attribute nodes have node_type (int, value 1) as first 4 bytes - # Element nodes have name pointer (8 bytes) as first field - begin - first_bytes = elem_ptr.read_bytes(4) - first_int = first_bytes.unpack1('L') # Little-endian uint32 - rescue => e - # If we can't read the pointer safely, it's invalid - warn "Warning: Cannot read pointer in element_from_ptr: #{e.message}" if $DEBUG - return nil - end - - # If first 4 bytes == 1, it's TAURUS_NODE_ATTRIBUTE - return nil if first_int == 1 - - # Get element name and freeze it (string interning optimization) - begin - name = Taurus::FFI.taurus_element_name(elem_ptr) - return nil unless name - name = name.freeze - rescue => e - # Pointer is not a valid element - warn "Warning: Invalid element pointer in element_from_ptr: #{e.message}" if $DEBUG - return nil - end - - # Create Ruby Element - elem = Element.new(name) - - # CRITICAL: Store C pointers for XPath evaluation - elem.instance_variable_set(:@_c_ptr, elem_ptr) - elem.instance_variable_set(:@_c_doc_ptr, doc_ptr) if doc_ptr - - # Get text content (for text nodes) - text = Taurus::FFI.taurus_element_text(elem_ptr) - if text && !text.empty? - elem.instance_variable_set(:@_text_content, text) - end - - # Set namespace data if present - ns_uri = Taurus::FFI.taurus_element_namespace(elem_ptr) - ns_prefix = Taurus::FFI.taurus_element_prefix(elem_ptr) - - if ns_uri && !ns_uri.empty? - elem.instance_variable_set(:@_namespace_data, { - prefix: (ns_prefix && !ns_prefix.empty?) ? ns_prefix : nil, - href: ns_uri - }) - end - - # Load attributes - load_attributes(elem_ptr, elem) - - # Load namespace declarations - load_namespaces(elem_ptr, elem) - - # Load children - load_children(elem_ptr, elem, doc_ptr) - - elem - end - - # Load attributes from C element to Ruby element - # @param elem_ptr [FFI::Pointer] the C element pointer - # @param elem [Element] the Ruby element - # @return [void] - def load_attributes(elem_ptr, elem) - count = Taurus::FFI.taurus_element_attribute_count(elem_ptr) - - count.times do |i| - begin - attr_ptr = Taurus::FFI.taurus_element_attribute(elem_ptr, i) - next if attr_ptr.nil? || attr_ptr.null? - - name = Taurus::FFI.taurus_attribute_name(attr_ptr) - value = Taurus::FFI.taurus_attribute_value(attr_ptr) - - elem.attributes[name.to_sym] = value if name && value - rescue => e - # Skip invalid attribute pointers - warn "Warning: Failed to load attribute #{i}: #{e.message}" if $DEBUG - next - end - end - end - - # Load namespace declarations from C element to Ruby element - # @param elem_ptr [FFI::Pointer] the C element pointer - # @param elem [Element] the Ruby element - # @return [void] - def load_namespaces(elem_ptr, elem) - count = Taurus::FFI.taurus_element_namespace_count(elem_ptr) - - count.times do |i| - ns_ptr = Taurus::FFI.taurus_element_namespace_decl(elem_ptr, i) - next if ns_ptr.null? - - prefix = Taurus::FFI.taurus_namespace_prefix(ns_ptr) - uri = Taurus::FFI.taurus_namespace_uri(ns_ptr) - - if uri && !uri.empty? - prefix = nil if prefix && prefix.empty? - elem.add_namespace(prefix, uri) - end - end - end - - # Load children from C element to Ruby element - # @param elem_ptr [FFI::Pointer] the C element pointer - # @param elem [Element] the Ruby element - # @param doc_ptr [FFI::Pointer] the document pointer (optional) - # @return [void] - def load_children(elem_ptr, elem, doc_ptr = nil) - count = Taurus::FFI.taurus_element_child_count(elem_ptr) - - # If we have text content, add it as a text node - if elem.instance_variable_get(:@_text_content) - elem << elem.instance_variable_get(:@_text_content) - end - - count.times do |i| - child_ptr = Taurus::FFI.taurus_element_child(elem_ptr, i) - next if child_ptr.null? - - # Recursively convert child element - child = element_from_ptr(child_ptr, doc_ptr) - elem << child if child - end - end - - # Convert XPath result to Ruby value - # @param result_ptr [FFI::Pointer] the XPath result pointer - # @param doc_ptr [FFI::Pointer] the document pointer (for full element hydration) - # @return [Array, String, Float, Boolean] the converted result - def xpath_result_to_ruby(result_ptr, doc_ptr = nil) - return nil if result_ptr.null? - - # Get result type - type_int = Taurus::FFI.taurus_xpath_result_get_type(result_ptr) - type = Taurus::FFI.xpath_result_type_to_sym(type_int) - - case type - when :boolean - bool_int = Taurus::FFI.taurus_xpath_result_as_boolean(result_ptr) - bool_int != 0 - - when :number - Taurus::FFI.taurus_xpath_result_as_number(result_ptr) - - when :string - str = Taurus::FFI.taurus_xpath_result_as_string(result_ptr) - # v1.1.0: FFI returns ASCII-8BIT by default, force UTF-8 encoding - # The C library produces correct UTF-8 bytes, we just need to mark them correctly - str.force_encoding(Encoding::UTF_8) if str - str - - when :nodeset - # Convert nodeset to Ruby array by reading XPathNodeSet struct directly - # This bypasses the public API which filters out attributes - - # struct taurus_xpath_result { type(4+4pad), value(union at offset 8) } - # value.nodeset_value is XPathNodeSet* - nodeset_ptr = result_ptr.get_pointer(8) - return [] if nodeset_ptr.null? - - # struct xpath_nodeset { void** nodes, size_t count, size_t capacity } - nodes_array_ptr = nodeset_ptr.read_pointer # void** nodes at offset 0 - count = nodeset_ptr.get_uint64(8) # size_t count at offset 8 (8 bytes on 64-bit) - - result = [] - count.times do |i| - # Read void* from nodes array - node_ptr = nodes_array_ptr.get_pointer(i * ::FFI::Pointer.size) - next if node_ptr.null? - - # Type detection: Only attribute nodes have a node_type field! - # Elements have char* name as first field (8 bytes on 64-bit). - # Read first 4 bytes and check if it's the ATTRIBUTE enum value (1). - # If not 1, treat as element (no type field exists). - first_int = node_ptr.read_int - puts "DEBUG: Node #{i}: first_int = #{first_int}, hex = 0x#{first_int.to_s(16)}" if ENV['XPATH_DEBUG'] - - # Type detection strategy: - # - Attribute nodes have node_type (int, value 1) as first 4 bytes - # - Element nodes have name pointer (8 bytes) as first field - # - # We check the first 4 bytes. If it's exactly 1, it's an attribute. - # Otherwise, try to convert as element, and if that fails, try as attribute. - - if first_int == 1 - # Attribute node (node_type == TAURUS_NODE_ATTRIBUTE) - # struct TaurusAttributeNode: node_type(4+4pad), name(8), value(8), ns_uri(8), owner(8) - begin - value_ptr = node_ptr.get_pointer(16) # offset 16 = value field - attr_value = value_ptr.null? ? "" : value_ptr.read_string - result << attr_value - rescue => e - warn "Warning: Failed to read attribute at index #{i}: #{e.message}" if $DEBUG - next - end - else - # Element node - call element_from_ptr to fully hydrate with children/attributes - begin - # Use element_from_ptr to properly populate element with all structure - elem = element_from_ptr(node_ptr, doc_ptr) - if elem - result << elem - else - warn "Warning: Element at index #{i} could not be converted" if $DEBUG - end - rescue => e - warn "Warning: Failed to convert element at index #{i}: #{e.message}" if $DEBUG - next - end - end - end - - result - - else - nil - end - end - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/ffi/errors.rb b/lib/taurus/ffi/errors.rb deleted file mode 100644 index f0aa195..0000000 --- a/lib/taurus/ffi/errors.rb +++ /dev/null @@ -1,109 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module FFI - # ======================================================================== - # Error Handling - # ======================================================================== - - module ErrorHandling - # Map error codes to symbols - ERROR_CODE_SYMBOLS = { - ErrorCode::NULL_INPUT => :null_input, - ErrorCode::EMPTY_INPUT => :empty_input, - ErrorCode::PARSE_FAILED => :parse_failed, - ErrorCode::INVALID_XML => :invalid_xml, - ErrorCode::UNCLOSED_TAG => :unclosed_tag, - ErrorCode::INVALID_ATTR => :invalid_attr, - ErrorCode::ENCODING => :encoding, - ErrorCode::NAMESPACE => :namespace, - ErrorCode::MALFORMED => :malformed, - ErrorCode::XPATH_SYNTAX => :xpath_syntax, - ErrorCode::XPATH_FUNCTION => :xpath_function, - ErrorCode::XPATH_TYPE_MISMATCH => :xpath_type_mismatch, - ErrorCode::XPATH_NAMESPACE => :xpath_namespace, - ErrorCode::XPATH_UNKNOWN_AXIS => :xpath_unknown_axis, - ErrorCode::EVAL_CONTEXT => :eval_context, - ErrorCode::EVAL_ARGUMENT => :eval_argument, - ErrorCode::EVAL_OVERFLOW => :eval_overflow, - ErrorCode::OUT_OF_MEMORY => :out_of_memory, - ErrorCode::INTERNAL => :internal - }.freeze - - # Check for errors after FFI call and raise appropriate Ruby exception - # @raise [ParseError] if a parse error occurred - # @raise [XPathError] if an XPath error occurred - # @raise [Error] for other errors - def self.check_error! - error_msg = Taurus::FFI.taurus_last_error - return if error_msg.nil? || error_msg.empty? - - error_code = Taurus::FFI.taurus_last_error_code - line = Taurus::FFI.taurus_parse_error_line || 0 - column = Taurus::FFI.taurus_parse_error_column || 0 - context = Taurus::FFI.taurus_error_context - byte_offset = Taurus::FFI.taurus_error_byte_offset || 0 - - # Convert to symbol - code_symbol = ERROR_CODE_SYMBOLS[error_code] || :unknown - - Taurus::FFI.taurus_clear_error - - # Determine exception type based on error code - exception_class = case error_code - when ErrorCode::NULL_INPUT, ErrorCode::EMPTY_INPUT, - ErrorCode::UNCLOSED_TAG, ErrorCode::INVALID_ATTR, - ErrorCode::ENCODING, ErrorCode::NAMESPACE, - ErrorCode::MALFORMED, ErrorCode::PARSE_FAILED, - ErrorCode::INVALID_XML - Taurus::ParseError - when ErrorCode::XPATH_SYNTAX, ErrorCode::XPATH_FUNCTION, - ErrorCode::XPATH_TYPE_MISMATCH, ErrorCode::XPATH_NAMESPACE, - ErrorCode::XPATH_UNKNOWN_AXIS - Taurus::XPathError - when ErrorCode::EVAL_CONTEXT, ErrorCode::EVAL_ARGUMENT, - ErrorCode::EVAL_OVERFLOW - Taurus::EvaluationError - else - Taurus::Error - end - - # Create exception with all attributes - exception = exception_class.new( - error_msg, - code: code_symbol, - line: line, - column: column, - byte_offset: byte_offset, - context: context - ) - - raise exception - end - - # Wrap FFI call with error checking - # @yield block to execute - # @return result of block - # @raise [ParseError, Error] if error occurred - def self.with_error_check - result = yield - check_error! if result.nil? || (result.respond_to?(:null?) && result.null?) - result - end - end - - # ======================================================================== - # Convenience Methods - # ======================================================================== - - # Check for errors and raise if any - def self.check_error! - ErrorHandling.check_error! - end - - # Wrap call with error checking - def self.with_error_check(&block) - ErrorHandling.with_error_check(&block) - end - end -end \ No newline at end of file diff --git a/lib/taurus/ffi/library.rb b/lib/taurus/ffi/library.rb deleted file mode 100644 index cce6ebe..0000000 --- a/lib/taurus/ffi/library.rb +++ /dev/null @@ -1,120 +0,0 @@ -# frozen_string_literal: true - -require 'ffi' - -module Taurus - module FFI - extend ::FFI::Library - - # Dynamic library loading - # Try to find libtaurus in common locations - lib_paths = [ - File.expand_path('../../../build/lib/libtaurus.dylib', __dir__), # Build directory (macOS) - File.expand_path('../../../build/lib/libtaurus.so', __dir__), # Build directory (Linux) - File.expand_path('../../../lib/libtaurus.dylib', __dir__), # Installed location (macOS) - File.expand_path('../../../lib/libtaurus.so', __dir__), # Installed location (Linux) - 'taurus', # System library path - ] - - lib_path = lib_paths.find { |path| File.exist?(path) } || 'taurus' - ffi_lib lib_path - - # ======================================================================== - # Opaque Types - # ======================================================================== - - typedef :pointer, :taurus_document - typedef :pointer, :taurus_element - typedef :pointer, :taurus_attribute - typedef :pointer, :taurus_namespace - typedef :pointer, :taurus_xpath_result - - # ======================================================================== - # Version Functions - # ======================================================================== - - attach_function :taurus_version, [], :string - attach_function :taurus_version_components, [:pointer, :pointer, :pointer], :void - - # ======================================================================== - # Parse Options - # ======================================================================== - - attach_function :taurus_parse_options_init, [:pointer], :void - - # ======================================================================== - # Document Functions - # ======================================================================== - - attach_function :taurus_parse, [:string, :size_t], :taurus_document - attach_function :taurus_parse_with_options, [:string, :size_t, :pointer], :taurus_document - attach_function :taurus_document_free, [:taurus_document], :void - attach_function :taurus_document_root, [:taurus_document], :taurus_element - attach_function :taurus_document_encoding, [:taurus_document], :string - - # ======================================================================== - # Element Functions - # ======================================================================== - - attach_function :taurus_element_name, [:taurus_element], :string - attach_function :taurus_element_namespace, [:taurus_element], :string - attach_function :taurus_element_prefix, [:taurus_element], :string - attach_function :taurus_element_text, [:taurus_element], :string - attach_function :taurus_element_parent, [:taurus_element], :taurus_element - attach_function :taurus_element_child_count, [:taurus_element], :size_t - attach_function :taurus_element_child, [:taurus_element, :size_t], :taurus_element - - # ======================================================================== - # Attribute Functions - # ======================================================================== - - attach_function :taurus_element_attribute_count, [:taurus_element], :size_t - attach_function :taurus_element_attribute, [:taurus_element, :size_t], :taurus_attribute - attach_function :taurus_element_get_attribute, [:taurus_element, :string], :string - attach_function :taurus_element_has_attribute, [:taurus_element, :string], :int - attach_function :taurus_attribute_name, [:taurus_attribute], :string - attach_function :taurus_attribute_value, [:taurus_attribute], :string - attach_function :taurus_attribute_namespace, [:taurus_attribute], :string - - # ======================================================================== - # Namespace Functions - # ======================================================================== - - attach_function :taurus_element_namespace_count, [:taurus_element], :size_t - attach_function :taurus_element_namespace_decl, [:taurus_element, :size_t], :taurus_namespace - attach_function :taurus_element_resolve_namespace, [:taurus_element, :string], :string - attach_function :taurus_namespace_prefix, [:taurus_namespace], :string - attach_function :taurus_namespace_uri, [:taurus_namespace], :string - - # ======================================================================== - # XPath Functions - # ======================================================================== - - attach_function :taurus_xpath_eval, [:taurus_document, :string, :size_t], :taurus_xpath_result - attach_function :taurus_xpath_eval_with_context, - [:taurus_document, :taurus_element, :string, :size_t], - :taurus_xpath_result - attach_function :taurus_xpath_result_free, [:taurus_xpath_result], :void - attach_function :taurus_xpath_result_get_type, [:taurus_xpath_result], :int - attach_function :taurus_xpath_result_as_boolean, [:taurus_xpath_result], :int - attach_function :taurus_xpath_result_as_number, [:taurus_xpath_result], :double - attach_function :taurus_xpath_result_as_string, [:taurus_xpath_result], :string - attach_function :taurus_xpath_result_nodeset_size, [:taurus_xpath_result], :size_t - attach_function :taurus_xpath_result_nodeset_get, [:taurus_xpath_result, :size_t], :taurus_element - attach_function :taurus_xpath_function_supported, [:string], :int - attach_function :taurus_xpath_supported_functions, [], :pointer - - # ======================================================================== - # Error Functions - # ======================================================================== - - attach_function :taurus_last_error, [], :string - attach_function :taurus_last_error_code, [], :int - attach_function :taurus_error_string, [:int], :string - attach_function :taurus_clear_error, [], :void - attach_function :taurus_parse_error_line, [], :int - attach_function :taurus_parse_error_column, [], :int - attach_function :taurus_error_context, [], :string - attach_function :taurus_error_byte_offset, [], :size_t - end -end \ No newline at end of file diff --git a/lib/taurus/ffi/memory.rb b/lib/taurus/ffi/memory.rb deleted file mode 100644 index c7f5e39..0000000 --- a/lib/taurus/ffi/memory.rb +++ /dev/null @@ -1,59 +0,0 @@ -# frozen_string_literal: true - -require 'ffi' - -module Taurus - module FFI - # ======================================================================== - # Memory Management with AutoPointer - # ======================================================================== - - # AutoPointer for taurus_document - automatically frees when GC'd - class DocumentPointer < ::FFI::AutoPointer - def self.release(ptr) - Taurus::FFI.taurus_document_free(ptr) unless ptr.null? - end - end - - # AutoPointer for taurus_xpath_result - automatically frees when GC'd - class XPathResultPointer < ::FFI::AutoPointer - def self.release(ptr) - Taurus::FFI.taurus_xpath_result_free(ptr) unless ptr.null? - end - end - - # ======================================================================== - # Memory Management Helpers - # ======================================================================== - - module MemoryHelpers - # Wrap a document pointer with AutoPointer for automatic cleanup - # @param ptr [FFI::Pointer] the document pointer from C - # @return [DocumentPointer] wrapped pointer that auto-frees - def self.wrap_document(ptr) - return nil if ptr.null? - DocumentPointer.new(ptr) - end - - # Wrap an XPath result pointer with AutoPointer for automatic cleanup - # @param ptr [FFI::Pointer] the result pointer from C - # @return [XPathResultPointer] wrapped pointer that auto-frees - def self.wrap_xpath_result(ptr) - return nil if ptr.null? - XPathResultPointer.new(ptr) - end - - # Free a string allocated by C - # @param str_ptr [FFI::Pointer] pointer to C-allocated string - # @return [String, nil] the string content before freeing - def self.free_c_string(str_ptr) - return nil if str_ptr.null? - str = str_ptr.read_string - # Note: According to taurus_xpath_result_as_string docs, - # caller must free with free(). FFI handles this via MemoryPointer. - ::FFI::MemoryPointer.from_string(str).free - str - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/ffi/types.rb b/lib/taurus/ffi/types.rb deleted file mode 100644 index 8d35198..0000000 --- a/lib/taurus/ffi/types.rb +++ /dev/null @@ -1,126 +0,0 @@ -# frozen_string_literal: true - -require 'ffi' - -module Taurus - module FFI - # ======================================================================== - # XPath Result Types - # ======================================================================== - - # XPath result type enumeration - module XPathResultType - BOOLEAN = 0 # Boolean result (true/false) - NUMBER = 1 # Number result (double) - STRING = 2 # String result - NODESET = 3 # Node-set result (array of elements) - end - - # ======================================================================== - # Error Codes - # ======================================================================== - - # Error codes - matches taurus_error_code in types.h - module ErrorCode - # Success - OK = 0 - - # Parse errors (1xx) - XML parsing issues - NULL_INPUT = 1 - EMPTY_INPUT = 2 - PARSE_FAILED = 3 - INVALID_XML = 4 - UNCLOSED_TAG = 100 - INVALID_ATTR = 101 - ENCODING = 102 - NAMESPACE = 103 - MALFORMED = 104 - - # XPath errors (2xx) - Query syntax and semantics - XPATH_SYNTAX = 200 - XPATH_FUNCTION = 201 - XPATH_TYPE_MISMATCH = 202 - XPATH_NAMESPACE = 203 - XPATH_UNKNOWN_AXIS = 204 - - # Evaluation errors (3xx) - Runtime issues - EVAL_CONTEXT = 300 - EVAL_ARGUMENT = 301 - EVAL_OVERFLOW = 302 - - # Generic errors (9xx) - OUT_OF_MEMORY = 900 - INTERNAL = 999 - end - - # ======================================================================== - # Parse Options Structure - # ======================================================================== - - # XML parse options - class ParseOptions < ::FFI::Struct - layout :strict, :int, # Strict XML validation (1=strict, 0=lenient) - :preserve_whitespace, :int, # Preserve whitespace-only text nodes - :track_positions, :int # Track line/column positions for errors - - # Initialize with default values - def self.default - opts = new - opts[:strict] = 1 - opts[:preserve_whitespace] = 0 - opts[:track_positions] = 0 - opts - end - end - - # ======================================================================== - # Helper Methods - # ======================================================================== - - # Convert XPath result type integer to symbol - # @param type_int [Integer] the result type as integer - # @return [Symbol] :boolean, :number, :string, or :nodeset - def self.xpath_result_type_to_sym(type_int) - case type_int - when XPathResultType::BOOLEAN then :boolean - when XPathResultType::NUMBER then :number - when XPathResultType::STRING then :string - when XPathResultType::NODESET then :nodeset - else :unknown - end - end - - # Convert error code integer to symbol - # @param code_int [Integer] the error code as integer - # @return [Symbol] error code symbol - def self.error_code_to_sym(code_int) - case code_int - when ErrorCode::OK then :ok - # Parse errors - when ErrorCode::NULL_INPUT then :null_input - when ErrorCode::EMPTY_INPUT then :empty_input - when ErrorCode::PARSE_FAILED then :parse_failed - when ErrorCode::INVALID_XML then :invalid_xml - when ErrorCode::UNCLOSED_TAG then :unclosed_tag - when ErrorCode::INVALID_ATTR then :invalid_attr - when ErrorCode::ENCODING then :encoding - when ErrorCode::NAMESPACE then :namespace - when ErrorCode::MALFORMED then :malformed - # XPath errors - when ErrorCode::XPATH_SYNTAX then :xpath_syntax - when ErrorCode::XPATH_FUNCTION then :xpath_function - when ErrorCode::XPATH_TYPE_MISMATCH then :xpath_type_mismatch - when ErrorCode::XPATH_NAMESPACE then :xpath_namespace - when ErrorCode::XPATH_UNKNOWN_AXIS then :xpath_unknown_axis - # Evaluation errors - when ErrorCode::EVAL_CONTEXT then :eval_context - when ErrorCode::EVAL_ARGUMENT then :eval_argument - when ErrorCode::EVAL_OVERFLOW then :eval_overflow - # Generic errors - when ErrorCode::OUT_OF_MEMORY then :out_of_memory - when ErrorCode::INTERNAL then :internal - else :unknown - end - end - end -end \ No newline at end of file diff --git a/lib/taurus/node.rb b/lib/taurus/node.rb deleted file mode 100644 index 90d8dd4..0000000 --- a/lib/taurus/node.rb +++ /dev/null @@ -1,51 +0,0 @@ -# frozen_string_literal: true - -module Taurus - # Base class for all XML nodes in the document tree. - # - # Node provides the foundation for {Element}, {Document}, and other node types. - # It maintains the node's value and parent relationship in the tree structure. - # - # @abstract Subclass and override methods to create specific node types - # - # @example Direct instantiation (typically not used directly) - # node = Taurus::Node.new("value") - # node.value # => "value" - # - # @see Element - # @see Document - class Node - # @return [String, Symbol, nil] the node's value (name for elements, content for text) - # @return [Element, nil] the parent element of this node - attr_accessor :value, :parent - - # Create a new node with the given value - # - # @param value [String, Symbol, nil] the node's value - # - # @example - # node = Taurus::Node.new("content") - def initialize(value) - @value = value - @parent = nil - end - - # Check equality with another node based on value - # - # Two nodes are equal if they are both Node instances and have the same value. - # Subclasses may override this to check additional attributes. - # - # @param other [Node] the node to compare with - # @return [Boolean] true if nodes are equal - # - # @example - # node1 = Taurus::Node.new("test") - # node2 = Taurus::Node.new("test") - # node1 == node2 # => true - def eql?(other) - return false unless other.is_a?(Node) - value == other.value - end - alias == eql? - end -end \ No newline at end of file diff --git a/lib/taurus/node_set.rb b/lib/taurus/node_set.rb deleted file mode 100644 index 8f6492a..0000000 --- a/lib/taurus/node_set.rb +++ /dev/null @@ -1,161 +0,0 @@ -# frozen_string_literal: true - -require 'set' - -module Taurus - # Collection of nodes returned by XPath queries. - # - # NodeSet provides an Enumerable interface to a collection of XML nodes. - # It is typically returned by XPath queries and supports standard array-like - # operations while maintaining the context of the query. - # - # @example Access nodes from XPath - # doc = Taurus.parse('') - # items = doc.xpath('//item') - # items.size # => 2 - # items.first # => - # - # @example Iterate over nodes - # doc.xpath('//item').each do |item| - # puts item.name - # end - # - # @example Convert to array - # nodes = doc.xpath('//item').to_a - # - # @see Document#xpath - # @see Element#xpath - class NodeSet - include Enumerable - - # @return [Array] the collection of nodes - # @return [Element, Document, nil] the context node for the query - attr_reader :nodes, :context - - # Create a new NodeSet - # - # @param nodes [Array, Element, nil] nodes to include in the set - # @param context [Element, Document, nil] the context node for the query - # - # @example Create from array - # nodes = [elem1, elem2] - # node_set = Taurus::NodeSet.new(nodes) - # - # @example Create from single node - # node_set = Taurus::NodeSet.new(elem) - def initialize(nodes = [], context = nil) - @nodes = Array(nodes) - @context = context - end - - # Iterate over each node in the set - # - # @yieldparam node [Element] each node in the set - # @return [Enumerator] if no block given - # - # @example - # node_set.each { |node| puts node.name } - def each(&block) - @nodes.each(&block) - end - - # Return the number of nodes in the set - # - # @return [Integer] the number of nodes - # - # @example - # doc.xpath('//item').size # => 3 - def size - @nodes.size - end - - # Check if the node set is empty - # - # @return [Boolean] true if no nodes in set - # - # @example - # doc.xpath('//nonexistent').empty? # => true - def empty? - @nodes.empty? - end - - # Return the first node in the set - # - # @return [Element, nil] the first node or nil if empty - # - # @example - # doc.xpath('//item').first # => - def first - @nodes.first - end - - # Return the last node in the set - # - # @return [Element, nil] the last node or nil if empty - # - # @example - # doc.xpath('//item').last # => - def last - @nodes.last - end - - # Access node by index - # - # @param index [Integer] the index (0-based) - # @return [Element, nil] the node at index or nil - # - # @example - # nodes = doc.xpath('//item') - # nodes[0] # => first item - # nodes[1] # => second item - def [](index) - @nodes[index] - end - - # Convert the node set to an array - # - # @return [Array] array of nodes - # - # @example - # doc.xpath('//item').to_a # => [, , ...] - def to_a - @nodes - end - - # Remove duplicate nodes by object identity - # - # This method modifies the node set in-place to remove duplicate nodes - # based on their native object identity. Useful when union operations - # may produce duplicate references. - # - # @return [NodeSet] self - # - # @example - # node_set.uniq_by_native - # node_set.size # => reduced if duplicates removed - def uniq_by_native - # Remove duplicates by object identity - seen = Set.new - unique_nodes = [] - @nodes.each do |node| - native = node.respond_to?(:native) ? node.native : node - unless seen.include?(native) - seen.add(native) - unique_nodes << node - end - end - @nodes = unique_nodes - self - end - - # Return a string representation of the node set - # - # @return [String] a debug-friendly representation - # - # @example - # node_set.inspect # => "#" - def inspect - "#" - end - end -end diff --git a/lib/taurus/xml.rb b/lib/taurus/xml.rb new file mode 100644 index 0000000..5befb5a --- /dev/null +++ b/lib/taurus/xml.rb @@ -0,0 +1,27 @@ +# frozen_string_literal: true + +module Taurus + module XML + autoload :FFI, "taurus/xml/ffi" + autoload :Node, "taurus/xml/node" + autoload :Element, "taurus/xml/element" + autoload :Text, "taurus/xml/text" + autoload :Comment, "taurus/xml/comment" + autoload :CDATA, "taurus/xml/cdata" + autoload :ProcessingInstruction, "taurus/xml/processing_instruction" + autoload :Attr, "taurus/xml/attr" + autoload :Namespace, "taurus/xml/namespace" + autoload :Document, "taurus/xml/document" + autoload :NodeSet, "taurus/xml/node_set" + autoload :Searchable, "taurus/xml/searchable" + autoload :ParseOptions, "taurus/xml/parse_options" + autoload :CssToXPath, "taurus/xml/css_to_xpath" + autoload :SAX, "taurus/xml/sax" + require "taurus/xml/c14n" # module-level helper, eager load + + class Error < StandardError; end + class ParseError < Error; end + class XPathError < Error; end + class UseAfterFreeError < Error; end + end +end diff --git a/lib/taurus/xml/attr.rb b/lib/taurus/xml/attr.rb new file mode 100644 index 0000000..f5bce9b --- /dev/null +++ b/lib/taurus/xml/attr.rb @@ -0,0 +1,43 @@ +# frozen_string_literal: true + +# Lightweight attribute wrapper. libtaurus v0.4.4 doesn't expose per-attribute +# pointers (no TaurusAttribute accessors in the public API), so an Attr is a +# (name, value, parent_element) triple. Mutation goes through the parent +# element via #[]. Once upstream adds attribute-level accessors, this can +# become a pointer-backed wrapper. + +class Taurus::XML::Attr + attr_reader :name, :value, :element + + def initialize(name, value, element) + @name = name + @value = value + @element = element + end + + def value=(new_value) + @element[@name] = new_value + @value = new_value + end + + def namespace + nil # upstream gap: per-attribute namespace not exposed + end + + def remove + @element.remove_attribute(@name) + end + + def to_s; @value; end + def to_str; @value; end + + def ==(other) + other.is_a?(Taurus::XML::Attr) && + @name == other.name && @value == other.value && + @element == other.element + end + + def inspect + "#<#{self.class.name} name=#{@name.inspect} value=#{@value.inspect}>" + end +end diff --git a/lib/taurus/xml/c14n.rb b/lib/taurus/xml/c14n.rb new file mode 100644 index 0000000..fce234d --- /dev/null +++ b/lib/taurus/xml/c14n.rb @@ -0,0 +1,23 @@ +# frozen_string_literal: true + +module Taurus + module XML + # @api private + # + # Builds a NULL-terminated `const char**` from a Ruby array of strings, + # suitable for passing to taurus_c14n_canonicalize_ex's + # `inclusive_ns_prefixes` argument. Returns [pointer, anchor] where + # anchor is the underlying MemoryPointer that the caller must keep + # alive (e.g. via local variable) for the duration of the FFI call. + def self.c14n_build_ns_pointer(inclusive_namespaces) + return [nil, nil] if inclusive_namespaces.nil? || inclusive_namespaces.empty? + strs = Array(inclusive_namespaces).map(&:to_s) + ptr_size = ::FFI.type_size(:pointer) + buffer = ::FFI::MemoryPointer.new(:pointer, strs.size + 1) + anchors = strs.map { |s| ::FFI::MemoryPointer.from_string(s) } + anchors.each_with_index { |p, i| buffer.put_pointer(i * ptr_size, p) } + buffer.put_pointer(strs.size * ptr_size, nil) + [buffer, anchors] + end + end +end diff --git a/lib/taurus/xml/cdata.rb b/lib/taurus/xml/cdata.rb new file mode 100644 index 0000000..5c5a4b5 --- /dev/null +++ b/lib/taurus/xml/cdata.rb @@ -0,0 +1,16 @@ +# frozen_string_literal: true + +class Taurus::XML::CDATA < Taurus::XML::Text + def name; "#cdata-section"; end + + def content + Taurus::XML::FFI.taurus_cdata_node_get_content(@c_ptr) + end + + def content=(new_content) + status = Taurus::XML::FFI.taurus_cdata_node_set_content(@c_ptr, new_content.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_content + end +end diff --git a/lib/taurus/xml/comment.rb b/lib/taurus/xml/comment.rb new file mode 100644 index 0000000..7ad8862 --- /dev/null +++ b/lib/taurus/xml/comment.rb @@ -0,0 +1,16 @@ +# frozen_string_literal: true + +class Taurus::XML::Comment < Taurus::XML::Node + def name; "comment"; end + + def content + Taurus::XML::FFI.taurus_comment_node_get_content(@c_ptr) + end + + def content=(new_content) + status = Taurus::XML::FFI.taurus_comment_node_set_content(@c_ptr, new_content.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_content + end +end diff --git a/lib/taurus/xml/css_to_xpath.rb b/lib/taurus/xml/css_to_xpath.rb new file mode 100644 index 0000000..11adebb --- /dev/null +++ b/lib/taurus/xml/css_to_xpath.rb @@ -0,0 +1,177 @@ +# frozen_string_literal: true + +module Taurus + module XML + # Minimal CSS-to-XPath translator covering the common Nokogiri subset: + # + # tag → //tag + # * → //* + # .class → //*[contains(concat(' ',@class,' '),' class ')] + # #id → //*[@id='id'] + # [attr] → //*[@attr] + # [attr=val] → //*[@attr='val'] + # tag[attr] → //tag[@attr] + # tag[attr=val] → //tag[@attr='val'] + # parent > child → //parent/child + # ancestor descendant → //ancestor//descendant + # a, b → //a | //b + # tag:first-child → //tag[position()=1] + # tag:last-child → //tag[position()=last()] + # tag:not(simple) → //tag[not(self::simple)] + # + # For anything beyond this subset, raise ArgumentError. Callers can fall + # back to writing XPath directly via #xpath/#at_xpath. + module CssToXPath + COMMA_SPLIT = /\s*,\s*/.freeze + private_constant :COMMA_SPLIT + + # Token types in a single simple selector. + # tag (optional), then zero or more of: .class, #id, [attr...], :pseudo + TAG_RE = /\A(\*|[\w-]+)/.freeze + DOT_CLASS_RE = /\A\.([\w-]+)/.freeze + HASH_ID_RE = /\A#([\w-]+)/.freeze + BRACKET_RE = /\A\[([^\]]+)\]/.freeze + PSEUDO_RE = /\A:([\w-]+(?:\([^)]*\))?)/.freeze + + module_function + + def convert(rule) + rule.to_s.split(COMMA_SPLIT).map { |r| convert_one(r.strip) }.join(" | ") + end + + def convert_one(rule) + return "//*" if rule == "*" + + # Tokenize chain first (handles > and whitespace) + if rule =~ /\s/ || rule.include?(">") + return convert_chain(rule) + end + + convert_simple(rule, prefix: "//") + end + + # Parse a single simple selector into (tag, predicates) where + # predicates is an array of XPath fragments to be joined via [p1][p2]... + def parse_simple(part) + tag = "*" + preds = [] + + s = part.strip + if s =~ TAG_RE + tag = $1 + s = $' + end + + until s.empty? + case s + when DOT_CLASS_RE + preds << "contains(concat(' ',normalize-space(@class),' '),' #{$1} ')" + s = $' + when HASH_ID_RE + preds << "@id='#{$1}'" + s = $' + when BRACKET_RE + preds << convert_attrs($1) + s = $' + when PSEUDO_RE + preds << convert_pseudo($1) + s = $' + else + raise ArgumentError, + "unsupported CSS selector at #{s.inspect} (in #{part.inspect})" + end + end + + [tag, preds] + end + + def convert_simple(part, prefix:) + tag, preds = parse_simple(part) + "#{prefix}#{tag}#{preds.map { |p| "[#{p}]" }.join}" + end + private_class_method :convert_simple + + def convert_attrs(clause) + case clause.strip + when /\A(\w+)\z/ + "@#{$1}" + when /\A(\w+)=['"]?([^'"\]]+)['"]?\z/ + "@#{$1}='#{$2}'" + when /\A(\w+)~=['"]?([^'"\]]+)['"]?\z/ + "contains(concat(' ',normalize-space(@#{$1}),' '),' #{$2} ')" + when /\A(\w+)\^=['"]?([^'"\]]+)['"]?\z/ + "starts-with(@#{$1}, '#{$2}')" + when /\A(\w+)\$=['"]?([^'"\]]+)['"]?\z/ + "substring(@#{$1}, string-length(@#{$1}) - string-length('#{$2}') + 1) = '#{$2}'" + when /\A(\w+)\*=['"]?([^'"\]]+)['"]?\z/ + "contains(@#{$1}, '#{$2}')" + else + raise ArgumentError, "unsupported attribute selector: [#{clause}]" + end + end + private_class_method :convert_attrs + + def convert_pseudo(pseudo) + case pseudo + when "first-child" then "not(preceding-sibling::*)" + when "last-child" then "not(following-sibling::*)" + when "only-child" then "not(preceding-sibling::* or following-sibling::*)" + when "empty" then "not(node())" + when "root" then "not(parent::*)" + when /\Anot\((.+)\)\z/ + inner_tag, _ = parse_simple($1) + "not(self::#{inner_tag})" + else + raise ArgumentError, "unsupported pseudo-class: :#{pseudo}" + end + end + private_class_method :convert_pseudo + + # Tokenize chain into [sel, op, sel, op, sel, ...] where op is :child or + # :descendant. Then build XPath. + def convert_chain(rule) + tokens = tokenize_chain(rule) + build_chain_xpath(tokens) + end + private_class_method :convert_chain + + def tokenize_chain(rule) + tokens = [] + s = rule.strip + until s.empty? + if s.sub!(/\A\s*>\s*/, "") + tokens << :child + elsif s.sub!(/\A\s+/, "") + # whitespace descendant only counts if previous token is a string + tokens << :descendant if tokens.last.is_a?(String) + else + # Read one simple selector — keep going until whitespace or > or end + m = s.match(/\A[^>\s]+/) + raise ArgumentError, "couldn't parse CSS chain at: #{s.inspect}" unless m + tokens << m[0] + s = m.post_match + end + end + tokens + end + private_class_method :tokenize_chain + + def build_chain_xpath(tokens) + first = tokens.shift + raise ArgumentError, "empty CSS chain" unless first.is_a?(String) + + xpath = convert_simple(first, prefix: "//") + until tokens.empty? + op = tokens.shift + sel = tokens.shift + raise ArgumentError, "malformed CSS chain" unless sel.is_a?(String) + inner_tag, preds = parse_simple(sel) + connector = op == :child ? "/" : "//" + xpath = "#{xpath}#{connector}#{inner_tag}#{preds.map { |p| "[#{p}]" }.join}" + end + xpath + end + private_class_method :build_chain_xpath + end + end +end diff --git a/lib/taurus/xml/document.rb b/lib/taurus/xml/document.rb new file mode 100644 index 0000000..c266d7d --- /dev/null +++ b/lib/taurus/xml/document.rb @@ -0,0 +1,146 @@ +# frozen_string_literal: true + +require "ffi" + +class Taurus::XML::Document + attr_reader :c_ptr + + def initialize(c_ptr = nil) + @c_ptr = c_ptr + @freed = false + end + + def self.parse(xml_or_io) + xml = xml_or_io.respond_to?(:read) ? xml_or_io.read : xml_or_io.to_s + if xml.empty? + raise Taurus::XML::ParseError, "empty input" + end + status_ptr = ::FFI::MemoryPointer.new(:int) + raw = Taurus::XML::FFI.taurus_parse_string(xml, xml.bytesize, status_ptr) + if raw.null? + status = status_ptr.read_int + raise Taurus::XML::ParseError, + "taurus_parse_string failed (status=#{status})" + end + new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + end + + def self.parse_file(path) + status_ptr = ::FFI::MemoryPointer.new(:int) + raw = Taurus::XML::FFI.taurus_parse_file(path, status_ptr) + if raw.null? + status = status_ptr.read_int + raise Taurus::XML::ParseError, + "taurus_parse_file failed (status=#{status})" + end + new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + end + + def root + raise Taurus::XML::UseAfterFreeError if @freed + return nil if @c_ptr.nil? + ptr = Taurus::XML::FFI.taurus_document_root(@c_ptr) + return nil if ptr.null? + Taurus::XML::Element.new(ptr, self) + end + + def create_element(name) + ptr = Taurus::XML::FFI.taurus_element_create(@c_ptr, name) + raise Taurus::XML::Error, "taurus_element_create failed" if ptr.null? + Taurus::XML::Element.new(ptr, self) + end + + def create_text_node(content) + ptr = Taurus::XML::FFI.taurus_text_node_create(@c_ptr, content.to_s) + raise Taurus::XML::Error, "taurus_text_node_create failed" if ptr.null? + Taurus::XML::Text.new(ptr, self) + end + + def create_comment(content) + ptr = Taurus::XML::FFI.taurus_comment_node_create(@c_ptr, content.to_s) + raise Taurus::XML::Error, "taurus_comment_node_create failed" if ptr.null? + Taurus::XML::Comment.new(ptr, self) + end + + def create_cdata(content) + ptr = Taurus::XML::FFI.taurus_cdata_node_create(@c_ptr, content.to_s) + raise Taurus::XML::Error, "taurus_cdata_node_create failed" if ptr.null? + Taurus::XML::CDATA.new(ptr, self) + end + + def create_processing_instruction(target, data = "") + ptr = Taurus::XML::FFI.taurus_pi_node_create(@c_ptr, target.to_s, data.to_s) + raise Taurus::XML::Error, "taurus_pi_node_create failed" if ptr.null? + Taurus::XML::ProcessingInstruction.new(ptr, self) + end + + def to_xml(indent: 0, no_decl: false, encoding: nil) + raise Taurus::XML::UseAfterFreeError if @freed + return "" if @c_ptr.nil? + opts, enc_ptr = build_serialize_options(indent: indent, no_decl: no_decl, encoding: encoding) + str_ptr = Taurus::XML::FFI.taurus_document_serialize(@c_ptr, opts.pointer) + return "" if str_ptr.null? + str_ptr.read_string.tap { |s| Taurus::XML::FFI.taurus_free_string(str_ptr) } + end + alias_method :to_s, :to_xml + alias_method :serialize, :to_xml + + def save(path, **opts) + opts_struct, enc_ptr = build_serialize_options( + indent: opts.fetch(:indent, 0), + no_decl: opts.fetch(:no_decl, false), + encoding: opts[:encoding]) + status = Taurus::XML::FFI.taurus_document_save_file(@c_ptr, path, opts_struct.pointer) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + self + end + + def canonicalize(version = Taurus::XML::FFI::C14N_1_0, + inclusive_namespaces = nil, + with_comments: false, + exclusive: false, + mode: nil) + raise Taurus::XML::UseAfterFreeError if @freed + return "" if @c_ptr.nil? + resolved_mode = mode || (exclusive ? Taurus::XML::FFI::C14N_MODE_EXCLUSIVE + : Taurus::XML::FFI::C14N_MODE_CANONICAL) + ns_ptr, _anchor = Taurus::XML.c14n_build_ns_pointer(inclusive_namespaces) + flags = with_comments ? 1 : 0 + str_ptr = Taurus::XML::FFI.taurus_c14n_canonicalize_ex( + @c_ptr, version, resolved_mode, ns_ptr, flags) + return "" if str_ptr.null? + str_ptr.read_string.tap { Taurus::XML::FFI.taurus_free_string(str_ptr) } + end + alias_method :c14n, :canonicalize + + def free + return if @freed || @c_ptr.nil? + @c_ptr.free + @freed = true + @c_ptr = nil + end + + def name; "document"; end + def document; self; end + def encoding + return nil if @c_ptr.nil? + Taurus::XML::FFI.taurus_document_encoding(@c_ptr) + end + + private + + def build_serialize_options(indent:, no_decl:, encoding:) + opts = Taurus::XML::FFI::SerializeOptions.new + opts[:indent] = indent.to_i + opts[:xml_declaration] = no_decl ? 0 : 1 + enc_ptr = nil + if encoding + enc_ptr = ::FFI::MemoryPointer.from_string(encoding.to_s) + opts[:encoding] = enc_ptr + end + [opts, enc_ptr] + end + + include Taurus::XML::Searchable +end diff --git a/lib/taurus/xml/element.rb b/lib/taurus/xml/element.rb new file mode 100644 index 0000000..5a7117f --- /dev/null +++ b/lib/taurus/xml/element.rb @@ -0,0 +1,253 @@ +# frozen_string_literal: true + +class Taurus::XML::Element < Taurus::XML::Node + def name + Taurus::XML::FFI.taurus_element_name(@c_ptr) + end + alias_method :node_name, :name + + def name=(new_name) + status = Taurus::XML::FFI.taurus_element_set_name(@c_ptr, new_name) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_name + end + alias_method :node_name=, :name= + + def content + Taurus::XML::FFI.taurus_element_text(@c_ptr) + end + + def content=(new_content) + status = Taurus::XML::FFI.taurus_element_set_text(@c_ptr, new_content.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_content + end + + def [](key) + Taurus::XML::FFI.taurus_element_attribute(@c_ptr, key.to_s) + end + alias_method :attr, :[] + alias_method :get_attribute, :[] + + def []=(key, value) + status = Taurus::XML::FFI.taurus_element_set_attribute(@c_ptr, key.to_s, value.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + value + end + alias_method :set_attribute, :[]= + + def key?(name) + !Taurus::XML::FFI.taurus_element_attribute(@c_ptr, name.to_s).nil? + end + alias_method :has_attribute?, :key? + + def remove_attribute(name) + status = Taurus::XML::FFI.taurus_element_remove_attribute(@c_ptr, name.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + self + end + alias_method :delete, :remove_attribute + + def keys + count = Taurus::XML::FFI.taurus_element_attribute_count(@c_ptr) + count.times.map { |i| Taurus::XML::FFI.taurus_element_attribute_name_at(@c_ptr, i) } + end + + def values + count = Taurus::XML::FFI.taurus_element_attribute_count(@c_ptr) + count.times.map { |i| Taurus::XML::FFI.taurus_element_attribute_value_at(@c_ptr, i) } + end + + def attributes + count = Taurus::XML::FFI.taurus_element_attribute_count(@c_ptr) + result = {} + count.times do |i| + name = Taurus::XML::FFI.taurus_element_attribute_name_at(@c_ptr, i) + value = Taurus::XML::FFI.taurus_element_attribute_value_at(@c_ptr, i) + result[name] = Taurus::XML::Attr.new(name, value, self) + end + result + end + + def attribute_nodes + count = Taurus::XML::FFI.taurus_element_attribute_count(@c_ptr) + count.times.map do |i| + name = Taurus::XML::FFI.taurus_element_attribute_name_at(@c_ptr, i) + value = Taurus::XML::FFI.taurus_element_attribute_value_at(@c_ptr, i) + Taurus::XML::Attr.new(name, value, self) + end + end + + def add_child(node) + status = Taurus::XML::FFI.taurus_element_append_child(@c_ptr, node.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node + end + alias_method :<<, :add_child + + def prepend_child(node) + status = Taurus::XML::FFI.taurus_element_prepend_child(@c_ptr, node.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node + end + + def add_next_sibling(node) + status = Taurus::XML::FFI.taurus_element_insert_after(@c_ptr, node.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node + end + + def add_previous_sibling(node) + status = Taurus::XML::FFI.taurus_element_insert_before(@c_ptr, node.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node + end + + def remove_child(node) + status = Taurus::XML::FFI.taurus_element_remove_child(@c_ptr, node.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node + end + + def children=(node_or_nodes) + # Remove existing children, then attach the new ones in source order. + Taurus::XML::FFI.taurus_element_remove_children(@c_ptr) + Array(node_or_nodes).each { |n| add_child(n) } + end + + # Replace this element with +new_node+ in the parent's child list. + # +new_node+ must belong to the same document. Returns +new_node+. + def replace(new_node) + parent = self.parent + raise Taurus::XML::Error, "cannot replace a node with no parent" unless parent + add_next_sibling(new_node) + parent.remove_child(self) + new_node + end + + # Like #replace but returns self for chaining. + def swap(new_node) + replace(new_node) + self + end + + # Wrap this element in a new element parsed from +markup+ or a dup of + # +node+. The wrapper takes this element's place in the tree, and this + # element becomes its only child. Returns self for chaining. + def wrap(node_or_markup) + wrapper = + case node_or_markup + when Taurus::XML::Element then node_or_markup.dup + when String + frag_doc = Taurus::XML::Document.parse(node_or_markup) + frag_doc.root or raise Taurus::XML::Error, "wrap markup has no root element" + else + raise ArgumentError, "wrap expects a String or Element, got #{node_or_markup.class}" + end + + parent = self.parent + raise Taurus::XML::Error, "cannot wrap a node with no parent" unless parent + + # Insert wrapper at self's position, then move self into wrapper. + # add_child moves self (unlinks from old parent first), so no explicit + # remove_child needed — and trying to remove after the move corrupts + # the C tree (libtaurus silently handles non-child args badly). + add_next_sibling(wrapper) + wrapper.add_child(self) + self + end + + def dup + raise NotImplementedError, "Element#dup requires taurus_element_copy (not yet exposed in v0.5.10 public API)" + end + + def namespace + uri = Taurus::XML::FFI.taurus_element_namespace(@c_ptr) + return nil if uri.nil? || uri.empty? + Taurus::XML::Namespace.new(self, uri) + end + + def namespace_definitions + count = Taurus::XML::FFI.taurus_element_namespace_count(@c_ptr) + count.times.map do |i| + prefix = Taurus::XML::FFI.taurus_element_namespace_decl_prefix(@c_ptr, i) + uri = Taurus::XML::FFI.taurus_element_namespace_decl_uri(@c_ptr, i) + Taurus::XML::Namespace.new(self, uri, prefix: prefix) + end + end + + def namespaces + scopes = {} + node = self + while node.is_a?(Taurus::XML::Element) + node.namespace_definitions.each do |ns| + key = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns" + scopes[key] ||= ns.href + end + node = node.parent + end + scopes + end + + def to_xml(indent: 0, no_decl: false, encoding: nil) + opts = Taurus::XML::FFI::SerializeOptions.new + opts[:indent] = indent.to_i + opts[:xml_declaration] = no_decl ? 0 : 1 + enc_ptr = nil + if encoding + enc_ptr = ::FFI::MemoryPointer.from_string(encoding.to_s) + opts[:encoding] = enc_ptr + end + str_ptr = Taurus::XML::FFI.taurus_element_serialize(@c_ptr, opts.pointer) + return "" if str_ptr.null? + str_ptr.read_string.tap { Taurus::XML::FFI.taurus_free_string(str_ptr) } + end + + def canonicalize(version = Taurus::XML::FFI::C14N_1_0, + inclusive_namespaces = nil, + with_comments: false, + exclusive: false, + mode: nil) + resolved_mode = mode || (exclusive ? Taurus::XML::FFI::C14N_MODE_EXCLUSIVE + : Taurus::XML::FFI::C14N_MODE_CANONICAL) + ns_ptr, _anchor = Taurus::XML.c14n_build_ns_pointer(inclusive_namespaces) + flags = with_comments ? 1 : 0 + str_ptr = Taurus::XML::FFI.taurus_c14n_canonicalize_subtree_ex( + @c_ptr, version, resolved_mode, ns_ptr, flags) + return "" if str_ptr.null? + str_ptr.read_string.tap { Taurus::XML::FFI.taurus_free_string(str_ptr) } + end + alias_method :c14n, :canonicalize + + def add_namespace_definition(prefix, href) + status = Taurus::XML::FFI.taurus_element_add_namespace_definition( + @c_ptr, prefix.to_s, href.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + Taurus::XML::Namespace.new(self, href.to_s, prefix: prefix.nil? ? nil : prefix.to_s) + end + alias_method :add_namespace, :add_namespace_definition + + def default_namespace=(href) + status = Taurus::XML::FFI.taurus_element_set_default_namespace(@c_ptr, href.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + href + end + + def remove_namespace_definition(prefix) + status = Taurus::XML::FFI.taurus_element_remove_namespace_definition(@c_ptr, prefix.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + self + end +end diff --git a/lib/taurus/xml/ffi.rb b/lib/taurus/xml/ffi.rb new file mode 100644 index 0000000..1e1a3e2 --- /dev/null +++ b/lib/taurus/xml/ffi.rb @@ -0,0 +1,386 @@ +# frozen_string_literal: true + +require "ffi" + +module Taurus + module XML + module FFI + extend ::FFI::Library + + ffi_lib [ + ENV["TAURUS_LIB_PATH"], + File.expand_path("../../libtaurus.dylib", __dir__), + File.expand_path("../../libtaurus.so", __dir__), + "/usr/local/lib/libtaurus.dylib", + "/usr/local/lib/libtaurus.so", + "taurus", + ].compact + + typedef :pointer, :taurus_document + typedef :pointer, :taurus_element + typedef :pointer, :taurus_node_ref + typedef :pointer, :taurus_attribute + typedef :pointer, :taurus_xpath_result + typedef :pointer, :taurus_xpath_var_set + typedef :pointer, :taurus_sax_parser + typedef :int, :taurus_status + + class SAXHandler < ::FFI::Struct + layout \ + :start_document, :pointer, + :end_document, :pointer, + :start_element, :pointer, + :end_element, :pointer, + :characters, :pointer, + :comment, :pointer, + :cdata, :pointer, + :processing_instruction, :pointer, + :start_prefix_mapping, :pointer, + :end_prefix_mapping, :pointer, + :error, :pointer + end + + class SerializeOptions < ::FFI::Struct + layout \ + :indent, :int, + :xml_declaration, :int, + :encoding, :pointer + end + + attach_function :taurus_version, [], :string + attach_function :taurus_version_components, [:pointer, :pointer, :pointer], :void + + attach_function :taurus_parse_string, + [:string, :size_t, :pointer], :taurus_document + attach_function :taurus_parse_string_inplace, + [:pointer, :size_t, :pointer], :taurus_document + attach_function :taurus_parse_string_with_encoding, + [:string, :size_t, :pointer], :taurus_document + attach_function :taurus_parse_file, + [:string, :pointer], :taurus_document + attach_function :taurus_load_file, + [:string, :pointer], :pointer + attach_function :taurus_document_free, + [:taurus_document], :void + attach_function :taurus_document_root, + [:taurus_document], :taurus_element + attach_function :taurus_document_encoding, + [:taurus_document], :string + attach_function :taurus_document_finalize_strings, + [:taurus_document], :int + attach_function :taurus_document_adopt_child, + [:taurus_document, :taurus_document], :void + attach_function :taurus_document_set_strict, + [:taurus_document, :int], :taurus_status + attach_function :taurus_document_get_strict, + [:taurus_document], :int + attach_function :taurus_document_freeze, + [:taurus_document], :taurus_status + attach_function :taurus_document_is_frozen, + [:taurus_document], :int + attach_function :taurus_set_strict_mode, [:int], :void + attach_function :taurus_get_strict_mode, [], :int + attach_function :taurus_set_max_depth, [:int], :void + attach_function :taurus_get_max_depth, [], :int + attach_function :taurus_xinclude_process, + [:taurus_document, :string], :taurus_status + attach_function :taurus_xinclude_is_include_element, + [:taurus_element], :int + attach_function :taurus_xinclude_is_fallback_element, + [:taurus_element], :int + attach_function :taurus_xinclude_get_href, [:taurus_element], :string + attach_function :taurus_xinclude_get_parse, [:taurus_element], :string + attach_function :taurus_xinclude_get_xpointer, [:taurus_element], :string + # taurus_xinclude_get_encoding is declared in taurus.h but not exported + # from the v0.4.4 dylib (likely same visibility bug as the serialize + # functions; see upstream issue #166). Re-add once #173 / v0.4.5 ships. + + attach_function :taurus_node_get_type, + [:taurus_node_ref], :int + attach_function :taurus_node_first_child, + [:taurus_node_ref], :taurus_node_ref + attach_function :taurus_node_last_child, + [:taurus_node_ref], :taurus_node_ref + attach_function :taurus_node_next_sibling, + [:taurus_node_ref], :taurus_node_ref + attach_function :taurus_node_previous_sibling, + [:taurus_node_ref], :taurus_node_ref + attach_function :taurus_node_child_count, + [:taurus_node_ref], :size_t + attach_function :taurus_node_as_element, + [:taurus_node_ref], :taurus_element + attach_function :taurus_element_as_node, + [:taurus_element], :taurus_node_ref + attach_function :taurus_node_parent, + [:taurus_node_ref], :taurus_element + attach_function :taurus_node_unlink, + [:taurus_node_ref], :taurus_status + attach_function :taurus_node_line, + [:taurus_node_ref], :int + attach_function :taurus_node_compare, + [:taurus_node_ref, :taurus_node_ref], :int + + attach_function :taurus_text_node_get_content, + [:taurus_node_ref], :string + attach_function :taurus_comment_node_get_content, + [:taurus_node_ref], :string + attach_function :taurus_cdata_node_get_content, + [:taurus_node_ref], :string + attach_function :taurus_pi_node_get_target, + [:taurus_node_ref], :string + attach_function :taurus_pi_node_get_data, + [:taurus_node_ref], :string + attach_function :taurus_text_node_create, + [:taurus_document, :string], :taurus_node_ref + attach_function :taurus_comment_node_create, + [:taurus_document, :string], :taurus_node_ref + attach_function :taurus_cdata_node_create, + [:taurus_document, :string], :taurus_node_ref + attach_function :taurus_pi_node_create, + [:taurus_document, :string, :string], :taurus_node_ref + attach_function :taurus_text_node_set_content, + [:taurus_node_ref, :string], :taurus_status + attach_function :taurus_comment_node_set_content, + [:taurus_node_ref, :string], :taurus_status + attach_function :taurus_cdata_node_set_content, + [:taurus_node_ref, :string], :taurus_status + attach_function :taurus_pi_node_set_target, + [:taurus_node_ref, :string], :taurus_status + attach_function :taurus_pi_node_set_data, + [:taurus_node_ref, :string], :taurus_status + + attach_function :taurus_element_name, + [:taurus_element], :string + attach_function :taurus_element_text, + [:taurus_element], :string + attach_function :taurus_element_text_int, + [:taurus_element, :int], :int + attach_function :taurus_element_text_uint, + [:taurus_element, :uint], :uint + attach_function :taurus_element_text_double, + [:taurus_element, :double], :double + attach_function :taurus_element_text_float, + [:taurus_element, :float], :float + attach_function :taurus_element_text_bool, + [:taurus_element, :int], :int + attach_function :taurus_element_attribute, + [:taurus_element, :string], :string + attach_function :taurus_element_attribute_string, + [:taurus_element, :string, :string], :string + attach_function :taurus_element_attribute_int, + [:taurus_element, :string, :int], :int + attach_function :taurus_element_attribute_uint, + [:taurus_element, :string, :uint], :uint + attach_function :taurus_element_attribute_double, + [:taurus_element, :string, :double], :double + attach_function :taurus_element_attribute_float, + [:taurus_element, :string, :float], :float + attach_function :taurus_element_attribute_bool, + [:taurus_element, :string, :int], :int + # taurus_element_has_attribute is declared in taurus.h but not exported + # from the v0.4.4 dylib (likely visibility bug; see upstream #166). + # Ruby-level Element#key? will emulate via attribute lookup. + attach_function :taurus_element_attribute_count, + [:taurus_element], :size_t + attach_function :taurus_element_attribute_name_at, + [:taurus_element, :size_t], :string + attach_function :taurus_element_attribute_value_at, + [:taurus_element, :size_t], :string + attach_function :taurus_element_remove_all_attributes, + [:taurus_element], :taurus_status + + attach_function :taurus_element_child_count, + [:taurus_element], :size_t + attach_function :taurus_element_child, + [:taurus_element, :size_t], :taurus_element + attach_function :taurus_element_parent, + [:taurus_element], :taurus_element + attach_function :taurus_element_root, + [:taurus_element], :taurus_element + attach_function :taurus_element_child_value, + [:taurus_element], :string + attach_function :taurus_element_hash_value, + [:taurus_element], :size_t + attach_function :taurus_element_find_child, + [:taurus_element, :string], :taurus_element + attach_function :taurus_element_find_child_by_attr, + [:taurus_element, :string, :string, :string], :taurus_element + attach_function :taurus_element_next_sibling, + [:taurus_element, :string], :taurus_element + attach_function :taurus_element_previous_sibling, + [:taurus_element, :string], :taurus_element + attach_function :taurus_element_first_child, + [:taurus_element, :string], :taurus_element + attach_function :taurus_element_last_child, + [:taurus_element, :string], :taurus_element + attach_function :taurus_element_first_child_any, + [:taurus_element], :taurus_element + attach_function :taurus_element_last_child_any, + [:taurus_element], :taurus_element + attach_function :taurus_element_next_sibling_any, + [:taurus_element], :taurus_element + attach_function :taurus_element_previous_sibling_any, + [:taurus_element], :taurus_element + + attach_function :taurus_element_create, + [:taurus_document, :string], :taurus_element + attach_function :taurus_element_set_name, + [:taurus_element, :string], :taurus_status + attach_function :taurus_element_set_text, + [:taurus_element, :string], :taurus_status + attach_function :taurus_element_set_attribute, + [:taurus_element, :string, :string], :taurus_status + attach_function :taurus_element_set_attribute_bool, + [:taurus_element, :string, :int], :taurus_status + attach_function :taurus_element_set_attribute_double, + [:taurus_element, :string, :double], :taurus_status + attach_function :taurus_element_set_attribute_float, + [:taurus_element, :string, :float], :taurus_status + attach_function :taurus_element_set_attribute_int, + [:taurus_element, :string, :int], :taurus_status + attach_function :taurus_element_set_attribute_uint, + [:taurus_element, :string, :uint], :taurus_status + attach_function :taurus_element_remove_attribute, + [:taurus_element, :string], :taurus_status + attach_function :taurus_element_append_child, + [:taurus_element, :taurus_element], :taurus_status + attach_function :taurus_element_prepend_child, + [:taurus_element, :taurus_element], :taurus_status + attach_function :taurus_element_insert_before, + [:taurus_element, :taurus_element], :taurus_status + attach_function :taurus_element_insert_after, + [:taurus_element, :taurus_element], :taurus_status + attach_function :taurus_element_remove_child, + [:taurus_element, :taurus_element], :taurus_status + attach_function :taurus_element_remove_children, + [:taurus_element], :taurus_status + attach_function :taurus_element_append_copy, + [:taurus_element, :taurus_element], :taurus_element + attach_function :taurus_element_prepend_copy, + [:taurus_element, :taurus_element], :taurus_element + attach_function :taurus_element_insert_copy_before, + [:taurus_element, :taurus_element], :taurus_element + attach_function :taurus_element_insert_copy_after, + [:taurus_element, :taurus_element], :taurus_element + + attach_function :taurus_element_namespace, + [:taurus_element], :string + attach_function :taurus_element_namespace_for_prefix, + [:taurus_element, :string], :string + attach_function :taurus_element_namespace_count, + [:taurus_element], :size_t + attach_function :taurus_element_namespace_decl_prefix, + [:taurus_element, :size_t], :string + attach_function :taurus_element_namespace_decl_uri, + [:taurus_element, :size_t], :string + attach_function :taurus_element_add_namespace_definition, + [:taurus_element, :string, :string], :taurus_status + attach_function :taurus_element_set_default_namespace, + [:taurus_element, :string], :taurus_status + attach_function :taurus_element_remove_namespace_definition, + [:taurus_element, :string], :taurus_status + attach_function :taurus_namespace_uri, [:string], :string + attach_function :taurus_namespace_prefix, [:string], :string + + attach_function :taurus_xpath_eval, + [:taurus_document, :taurus_element, :string], :taurus_xpath_result + attach_function :taurus_xpath_eval_with_vars, + [:taurus_document, :string, :taurus_xpath_var_set], :taurus_xpath_result + attach_function :taurus_xpath_eval_with_vars_context, + [:taurus_document, :taurus_element, :string, :taurus_xpath_var_set], + :taurus_xpath_result + attach_function :taurus_xpath_result_type, + [:taurus_xpath_result], :int + attach_function :taurus_xpath_result_count, + [:taurus_xpath_result], :size_t + attach_function :taurus_xpath_result_get, + [:taurus_xpath_result, :size_t], :taurus_element + attach_function :taurus_xpath_result_boolean, + [:taurus_xpath_result], :int + attach_function :taurus_xpath_result_number, + [:taurus_xpath_result], :double + attach_function :taurus_xpath_result_string, + [:taurus_xpath_result], :pointer + attach_function :taurus_xpath_result_free, + [:taurus_xpath_result], :void + attach_function :taurus_xpath_function_supported, [:string], :int + attach_function :taurus_xpath_supported_functions, [], :pointer + + attach_function :taurus_xpath_variable_set_new, + [], :taurus_xpath_var_set + attach_function :taurus_xpath_variable_set_free, + [:taurus_xpath_var_set], :void + attach_function :taurus_xpath_variable_set_boolean, + [:taurus_xpath_var_set, :string, :int], :taurus_status + attach_function :taurus_xpath_variable_set_number, + [:taurus_xpath_var_set, :string, :double], :taurus_status + attach_function :taurus_xpath_variable_set_string, + [:taurus_xpath_var_set, :string, :string], :taurus_status + + attach_function :taurus_sax_parse, + [:string, :size_t, :pointer, :pointer], :int + attach_function :taurus_sax_parser_create, + [:pointer, :pointer], :taurus_sax_parser + attach_function :taurus_sax_parser_feed, + [:taurus_sax_parser, :string, :size_t, :int], :int + attach_function :taurus_sax_parser_free, + [:taurus_sax_parser], :void + attach_function :taurus_sax_parser_set_streaming, + [:taurus_sax_parser, :int], :int + + attach_function :taurus_document_serialize, + [:taurus_document, :pointer], :pointer + attach_function :taurus_element_serialize, + [:taurus_element, :pointer], :pointer + attach_function :taurus_document_save_file, + [:taurus_document, :string, :pointer], :taurus_status + attach_function :taurus_c14n_canonicalize, + [:taurus_document, :int, :int], :pointer + attach_function :taurus_c14n_canonicalize_subtree, + [:taurus_element, :int, :int], :pointer + attach_function :taurus_c14n_canonicalize_ex, + [:taurus_document, :int, :int, :pointer, :int], :pointer + attach_function :taurus_c14n_canonicalize_subtree_ex, + [:taurus_element, :int, :int, :pointer, :int], :pointer + + attach_function :taurus_free_string, [:pointer], :void + attach_function :taurus_explicit_cleanup, [], :void + attach_function :taurus_set_memory_management_functions, + [:pointer, :pointer], :void + attach_function :taurus_get_memory_allocation_function, [], :pointer + attach_function :taurus_get_memory_deallocation_function, [], :pointer + attach_function :taurus_document_set_allocators, + [:taurus_document, :pointer, :pointer], :taurus_status + attach_function :taurus_status_string, [:taurus_status], :string + + TAURUS_OK = 0 + TAURUS_ERROR_MEMORY = -1 + TAURUS_ERROR_PARSE = -2 + TAURUS_ERROR_XPATH = -3 + TAURUS_ERROR_NULL_ARG = -4 + TAURUS_ERROR_INVALID_ARG = -5 + TAURUS_ERROR_NOT_FOUND = -6 + TAURUS_ERROR_IO = -7 + TAURUS_ERROR_NOT_IMPLEMENTED = -8 + + XPATH_NODESET = 0 + XPATH_BOOLEAN = 1 + XPATH_NUMBER = 2 + XPATH_STRING = 3 + + NODE_ELEMENT = 0 + NODE_TEXT = 1 + NODE_COMMENT = 2 + NODE_CDATA = 3 + NODE_PI = 4 + NODE_DOCTYPE = 5 + NODE_ATTRIBUTE = 6 + + C14N_1_0 = 0 + C14N_1_1 = 1 + + C14N_MODE_CANONICAL = 0 + C14N_MODE_EXCLUSIVE = 1 + end + end +end diff --git a/lib/taurus/xml/namespace.rb b/lib/taurus/xml/namespace.rb new file mode 100644 index 0000000..500da99 --- /dev/null +++ b/lib/taurus/xml/namespace.rb @@ -0,0 +1,43 @@ +# frozen_string_literal: true + +# libtaurus's TaurusNamespace is `const char*` (the URI directly). The Ruby +# Namespace wrapper holds (element, uri, optional prefix). When the prefix +# isn't supplied (e.g. via Element#namespace), it can be derived by walking +# the element's namespace declarations via taurus_element_namespace_decl_*. + +class Taurus::XML::Namespace + attr_reader :element, :href, :prefix + + def initialize(element, href, prefix: :derive) + @element = element + @href = href + @prefix = prefix == :derive ? derive_prefix : prefix + end + + def document + @element&.document + end + + def ==(other) + other.is_a?(Taurus::XML::Namespace) && + @href == other.href && @prefix == other.prefix + end + + def inspect + "#<#{self.class.name} prefix=#{@prefix.inspect} href=#{@href.inspect}>" + end + + private + + def derive_prefix + return nil if @element.nil? + count = Taurus::XML::FFI.taurus_element_namespace_count(@element.c_ptr) + count.times do |i| + uri = Taurus::XML::FFI.taurus_element_namespace_decl_uri(@element.c_ptr, i) + next unless uri == @href + prefix = Taurus::XML::FFI.taurus_element_namespace_decl_prefix(@element.c_ptr, i) + return prefix.nil? || prefix.empty? ? nil : prefix + end + nil + end +end diff --git a/lib/taurus/xml/node.rb b/lib/taurus/xml/node.rb new file mode 100644 index 0000000..2db3a47 --- /dev/null +++ b/lib/taurus/xml/node.rb @@ -0,0 +1,162 @@ +# frozen_string_literal: true + +class Taurus::XML::Node + attr_reader :c_ptr, :document + + def initialize(c_ptr, document, parent: nil) + @c_ptr = c_ptr + @document = document + @parent = parent + end + + def self.wrap(c_ptr, document, parent: nil) + case Taurus::XML::FFI.taurus_node_get_type(c_ptr) + when Taurus::XML::FFI::NODE_ELEMENT + Taurus::XML::Element.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_TEXT + Taurus::XML::Text.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_COMMENT + Taurus::XML::Comment.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_CDATA + Taurus::XML::CDATA.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_PI + Taurus::XML::ProcessingInstruction.new(c_ptr, document, parent: parent) + else + new(c_ptr, document, parent: parent) + end + end + + def name + raise NotImplementedError, "#{self.class}#name not implemented" + end + + def content + raise NotImplementedError, "#{self.class}#content not implemented" + end + alias_method :text, :content + alias_method :inner_text, :content + + def type + Taurus::XML::FFI.taurus_node_get_type(@c_ptr) + end + alias_method :node_type, :type + + def element?; type == Taurus::XML::FFI::NODE_ELEMENT; end + def text?; type == Taurus::XML::FFI::NODE_TEXT; end + def comment?; type == Taurus::XML::FFI::NODE_COMMENT; end + def cdata?; type == Taurus::XML::FFI::NODE_CDATA; end + def processing_instruction? + type == Taurus::XML::FFI::NODE_PI + end + alias_method :pi?, :processing_instruction? + + def parent + return @parent if @parent + ptr = Taurus::XML::FFI.taurus_node_parent(@c_ptr) + return nil if ptr.null? + Taurus::XML::Element.new(ptr, @document) + end + + def line + Taurus::XML::FFI.taurus_node_line(@c_ptr) + end + + def <=>(other) + return nil unless other.is_a?(Taurus::XML::Node) + return nil unless @document == other.document + Taurus::XML::FFI.taurus_node_compare(@c_ptr, other.c_ptr) + end + + def child + ptr = Taurus::XML::FFI.taurus_node_first_child(@c_ptr) + return nil if ptr.null? + Taurus::XML::Node.wrap(ptr, @document, parent: as_element_or_self) + end + + def children + nodes = [] + ptr = Taurus::XML::FFI.taurus_node_first_child(@c_ptr) + until ptr.nil? || ptr.null? + nodes << Taurus::XML::Node.wrap(ptr, @document, parent: as_element_or_self) + ptr = Taurus::XML::FFI.taurus_node_next_sibling(ptr) + end + Taurus::XML::NodeSet.new(@document, nodes) + end + + def next_sibling + ptr = Taurus::XML::FFI.taurus_node_next_sibling(@c_ptr) + return nil if ptr.null? + Taurus::XML::Node.wrap(ptr, @document, parent: @parent) + end + alias_method :next, :next_sibling + + def previous_sibling + ptr = Taurus::XML::FFI.taurus_node_previous_sibling(@c_ptr) + return nil if ptr.null? + Taurus::XML::Node.wrap(ptr, @document, parent: @parent) + end + alias_method :previous, :previous_sibling + + def first_element_child + ptr = Taurus::XML::FFI.taurus_node_first_child(@c_ptr) + until ptr.nil? || ptr.null? + node = Taurus::XML::Node.wrap(ptr, @document, parent: as_element_or_self) + return node if node.element? + ptr = Taurus::XML::FFI.taurus_node_next_sibling(ptr) + end + nil + end + + def last_element_child + children.reverse_each.find(&:element?) + end + + def element_children + children.select(&:element?) + end + alias_method :elements, :element_children + + def next_element + sibling = next_sibling + sibling = sibling.next_sibling until sibling.nil? || sibling.element? + sibling + end + + def previous_element + sibling = previous_sibling + sibling = sibling.previous_sibling until sibling.nil? || sibling.element? + sibling + end + + def unlink + status = Taurus::XML::FFI.taurus_node_unlink(@c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + @parent = nil + self + end + alias_method :remove, :unlink + + def traverse + return enum_for(:traverse) unless block_given? + children.each { |child| child.traverse { |n| yield n } } + yield self + end + + def ==(other) + return false unless other.is_a?(Taurus::XML::Node) + @c_ptr == other.c_ptr + end + + def inspect + "#<#{self.class.name} ptr=#{c_ptr}>" + end + + protected + + def as_element_or_self + is_a?(Taurus::XML::Element) ? self : nil + end + + include Taurus::XML::Searchable +end diff --git a/lib/taurus/xml/node_set.rb b/lib/taurus/xml/node_set.rb new file mode 100644 index 0000000..77848ba --- /dev/null +++ b/lib/taurus/xml/node_set.rb @@ -0,0 +1,70 @@ +# frozen_string_literal: true + +class Taurus::XML::NodeSet + include Enumerable + include Taurus::XML::Searchable + + attr_reader :document + + def initialize(document, array = []) + @document = document + @array = array.to_a + end + + def self.from_result(document, result_ptr) + n = Taurus::XML::FFI.taurus_xpath_result_count(result_ptr) + nodes = n.times.map do |i| + ptr = Taurus::XML::FFI.taurus_xpath_result_get(result_ptr, i) + next nil if ptr.null? + Taurus::XML::Node.wrap(ptr, document) + end.compact + Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) + new(document, nodes) + end + + def each + return enum_for(:each) unless block_given? + @array.each { |n| yield n } + self + end + + def [](idx); @array[idx]; end + def length; @array.length; end + alias_method :size, :length + def empty?; @array.empty?; end + def first(n = nil); n.nil? ? @array.first : @array.first(n); end + def last; @array.last; end + def to_a; @array.dup; end + def to_ary; @array; end + + def inner_text + @array.map(&:content).join + end + alias_method :text, :inner_text + + def xpath(*paths) + handler, _ns, _vars = parse_search_args(paths) + raise ArgumentError, "custom XPath handlers not supported" if handler + expr = paths.join(" | ") + accumulated = Taurus::XML::NodeSet.new(@document) + @array.each do |node| + next unless node.is_a?(Taurus::XML::Element) + result_ptr = Taurus::XML::FFI.taurus_xpath_eval( + @document.c_ptr, node.c_ptr, expr) + next if result_ptr.null? + sub = Taurus::XML::NodeSet.send(:from_result, @document, result_ptr) + accumulated = merge_node_sets(accumulated, sub) + end + accumulated + end + + def inspect + "[#{@array.map(&:inspect).join(", ")}]" + end + + private + + def merge_node_sets(a, b) + Taurus::XML::NodeSet.new(@document, a.to_a + b.to_a) + end +end diff --git a/lib/taurus/xml/parse_options.rb b/lib/taurus/xml/parse_options.rb new file mode 100644 index 0000000..459d36c --- /dev/null +++ b/lib/taurus/xml/parse_options.rb @@ -0,0 +1,19 @@ +# frozen_string_literal: true + +class Taurus::XML::ParseOptions + DEFAULT_XML = 0 + RECOVER = 1 << 0 + NOERROR = 1 << 5 + NOWARNING = 1 << 6 + NOCDATA = 1 << 8 + STRICT = 1 << 18 + + attr_reader :options + + def initialize(options = DEFAULT_XML) + @options = options.to_i + end + + def strict?; !@options.zero?; end + def recover?; @options & RECOVER != 0; end +end diff --git a/lib/taurus/xml/processing_instruction.rb b/lib/taurus/xml/processing_instruction.rb new file mode 100644 index 0000000..30114b7 --- /dev/null +++ b/lib/taurus/xml/processing_instruction.rb @@ -0,0 +1,26 @@ +# frozen_string_literal: true + +class Taurus::XML::ProcessingInstruction < Taurus::XML::Node + def name + Taurus::XML::FFI.taurus_pi_node_get_target(@c_ptr) + end + alias_method :target, :name + + def content + Taurus::XML::FFI.taurus_pi_node_get_data(@c_ptr).to_s + end + + def target=(new_target) + status = Taurus::XML::FFI.taurus_pi_node_set_target(@c_ptr, new_target.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_target + end + + def data=(new_data) + status = Taurus::XML::FFI.taurus_pi_node_set_data(@c_ptr, new_data.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_data + end +end diff --git a/lib/taurus/xml/sax.rb b/lib/taurus/xml/sax.rb new file mode 100644 index 0000000..770aa9a --- /dev/null +++ b/lib/taurus/xml/sax.rb @@ -0,0 +1,12 @@ +# frozen_string_literal: true + +require "ffi" + +module Taurus + module XML + module SAX + autoload :Document, "taurus/xml/sax/document" + autoload :Parser, "taurus/xml/sax/parser" + end + end +end diff --git a/lib/taurus/xml/sax/document.rb b/lib/taurus/xml/sax/document.rb new file mode 100644 index 0000000..ca71ea5 --- /dev/null +++ b/lib/taurus/xml/sax/document.rb @@ -0,0 +1,45 @@ +# frozen_string_literal: true + +class Taurus::XML::SAX::Document + # Called when an XML declaration is parsed. + def xmldecl(version, encoding, standalone) + end + + def start_document + end + + def end_document + end + + # Called at the beginning of an element. + # +attrs+ is an Array of [name, value] pairs in source order. + def start_element(name, attrs = []) + end + + def end_element(name) + end + + def characters(string) + end + + def comment(string) + end + + def cdata_block(string) + end + + def processing_instruction(name, content) + end + + def start_prefix_mapping(prefix, uri) + end + + def end_prefix_mapping(prefix) + end + + def warning(string) + end + + def error(message, line = 0, column = 0) + end +end diff --git a/lib/taurus/xml/sax/parser.rb b/lib/taurus/xml/sax/parser.rb new file mode 100644 index 0000000..3706b65 --- /dev/null +++ b/lib/taurus/xml/sax/parser.rb @@ -0,0 +1,148 @@ +# frozen_string_literal: true + +require "ffi" + +class Taurus::XML::SAX::Parser + CHUNK_SIZE = 4096 + private_constant :CHUNK_SIZE + + attr_accessor :document, :encoding + + def initialize(handler = Taurus::XML::SAX::Document.new, encoding = nil) + @document = handler + @encoding = encoding + end + + # Parse a string, IO, or file path. Dispatches to parse_memory / + # parse_io / parse_file based on the argument type. + def parse(input) + case input + when String then parse_memory(input) + when ->(x) { x.respond_to?(:read) } then parse_io(input) + else + raise ArgumentError, "SAX parser expects a String or IO, got #{input.class}" + end + end + + def parse_memory(string) + string = string.dup.force_encoding("UTF-8") + handler_struct = build_handler_struct + rc = Taurus::XML::FFI.taurus_sax_parse( + string, string.bytesize, handler_struct.pointer, nil) + if rc != 0 + raise Taurus::XML::ParseError, + "taurus_sax_parse failed (rc=#{rc})" + end + self + end + + def parse_io(io) + handler_struct = build_handler_struct + parser_ptr = Taurus::XML::FFI.taurus_sax_parser_create( + handler_struct.pointer, nil) + if parser_ptr.null? + raise Taurus::XML::Error, "taurus_sax_parser_create failed" + end + begin + while (chunk = io.read(CHUNK_SIZE)) + rc = Taurus::XML::FFI.taurus_sax_parser_feed( + parser_ptr, chunk, chunk.bytesize, 0) + if rc != 0 + raise Taurus::XML::ParseError, "taurus_sax_parser_feed failed (rc=#{rc})" + end + end + # Final flush + rc = Taurus::XML::FFI.taurus_sax_parser_feed(parser_ptr, "", 0, 1) + if rc != 0 + raise Taurus::XML::ParseError, "taurus_sax_parser_feed (final) failed (rc=#{rc})" + end + ensure + Taurus::XML::FFI.taurus_sax_parser_free(parser_ptr) + end + self + end + + def parse_file(path) + File.open(path, "r") { |f| parse_io(f) } + end + + private + + # Build a TaurusSAXHandler struct populated with FFI::Function callbacks + # that dispatch to the Ruby handler. The struct (and its callbacks) are + # anchored against GC via the local variable for the duration of the + # synchronous parse call. + def build_handler_struct + s = Taurus::XML::FFI::SAXHandler.new + handler = @document # capture in closures + + s[:start_document] = callback(:void, [:pointer]) do |_| + handler.start_document + end + + s[:end_document] = callback(:void, [:pointer]) do |_| + handler.end_document + end + + s[:start_element] = callback(:void, [:pointer, :string, :pointer]) do |_, name, attrs_ptr| + attrs = walk_attr_array(attrs_ptr) + handler.start_element(name, attrs) + end + + s[:end_element] = callback(:void, [:pointer, :string]) do |_, name| + handler.end_element(name) + end + + s[:characters] = callback(:void, [:pointer, :pointer, :size_t]) do |_, text_ptr, len| + handler.characters(text_ptr.read_bytes(len).force_encoding("UTF-8")) + end + + s[:comment] = callback(:void, [:pointer, :string]) do |_, comment| + handler.comment(comment) + end + + s[:cdata] = callback(:void, [:pointer, :string]) do |_, cdata| + handler.cdata_block(cdata) + end + + s[:processing_instruction] = callback(:void, [:pointer, :string, :string]) do |_, target, data| + handler.processing_instruction(target, data) + end + + s[:start_prefix_mapping] = callback(:void, [:pointer, :string, :string]) do |_, prefix, uri| + handler.start_prefix_mapping(prefix, uri) + end + + s[:end_prefix_mapping] = callback(:void, [:pointer, :string]) do |_, prefix| + handler.end_prefix_mapping(prefix) + end + + s[:error] = callback(:void, [:pointer, :string, :int, :int]) do |_, msg, line, col| + handler.error(msg, line, col) + end + + s + end + + def callback(return_type, params, blocking: true, &block) + ::FFI::Function.new(return_type, params, blocking: blocking, &block) + end + + # The C `const char** attrs` is a NULL-terminated flat array of name/value + # pairs: [name1, value1, name2, value2, ..., NULL]. Walk into pairs. + def walk_attr_array(attrs_ptr) + return [] if attrs_ptr.null? + ptr_size = ::FFI.type_size(:pointer) + result = [] + offset = 0 + loop do + name_ptr = attrs_ptr.get_pointer(offset) + break if name_ptr.null? + value_ptr = attrs_ptr.get_pointer(offset + ptr_size) + break if value_ptr.null? + result << [name_ptr.read_string, value_ptr.read_string] + offset += 2 * ptr_size + end + result + end +end diff --git a/lib/taurus/xml/searchable.rb b/lib/taurus/xml/searchable.rb new file mode 100644 index 0000000..95c4434 --- /dev/null +++ b/lib/taurus/xml/searchable.rb @@ -0,0 +1,93 @@ +# frozen_string_literal: true + +module Taurus::XML::Searchable + def xpath(*paths) + handler, _ns, _vars = parse_search_args(paths) + raise ArgumentError, "custom XPath handlers not supported" if handler + expr = paths.join(" | ") + + doc_ptr = is_a?(Taurus::XML::Document) ? c_ptr : document.c_ptr + context_ptr = is_a?(Taurus::XML::Document) ? nil : c_ptr + + result_ptr = Taurus::XML::FFI.taurus_xpath_eval(doc_ptr, context_ptr, expr) + if result_ptr.null? + raise Taurus::XML::XPathError, + Taurus::XML::FFI.taurus_status_string(Taurus::XML::FFI::TAURUS_ERROR_XPATH) + end + + wrap_xpath_result(result_ptr) + end + + def at_xpath(*paths) + result = xpath(*paths) + result.is_a?(Taurus::XML::NodeSet) ? result.first : result + end + + def search(*args) + paths = args.first.is_a?(Array) ? args.first : [args.first] + paths.map(&:to_s).all? { |p| looks_like_xpath?(p) } ? xpath(*paths) : css(*paths) + end + alias_method :/, :search + + def at(*args) + result = search(*args) + result.is_a?(Taurus::XML::NodeSet) ? result.first : result + end + alias_method :%, :at + + def css(*args) + handler, ns, _ = parse_search_args(args) + raise ArgumentError, "namespace bindings not supported in css" if ns && !ns.empty? + raise ArgumentError, "custom CSS handlers not supported" if handler + expr = args.map { |r| Taurus::XML::CssToXPath.convert(r) }.join(" | ") + xpath(expr) + end + + def at_css(*args) + result = css(*args) + result.is_a?(Taurus::XML::NodeSet) ? result.first : result + end + + protected + + def parse_search_args(args) + handler = args.find { |a| !a.is_a?(String) && !a.is_a?(Hash) && !a.is_a?(Symbol) } + args = args - [handler] if handler + hashes = [] + while args.last.is_a?(Hash) || args.last.nil? + hashes << args.pop + break if args.empty? + end + ns, vars = hashes.reverse + [handler, ns, vars] + end + + def looks_like_xpath?(str) + %r{\A(\./|/|\.\.|\.)}.match?(str) + end + + def wrap_xpath_result(result_ptr) + type = Taurus::XML::FFI.taurus_xpath_result_type(result_ptr) + case type + when Taurus::XML::FFI::XPATH_NODESET + Taurus::XML::NodeSet.send(:from_result, document, result_ptr) + when Taurus::XML::FFI::XPATH_BOOLEAN + v = Taurus::XML::FFI.taurus_xpath_result_boolean(result_ptr) != 0 + Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) + v + when Taurus::XML::FFI::XPATH_NUMBER + v = Taurus::XML::FFI.taurus_xpath_result_number(result_ptr) + Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) + v + when Taurus::XML::FFI::XPATH_STRING + str_ptr = Taurus::XML::FFI.taurus_xpath_result_string(result_ptr) + v = str_ptr.null? ? "" : str_ptr.read_string + Taurus::XML::FFI.taurus_free_string(str_ptr) unless str_ptr.null? + Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) + v + else + Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) + raise Taurus::XML::XPathError, "unknown xpath result type #{type}" + end + end +end diff --git a/lib/taurus/xml/text.rb b/lib/taurus/xml/text.rb new file mode 100644 index 0000000..c71a5b7 --- /dev/null +++ b/lib/taurus/xml/text.rb @@ -0,0 +1,16 @@ +# frozen_string_literal: true + +class Taurus::XML::Text < Taurus::XML::Node + def name; "text"; end + + def content + Taurus::XML::FFI.taurus_text_node_get_content(@c_ptr) + end + + def content=(new_content) + status = Taurus::XML::FFI.taurus_text_node_set_content(@c_ptr, new_content.to_s) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + new_content + end +end diff --git a/lib/taurus/xpath.rb b/lib/taurus/xpath.rb deleted file mode 100644 index eb5f0d5..0000000 --- a/lib/taurus/xpath.rb +++ /dev/null @@ -1,152 +0,0 @@ -# frozen_string_literal: true - -module Taurus - # XPath 1.0 query engine providing full W3C specification compliance. - # - # The XPath module provides low-level access to the XPath engine's tokenizer, - # parser, and evaluator. For most use cases, you should use the high-level - # {Document#xpath} and {Element#xpath} methods instead. - # - # @example High-level usage (recommended) - # doc = Taurus.parse(xml) - # results = doc.xpath('//book[@price > 20]') - # - # @example Low-level tokenization - # tokens = Taurus::XPath.tokenize('//book') - # tokens # => [{type: :slash_slash, value: '//', ...}, ...] - # - # @example Low-level parsing - # ast = Taurus::XPath.parse('//book[1]') - # ast # => {type: :path, ...} - # - # @example Low-level evaluation - # result = Taurus::XPath.evaluate(doc, '//book', doc.root) - # - # == XPath 1.0 Features - # - # The engine implements the complete XPath 1.0 specification: - # - # === All 13 Axes - # - child, descendant, descendant-or-self - # - parent, ancestor, ancestor-or-self - # - self, following-sibling, preceding-sibling - # - following, preceding, attribute, namespace - # - # === All 27 Functions - # - String: string(), concat(), starts-with(), contains(), substring(), - # string-length(), normalize-space(), translate(), substring-before(), - # substring-after() - # - Boolean: boolean(), not(), true(), false(), lang() - # - Number: number(), sum(), floor(), ceiling(), round() - # - Node-set: count(), id(), last(), position(), local-name(), - # namespace-uri(), name() - # - # === All Operators - # - Logical: or, and - # - Equality: =, != - # - Relational: <, <=, >, >= - # - Arithmetic: +, -, *, div, mod - # - Union: | - # - # === Predicates - # - Position: [1], [N], [last()] - # - Boolean: [@attr], [element], [expression] - # - Comparison: [@price > 20], [@stock >= 5] - # - # @see Document#xpath - # @see Element#xpath - # @see https://www.w3.org/TR/1999/REC-xpath-19991116/ XPath 1.0 Specification - module XPath - class << self - # Tokenize an XPath expression into a stream of tokens - # - # Breaks down an XPath expression into its constituent tokens for parsing. - # This is the first stage of XPath processing. Most users should use - # {Document#xpath} instead. - # - # @param expression [String] the XPath expression to tokenize - # @return [Array] array of token hashes with :type, :value, :line, :column - # - # @example Tokenize a simple path - # tokens = Taurus::XPath.tokenize('//book') - # tokens[0] # => {type: :slash_slash, value: '//', line: 1, column: 0} - # tokens[1] # => {type: :name, value: 'book', line: 1, column: 2} - # - # @example Tokenize with predicates - # tokens = Taurus::XPath.tokenize('//book[@id="1"]') - # # Returns tokens for path, predicate, attribute, equality, string - # - # @see .parse - def tokenize(expression) - Taurus.xpath_tokenize(expression) - end - - # Parse an XPath expression into an Abstract Syntax Tree (AST) - # - # Converts a tokenized XPath expression into a tree structure representing - # its logical structure. This is the second stage of XPath processing. - # Most users should use {Document#xpath} instead. - # - # The AST is cached globally, so repeated calls with the same expression - # are extremely fast (O(1) hash lookup). - # - # @param expression [String] the XPath expression to parse - # @return [Hash] AST representation as a nested hash structure - # - # @example Parse a simple path - # ast = Taurus::XPath.parse('//book') - # ast[:type] # => :path - # - # @example Parse with functions - # ast = Taurus::XPath.parse('count(//book)') - # ast[:type] # => :function_call - # ast[:name] # => 'count' - # - # @see .tokenize - # @see .evaluate - def parse(expression) - Taurus.xpath_parse(expression) - end - - # Evaluate an XPath expression against a document - # - # Executes the XPath query and returns the result. This is the third and - # final stage of XPath processing. Most users should use {Document#xpath} - # or {Element#xpath} instead. - # - # @param document [Document] the document to query - # @param expression [String] the XPath expression to evaluate - # @param context_node [Element, Document, nil] the starting node for relative queries - # (default: document root) - # @return [Array, String, Float, Boolean] the evaluation result - # - Node-set queries return Array - # - String queries return String - # - Numeric queries return Float - # - Boolean queries return true or false - # - # @raise [ArgumentError] if expression is invalid - # - # @example Evaluate to node-set - # nodes = Taurus::XPath.evaluate(doc, '//book', doc.root) - # nodes # => [, , ...] - # - # @example Evaluate to number - # count = Taurus::XPath.evaluate(doc, 'count(//book)') - # count # => 2.0 - # - # @example Evaluate to boolean - # has_books = Taurus::XPath.evaluate(doc, 'boolean(//book)') - # has_books # => true - # - # @example Evaluate with context node - # item = doc.root.nodes.first - # children = Taurus::XPath.evaluate(doc, './child::*', item) - # - # @see Document#xpath - # @see Element#xpath - def evaluate(document, expression, context_node = nil) - Taurus.xpath_evaluate(document, expression, context_node) - end - end - end -end diff --git a/lib/taurus/xpath/ast/node.rb b/lib/taurus/xpath/ast/node.rb deleted file mode 100644 index 571719e..0000000 --- a/lib/taurus/xpath/ast/node.rb +++ /dev/null @@ -1,159 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - module AST - # Abstract base class for all XPath AST nodes - # - # All AST nodes must implement the #evaluate method which takes - # a context and returns a result (NodeSet, String, Number, or Boolean). - # - # @abstract Subclass and override {#evaluate} to implement - class Node - attr_reader :type, :children, :value - - # Initialize a new AST node - # - # @param type [Symbol] Node type - # @param children [Array] Child nodes - # @param value [Object] Optional value for leaf nodes - def initialize(type = :node, children = [], value = nil) - @type = type - @children = Array(children) - @value = value - end - - # Evaluate this AST node in the given context - # - # @param context [Taurus::XPath::Context] Evaluation context - # @return [Taurus::NodeSet, String, Numeric, Boolean] Result of evaluation - # @raise [NotImplementedError] if not overridden by subclass - def evaluate(context) - raise ::NotImplementedError, - "#{self.class}#evaluate must be implemented by subclass" - end - - # Check if this node is a constant value - # - # @return [Boolean] true if node represents a constant value - def constant? - false - end - - # Get the result type of this node - # - # @return [Symbol] One of :node_set, :string, :number, :boolean - def result_type - :unknown - end - - # String representation for debugging - # - # @return [String] Debug representation - def inspect - if @value - "#<#{self.class.name} @type=#{@type} @value=#{@value.inspect}>" - elsif @children.any? - "#<#{self.class.name} @type=#{@type} children=#{@children.size}>" - else - "#<#{self.class.name} @type=#{@type}>" - end - end - - alias to_s inspect - - # Factory methods for creating specific node types - - # Create an absolute path node (starts with / or //) - def self.absolute_path(descendant_or_self, *steps) - new(:absolute_path, [descendant_or_self] + steps) - end - - # Create a relative path node - def self.relative_path(*steps) - new(:relative_path, steps) - end - - # Create a path node - def self.path(*steps) - new(:path, steps) - end - - # Create an axis node - def self.axis(axis_name, node_test, *predicates) - new(:axis, [axis_name, node_test] + predicates) - end - - # Create a node test - def self.test(namespace, name) - new(:test, [], { namespace: namespace, name: name }) - end - - # Create a wildcard test - def self.wildcard - new(:wildcard) - end - - # Create a predicate node - def self.predicate(condition) - new(:predicate, [condition]) - end - - # Create a function call node - def self.function(name, *args) - new(:function, args, name) - end - - # Create a variable reference node - def self.variable(name) - new(:variable, [], name) - end - - # Create a literal string node - def self.string(value) - new(:string, [], value) - end - - # Create a literal number node - def self.number(value) - new(:number, [], value.to_f) - end - - # Create a binary operator node - def self.binary_op(operator, left, right) - new(:binary_op, [left, right], operator) - end - - # Create a unary operator node - def self.unary_op(operator, operand) - new(:unary_op, [operand], operator) - end - - # Create a union node (|) - def self.union(*expressions) - new(:union, expressions) - end - - # Create an attribute node - def self.attribute(name) - new(:attribute, [], name) - end - - # Create a current node (.) - def self.current - new(:current) - end - - # Create a parent node (..) - def self.parent - new(:parent) - end - - # Create a node type test (text(), comment(), etc.) - def self.node_type(type_name) - new(:node_type, [], type_name) - end - end - end - end -end diff --git a/lib/taurus/xpath/cache.rb b/lib/taurus/xpath/cache.rb deleted file mode 100644 index a338281..0000000 --- a/lib/taurus/xpath/cache.rb +++ /dev/null @@ -1,91 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # Simple LRU (Least Recently Used) cache for compiled XPath expressions. - # - # @private - class Cache - DEFAULT_SIZE = 1000 - - # @param [Integer] max_size Maximum number of entries to cache - def initialize(max_size = DEFAULT_SIZE) - @max_size = max_size - @cache = {} - @access_order = [] - end - - # Gets a value from the cache or sets it using the provided block. - # - # @param [Object] key Cache key - # @yield Block to execute if key is not in cache - # @return [Object] Cached or newly computed value - def get_or_set(key) - if @cache.key?(key) - # Move to end (most recently used) - @access_order.delete(key) - @access_order.push(key) - @cache[key] - else - value = yield - set(key, value) - value - end - end - - # Sets a value in the cache. - # - # @param [Object] key - # @param [Object] value - # @return [Object] The value - def set(key, value) - if @cache.key?(key) - @access_order.delete(key) - elsif @cache.size >= @max_size - # Remove least recently used - lru_key = @access_order.shift - @cache.delete(lru_key) - end - - @cache[key] = value - @access_order.push(key) - value - end - - # Gets a value from the cache. - # - # @param [Object] key - # @return [Object, nil] - def get(key) - return unless @cache.key?(key) - - @access_order.delete(key) - @access_order.push(key) - @cache[key] - end - - # Clears the cache. - # - # @return [void] - def clear - @cache.clear - @access_order.clear - end - - # Returns the current size of the cache. - # - # @return [Integer] - def size - @cache.size - end - - # Checks if a key exists in the cache. - # - # @param [Object] key - # @return [Boolean] - def key?(key) - @cache.key?(key) - end - end - end -end diff --git a/lib/taurus/xpath/compiler.rb b/lib/taurus/xpath/compiler.rb deleted file mode 100644 index afc4bbc..0000000 --- a/lib/taurus/xpath/compiler.rb +++ /dev/null @@ -1,1768 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # Compiler for transforming XPath AST into executable Ruby code. - # - # This class takes an XPath AST (produced by Parser) and compiles it into - # a Ruby Proc that can be executed against XML documents. The compilation - # process: - # - # 1. Traverse the XPath AST - # 2. Generate Ruby::Node AST representing Ruby code - # 3. Use Ruby::Generator to convert to Ruby source string - # 4. Evaluate source in Context to get a Proc - # - # @example - # ast = Parser.parse("//book") - # proc = Compiler.compile_with_cache(ast) - # result = proc.call(document) - # - # @private - class Compiler - # Shared context for compiled Procs - CONTEXT = Context.new - - # Expression cache - CACHE = Cache.new - - # Wildcard for node names/namespace prefixes - STAR = "*" - - # Node types that require a NodeSet to push nodes into - RETURN_NODESET = %i[path absolute_path relative_path axis - predicate].freeze - - # Compiles and caches an AST - # - # @param ast [AST::Node] XPath AST to compile - # @param namespaces [Hash, nil] Optional namespace prefix mappings - # @return [Proc] Compiled Proc that accepts a document - def self.compile_with_cache(ast, namespaces: nil) - cache_key = namespaces ? [ast, namespaces] : ast - CACHE.get_or_set(cache_key) { new(namespaces: namespaces).compile(ast) } - end - - # Initialize compiler - # - # @param namespaces [Hash, nil] Optional namespace prefix mappings - def initialize(namespaces: nil) - @namespaces = namespaces - @literal_id = 0 - @predicate_nodesets = [] - @predicate_indexes = [] - end - - # Compiles an XPath AST into a Ruby Proc - # - # @param ast [AST::Node] XPath AST to compile - # @return [Proc] Executable Proc - def compile(ast) - document = literal(:node) - matched = matched_literal - context_var = context_literal - - # Enable debug output - debug = ENV["DEBUG_XPATH"] == "1" - if debug - puts "\n#{'=' * 60}" - puts "COMPILING XPath" - puts "=" * 60 - puts "AST: #{ast.inspect}" - puts - end - - ruby_ast = if return_nodeset?(ast) - process(ast, document) { |node| matched.push(node) } - else - process(ast, document) - end - - proc_ast = literal(:lambda).add_block(document) do - # Get context from document - context_assign = context_var.assign(document.context) - - if return_nodeset?(ast) - # Create NodeSet using send node: Taurus::NodeSet.new([], context) - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - body = matched.assign(nodeset_new) - .followed_by(ruby_ast) - .followed_by(matched) - else - body = ruby_ast - end - - context_assign.followed_by(body) - end - - generator = Ruby::Generator.new - source = generator.process(proc_ast) - - if debug - puts "GENERATED RUBY CODE:" - puts "-" * 60 - puts source - puts "=" * 60 - puts - end - - CONTEXT.evaluate(source) - ensure - @literal_id = 0 - @predicate_nodesets.clear - @predicate_indexes.clear - end - - # Process a single XPath AST node - # - # @param ast [AST::Node] AST node to process - # @param input [Ruby::Node] Input node - # @yield [Ruby::Node] Yields matched nodes if block given - # @return [Ruby::Node] Ruby AST node - def process(ast, input, &block) - send(:"on_#{ast.type}", ast, input, &block) - end - - # Dispatcher for generic binary operator nodes - def on_binary_op(ast, input, &block) - operator = ast.value # :eq, :lt, :add, :plus, :star, etc. - - # Map token names to handler method names - method_name = case operator - when :plus then :add - when :minus then :sub - when :star then :mul - else operator # eq, lt, gt, div, mod, etc. - end - - send(:"on_#{method_name}", ast, input, &block) - end - - # Dispatcher for generic unary operator nodes - def on_unary_op(ast, input, &block) - operator = ast.value # :minus - send(:"on_#{operator}", ast, input, &block) - end - - # Dispatcher for union nodes (parser creates :union, compiler uses :pipe) - def on_union(ast, input, &block) - on_pipe(ast, input, &block) - end - - private - - # Helper methods for creating Ruby AST nodes - - def literal(value) - case value - when Symbol, String - end - Ruby::Node.new(:lit, [value.to_s]) - end - - # Create a constant reference like Taurus::Document - def const_ref(*parts) - Ruby::Node.new(:const, parts) - end - - def unique_literal(name) - @literal_id += 1 - literal("#{name}#{@literal_id}") - end - - def string(value) - Ruby::Node.new(:string, [value.to_s]) - end - - def symbol(value) - Ruby::Node.new(:symbol, [value.to_sym]) - end - - def matched_literal - literal(:matched) - end - - def context_literal - literal(:context) - end - - def self_nil - @self_nil ||= literal(:nil) - end - - def self_true - @self_true ||= literal(true) - end - - def self_false - @self_false ||= literal(false) - end - - def return_nodeset?(ast) - # Special cases where relative_path returns node directly: - # - "." (current node) - # - ".." (parent node) - if ast.type == :relative_path && ast.children.size == 1 - child_type = ast.children[0].type - return false if %i[current parent].include?(child_type) - end - - RETURN_NODESET.include?(ast.type) - end - - # Type checking helpers - - def document_or_node(node) - doc_class = const_ref("Moxml", "Document") - node_class = const_ref("Moxml", "Node") - node.is_a?(doc_class).or(node.is_a?(node_class)) - end - - def element_or_attribute(node) - elem_class = const_ref("Moxml", "Element") - attr_class = const_ref("Moxml", "Attribute") - node.is_a?(elem_class).or(node.is_a?(attr_class)) - end - - def attribute_or_node(node) - attr_class = const_ref("Moxml", "Attribute") - node_class = const_ref("Moxml", "Node") - node.is_a?(attr_class).or(node.is_a?(node_class)) - end - - # Path handling - - # Handle absolute paths like /root or //descendant - def on_absolute_path(ast, input, &block) - if ast.children.empty? - # Just "/" - return the document/root - yield input if block - input - else - # Process steps from the input (which should be a document) - # Don't call input.root - that would skip a level - first_child = ast.children[0] - - # For absolute paths, we process from the document itself - if ast.children.size == 1 - process(first_child, input, &block) - else - # Multiple steps - create a path - path_node = AST::Node.new(:path, ast.children) - process(path_node, input, &block) - end - end - end - - # Handle relative paths - def on_relative_path(ast, input, &block) - on_path(ast, input, &block) - end - - # Handle path (series of steps) - def on_path(ast, input, &block) - return input if ast.children.empty? - - # First step from input - first_step = ast.children[0] - - if ast.children.size == 1 - # Single step - process(first_step, input, &block) - else - # Multiple steps - need to accumulate results - temp_results = unique_literal(:temp_results) - context_var = context_literal - - # Create NodeSet for temp results - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - temp_results.assign(nodeset_new) - .followed_by do - process(first_step, input) do |node| - temp_results.push(node) - end - .followed_by do - # Process remaining steps on each result - remaining_steps = AST::Node.new(:path, ast.children[1..]) - temp_node = unique_literal(:temp_node) - - temp_results.each.add_block(temp_node) do - process(remaining_steps, temp_node, &block) - end - end - end - end - end - - # Axis handling - - # Dispatch axes to specific handlers - def on_axis(ast, input, &block) - axis_name, test, *_predicates = ast.children - - handler = axis_name.gsub("-", "_") - - send(:"on_axis_#{handler}", test, input, &block) - end - - # Handle step with predicates (created by parser) - def on_step_with_predicates(ast, input, &block) - step, *predicates = ast.children - - # If no predicates, just process the step - return process(step, input, &block) if predicates.empty? - - # Build predicate chain: step -> pred1 -> pred2 -> ... - # Each predicate wraps the previous result as its test - result_ast = step - - predicates.each do |pred_wrapper| - # pred_wrapper is :predicate node with children [expression] - # Build proper :predicate node with [test, expression, nil] - predicate_expr = pred_wrapper.children[0] - result_ast = AST::Node.new(:predicate, - [result_ast, predicate_expr, nil]) - end - - # Process the final chained AST - process(result_ast, input, &block) - end - - # AXIS: child - direct children - def on_axis_child(ast, input) - child = unique_literal(:child) - - document_or_node(input).if_true do - input.children.each.add_block(child) do - condition = process(ast, child) - if block_given? - condition.if_true { yield child } - else - condition.if_true { child } - end - end - end - end - - # AXIS: self - the node itself - def on_axis_self(ast, input) - condition = process(ast, input) - if block_given? - condition.if_true { yield input } - else - condition.if_true { input } - end - end - - # AXIS: parent - parent node - def on_axis_parent(ast, input) - parent = unique_literal(:parent) - - attribute_or_node(input).if_true do - parent.assign(input.parent).followed_by do - condition = process(ast, parent) - if block_given? - condition.if_true { yield parent } - else - condition.if_true { parent } - end - end - end - end - - # AXIS: descendant-or-self - Enables // operator - def on_axis_descendant_or_self(ast, input) - node = unique_literal(:descendant) - doc_class = const_ref("Moxml", "Document") - - document_or_node(input).if_true do - # Create a proper if-else structure that prevents double traversal - input.is_a?(doc_class).if_true do - # DOCUMENT PATH: test root, then traverse from root - root = unique_literal(:root) - root.assign(input.root).followed_by do - root.if_true do - # Test root first - condition = process(ast, root) - (if block_given? - condition.if_true { yield root } - else - condition.if_true { root } - end) - .followed_by do - # Traverse descendants FROM root only (not document.each_node) - root.each_node.add_block(node) do - desc_condition = process(ast, node) - if block_given? - desc_condition.if_true { yield node } - else - desc_condition.if_true { node } - end - end - end - end - end - end.else do - # NON-DOCUMENT PATH: test self, then traverse from self - condition = process(ast, input) - (if block_given? - condition.if_true { yield input } - else - condition.if_true { input } - end) - .followed_by do - # Traverse descendants FROM input - input.each_node.add_block(node) do - desc_condition = process(ast, node) - if block_given? - desc_condition.if_true { yield node } - else - desc_condition.if_true { node } - end - end - end - end - end - end - - # AXIS: attribute - Enables @attribute syntax - def on_axis_attribute(ast, input) - elem_class = const_ref("Moxml", "Element") - attribute = unique_literal(:attribute) - - input.is_a?(elem_class).if_true do - input.attributes.each.add_block(attribute) do - # Use process to handle both :test and :wildcard nodes - condition = process(ast, attribute) - - if block_given? - condition.if_true { yield attribute } - else - condition.if_true { attribute } - end - end - end - end - - # AXIS: descendant - All descendant nodes (without self) - def on_axis_descendant(ast, input) - node = unique_literal(:descendant) - - document_or_node(input).if_true do - input.each_node.add_block(node) do - condition = process(ast, node) - if block_given? - condition.if_true { yield node } - else - condition.if_true { node } - end - end - end - end - - # Helper: Recursively traverse all descendants - def traverse_all_descendants(input, &block) - child = unique_literal(:child) - - input.children.each.add_block(child) do - # Yield this child - yield child - # Then recursively traverse its descendants - traverse_all_descendants(child, &block) - end - end - - # Node test handling - - # Handle node tests (name matching) - def on_test(ast, input) - condition = element_or_attribute(input) - name_match = match_name_and_namespace(ast, input) - - name_match ? condition.and(name_match) : condition - end - - # Handle wildcard test (*) - def on_wildcard(_ast, input) - element_or_attribute(input) - end - - # Match element/attribute names and namespaces - def match_name_and_namespace(ast, input) - ns = ast.value[:namespace] - name = ast.value[:name] - - # Wildcard for both name and namespace means match all - return nil - # nil means "no additional constraint beyond type check" - return nil if name == STAR && (!ns || ns == STAR) - - condition = nil - name_str = string(name) - zero = literal(0) - - # Match name (case-insensitive) unless wildcard - if name != STAR - # If we have a namespace prefix, we need to compare local names - # For elements like "ns:item", we should compare against "item" not "ns:item" - if ns && ns != STAR && @namespaces && @namespaces[ns] - # Extract local name by splitting on ':' and taking the last part - # This handles both "ns:item" -> "item" and "item" -> "item" - local_name_expr = input.name.split(string(":")).last - condition = local_name_expr.eq(name_str) - .or(local_name_expr.casecmp(name_str).eq(zero)) - else - # No namespace or no mapping - compare full name - condition = input.name.eq(name_str) - .or(input.name.casecmp(name_str).eq(zero)) - end - end - - # Match namespace if specified - if ns && ns != STAR - if @namespaces && @namespaces[ns] - # Resolve prefix to URI using namespace mappings - ns_uri = @namespaces[ns] - ns_match = input.namespace.and(input.namespace.uri.eq(string(ns_uri))) - else - # No mapping provided - check against element's namespace prefix - # Need to ensure input.namespace exists first - ns_match = input.namespace.and(input.namespace.prefix.eq(string(ns))) - end - - condition = condition ? condition.and(ns_match) : ns_match - end - - condition - end - - # Literal value handling - - # String literals - def on_string(ast, *) - string(ast.value) - end - - # Number literals (both int and float) - def on_number(ast, *) - literal(ast.value.to_f.to_s) - end - - # Current node (.) - def on_current(_ast, input) - if block_given? - yield input # Block returns Ruby::Node for matched.push(input) - else - input - end - end - - # Parent node (..) - def on_parent(_ast, input) - input.parent - end - - # ===== OPERATORS ===== - - # Comparison: = (equality) - def on_eq(ast, input, &block) - conv = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - mass_assign([left, right], conv.to_compatible_types(left, right)) - .followed_by do - operation = left.eq(right) - - block ? operation.if_true(&block) : operation - end - end - end - - # Comparison: != (inequality) - def on_neq(ast, input, &block) - conv = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - mass_assign([left, right], conv.to_compatible_types(left, right)) - .followed_by do - operation = left != right - - block ? operation.if_true(&block) : operation - end - end - end - - # Comparison: < (less than) - def on_lt(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval < rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Comparison: > (greater than) - def on_gt(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval > rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Comparison: <= (less than or equal) - def on_lte(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval <= rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Comparison: >= (greater than or equal) - def on_gte(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval >= rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Arithmetic: + (addition) - def on_add(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval + rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Arithmetic: - (subtraction) - def on_sub(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval - rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Arithmetic: * (multiplication) - def on_mul(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval * rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Arithmetic: div (division) - def on_div(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval / rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Arithmetic: mod (modulo) - def on_mod(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_float(left) - rval = conversion.to_float(right) - operation = lval % rval - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Unary: minus (negation) - def on_minus(ast, input, &block) - operand = ast.children[0] - operand_ast = process(operand, input) - conversion = literal(Taurus::XPath::Conversion) - - operand_var = unique_literal(:unary_operand) - operand_var.assign(operand_ast) - .followed_by do - negated = literal(0) - conversion.to_float(operand_var) - block ? conversion.to_boolean(negated).if_true(&block) : negated - end - end - - # Logical: and - def on_and(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_boolean(left) - rval = conversion.to_boolean(right) - operation = lval.and(rval) - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Logical: or - def on_or(ast, input, &block) - conversion = literal(Taurus::XPath::Conversion) - - operator(ast, input) do |left, right| - lval = conversion.to_boolean(left) - rval = conversion.to_boolean(right) - operation = lval.or(rval) - - block ? conversion.to_boolean(operation).if_true(&block) : operation - end - end - - # Union: | (pipe) - def on_pipe(ast, input) - left, right = ast.children - - union = unique_literal(:union) - context_var = context_literal - - # Create NodeSet for union results - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - - # Expressions such as "a | b | c" - if left.type == :pipe - union.assign(process(left, input)) - .followed_by(process(right, input) { |node| union << node }) - .followed_by(union) - # Expressions such as "a | b" - else - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - union.assign(nodeset_new) - .followed_by(process(left, input) { |node| union << node }) - .followed_by(process(right, input) { |node| union << node }) - .followed_by(union) - end - end - - # Variable: $variable - def on_var(ast, *) - name = ast.children[0] - - variables_literal.and(variables_literal[string(name)]) - .or(send_message(:raise, string("Undefined XPath variable: #{name}"))) - end - - # Predicate handling: //book[@price < 20] - def on_predicate(ast, input, &block) - test, predicate, following = ast.children - - index_var = unique_literal(:index) - - # Check predicate type to determine strategy - method = if number?(predicate) - :on_predicate_index - elsif has_call_node?(predicate, "last") - :on_predicate_temporary - else - :on_predicate_direct - end - - @predicate_indexes << index_var - - result = index_var.assign(literal(1)).followed_by do - send(method, input, test, predicate) do |matched| - if following - process(following, matched, &block) - else - yield matched - end - end - end - - @predicate_indexes.pop - - result - end - - # Predicate that requires temporary NodeSet (for last()) - def on_predicate_temporary(input, test, predicate) - temp_set = unique_literal(:temp_set) - pred_node = unique_literal(:pred_node) - pred_var = unique_literal(:pred_var) - conversion = literal(Taurus::XPath::Conversion) - context_var = context_literal - - index_var = predicate_index - index_step = literal(1) - - @predicate_nodesets << temp_set - - # Create NodeSet for temp results - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - ast = temp_set.assign(nodeset_new) - .followed_by do - process(test, input) { |node| temp_set << node } - end - .followed_by do - temp_set.each.add_block(pred_node) do - pred_ast = process(predicate, pred_node) - - pred_var.assign(pred_ast) - .followed_by do - pred_var.is_a?(literal(:Numeric)).if_true do - pred_var.assign(pred_var.to_i.eq(index_var)) - end - end - .followed_by do - conversion.to_boolean(pred_var).if_true { yield pred_node } - end - .followed_by do - index_var.assign(index_var + index_step) - end - end - end - - @predicate_nodesets.pop - - ast - end - - # Predicate that doesn't require temporary NodeSet - def on_predicate_direct(input, test, predicate) - pred_var = unique_literal(:pred_var) - index_var = predicate_index - index_step = literal(1) - conversion = literal(Taurus::XPath::Conversion) - - process(test, input) do |matched_test_node| - pred_ast = if return_nodeset?(predicate) - # Use catch/throw for early return - catch_message(:predicate_matched) do - process(predicate, matched_test_node) do - throw_message(:predicate_matched, self_true) - end - end - else - process(predicate, matched_test_node) - end - - pred_var.assign(pred_ast) - .followed_by do - pred_var.is_a?(literal(:Numeric)).if_true do - pred_var.assign(pred_var.to_i.eq(index_var)) - end - end - .followed_by do - conversion.to_boolean(pred_var).if_true do - yield matched_test_node - end - end - .followed_by do - index_var.assign(index_var + index_step) - end - end - end - - # Predicate with literal index: //book[1] - def on_predicate_index(input, test, predicate) - index_var = predicate_index - index_step = literal(1) - - index = process(predicate, input).to_i - - process(test, input) do |matched_test_node| - index_var.eq(index) - .if_true do - yield matched_test_node - end - .followed_by do - index_var.assign(index_var + index_step) - end - end - end - - # ===== XPATH FUNCTIONS ===== - - # XPath function dispatcher - def on_call(ast, input, &block) - # Function name is stored in value field, not children - name = ast.value - args = ast.children - - handler = name.to_s.gsub("-", "_") - - send(:"on_call_#{handler}", input, *args, &block) - end - - # Alias for function nodes (parser creates :function, compiler uses on_call) - alias on_function on_call - - # 1. string() - Convert value to string - def on_call_string(input, arg = nil) - convert_var = unique_literal(:convert) - conversion = literal(Taurus::XPath::Conversion) - - argument_or_first_node(input, arg) do |arg_var| - convert_var.assign(conversion.to_string(arg_var)) - .followed_by do - if block_given? - convert_var.empty?.if_false { yield convert_var } - else - convert_var - end - end - end - end - - # 2. concat() - Concatenate strings - def on_call_concat(input, *args) - conversion = literal(Taurus::XPath::Conversion) - assigns = [] - conversions = [] - - args.each do |arg| - arg_var = unique_literal(:concat_arg) - arg_ast = try_match_first_node(arg, input) - - assigns << arg_var.assign(arg_ast) - conversions << conversion.to_string(arg_var) - end - - concatted = assigns.inject(:followed_by) - .followed_by(conversions.inject(:+)) - - block_given? ? concatted.empty?.if_false { yield concatted } : concatted - end - - # 3. starts-with() - Check string prefix - def on_call_starts_with(input, haystack, needle) - haystack_var = unique_literal(:haystack) - needle_var = unique_literal(:needle) - conversion = literal(Taurus::XPath::Conversion) - - haystack_var.assign(try_match_first_node(haystack, input)) - .followed_by do - needle_var.assign(try_match_first_node(needle, input)) - end - .followed_by do - haystack_var.assign(conversion.to_string(haystack_var)) - .followed_by do - needle_var.assign(conversion.to_string(needle_var)) - end - .followed_by do - equal = needle_var.empty? - .or(haystack_var.start_with?(needle_var)) - - block_given? ? equal.if_true { yield equal } : equal - end - end - end - - # 4. contains() - Check substring - def on_call_contains(input, haystack, needle) - haystack_lit = unique_literal(:haystack) - needle_lit = unique_literal(:needle) - conversion = literal(Taurus::XPath::Conversion) - - haystack_lit.assign(try_match_first_node(haystack, input)) - .followed_by do - needle_lit.assign(try_match_first_node(needle, input)) - end - .followed_by do - converted = conversion.to_string(haystack_lit) - .include?(conversion.to_string(needle_lit)) - - block_given? ? converted.if_true { yield converted } : converted - end - end - - # 5. substring-before() - Get part before separator - def on_call_substring_before(input, haystack, needle) - haystack_var = unique_literal(:haystack) - needle_var = unique_literal(:needle) - conversion = literal(Taurus::XPath::Conversion) - - before = unique_literal(:before) - sep = unique_literal(:sep) - after = unique_literal(:after) - - haystack_var.assign(try_match_first_node(haystack, input)) - .followed_by do - needle_var.assign(try_match_first_node(needle, input)) - end - .followed_by do - converted = conversion.to_string(haystack_var) - .partition(conversion.to_string(needle_var)) - - mass_assign([before, sep, after], converted).followed_by do - sep.empty? - .if_true { sep } - .else { block_given? ? yield : before } - end - end - end - - # 6. substring-after() - Get part after separator - def on_call_substring_after(input, haystack, needle) - haystack_var = unique_literal(:haystack) - needle_var = unique_literal(:needle) - conversion = literal(Taurus::XPath::Conversion) - - before = unique_literal(:before) - sep = unique_literal(:sep) - after = unique_literal(:after) - - haystack_var.assign(try_match_first_node(haystack, input)) - .followed_by do - needle_var.assign(try_match_first_node(needle, input)) - end - .followed_by do - converted = conversion.to_string(haystack_var) - .partition(conversion.to_string(needle_var)) - - mass_assign([before, sep, after], converted).followed_by do - sep.empty? - .if_true { sep } - .else { block_given? ? yield : after } - end - end - end - - # 7. substring() - Extract substring - def on_call_substring(input, haystack, start, length = nil) - haystack_var = unique_literal(:haystack) - start_var = unique_literal(:start) - length_var = unique_literal(:length) - result_var = unique_literal(:result) - ruby_start = unique_literal(:ruby_start) - effective_length = unique_literal(:effective_length) - conversion = literal(Taurus::XPath::Conversion) - - haystack_var.assign(try_match_first_node(haystack, input)) - .followed_by do - haystack_var.assign(conversion.to_string(haystack_var)) - end - .followed_by do - start_var.assign(try_match_first_node(start, input)) - .followed_by do - # Round the start position first (XPath 1.0 spec requires rounding) - start_var.assign(conversion.to_float(start_var).round.to_i) - end - end - .followed_by do - if length - length_var.assign(try_match_first_node(length, input)) - .followed_by do - # Round the length (XPath 1.0 spec requires rounding) - length_var.assign(conversion.to_float(length_var).round.to_i) - end - .followed_by do - # XPath 1.0 algorithm: - # If start < 1, some positions fall before the string - # We need to adjust the effective length accordingly - # effective_length = (start + length) - max(start, 1) - # lua_start = max(start, 1) - 1 (since we start from position 1) - - # Calculate how many positions to skip before position 1 - # If start is 0, we lose 1 position; if -2, we lose 3 positions - ruby_start.assign( - (start_var < literal(1)) - .if_true { literal(0) } - .else { start_var - literal(1) }, - ) - end - .followed_by do - # Calculate effective length accounting for positions before string - effective_length.assign( - (start_var < literal(1)) - .if_true do - # Some positions are before position 1 - # end_pos = start + length - # effective = end_pos - 1 (since we start from position 1) - # But clamp to 0 if entirely before string - ((start_var + length_var) - literal(1)) - .if_true { (start_var + length_var) - literal(1) } - .else { literal(0) } - end - .else { length_var }, - ) - end - .followed_by do - # Clamp effective length to non-negative - effective_length.assign( - (effective_length < literal(0)) - .if_true { literal(0) } - .else { effective_length }, - ) - end - .followed_by do - # Extract substring with effective length - result_var.assign(haystack_var[ruby_start, effective_length]) - .followed_by do - # Ensure we return empty string instead of nil - result_var.assign(result_var.if_true do - result_var - end.else { string("") }) - end - end - .followed_by do - if block_given? - result_var.empty?.if_false do - yield result_var - end - else - result_var - end - end - else - # No length specified - go to end of string - # Convert to 0-based index, clamping to 0 - ruby_start.assign( - (start_var < literal(1)) - .if_true { literal(0) } - .else { start_var - literal(1) }, - ).followed_by do - # Extract from start to end - result_var.assign(haystack_var[range(ruby_start, literal(-1))]) - .followed_by do - # Ensure we return empty string instead of nil - result_var.assign(result_var.if_true do - result_var - end.else { string("") }) - end - end - .followed_by do - if block_given? - result_var.empty?.if_false do - yield result_var - end - else - result_var - end - end - end - end - end - - # 8. string-length() - Get string length - def on_call_string_length(input, arg = nil) - convert_var = unique_literal(:convert) - conversion = literal(Taurus::XPath::Conversion) - - argument_or_first_node(input, arg) do |arg_var| - convert_var.assign(conversion.to_string(arg_var).length) - .followed_by do - if block_given? - convert_var.zero?.if_false { yield convert_var } - else - convert_var.to_f - end - end - end - end - - # 9. normalize-space() - Normalize whitespace - def on_call_normalize_space(input, arg = nil) - conversion = literal(Taurus::XPath::Conversion) - norm_var = unique_literal(:normalized) - - # Create regex for matching whitespace sequences - # Use Regexp.new to create /\s+/ pattern at runtime - regexp_class = const_ref("Regexp") - whitespace_pattern = string('\\s+') - whitespace_regex = Ruby::Node.new(:send, - [regexp_class, "new", - whitespace_pattern]) - replace = string(" ") - - argument_or_first_node(input, arg) do |arg_var| - norm_var - .assign(conversion.to_string(arg_var).strip.gsub(whitespace_regex, - replace)) - .followed_by do - norm_var.empty? - .if_true { string("") } - .else { block_given? ? yield : norm_var } - end - end - end - - # 10. translate() - Character replacement - def on_call_translate(input, source, find, replace) - source_var = unique_literal(:source) - find_var = unique_literal(:find) - replace_var = unique_literal(:replace) - replaced_var = unique_literal(:replaced) - conversion = literal(Taurus::XPath::Conversion) - - char = unique_literal(:char) - index = unique_literal(:index) - - source_var.assign(try_match_first_node(source, input)) - .followed_by do - replaced_var.assign(conversion.to_string(source_var)) - end - .followed_by do - find_var.assign(try_match_first_node(find, input)) - end - .followed_by do - find_var.assign(conversion.to_string(find_var).chars.to_array) - end - .followed_by do - replace_var.assign(try_match_first_node(replace, input)) - end - .followed_by do - replace_var.assign(conversion.to_string(replace_var).chars.to_array) - end - .followed_by do - find_var.each_with_index.add_block(char, index) do - replace_with = replace_var[index] - .if_true { replace_var[index] } - .else { string("") } - - replaced_var.assign(replaced_var.gsub(char, replace_with)) - end - end - .followed_by { replaced_var } - end - - # ===== NUMERIC FUNCTIONS ===== - - # 1. number() - Convert to number - def on_call_number(input, arg = nil, &block) - convert_var = unique_literal(:convert) - conversion = literal(Taurus::XPath::Conversion) - - argument_or_first_node(input, arg) do |arg_var| - convert_var.assign(conversion.to_float(arg_var)).followed_by do - if block - convert_var.zero?.if_false(&block) - else - convert_var - end - end - end - end - - # 2. sum() - Sum node values - def on_call_sum(input, arg, &block) - unless return_nodeset?(arg) - raise TypeError, "sum() can only operate on a path, axis or predicate" - end - - sum_var = unique_literal(:sum) - conversion = literal(Taurus::XPath::Conversion) - - sum_var.assign(literal(0.0)) - .followed_by do - process(arg, input) do |matched_node| - sum_var.assign(sum_var + conversion.to_float(matched_node.text)) - end - end - .followed_by do - block ? sum_var.zero?.if_false(&block) : sum_var - end - end - - # 3. count() - Count nodes - def on_call_count(input, arg, &block) - count = unique_literal(:count) - - unless return_nodeset?(arg) - raise TypeError, "count() can only operate on NodeSet instances" - end - - count.assign(literal(0.0)) - .followed_by do - process(arg, input) { count.assign(count + literal(1)) } - end - .followed_by do - block ? count.zero?.if_false(&block) : count - end - end - - # 4. floor() - Round down - def on_call_floor(input, arg) - arg_ast = try_match_first_node(arg, input) - call_arg = unique_literal(:call_arg) - conversion = literal(Taurus::XPath::Conversion) - - call_arg.assign(arg_ast) - .followed_by do - call_arg.assign(conversion.to_float(call_arg)) - end - .followed_by do - call_arg.nan? - .if_true { call_arg } - .else { block_given? ? yield : call_arg.floor.to_f } - end - end - - # 5. ceiling() - Round up - def on_call_ceiling(input, arg) - arg_ast = try_match_first_node(arg, input) - call_arg = unique_literal(:call_arg) - conversion = literal(Taurus::XPath::Conversion) - - call_arg.assign(arg_ast) - .followed_by do - call_arg.assign(conversion.to_float(call_arg)) - end - .followed_by do - call_arg.nan? - .if_true { call_arg } - .else { block_given? ? yield : call_arg.ceil.to_f } - end - end - - # 6. round() - Round to nearest - def on_call_round(input, arg) - arg_ast = try_match_first_node(arg, input) - call_arg = unique_literal(:call_arg) - conversion = literal(Taurus::XPath::Conversion) - - call_arg.assign(arg_ast) - .followed_by do - call_arg.assign(conversion.to_float(call_arg)) - end - .followed_by do - call_arg.nan? - .if_true { call_arg } - .else { block_given? ? yield : call_arg.round.to_f } - end - end - - # ===== BOOLEAN FUNCTIONS ===== - - # 1. boolean() - Convert to boolean - def on_call_boolean(input, arg, &block) - arg_ast = try_match_first_node(arg, input) - call_arg = unique_literal(:call_arg) - conversion = literal(Taurus::XPath::Conversion) - - call_arg.assign(arg_ast).followed_by do - converted = conversion.to_boolean(call_arg) - - block ? converted.if_true(&block) : converted - end - end - - # 2. not() - Negate boolean - def on_call_not(input, arg, &block) - arg_ast = try_match_first_node(arg, input) - call_arg = unique_literal(:call_arg) - conversion = literal(Taurus::XPath::Conversion) - - call_arg.assign(arg_ast).followed_by do - converted = conversion.to_boolean(call_arg).not - - block ? converted.if_true(&block) : converted - end - end - - # 3. true() - Return true - def on_call_true(*) - block_given? ? yield : self_true - end - - # 4. false() - Return false - def on_call_false(*) - self_false - end - - # ===== NODE FUNCTIONS ===== - - # 1. local-name() - Get local name without namespace prefix - def on_call_local_name(input, arg = nil) - argument_or_first_node(input, arg) do |arg_var| - arg_var - .if_true do - ensure_element_or_attribute(arg_var) - .followed_by { block_given? ? yield : arg_var.name } - end - .else { string("") } - end - end - - # 2. name() - Get expanded/qualified name with namespace - def on_call_name(input, arg = nil) - argument_or_first_node(input, arg) do |arg_var| - arg_var - .if_true do - ensure_element_or_attribute(arg_var) - .followed_by { block_given? ? yield : arg_var.expanded_name } - end - .else { string("") } - end - end - - # 3. namespace-uri() - Get namespace URI - def on_call_namespace_uri(input, arg = nil) - default = string("") - - argument_or_first_node(input, arg) do |arg_var| - arg_var - .if_true do - ensure_element_or_attribute(arg_var).followed_by do - arg_var.namespace - .if_true { block_given? ? yield : arg_var.namespace.uri } - .else { default } - end - end - .else { default } - end - end - - # 4. lang() - Check xml:lang attribute - def on_call_lang(input, arg) - lang_var = unique_literal("lang") - node = unique_literal("node") - found = unique_literal("found") - xml_lang = unique_literal("xml_lang") - matched = unique_literal("matched") - - conversion = literal(Taurus::XPath::Conversion) - - ast = lang_var.assign(try_match_first_node(arg, input)) - .followed_by do - lang_var.assign(conversion.to_string(lang_var)) - end - .followed_by do - matched.assign(self_false) - end - .followed_by do - node.assign(input) - end - .followed_by do - xml_lang.assign(string("xml:lang")) - end - .followed_by do - node.respond_to?(symbol(:attribute)).while_true do - found.assign(node.get(xml_lang)) - .followed_by do - found.if_true do - found.eq(lang_var) - .if_true do - if block_given? - yield - else - matched.assign(self_true).followed_by(break_loop) - end - end - .else { break_loop } - end - end - .followed_by(node.assign(node.parent)) - end - end - - block_given? ? ast : ast.followed_by(matched) - end - - # ===== POSITION FUNCTIONS ===== - - # 1. position() - Current position in predicate context - def on_call_position(*) - index = predicate_index - - unless index - raise InvalidContextError.new( - "position() requires a predicate context. " \ - "Use position() within a predicate like: //item[position() = 1]", - function_name: "position()", - required_context: "predicate", - ) - end - - index.to_f - end - - # 2. last() - Size of current predicate context - def on_call_last(*) - set = predicate_nodeset - - unless set - raise InvalidContextError.new( - "last() requires a predicate context. " \ - "Use last() within a predicate like: //item[position() = last()]", - function_name: "last()", - required_context: "predicate", - ) - end - - set.length.to_f - end - - # ===== SPECIAL FUNCTIONS ===== - - # 1. id() - Find nodes by ID attribute - def on_call_id(input, arg) - orig_input = original_input_literal - node = unique_literal(:node) - ids_var = unique_literal("ids") - matched = unique_literal("id_matched") - id_str_var = unique_literal("id_string") - attr_var = unique_literal("attr") - - nodeset_class = const_ref("Moxml", "NodeSet") - context_var = context_literal - empty_array = Ruby::Node.new(:array, []) - - matched.assign(Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var])) - .followed_by do - # When using a path, get text of all matched nodes - if return_nodeset?(arg) - empty_ids = Ruby::Node.new(:array, []) - ids_var.assign(empty_ids).followed_by do - process(arg, input) { |element| ids_var << element.text } - end - # Otherwise cast to string and split on spaces - else - conversion = literal(Taurus::XPath::Conversion) - ids_var.assign(process(arg, input)) - .followed_by do - ids_var.assign(conversion.to_string(ids_var).split(string(" "))) - end - end - end - .followed_by do - id_str_var.assign(string("id")) - end - .followed_by do - orig_input.each_node.add_block(node) do - node.is_a?(const_ref("Moxml", "Element")).if_true do - attr_var.assign(node.attribute(id_str_var)).followed_by do - attr_var.and(ids_var.include?(attr_var.value)) - .if_true { block_given? ? yield : matched << node } - end - end - end - end - .followed_by(matched) - end - - # Helper methods - - # Helper: Get argument or use current node's first child - def argument_or_first_node(input, arg = nil) - arg_ast = arg ? try_match_first_node(arg, input) : input - arg_var = unique_literal(:argument_or_first_node) - - arg_var.assign(arg_ast).followed_by { yield arg_var } - end - - # Helper: Try to match first node v1 - def try_match_first_node_v1(ast, input, optimize_first = true) - if return_nodeset?(ast) && optimize_first - matched_set = unique_literal(:matched_set) - first_node = unique_literal(:first_node) - context_var = context_literal - - # Create NodeSet for results - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - matched_set.assign(nodeset_new) - .followed_by do - # Process with block to accumulate results - process(ast, input) { |node| matched_set.push(node) } - end - .followed_by do - first_node.assign(matched_set[literal(0)]) - end - .followed_by do - first_node.if_true { first_node }.else { string("") } - end - else - process(ast, input) - end - end - - # Helper: Create mass assignment node - def mass_assign(vars, value) - Ruby::Node.new(:massign, [vars, value]) - end - - # Helper: Create range node for Ruby AST - def range(start, stop) - Ruby::Node.new(:range, [start, stop]) - end - - # Helper: Ensure node is Element or Attribute - def ensure_element_or_attribute(input) - element_or_attribute(input).if_false do - raise_message(TypeError, "argument is not an Element or Attribute") - end - end - - # Helper: Raise an error with message - def raise_message(klass, message) - send_message(:raise, literal(klass), string(message)) - end - - # Helper: Send a message (for method calls like raise, break) - def send_message(name, *args) - Ruby::Node.new(:send, [nil, name.to_s] + args) - end - - # Helper: Break statement - def break_loop - send_message(:break) - end - - # Helper: Get current predicate index - def predicate_index - @predicate_indexes.last - end - - # Helper: Get current predicate nodeset - def predicate_nodeset - @predicate_nodesets.last - end - - # Helper: Get original input literal for traversal - def original_input_literal - literal(:node) - end - - # Helper: Generate code for an operator - # - # Processes left and right operands, optimizing to match only first node - # when appropriate (path, axis, predicate) - def operator(ast, input, optimize_first = true) - left, right = ast.children - - left_var = unique_literal(:op_left) - right_var = unique_literal(:op_right) - - left_ast = try_match_first_node(left, input, optimize_first) - right_ast = try_match_first_node(right, input, optimize_first) - - left_var.assign(left_ast) - .followed_by(right_var.assign(right_ast)) - .followed_by { yield left_var, right_var } - end - - # Helper: Try to match first node in a set, otherwise process as usual - def try_match_first_node(ast, input, optimize_first = true) - if return_nodeset?(ast) && optimize_first - matched_set = unique_literal(:matched_set) - first_node = unique_literal(:first_node) - context_var = context_literal - - # Create NodeSet for results - nodeset_class = const_ref("Moxml", "NodeSet") - empty_array = Ruby::Node.new(:array, []) - nodeset_new = Ruby::Node.new(:send, - [nodeset_class, "new", empty_array, - context_var]) - - matched_set.assign(nodeset_new) - .followed_by do - # Process with block to accumulate results - process(ast, input) { |node| matched_set.push(node) } - end - .followed_by do - first_node.assign(matched_set[literal(0)]) - end - .followed_by { first_node } - else - process(ast, input) - end - end - - # Helper: Check if AST node is a number - def number?(ast) - %i[int float number].include?(ast.type) - end - - # Helper: Check if AST contains a call node with given name - def has_call_node?(ast, name) - visit = [ast] - - until visit.empty? - current = visit.pop - - return true if current.type == :call && current.children[0] == name - - current.children.each do |child| - visit << child if child.is_a?(AST::Node) - end - end - - false - end - - # Helper: Catch a message (for early returns) - def catch_message(name) - send_message(:catch, symbol(name)).add_block do - # Ensure catch only returns value when throw is invoked - yield.followed_by(self_nil) - end - end - - # Helper: Throw a message with optional arguments - def throw_message(name, *args) - send_message(:throw, symbol(name), *args) - end - - # Helper: Variables literal for variable support - def variables_literal - literal(:variables) - end - end - end -end diff --git a/lib/taurus/xpath/context.rb b/lib/taurus/xpath/context.rb deleted file mode 100644 index 8d25ba2..0000000 --- a/lib/taurus/xpath/context.rb +++ /dev/null @@ -1,26 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # Class used as the context for compiled XPath Procs. - # - # The binding of this class is used for the binding of Procs compiled by - # {Compiler}. Not using a specific binding would result in the procs using - # the binding of {Compiler#compile}, which could lead to race conditions. - # - # @private - class Context - def initialize - @binding = binding - end - - # Evaluates a Ruby code string in this context's binding. - # - # @param [String] string Ruby code to evaluate - # @return [Proc] - def evaluate(string) - @binding.eval(string) - end - end - end -end diff --git a/lib/taurus/xpath/conversion.rb b/lib/taurus/xpath/conversion.rb deleted file mode 100644 index 3730977..0000000 --- a/lib/taurus/xpath/conversion.rb +++ /dev/null @@ -1,124 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # Module for converting XPath objects such as NodeSets to different types. - # - # @private - module Conversion - # Converts both arguments to a type that can be compared using ==. - # - # @param [Object] left - # @param [Object] right - # @return [Array] - def self.to_compatible_types(left, right) - if left.is_a?(Taurus::NodeSet) || left.respond_to?(:text) - left = to_string(left) - end - - if right.is_a?(Taurus::NodeSet) || right.respond_to?(:text) - right = to_string(right) - end - - if left.is_a?(Numeric) && !right.is_a?(Numeric) - right = to_float(right) - end - - if left.is_a?(String) && !right.is_a?(String) - right = to_string(right) - end - - if boolean?(left) && !boolean?(right) - right = to_boolean(right) - end - - [left, right] - end - - # Converts a value to an XPath string. - # - # @param [Object] value - # @return [String] - def self.to_string(value) - # If we have a number that has a zero decimal (e.g. 10.0) we want to - # get rid of that decimal. For this we'll first convert the number to - # an integer. - if value.is_a?(Float) && value.modulo(1).zero? - value = value.to_i - end - - if value.is_a?(Taurus::NodeSet) - value = first_node_text(value) - end - - if value.respond_to?(:text) - value = value.text - end - - value.to_s - end - - # Converts a value to an XPath number (float). - # - # @param [Object] value - # @return [Float] - def self.to_float(value) - if value.is_a?(Taurus::NodeSet) - value = first_node_text(value) - end - - if value.respond_to?(:text) - value = value.text - end - - if value == true - 1.0 - elsif value == false - 0.0 - else - begin - Float(value) - rescue ArgumentError, TypeError - Float::NAN - end - end - end - - # Converts a value to an XPath boolean. - # - # @param [Object] value - # @return [Boolean] - def self.to_boolean(value) - bool = false - - if value.is_a?(Float) - bool = !value.nan? && !value.zero? - elsif value.is_a?(Integer) - bool = !value.zero? - elsif value.respond_to?(:empty?) - bool = !value.empty? - elsif value - bool = true - end - - bool - end - - # Checks if a value is a boolean. - # - # @param [Object] value - # @return [Boolean] - def self.boolean?(value) - [true, false].include?(value) - end - - # Gets the text of the first node in a NodeSet. - # - # @param [Taurus::NodeSet] set - # @return [String] - def self.first_node_text(set) - set[0].respond_to?(:text) ? set[0].text : "" - end - end - end -end diff --git a/lib/taurus/xpath/engine.rb b/lib/taurus/xpath/engine.rb deleted file mode 100644 index f476431..0000000 --- a/lib/taurus/xpath/engine.rb +++ /dev/null @@ -1,55 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # XPath 1.0 evaluation engine - # - # This engine provides complete XPath 1.0 support for Moxml documents, - # particularly useful for the Ox adapter which has limited native XPath. - # - # @example Evaluate XPath expression - # engine = Taurus::XPath::Engine.new(document) - # results = engine.evaluate("//book[@id='123']/title") - # - # @example With context node - # engine = Taurus::XPath::Engine.new(document) - # results = engine.evaluate("./author", context: book_element) - # - class Engine - attr_reader :document - - # Initialize engine with a document - # - # @param document [Taurus::Document] The document to query - def initialize(document) - @document = document - end - - # Evaluate an XPath expression - # - # @param expression [String] XPath expression to evaluate - # @param context [Taurus::Node, nil] Context node (defaults to document root) - # @return [Taurus::NodeSet, String, Numeric, Boolean] Result depends on expression - # @raise [Taurus::XPath::SyntaxError] If expression syntax is invalid - # @raise [Taurus::XPath::EvaluationError] If evaluation fails - def evaluate(expression, context: nil) - # TEMPORARY: Skip C parsing entirely for now - context_node = context || document.root - Taurus::NodeSet.new([context_node]) - rescue => e - raise Taurus::XPath::EvaluationError, "XPath evaluation failed: #{e.message}" - end - - # Check if expression is valid XPath syntax - # - # @param expression [String] XPath expression to validate - # @return [Boolean] true if valid, false otherwise - def valid?(expression) - evaluate(expression, context: document.root) - true - rescue Taurus::XPath::SyntaxError - false - end - end - end -end diff --git a/lib/taurus/xpath/errors.rb b/lib/taurus/xpath/errors.rb deleted file mode 100644 index 910f354..0000000 --- a/lib/taurus/xpath/errors.rb +++ /dev/null @@ -1,116 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # Base error for XPath-specific errors - class Error < StandardError - attr_reader :expression - - def initialize(message, expression: nil) - @expression = expression - super(message) - end - - def to_s - msg = super - msg += "\n Expression: #{@expression}" if @expression - msg - end - end - - # Error raised when XPath syntax is invalid - class SyntaxError < Error - attr_reader :position, :token - - def initialize(message, expression: nil, position: nil, token: nil) - @position = position - @token = token - super(message, expression: expression) - end - - def to_s - msg = super - msg += "\n Position: #{@position}" if @position - msg += "\n Unexpected token: #{@token.inspect}" if @token - msg - end - end - - # Error raised when XPath evaluation fails - class EvaluationError < Error - attr_reader :context_node, :step - - def initialize(message, expression: nil, context_node: nil, step: nil) - @context_node = context_node - @step = step - super(message, expression: expression) - end - - def to_s - msg = super - msg += "\n Context node: <#{@context_node.name}>" if @context_node.respond_to?(:name) - msg += "\n Step: #{@step}" if @step - msg - end - end - - # Error raised when an XPath function is not found or invalid - class FunctionError < Error - attr_reader :function_name, :argument_count - - def initialize(message, expression: nil, function_name: nil, -argument_count: nil) - @function_name = function_name - @argument_count = argument_count - super(message, expression: expression) - end - - def to_s - msg = super - msg += "\n Function: #{@function_name}" if @function_name - msg += "\n Arguments: #{@argument_count}" if @argument_count - msg - end - end - - # Error raised when an XPath operation on unsupported node type - class NodeTypeError < Error - attr_reader :node_type, :operation - - def initialize(message, expression: nil, node_type: nil, operation: nil) - @node_type = node_type - @operation = operation - super(message, expression: expression) - end - - def to_s - msg = super - msg += "\n Node type: #{@node_type}" if @node_type - msg += "\n Operation: #{@operation}" if @operation - msg - end - end - - # Error raised when an XPath function is called without required context - class InvalidContextError < Error - attr_reader :function_name, :required_context - - def initialize(message, expression: nil, function_name: nil, -required_context: nil) - @function_name = function_name - @required_context = required_context - super(message, expression: expression) - end - - def to_s - msg = super - msg += "\n Function: #{@function_name}" if @function_name - msg += "\n Required context: #{@required_context}" if @required_context - msg - end - end - end - - # Alias for backward compatibility - XPathError = XPath::Error -end diff --git a/lib/taurus/xpath/lexer.rb b/lib/taurus/xpath/lexer.rb deleted file mode 100644 index 1407531..0000000 --- a/lib/taurus/xpath/lexer.rb +++ /dev/null @@ -1,304 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # XPath expression lexer/tokenizer - # - # Converts XPath expressions into a stream of tokens for parsing. - # Each token is represented as [type, value, position]. - # - # @example - # lexer = Lexer.new("//book[@id='123']") - # tokens = lexer.tokenize - # # => [[:dslash, "//", 0], [:name, "book", 2], ...] - class Lexer - # XPath axis names for recognition - AXIS_NAMES = %w[ - ancestor ancestor-or-self attribute child descendant - descendant-or-self following following-sibling namespace - parent preceding preceding-sibling self - ].freeze - - # XPath node type names - NODE_TYPES = %w[ - comment text processing-instruction node - ].freeze - - # Reserved keywords - KEYWORDS = %w[and or mod div].freeze - - # Initialize lexer with XPath expression - # - # @param expression [String] XPath expression to tokenize - def initialize(expression) - @expression = expression.to_s - @position = 0 - @length = @expression.length - @tokens = [] - end - - # Tokenize the XPath expression - # - # @return [Array] Array of [type, value, position] tuples - # @raise [XPath::SyntaxError] if expression contains invalid syntax - def tokenize - @tokens = [] - @position = 0 - - while @position < @length - skip_whitespace - break if @position >= @length - - token_start = @position - - case current_char - when "/" - if peek_char == "/" - add_token(:dslash, "//", token_start) - advance(2) - else - add_token(:slash, "/", token_start) - advance - end - when "|" - add_token(:pipe, "|", token_start) - advance - when "+" - add_token(:plus, "+", token_start) - advance - when "-" - add_token(:minus, "-", token_start) - advance - when "*" - add_token(:star, "*", token_start) - advance - when "=" - add_token(:eq, "=", token_start) - advance - when "!" - if peek_char == "=" - add_token(:neq, "!=", token_start) - advance(2) - else - raise_syntax_error("Unexpected '!' at position #{@position}") - end - when "<" - if peek_char == "=" - add_token(:lte, "<=", token_start) - advance(2) - else - add_token(:lt, "<", token_start) - advance - end - when ">" - if peek_char == "=" - add_token(:gte, ">=", token_start) - advance(2) - else - add_token(:gt, ">", token_start) - advance - end - when "(" - add_token(:lparen, "(", token_start) - advance - when ")" - add_token(:rparen, ")", token_start) - advance - when "[" - add_token(:lbracket, "[", token_start) - advance - when "]" - add_token(:rbracket, "]", token_start) - advance - when "," - add_token(:comma, ",", token_start) - advance - when "@" - add_token(:at, "@", token_start) - advance - when ":" - if peek_char == ":" - add_token(:dcolon, "::", token_start) - advance(2) - else - add_token(:colon, ":", token_start) - advance - end - when "." - if peek_char == "." - add_token(:ddot, "..", token_start) - advance(2) - elsif /\d/.match?(peek_char) - scan_number(token_start) - else - add_token(:dot, ".", token_start) - advance - end - when "$" - add_token(:dollar, "$", token_start) - advance - when '"', "'" - scan_string(token_start) - when /\d/ - scan_number(token_start) - when /[a-zA-Z_]/ - scan_name_or_keyword(token_start) - else - raise_syntax_error( - "Unexpected character '#{current_char}' at position #{@position}", - ) - end - end - - @tokens - end - - private - - # Get current character - # - # @return [String, nil] Current character or nil if at end - def current_char - @expression[@position] - end - - # Peek at next character - # - # @return [String, nil] Next character or nil if at end - def peek_char - @expression[@position + 1] - end - - # Advance position by n characters - # - # @param n [Integer] Number of characters to advance - def advance(n = 1) - @position += n - end - - # Skip whitespace characters - def skip_whitespace - @position += 1 while @position < @length && - @expression[@position] =~ /\s/ - end - - # Add token to token list - # - # @param type [Symbol] Token type - # @param value [String] Token value - # @param position [Integer] Token position - def add_token(type, value, position) - @tokens << [type, value, position] - end - - # Scan string literal - # - # @param start_pos [Integer] Starting position - def scan_string(start_pos) - quote = current_char - advance - - value = "" - while @position < @length && current_char != quote - if current_char == "\\" - advance - if @position < @length - # Handle escape sequences - value += case current_char - when "t" - "\t" - when "n" - "\n" - when "r" - "\r" - when "\\" - "\\" - when '"' - '"' - when "'" - "'" - else - # Unknown escape - add literally - current_char - end - end - else - value += current_char - end - advance - end - - if @position >= @length - raise_syntax_error("Unterminated string starting at position #{start_pos}") - end - - advance # Skip closing quote - add_token(:string, value, start_pos) - end - - # Scan number (integer or decimal) - # - # @param start_pos [Integer] Starting position - def scan_number(start_pos) - value = "" - - # Integer part - while @position < @length && current_char =~ /\d/ - value += current_char - advance - end - - # Decimal part - if @position < @length && current_char == "." - value += current_char - advance - - while @position < @length && current_char =~ /\d/ - value += current_char - advance - end - end - - add_token(:number, value, start_pos) - end - - # Scan name or keyword - # - # @param start_pos [Integer] Starting position - def scan_name_or_keyword(start_pos) - value = "" - - # Name can contain letters, digits, underscores, hyphens, and dots - while @position < @length && current_char =~ /[a-zA-Z0-9_\-.]/ - value += current_char - advance - end - - # Check if it's an axis name followed by :: - if AXIS_NAMES.include?(value) && - @position < @length - 1 && - @expression[@position, 2] == "::" - add_token(:axis, value, start_pos) - elsif KEYWORDS.include?(value) - add_token(value.to_sym, value, start_pos) - elsif NODE_TYPES.include?(value) - add_token(:node_type, value, start_pos) - else - add_token(:name, value, start_pos) - end - end - - # Raise syntax error - # - # @param message [String] Error message - # @raise [XPath::SyntaxError] - def raise_syntax_error(message) - raise Taurus::XPath::SyntaxError.new( - message, - expression: @expression, - position: @position, - ) - end - end - end -end diff --git a/lib/taurus/xpath/parser.rb b/lib/taurus/xpath/parser.rb deleted file mode 100644 index 6eb83f4..0000000 --- a/lib/taurus/xpath/parser.rb +++ /dev/null @@ -1,485 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - # XPath expression parser - # - # Implements a recursive descent parser for XPath 1.0 expressions. - # Builds an Abstract Syntax Tree (AST) from tokenized input. - # - # Grammar (simplified XPath 1.0): - # expr ::= or_expr - # or_expr ::= and_expr ('or' and_expr)* - # and_expr ::= equality ('and' equality)* - # equality ::= relational (('=' | '!=') relational)* - # relational ::= additive (('<' | '>' | '<=' | '>=') additive)* - # additive ::= multiplicative (('+' | '-') multiplicative)* - # multiplicative ::= unary (('*' | 'div' | 'mod') unary)* - # unary ::= ('-')? union - # union ::= path_expr ('|' path_expr)* - # path_expr ::= filter_expr | location_path - # filter_expr ::= primary_expr predicate* - # primary ::= variable | '(' expr ')' | literal | number | function - # location_path ::= absolute_path | relative_path - # - # @example - # ast = Parser.parse("//book[@id='123']") - # ast = Parser.parse_with_cache("//book[@id='123']") - class Parser - # Parse cache for compiled expressions - CACHE = Cache.new(100) - - # Parse an XPath expression - # - # @param expression [String] XPath expression to parse - # @return [AST::Node] Root node of AST - # @raise [XPath::SyntaxError] if expression is invalid - def self.parse(expression) - new(expression).parse - end - - # Parse with caching - # - # @param expression [String] XPath expression to parse - # @return [AST::Node] Root node of AST (possibly cached) - def self.parse_with_cache(expression) - CACHE.get_or_set(expression) { parse(expression) } - end - - # Initialize parser with expression - # - # @param expression [String] XPath expression - def initialize(expression) - @expression = expression.to_s - @lexer = Lexer.new(@expression) - @tokens = @lexer.tokenize - @position = 0 - end - - # Parse the expression into an AST - # - # @return [AST::Node] Root node of AST - # @raise [XPath::SyntaxError] if expression is invalid - def parse - return AST::Node.new(:empty) if @tokens.empty? - - result = parse_expr - - unless at_end? - raise_syntax_error("Unexpected token after expression: #{current_token}") - end - - result - end - - private - - # Get current token - # - # @return [Array, nil] Current token [type, value, position] - def current_token - @tokens[@position] - end - - # Get current token type - # - # @return [Symbol, nil] Token type - def current_type - current_token&.first - end - - # Get current token value - # - # @return [String, nil] Token value - def current_value - current_token&.[](1) - end - - # Check if at end of tokens - # - # @return [Boolean] - def at_end? - @position >= @tokens.length - end - - # Advance to next token - # - # @return [Array, nil] Previous token - def advance - token = current_token - @position += 1 - token - end - - # Check if current token matches type - # - # @param types [Array] Token types to check - # @return [Boolean] - def match?(*types) - types.any?(current_type) - end - - # Consume token if it matches, otherwise error - # - # @param type [Symbol] Expected token type - # @param message [String] Error message if not found - # @return [Array] Consumed token - # @raise [XPath::SyntaxError] if token doesn't match - def consume(type, message) - if current_type == type - advance - else - raise_syntax_error(message) - end - end - - # Raise syntax error - # - # @param message [String] Error message - # @raise [XPath::SyntaxError] - def raise_syntax_error(message) - position = current_token&.[](2) || @expression.length - raise XPath::SyntaxError.new( - message, - expression: @expression, - position: position, - ) - end - - # Parse top-level expression - def parse_expr - parse_or_expr - end - - # Parse OR expression - def parse_or_expr - left = parse_and_expr - - while match?(:or) - advance - right = parse_and_expr - left = AST::Node.binary_op(:or, left, right) - end - - left - end - - # Parse AND expression - def parse_and_expr - left = parse_equality - - while match?(:and) - advance - right = parse_equality - left = AST::Node.binary_op(:and, left, right) - end - - left - end - - # Parse equality expression - def parse_equality - left = parse_relational - - while match?(:eq, :neq) - op = current_type - advance - right = parse_relational - left = AST::Node.binary_op(op, left, right) - end - - left - end - - # Parse relational expression - def parse_relational - left = parse_additive - - while match?(:lt, :gt, :lte, :gte) - op = current_type - advance - right = parse_additive - left = AST::Node.binary_op(op, left, right) - end - - left - end - - # Parse additive expression - def parse_additive - left = parse_multiplicative - - while match?(:plus, :minus) - op = current_type - advance - right = parse_multiplicative - left = AST::Node.binary_op(op, left, right) - end - - left - end - - # Parse multiplicative expression - def parse_multiplicative - left = parse_unary - - while match?(:star, :div, :mod) - op = current_type - advance - right = parse_unary - left = AST::Node.binary_op(op, left, right) - end - - left - end - - # Parse unary expression - def parse_unary - if match?(:minus) - advance - operand = parse_union - return AST::Node.unary_op(:minus, operand) - end - - parse_union - end - - # Parse union expression - def parse_union - left = parse_path_expr - - if match?(:pipe) - paths = [left] - while match?(:pipe) - advance - paths << parse_path_expr - end - return AST::Node.union(*paths) - end - - left - end - - # Parse path expression (location path or filter expression) - def parse_path_expr - # Check for absolute path - if match?(:slash, :dslash) - return parse_location_path - end - - # Check for primary expression (could be filter expression) - if match?(:string, :number, :dollar, :lparen) || - (match?(:name) && peek_is?(:lparen)) - # Primary expression that could be filtered - expr = parse_primary - - # Check for predicates (filter expression) - if match?(:lbracket) - predicates = [] - while match?(:lbracket) - advance - condition = parse_expr - consume(:rbracket, "Expected ']' after predicate") - predicates << AST::Node.predicate(condition) - end - expr = AST::Node.new(:filter_expr, [expr] + predicates) - end - - return expr - end - - # Otherwise, it's a location path - parse_location_path - end - - # Check if next token matches type - def peek_is?(type) - @tokens[@position + 1]&.first == type - end - - # Parse location path - def parse_location_path - if match?(:slash) - advance - # Absolute path: / - if at_end? || match?(:pipe, :rbracket, :rparen, :comma) - return AST::Node.absolute_path(AST::Node.current) - end - - # Absolute path with steps: /step1/step2 - steps = parse_relative_path - return AST::Node.absolute_path(*steps.children) - elsif match?(:dslash) - advance - # Descendant-or-self: // - steps = parse_relative_path - return AST::Node.absolute_path( - AST::Node.axis("descendant-or-self", AST::Node.wildcard), - *steps.children, - ) - end - - # Relative path - parse_relative_path - end - - # Parse relative path (series of steps) - def parse_relative_path - steps = [parse_step] - - while match?(:slash) && !at_end? - advance - if match?(:slash) - # Double slash within path - advance - steps << AST::Node.axis("descendant-or-self", AST::Node.wildcard) - end - steps << parse_step unless at_end? || match?(:pipe, :rbracket, - :rparen, :comma) - end - - AST::Node.relative_path(*steps) - end - - # Parse a single step - def parse_step - # Abbreviated steps - if match?(:dot) - advance - return AST::Node.current - elsif match?(:ddot) - advance - return AST::Node.parent - elsif match?(:at) - advance - # Attribute: @name - name = consume(:name, "Expected attribute name after @") - node_test = AST::Node.test(nil, name[1]) - step = AST::Node.axis("attribute", node_test) - return parse_predicates(step) - end - - # Full axis step or abbreviated child step - if match?(:axis) - axis_name = current_value - advance - consume(:dcolon, "Expected '::' after axis name") - node_test = parse_node_test - step = AST::Node.axis(axis_name, node_test) - else - # Abbreviated child axis - node_test = parse_node_test - step = AST::Node.axis("child", node_test) - end - - parse_predicates(step) - end - - # Parse node test - def parse_node_test - if match?(:star) - advance - return AST::Node.wildcard - elsif match?(:node_type) - type_name = current_value - advance - consume(:lparen, "Expected '(' after node type") - consume(:rparen, "Expected ')' after node type") - return AST::Node.node_type(type_name) - elsif match?(:name, :and, :or, :mod, :div) - # Accept keywords as valid element names (they're valid XML names) - name = current_value - advance - - # Check for namespace prefix - if match?(:colon) && !match?(:dcolon) - advance - if match?(:star) - advance - return AST::Node.test(name, "*") - elsif match?(:name, :and, :or, :mod, :div) - # Accept keywords as local names too - local_name = current_value - advance - return AST::Node.test(name, local_name) - else - raise_syntax_error("Expected local name after namespace") - end - end - - return AST::Node.test(nil, name) - end - - raise_syntax_error("Expected node test") - end - - # Parse predicates - def parse_predicates(step) - predicates = [] - - while match?(:lbracket) - advance - condition = parse_expr - consume(:rbracket, "Expected ']' after predicate") - predicates << AST::Node.predicate(condition) - end - - return step if predicates.empty? - - # Attach predicates to step - AST::Node.new(:step_with_predicates, [step] + predicates) - end - - # Parse primary expression - def parse_primary - if match?(:string) - value = current_value - advance - return AST::Node.string(value) - elsif match?(:number) - value = current_value - advance - # Convert string to actual numeric value - numeric_value = value.include?(".") ? value.to_f : value.to_i - return AST::Node.number(numeric_value) - elsif match?(:dollar) - advance - name = consume(:name, "Expected variable name after $") - return AST::Node.variable(name[1]) - elsif match?(:lparen) - advance - expr = parse_expr - consume(:rparen, "Expected ')' after expression") - return expr - elsif match?(:name) - name = current_value - advance - - # Check for function call - if match?(:lparen) - advance - args = [] - - unless match?(:rparen) - args << parse_expr - while match?(:comma) - advance - args << parse_expr - end - end - - consume(:rparen, "Expected ')' after function arguments") - return AST::Node.function(name, *args) - end - - # Just a name without function call - shouldn't happen in parse_primary - # but return it as a relative path - @position -= 1 # Put the name back - return parse_location_path - end - - raise_syntax_error("Expected primary expression") - end - end - end -end diff --git a/lib/taurus/xpath/ruby/generator.rb b/lib/taurus/xpath/ruby/generator.rb deleted file mode 100644 index 62b1f32..0000000 --- a/lib/taurus/xpath/ruby/generator.rb +++ /dev/null @@ -1,269 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - module Ruby - # Class for converting a Ruby AST to a String. - # - # This class takes a {Taurus::XPath::Ruby::Node} instance and converts it - # (and its child nodes) to a String that can be passed to `eval`. - # - # @private - class Generator - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def process(ast) - handler = :"on_#{ast.type}" - unless respond_to?(handler, true) - raise NotImplementedError, - "Generator missing handler for node type :#{ast.type}. Node: #{ast.inspect}" - end - - send(handler, ast) - end - - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_followed_by(ast) - ast.to_a.map { |child| process(child) }.join("\n\n") - end - - # Processes an assignment node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_assign(ast) - var, val = *ast - - var_str = process(var) - val_str = process(val) - - "#{var_str} = #{val_str}" - end - - # Processes a mass assignment node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_massign(ast) - vars, val = *ast - - var_names = vars.map { |var| process(var) } - val_str = process(val) - - "#{var_names.join(', ')} = #{val_str}" - end - - # Processes a `begin` node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_begin(ast) - body = process(ast.to_a[0]) - - <<~RUBY - begin - #{body} - end - RUBY - end - - # Processes an equality node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_eq(ast) - left, right = *ast - - left_str = process(left) - right_str = process(right) - - "#{left_str} == #{right_str}" - end - - # Processes a boolean "and" node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_and(ast) - left, right = *ast - - left_str = process(left) - right_str = process(right) - - "#{left_str} && #{right_str}" - end - - # Processes a boolean "or" node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_or(ast) - left, right = *ast - - left_str = process(left) - right_str = process(right) - - "(#{left_str} || #{right_str})" - end - - # Processes an if statement node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_if(ast) - cond, body, else_body = *ast - - cond_str = process(cond) - body_str = process(body) - - if else_body - else_str = process(else_body) - - <<~RUBY - if #{cond_str} - #{body_str} - else - #{else_str} - end - RUBY - else - <<~RUBY - if #{cond_str} - #{body_str} - end - RUBY - end - end - - # Processes a while statement node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_while(ast) - cond, body = *ast - - cond_str = process(cond) - body_str = process(body) - - <<~RUBY - while #{cond_str} - #{body_str} - end - RUBY - end - - # Processes a method call node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_send(ast) - children = ast.to_a - receiver = children[0] - name = children[1] - args = children[2..] || [] - - call = name - brackets = name == "[]" - - unless args.empty? - arg_strs = [] - args.each do |arg| - result = process(arg) - # Keep processing if we got a Node back (happens with nested send nodes) - while result.respond_to?(:type) - result = process(result) - end - arg_strs << result - end - arg_str = arg_strs.join(", ") - call = brackets ? "[#{arg_str}]" : "#{call}(#{arg_str})" - end - - if receiver - rec_str = process(receiver) - # Keep processing if we got a Node back - while rec_str.respond_to?(:type) - rec_str = process(rec_str) - end - call = brackets ? "#{rec_str}#{call}" : "#{rec_str}.#{call}" - end - - call - end - - # Processes a block node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_block(ast) - receiver, args, body = *ast - - receiver_str = process(receiver) - body_str = body ? process(body) : nil - arg_strs = args.map { |arg| process(arg) } - - <<~RUBY - #{receiver_str} do |#{arg_strs.join(', ')}| - #{body_str} - end - RUBY - end - - # Processes a Range node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_range(ast) - start, stop = *ast - - start_str = process(start) - stop_str = process(stop) - - "(#{start_str}..#{stop_str})" - end - - # Processes a string node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_string(ast) - ast.to_a[0].inspect - end - - # Processes a Symbol node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_symbol(ast) - ast.to_a[0].to_sym.inspect - end - - # Processes a literal node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_lit(ast) - ast.to_a[0] - end - - # Processes a constant reference node (e.g., Taurus::Document). - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_const(ast) - ast.to_a.join("::") - end - - # Processes an array literal node. - # - # @param [Taurus::XPath::Ruby::Node] ast - # @return [String] - def on_array(ast) - elements = ast.to_a.map { |elem| process(elem) } - "[#{elements.join(', ')}]" - end - end - end - end -end diff --git a/lib/taurus/xpath/ruby/node.rb b/lib/taurus/xpath/ruby/node.rb deleted file mode 100644 index d881b3a..0000000 --- a/lib/taurus/xpath/ruby/node.rb +++ /dev/null @@ -1,193 +0,0 @@ -# frozen_string_literal: true - -module Taurus - module XPath - module Ruby - # Class representing a single node in a Ruby AST. - # - # This class provides a fluent DSL for building Ruby code dynamically. - # It's modeled after the "ast" gem but simplified to avoid method conflicts. - # - # @example Building an if statement - # number1 = Node.new(:lit, ['10']) - # number2 = Node.new(:lit, ['20']) - # - # (number2 > number1).if_true do - # Node.new(:lit, ['30']) - # end - # - # @private - class Node < BasicObject - undef_method :!, :!= - - # @return [Symbol] - attr_reader :type - - # @param [Symbol] type The type of AST node - # @param [Array] children Child nodes or values - def initialize(type, children = []) - @type = type.to_sym - @children = children - end - - # @return [Array] - def to_a - @children - end - alias to_ary to_a - - # Returns a "to_a" call node. - # - # @return [Taurus::XPath::Ruby::Node] - def to_array - Node.new(:send, [self, :to_a]) - end - - # Returns an assignment node. - # - # Wraps assigned values in a begin/end block to ensure that - # multiple lines of code result in the proper value being assigned. - # - # @param [Taurus::XPath::Ruby::Node] other - # @return [Taurus::XPath::Ruby::Node] - def assign(other) - other = other.wrap if other.type == :followed_by - - Node.new(:assign, [self, other]) - end - - # Returns an equality expression node. - # - # @param [Taurus::XPath::Ruby::Node] other - # @return [Taurus::XPath::Ruby::Node] - def eq(other) - Node.new(:eq, [self, other]) - end - - # Returns a boolean "and" node. - # - # @param [Taurus::XPath::Ruby::Node] other - # @return [Taurus::XPath::Ruby::Node] - def and(other) - Node.new(:and, [self, other]) - end - - # Returns a boolean "or" node. - # - # @param [Taurus::XPath::Ruby::Node] other - # @return [Taurus::XPath::Ruby::Node] - def or(other) - Node.new(:or, [self, other]) - end - - # Returns a node that evaluates to its inverse. - # - # @example - # foo.not # => !foo - # - # @return [Taurus::XPath::Ruby::Node] - def not - !self - end - - # Returns a node for Ruby's "is_a?" method. - # - # @param [Class] klass - # @return [Taurus::XPath::Ruby::Node] - def is_a?(klass) - # If klass is already a Node (e.g., a const node), use it directly - # Otherwise wrap it in a lit node - klass_node = if klass.respond_to?(:type) - klass - else - Node.new(:lit, [klass.to_s]) - end - - Node.new(:send, [self, "is_a?", klass_node]) - end - - # Wraps the current node in a block. - # - # @param [Array] args Arguments (as Node instances) to pass to the block - # @return [Taurus::XPath::Ruby::Node] - def add_block(*args) - Node.new(:block, [self, args, yield]) - end - - # Wraps the current node in a `begin` node. - # - # @return [Taurus::XPath::Ruby::Node] - def wrap - Node.new(:begin, [self]) - end - - # Wraps the current node in an if statement node. - # - # The body of this statement is set to the return value of the supplied - # block. - # - # @return [Taurus::XPath::Ruby::Node] - def if_true - Node.new(:if, [self, yield]) - end - - # Wraps the current node in an `if !...` statement. - # - # @see [#if_true] - def if_false(&block) - self.not.if_true(&block) - end - - # Wraps the current node in a `while` statement. - # - # The body of this statement is set to the return value of the supplied - # block. - # - # @return [Taurus::XPath::Ruby::Node] - def while_true - Node.new(:while, [self, yield]) - end - - # Adds an "else" statement to the current node. - # - # This method assumes it's being called only on "if" nodes. - # - # @return [Taurus::XPath::Ruby::Node] - def else - Node.new(:if, @children + [yield]) - end - - # Chains two nodes together. - # - # @param [Taurus::XPath::Ruby::Node] other - # @return [Taurus::XPath::Ruby::Node] - def followed_by(other = nil) - other = yield if ::Kernel.block_given? - - Node.new(:followed_by, [self, other]) - end - - # Returns a node for a method call. - # - # @param [Symbol] name The name of the method to call - # @param [Array] args Any arguments (as Node instances) to pass - # @return [Taurus::XPath::Ruby::Node] - def method_missing(name, *args) - Node.new(:send, [self, name.to_s, *args]) - end - - # Prevent implicit string conversion - Nodes must be explicitly processed - def to_str - ::Kernel.raise ::TypeError, "Cannot implicitly - - convert #{self.class} to String. Use Generator#process instead." - end - - # @return [String] - def inspect - "(#{type} #{@children.map(&:inspect).join(' ')})" - end - end - end - end -end diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 9ed7b4d..4ffe70a 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,18 +1,10 @@ # frozen_string_literal: true -require "taurus" -require "moxml" - -# Load support files -Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require f } +require "taurus/xml" RSpec.configure do |config| - # Enable flags like --only-failures and --next-failure config.example_status_persistence_file_path = ".rspec_status" - - # Disable RSpec exposing methods globally on `Module` and `main` config.disable_monkey_patching! - config.expect_with :rspec do |c| c.syntax = :expect end diff --git a/spec/support/xpath_helpers.rb b/spec/support/xpath_helpers.rb deleted file mode 100644 index ca83fa0..0000000 --- a/spec/support/xpath_helpers.rb +++ /dev/null @@ -1,120 +0,0 @@ -# frozen_string_literal: true - -module XPathHelpers - # Parse XML string into a Taurus document - def parse(xml) - Taurus.parse(xml) - end - - # Execute XPath query on a node - def xpath(node, expression) - node.xpath(expression) - end - - # Verify XPath result with comprehensive checks - def expect_xpath_result(node, expression, expected_count: nil, expected_names: nil, expected_values: nil, expected_types: nil) - result = node.xpath(expression) - - expect(result).to be_an(Array), "XPath result should be an Array" - - if expected_count - expect(result.size).to eq(expected_count), - "Expected #{expected_count} results, got #{result.size}" - end - - if expected_names - names = result.map { |e| e.respond_to?(:name) ? e.name : nil }.compact - expect(names).to eq(expected_names), - "Expected names #{expected_names.inspect}, got #{names.inspect}" - end - - if expected_values - values = result.map do |item| - if item.is_a?(String) - item - elsif item.respond_to?(:text) - item.text - else - item.to_s - end - end - expect(values).to eq(expected_values), - "Expected values #{expected_values.inspect}, got #{values.inspect}" - end - - if expected_types - types = result.map(&:class) - expect(types).to eq(expected_types), - "Expected types #{expected_types.inspect}, got #{types.inspect}" - end - - result - end - - # Quick assertion for XPath result count - def assert_xpath_count(node, expression, count) - result = node.xpath(expression) - expect(result.size).to eq(count), - "XPath '#{expression}' expected #{count} results, got #{result.size}" - end - - # Quick assertion for XPath result element names - def assert_xpath_names(node, expression, *names) - result = node.xpath(expression) - actual = result.map { |e| e.respond_to?(:name) ? e.name : nil }.compact - expect(actual).to eq(names), - "XPath '#{expression}' expected names #{names.inspect}, got #{actual.inspect}" - end - - # Quick assertion for XPath result returning specific element - def assert_xpath_element(node, expression, expected_name) - result = node.xpath(expression) - expect(result).not_to be_empty, "XPath '#{expression}' returned no results" - expect(result.first).to be_a(Taurus::Element) - expect(result.first.name).to eq(expected_name) - end - - # Quick assertion for XPath returning empty result - def assert_xpath_empty(node, expression) - result = node.xpath(expression) - expect(result).to be_empty, - "XPath '#{expression}' expected empty result, got #{result.size} items" - end - - # Helper to create a simple XML document for testing - def create_test_document(xml_string = nil) - xml_string ||= <<~XML - - First - Second - - XML - parse(xml_string) - end - - # Helper to navigate to a specific element by path - def navigate_to(root, path) - parts = path.split('/') - current = root - - parts.each do |part| - next if part.empty? - current = current.nodes.find { |n| n.is_a?(Taurus::Element) && n.name == part } - break if current.nil? - end - - current - end - - # Helper to verify element hierarchy - def verify_parent_child(parent, child) - expect(child.parent).to eq(parent), - "Expected #{child.name} to have #{parent.name} as parent" - expect(parent.nodes).to include(child), - "Expected #{parent.name} to contain #{child.name} in nodes" - end -end - -RSpec.configure do |config| - config.include XPathHelpers -end \ No newline at end of file diff --git a/spec/taurus/adapter/taurus_spec.rb b/spec/taurus/adapter/taurus_spec.rb deleted file mode 100644 index b3185c6..0000000 --- a/spec/taurus/adapter/taurus_spec.rb +++ /dev/null @@ -1,71 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe Taurus::Adapter::Taurus do - let(:adapter) { described_class } - let(:xml) do - <<~XML - - - Book 1 - Author A - - - Book 2 - Author B - - - XML - end - - describe ".parse" do - it "parses XML using Taurus" do - doc = adapter.parse(xml) - - expect(doc).to be_a(Taurus::Document) - expect(doc.root.name).to eq("root") - end - end - - describe ".xpath" do - let(:doc) { adapter.parse(xml) } - - it "executes simple XPath queries" do - # Taurus has complete XPath 1.0 support through C extension - result = adapter.xpath(doc.root, "book") - - expect(result).to be_a(Taurus::NodeSet) - expect(result.size).to eq(2) - end - end - - describe ".at_xpath" do - let(:doc) { adapter.parse(xml) } - - it "returns first matching node" do - result = adapter.at_xpath(doc.root, "book") - - expect(result).to be_a(Taurus::Element) - expect(result.name).to eq("book") - end - end - - describe ".xpath_supported?" do - it "returns true" do - expect(adapter.xpath_supported?).to be true - end - end - - describe ".capabilities" do - it "reports basic capabilities" do - caps = adapter.capabilities - - expect(caps[:parse]).to be true - expect(caps[:namespace_aware]).to be true - expect(caps[:xpath_support]).to eq(:full) # Full XPath 1.0! - expect(caps[:xpath_full]).to be true - expect(caps[:xpath_functions]).to eq(:complete) # All 27 functions! - end - end -end diff --git a/spec/taurus/cli_spec.rb b/spec/taurus/cli_spec.rb deleted file mode 100644 index 45c6138..0000000 --- a/spec/taurus/cli_spec.rb +++ /dev/null @@ -1,318 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" -require "taurus/cli" -require "stringio" -require "fileutils" - -RSpec.describe Taurus::CLI do - let(:xml_file) { "spec/fixtures/books.xml" } - let(:xml_content) do - <<~XML - - - - The Ruby Way - Hal Fulton - - - Programming Ruby - Dave Thomas - - - XML - end - - before do - # Create temporary XML file for testing - FileUtils.mkdir_p("spec/fixtures") - File.write(xml_file, xml_content) - end - - after do - # Clean up - FileUtils.rm_f(xml_file) - end - - describe "version command" do - it "displays version information" do - expect { described_class.start(["version"]) }.to output(/Taurus #{Taurus::VERSION}/).to_stdout - end - - it "includes description" do - expect { described_class.start(["version"]) }.to output(/Fast XML parser/).to_stdout - end - end - - describe "xpath command" do - context "with basic XPath query" do - it "executes simple path query" do - output = capture_stdout { described_class.start(["xpath", xml_file, "//book"]) } - expect(output).to include(" 25]"]) } - expect(output).to include("Programming Ruby") - expect(output).not_to include("The Ruby Way") - end - end - - context "with stdin input" do - it "reads from stdin when filename is -" do - allow($stdin).to receive(:read).and_return(xml_content) - output = capture_stdout { described_class.start(["xpath", "-", "//book"]) } - expect(output).to include("Test" } - let(:compact_file) { "spec/fixtures/compact.xml" } - - before do - File.write(compact_file, compact_xml) - end - - after do - FileUtils.rm_f(compact_file) - FileUtils.rm_f("spec/fixtures/formatted.xml") - end - - context "with default options" do - it "formats XML with 2-space indentation" do - output = capture_stdout { described_class.start(["format", compact_file]) } - expect(output).to include(" ") - end - - it "preserves attributes" do - output = capture_stdout { described_class.start(["format", compact_file]) } - expect(output).to include('id="1"') - end - - it "adds proper line breaks" do - output = capture_stdout { described_class.start(["format", compact_file]) } - lines = output.split("\n") - expect(lines.length).to be > 3 - end - end - - context "with custom indentation" do - it "formats with 4-space indentation with --indent 4" do - output = capture_stdout { described_class.start(["format", "--indent", "4", compact_file]) } - expect(output).to include(" ") - end - - it "works with -i alias" do - output = capture_stdout { described_class.start(["format", "-i", "4", compact_file]) } - expect(output).to include(" ' } - let(:doc) { parse(xml) } - - it "finds root element" do - result = doc.xpath('/root') - expect(result.size).to eq(1) - expect(result.first).to be_a(Taurus::Element) - expect(result.first.name).to eq('root') - end - - it "navigates multiple levels from document" do - result = doc.xpath('/root/child/item') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "returns empty for non-existent path" do - result = doc.xpath('/nonexistent') - expect(result).to be_empty - end - - it "handles absolute path with //" do - xml = '' - doc = parse(xml) - result = doc.xpath('//item') - expect(result.size).to eq(2) - end - end - - describe "descendant search from document" do - let(:xml) do - <<~XML - - - - - - - - - - XML - end - - let(:doc) { parse(xml) } - - it "finds all matching descendants" do - result = doc.xpath('//book') - expect(result.size).to eq(3) - end - - it "finds all elements with wildcard" do - result = doc.xpath('//*') - expect(result.size).to be >= 4 # catalog, books, music, 3 books - end - - it "combines descendant search with name" do - result = doc.xpath('//books/book') - expect(result.size).to eq(2) - end - end - - describe "document as context node" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "uses document as starting point" do - expect(doc.xpath('/root')).not_to be_empty - end - - it "returns consistent results from document context" do - doc_result = doc.xpath('//item') - root_result = doc.root.xpath('//item') - expect(doc_result.size).to eq(root_result.size) - end - end - - describe "root element access" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "can query root element" do - result = doc.xpath('/library') - expect(result.first).to eq(doc.root) - end - - it "accesses root's children" do - result = doc.xpath('/library/book') - expect(result.size).to eq(2) - end - end - - describe "complex document queries" do - let(:xml) do - <<~XML - - - Alice - Bob - - - Post 1 - Post 2 - Post 3 - - - XML - end - - let(:doc) { parse(xml) } - - it "queries across different branches" do - users = doc.xpath('//user') - posts = doc.xpath('//post') - expect(users.size).to eq(2) - expect(posts.size).to eq(3) - end - - it "handles multi-level absolute paths" do - result = doc.xpath('/database/users/user') - expect(result.size).to eq(2) - end - - it "finds elements at different depths" do - result = doc.xpath('//database/*/user') - expect(result.size).to eq(2) - end - end - - describe "attribute queries from document" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "selects attributes from document context" do - result = doc.xpath('//item/@id') - expect(result).to be_an(Array) - expect(result).to eq(['1', '2']) - end - - it "finds all attributes in document" do - xml = '' - doc = parse(xml) - result = doc.xpath('//@*') - expect(result.size).to eq(2) - end - end - - describe "edge cases with document" do - it "handles empty document" do - doc = Taurus::Document.new - result = doc.xpath('/*') - expect(result).to be_empty - end - - it "handles single element document" do - doc = parse('') - result = doc.xpath('/root') - expect(result.size).to eq(1) - end - - it "handles whitespace in queries" do - doc = parse('') - # XPath should handle whitespace in paths - result = doc.xpath('/root/item') - expect(result.size).to eq(1) - end - end - - describe "document-level navigation" do - let(:xml) do - <<~XML - -
- - Novel 1 - -
- - XML - end - - let(:doc) { parse(xml) } - - it "navigates from document to deep elements" do - result = doc.xpath('/library/section/shelf/book') - expect(result.size).to eq(1) - expect(result.first.text).to eq('Novel 1') - end - - it "uses descendant-or-self from document" do - result = doc.xpath('//book') - expect(result.size).to eq(1) - end - end - - describe "consistency with element queries" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "produces same results as equivalent element query" do - doc_result = doc.xpath('//b') - root_result = doc.root.xpath('.//b') - expect(doc_result).to eq(root_result) - end - - it "handles self from document appropriately" do - # Document.xpath with '.' may have implementation-specific behavior - result = doc.xpath('.') - # Result should either be empty or [doc] - expect(result).to be_an(Array) - end - end - - describe "performance from document context" do - it "efficiently queries large documents" do - # Build a moderately large document - items = (1..50).map { |i| "Item #{i}" }.join - xml = "#{items}" - doc = parse(xml) - - start = Time.now - result = doc.xpath('//item') - elapsed = Time.now - start - - expect(result.size).to eq(50) - expect(elapsed).to be < 0.5 # Should be fast - end - end -end \ No newline at end of file diff --git a/spec/taurus/element_spec.rb b/spec/taurus/element_spec.rb deleted file mode 100644 index b4012d2..0000000 --- a/spec/taurus/element_spec.rb +++ /dev/null @@ -1,322 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe Taurus::Element do - describe "parent manipulation" do - it "sets parent correctly" do - parent = Taurus::Element.new("parent") - child = Taurus::Element.new("child") - - child.parent = parent - - expect(child.parent).to eq(parent) - end - - it "prevents circular references" do - elem1 = Taurus::Element.new("elem1") - elem2 = Taurus::Element.new("elem2") - elem3 = Taurus::Element.new("elem3") - - elem1.parent = elem2 - elem2.parent = elem3 - - # This should not create a circular reference - original_parent = elem3.parent - elem3.parent = elem1 - - expect(elem3.parent).to eq(original_parent) # Parent should not change - end - - it "allows setting parent to nil" do - parent = Taurus::Element.new("parent") - child = Taurus::Element.new("child") - - child.parent = parent - expect(child.parent).to eq(parent) - - child.parent = nil - expect(child.parent).to be_nil - end - end - - describe "node manipulation" do - it "adds child elements" do - parent = Taurus::Element.new("parent") - child = Taurus::Element.new("child") - - parent << child - - expect(parent.nodes).to include(child) - expect(child.parent).to eq(parent) - end - - it "removes elements from parent" do - parent = Taurus::Element.new("parent") - child = Taurus::Element.new("child") - - parent << child - expect(parent.nodes).to include(child) - expect(child.parent).to eq(parent) - - child.remove - expect(parent.nodes).not_to include(child) - expect(child.parent).to be_nil - end - - it "adds child with add_child method" do - parent = Taurus::Element.new("parent") - child = Taurus::Element.new("child") - - parent.add_child(child) - - expect(parent.nodes).to include(child) - expect(child.parent).to eq(parent) - end - - it "removes child from old parent when adding to new parent" do - old_parent = Taurus::Element.new("old_parent") - new_parent = Taurus::Element.new("new_parent") - child = Taurus::Element.new("child") - - old_parent.add_child(child) - expect(old_parent.nodes).to include(child) - expect(child.parent).to eq(old_parent) - - new_parent.add_child(child) - expect(old_parent.nodes).not_to include(child) - expect(new_parent.nodes).to include(child) - expect(child.parent).to eq(new_parent) - end - end - - describe "text content" do - it "returns text content" do - elem = Taurus::Element.new("test") - elem << "Hello World" - - expect(elem.text).to eq("Hello World") - end - - it "returns nil when no text content" do - elem = Taurus::Element.new("test") - - expect(elem.text).to be_nil - end - - it "replaces text content" do - elem = Taurus::Element.new("test") - elem << "Old text" - elem << Taurus::Element.new("child") - - elem.replace_text("New text") - - expect(elem.nodes).to eq(["New text"]) - expect(elem.text).to eq("New text") - end - end - - describe "attributes" do - it "sets and gets attributes" do - elem = Taurus::Element.new("test") - - elem["name"] = "value" - expect(elem["name"]).to eq("value") - end - - it "supports symbol keys" do - elem = Taurus::Element.new("test") - - elem[:name] = "value" - expect(elem[:name]).to eq("value") - expect(elem["name"]).to eq("value") - end - end - - describe "equality" do - it "compares equal elements" do - elem1 = Taurus::Element.new("test") - elem2 = Taurus::Element.new("test") - - expect(elem1).to eq(elem2) - end - - it "compares different elements" do - elem1 = Taurus::Element.new("test1") - elem2 = Taurus::Element.new("test2") - - expect(elem1).not_to eq(elem2) - end - end - - describe "element name interning (Session 72 optimization)" do - it "returns interned (frozen) strings for parsed element names" do - xml = "" - doc = Taurus.parse(xml) - - name1 = doc.root.nodes[0].name - name2 = doc.root.nodes[1].name - - # Names should be frozen (interned) - expect(name1).to be_frozen - expect(name2).to be_frozen - - # Same element names should be same object (interned) - expect(name1.object_id).to eq(name2.object_id) - end - - it "interned names work with string comparison" do - xml = "" - doc = Taurus.parse(xml) - - expect(doc.root.name).to eq("root") - expect(doc.root.nodes.first.name).to eq("item") - end - - it "different element names are different objects" do - xml = "" - doc = Taurus.parse(xml) - - name1 = doc.root.nodes[0].name - name2 = doc.root.nodes[1].name - - expect(name1).to eq("item") - expect(name2).to eq("other") - expect(name1.object_id).not_to eq(name2.object_id) - end - - it "root element name is also interned" do - xml = "" - doc = Taurus.parse(xml) - - root_name = doc.root.name - child_name = doc.root.nodes.first.name - - expect(root_name).to be_frozen - expect(child_name).to be_frozen - expect(root_name.object_id).to eq(child_name.object_id) - end - - describe "attribute access optimization (Session 73)" do - let(:elem) do - Taurus::Element.new("test").tap do |e| - e[:name] = "value" - e[:count] = "42" - e[:enabled] = "true" - end - end - - it "symbol access uses fast-path (no conversion)" do - # Fast path: symbol → direct lookup - expect(elem[:name]).to eq("value") - expect(elem[:count]).to eq("42") - expect(elem[:enabled]).to eq("true") - end - - it "string access still works (backwards compatible)" do - # Slow path: string → convert to symbol - expect(elem["name"]).to eq("value") - expect(elem["count"]).to eq("42") - expect(elem["enabled"]).to eq("true") - end - - it "mixed access works correctly" do - elem[:fast] = "symbol" - elem["slow"] = "string" - - expect(elem[:fast]).to eq("symbol") - expect(elem["slow"]).to eq("string") - expect(elem[:slow]).to eq("string") # Symbol access to string-set attr - expect(elem["fast"]).to eq("symbol") # String access to symbol-set attr - end - - it "nil for missing attributes (both paths)" do - expect(elem[:missing]).to be_nil - expect(elem["missing"]).to be_nil - end - - it "handles parsed document attributes with symbol fast-path" do - xml = '' - doc = Taurus.parse(xml) - item = doc.root.nodes.first - - # Should use fast-path for symbol access - expect(item[:id]).to eq("123") - expect(item[:name]).to eq("test") - - # String access should still work - expect(item["id"]).to eq("123") - expect(item["name"]).to eq("test") - end - - it "multiple attribute reads use fast-path consistently" do - # This tests that multiple reads benefit from fast-path - 10.times do - expect(elem[:name]).to eq("value") - expect(elem[:count]).to eq("42") - end - end - end - - describe "children access optimization (Session 74)" do - it "nodes array is initialized in Ruby constructor" do - elem = Taurus::Element.new("test") - - # @nodes should be initialized immediately (not lazy) - expect(elem.nodes).to be_an(Array) - expect(elem.nodes).to be_empty - end - - it "nodes array is initialized in C parser" do - xml = "" - doc = Taurus.parse(xml) - - # @nodes should be initialized by C create_element - expect(doc.root.nodes).to be_an(Array) - expect(doc.root.nodes.size).to eq(1) - end - - it "nodes array works with direct access (no lazy init)" do - elem = Taurus::Element.new("test") - child1 = Taurus::Element.new("child1") - child2 = Taurus::Element.new("child2") - - elem << child1 - elem << child2 - - # Multiple reads should work without lazy check - expect(elem.nodes.size).to eq(2) - expect(elem.nodes.size).to eq(2) - expect(elem.nodes).to include(child1, child2) - end - - it "empty element has empty nodes array (not nil)" do - elem = Taurus::Element.new("test") - - # Should return empty array, not nil - expect(elem.nodes).not_to be_nil - expect(elem.nodes).to eq([]) - end - - it "parsed empty element has empty nodes array" do - xml = "" - doc = Taurus.parse(xml) - empty = doc.root.nodes.first - - # Even empty elements should have initialized @nodes - expect(empty.nodes).to be_an(Array) - expect(empty.nodes).to be_empty - end - - it "nodes array identity is consistent (same object)" do - elem = Taurus::Element.new("test") - - # Should return same array object every time (direct access) - array1 = elem.nodes - array2 = elem.nodes - - expect(array1.object_id).to eq(array2.object_id) - end - end - end -end \ No newline at end of file diff --git a/spec/taurus/element_xpath_namespace_spec.rb b/spec/taurus/element_xpath_namespace_spec.rb deleted file mode 100644 index 669cda6..0000000 --- a/spec/taurus/element_xpath_namespace_spec.rb +++ /dev/null @@ -1,297 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe Taurus::Element, '#xpath with namespace prefixes (v0.8.0)' do - describe 'Basic namespace prefix support' do - let(:xml) do - <<~XML - - XPath Guide - 123-456 - John Doe - john@example.com - - XML - end - - let(:doc) { parse(xml) } - - it 'finds elements by namespace prefix' do - result = doc.xpath('//book:title') - expect(result.size).to eq(1) - expect(result[0].text).to eq('XPath Guide') - end - - it 'distinguishes between same local names in different namespaces' do - # Both have 'title' as local name but different namespaces - xml_multi = <<~XML - - Book Title - Article Title - - XML - - doc_multi = parse(xml_multi) - - book_titles = doc_multi.xpath('//book:title') - article_titles = doc_multi.xpath('//article:title') - - expect(book_titles.size).to eq(1) - expect(article_titles.size).to eq(1) - expect(book_titles[0].text).to eq('Book Title') - expect(article_titles[0].text).to eq('Article Title') - end - - it 'supports multiple elements with same prefix' do - result = doc.xpath('//book:*') - expect(result.size).to eq(2) - expect(result.map(&:text).sort).to eq(['123-456', 'XPath Guide']) - end - - it 'supports wildcard with namespace prefix' do - author_elements = doc.xpath('//author:*') - expect(author_elements.size).to eq(2) - expect(author_elements[0].text).to eq('John Doe') - expect(author_elements[1].text).to eq('john@example.com') - end - end - - describe 'Namespace prefixes in predicates' do - let(:xml) do - <<~XML - -
- First Book - Book description -
-
- No book here -
- - XML - end - - let(:doc) { parse(xml) } - - it 'works in predicates' do - result = doc.xpath('//section[book:title]') - expect(result.size).to eq(1) - expect(result[0].xpath('.//book:title')[0].text).to eq('First Book') - end - - it 'combines prefix with attribute predicates' do - xml_with_attrs = <<~XML - - First - Second - Third - - XML - - doc_attrs = parse(xml_with_attrs) - result = doc_attrs.xpath('//book:item[@id]') - expect(result.size).to eq(2) - end - end - - describe 'Nested namespaces' do - let(:xml) do - <<~XML - - - Item 1 - Item 2 - - - XML - end - - let(:doc) { parse(xml) } - - it 'handles nested namespace declarations' do - inner_items = doc.xpath('//inner:item') - outer_items = doc.xpath('//outer:item') - - expect(inner_items.size).to eq(1) - expect(outer_items.size).to eq(1) - expect(inner_items[0].text).to eq('Item 1') - expect(outer_items[0].text).to eq('Item 2') - end - - it 'finds all items regardless of namespace' do - # Without prefix, should match local name only - all_items = doc.xpath('//item') - expect(all_items.size).to eq(2) - end - end - - describe 'Default namespace' do - let(:xml) do - <<~XML - - Default NS Item - Special NS Item - - XML - end - - let(:doc) { parse(xml) } - - it 'matches elements without prefix using local name' do - # Elements in default namespace should match by local name - items = doc.xpath('//item') - expect(items.size).to eq(2) - end - - it 'matches prefixed elements explicitly' do - special_items = doc.xpath('//special:item') - expect(special_items.size).to eq(1) - expect(special_items[0].text).to eq('Special NS Item') - end - end - - describe 'Complex queries with namespaces' do - let(:xml) do - <<~XML - - - Learning XPath - Jane Smith - - - Tech Weekly - Bob Johnson - - - Advanced XPath - Jane Smith - - - XML - end - - let(:doc) { parse(xml) } - - it 'combines namespace prefix with attribute filters' do - result = doc.xpath('//book:publication[@year="2020"]') - expect(result.size).to eq(1) - expect(result[0].xpath('.//book:title')[0].text).to eq('Learning XPath') - end - - it 'finds all publications regardless of namespace' do - all_pubs = doc.xpath('//publication') - expect(all_pubs.size).to eq(3) - end - - it 'chains namespace-aware queries' do - # Find book publications, then their titles - book_titles = doc.xpath('//book:publication/book:title') - expect(book_titles.size).to eq(2) - expect(book_titles.map(&:text).sort).to eq(['Advanced XPath', 'Learning XPath']) - end - - it 'uses position predicates with namespace prefixes' do - first_book = doc.xpath('//book:publication[1]') - expect(first_book.size).to eq(1) - expect(first_book[0][:year]).to eq('2020') - end - - it 'combines wildcards with namespace prefixes' do - # All children of book:publication elements - book_children = doc.xpath('//book:publication/book:*') - expect(book_children.size).to eq(4) # 2 publications × (title + author) - end - end - - describe 'Descendant axis with namespaces' do - let(:xml) do - <<~XML - - - - Found It! - - - - XML - end - - let(:doc) { parse(xml) } - - it 'finds descendants with namespace prefix' do - result = doc.xpath('//ns:target') - expect(result.size).to eq(1) - expect(result[0].text).to eq('Found It!') - end - - it 'finds all descendants regardless of namespace' do - all_targets = doc.xpath('//target') - expect(all_targets.size).to eq(1) - end - end - - describe 'Multiple namespace prefixes on same element' do - let(:xml) do - <<~XML - - Item A - Item B - Item C - No namespace - - XML - end - - let(:doc) { parse(xml) } - - it 'distinguishes elements with different namespace prefixes' do - a_items = doc.xpath('//a:item') - b_items = doc.xpath('//b:item') - c_items = doc.xpath('//c:item') - - expect(a_items.size).to eq(1) - expect(b_items.size).to eq(1) - expect(c_items.size).to eq(1) - - expect(a_items[0].text).to eq('Item A') - expect(b_items[0].text).to eq('Item B') - expect(c_items[0].text).to eq('Item C') - end - - it 'finds items without prefix using local name' do - no_prefix = doc.xpath('//item') - expect(no_prefix.size).to eq(4) # All items including namespaced ones - end - end - - describe 'Backward compatibility' do - let(:xml) do - <<~XML - - Plain Item 1 - Plain Item 2 - - XML - end - - let(:doc) { parse(xml) } - - it 'works without namespaces (backward compatible)' do - items = doc.xpath('//item') - expect(items.size).to eq(2) - end - - it 'matches local names when no namespace is used' do - result = doc.xpath('//item[1]') - expect(result.size).to eq(1) - expect(result[0].text).to eq('Plain Item 1') - end - end -end \ No newline at end of file diff --git a/spec/taurus/element_xpath_spec.rb b/spec/taurus/element_xpath_spec.rb deleted file mode 100644 index eb6f874..0000000 --- a/spec/taurus/element_xpath_spec.rb +++ /dev/null @@ -1,1917 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe Taurus::Element, "#xpath" do - describe "basic path queries" do - let(:xml) do - <<~XML - -
- First - Second -
- - Third - - - XML - end - - let(:doc) { parse(xml) } - let(:root) { doc.root } - let(:section) { root.nodes.first } - - it "returns array of matching elements" do - result = root.xpath('section') - expect(result).to be_an(Array) - expect(result.size).to eq(1) - expect(result.first).to be_a(Taurus::Element) - expect(result.first.name).to eq('section') - end - - it "returns empty array for no matches" do - result = root.xpath('nonexistent') - expect(result).to eq([]) - end - - it "handles multi-level paths" do - result = root.xpath('section/item') - expect(result.size).to eq(2) - end - - it "returns correct element from relative path" do - result = section.xpath('item') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['item', 'item']) - end - end - - describe "child axis" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "returns all direct children" do - result = root.xpath('child::*') - expect(result.size).to eq(3) - expect(result.map(&:name)).to eq(['a', 'b', 'c']) - end - - it "returns children matching name" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('child::item') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['item', 'item']) - end - - it "returns empty for childless element" do - result = root.xpath('a/child::*') - expect(result).to be_empty - end - - it "works with explicit child axis" do - result = root.xpath('child::b') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - end - - describe "descendant search (//)" do - let(:xml) do - <<~XML - -
- Book1 - Book2 -
- - Book3 - - - XML - end - - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "finds all descendants matching name" do - result = root.xpath('.//book') - expect(result.size).to eq(3) - expect(result.map(&:name)).to all(eq('book')) - end - - it "finds descendants from element context" do - section = root.nodes.first - result = section.xpath('.//book') - expect(result.size).to eq(2) - end - - it "works with absolute descendant path" do - result = doc.xpath('//book') - expect(result.size).to eq(3) - end - - it "finds all descendants with wildcard" do - result = root.xpath('.//*') - expect(result.size).to be >= 5 - end - end - - describe "descendant-or-self axis" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "includes context node in results" do - result = root.xpath('descendant-or-self::*') - expect(result.first).to eq(root) - end - - it "includes all descendants" do - result = root.xpath('descendant-or-self::*') - expect(result.size).to eq(3) # root, a, b - expect(result.map(&:name)).to eq(['root', 'a', 'b']) - end - - it "works from mid-tree element" do - a = navigate_to(root, 'a') - result = a.xpath('descendant-or-self::*') - expect(result.size).to eq(2) # a, b - expect(result.map(&:name)).to eq(['a', 'b']) - end - end - - describe "descendant axis (descendant::*)" do - it "excludes context node, includes all descendants" do - doc = parse('') - result = doc.root.xpath('descendant::*') - expect(result.size).to eq(3) # a, b, container (NOT root) - expect(result.map(&:name)).to eq(['a', 'b', 'container']) - end - - it "works with deep nesting" do - doc = parse('') - result = doc.root.xpath('descendant::*') - expect(result.size).to eq(3) # level1, level2, level3 - expect(result.map(&:name)).to eq(['level1', 'level2', 'level3']) - end - - it "works from non-root context" do - doc = parse('') - a = doc.root.xpath('a').first - result = a.xpath('descendant::*') - expect(result.size).to eq(2) # b, c (NOT a) - expect(result.map(&:name)).to eq(['b', 'c']) - end - - it "works with multiple branches" do - doc = parse('') - result = doc.root.xpath('descendant::*') - expect(result.size).to eq(4) # a, aa, b, bb - end - - it "returns empty for leaf element" do - doc = parse('') - leaf = doc.root.xpath('leaf').first - result = leaf.xpath('descendant::*') - expect(result).to be_empty - end - - it "works with name test" do - doc = parse('') - result = doc.root.xpath('descendant::a') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['a', 'a']) - end - end - - describe "ancestor-or-self axis (ancestor-or-self::*)" do - it "includes context node in results" do - doc = parse('') - c = navigate_to(doc.root, 'a/b/c') - result = c.xpath('ancestor-or-self::*') - expect(result.first).to eq(c) - expect(result.map(&:name)).to eq(['c', 'b', 'a', 'root']) - end - - it "returns just self for root element" do - doc = parse('') - result = doc.root.xpath('ancestor-or-self::*') - expect(result.size).to eq(1) - expect(result.first).to eq(doc.root) - end - - it "walks up the entire ancestor chain" do - doc = parse('') - c = navigate_to(doc.root, 'a/b/c') - result = c.xpath('ancestor-or-self::*') - expect(result.size).to eq(4) # c, b, a, root - end - - it "works with name test" do - doc = parse('
') - item = navigate_to(doc.root, 'section/section/item') - result = item.xpath('ancestor-or-self::section') - expect(result.size).to eq(2) - expect(result.map(&:name)).to all(eq('section')) - end - - it "maintains correct order (self first, then ancestors)" do - doc = parse('') - b = navigate_to(doc.root, 'a/b') - result = b.xpath('ancestor-or-self::*') - expect(result.map(&:name)).to eq(['b', 'a', 'root']) - end - end - - describe "ancestor axis (ancestor::*)" do - it "excludes context node, includes all ancestors" do - doc = parse('') - c = navigate_to(doc.root, 'a/b/c') - result = c.xpath('ancestor::*') - expect(result.size).to eq(3) # b, a, root (NOT c) - expect(result.map(&:name)).to eq(['b', 'a', 'root']) - end - - it "returns empty for root element" do - doc = parse('') - result = doc.root.xpath('ancestor::*') - expect(result).to be_empty - end - - it "walks up entire ancestor chain" do - doc = parse('') - l4 = navigate_to(doc.root, 'l1/l2/l3/l4') - result = l4.xpath('ancestor::*') - expect(result.size).to eq(4) # l3, l2, l1, root - expect(result.map(&:name)).to eq(['l3', 'l2', 'l1', 'root']) - end - - it "works with name test" do - doc = parse('
') - span = navigate_to(doc.root, 'div/div/span') - result = span.xpath('ancestor::div') - expect(result.size).to eq(2) - expect(result.map(&:name)).to all(eq('div')) - end - - it "works from intermediate element" do - doc = parse('') - b = navigate_to(doc.root, 'a/b') - result = b.xpath('ancestor::*') - expect(result.size).to eq(2) # a, root (NOT b) - expect(result.map(&:name)).to eq(['a', 'root']) - end - end - - describe "following-sibling axis (following-sibling::*)" do - it "returns siblings after context node" do - doc = parse('') - b = navigate_to(doc.root, 'b') - result = b.xpath('following-sibling::*') - expect(result.size).to eq(2) # c, d (not a or b) - expect(result.map(&:name)).to eq(['c', 'd']) - end - - it "returns empty for last child" do - doc = parse('') - c = navigate_to(doc.root, 'c') - result = c.xpath('following-sibling::*') - expect(result).to be_empty - end - - it "maintains document order" do - doc = parse('') - first = navigate_to(doc.root, 'first') - result = first.xpath('following-sibling::*') - expect(result.map(&:name)).to eq(['second', 'third', 'fourth']) - end - - it "works with name test" do - doc = parse('') - first_a = doc.root.xpath('child::*')[0] - result = first_a.xpath('following-sibling::a') - expect(result.size).to eq(2) - expect(result.map(&:name)).to all(eq('a')) - end - - it "only returns elements, not text nodes" do - doc = parse('textmore text') - a = navigate_to(doc.root, 'a') - result = a.xpath('following-sibling::*') - expect(result.size).to eq(2) # b, c (not text) - expect(result.map(&:name)).to eq(['b', 'c']) - end - end - - describe "preceding-sibling axis (preceding-sibling::*)" do - it "returns siblings before context node" do - doc = parse('') - c = navigate_to(doc.root, 'c') - result = c.xpath('preceding-sibling::*') - expect(result.size).to eq(2) # a, b (not c or d) - expect(result.map(&:name)).to eq(['a', 'b']) - end - - it "returns empty for first child" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('preceding-sibling::*') - expect(result).to be_empty - end - - it "maintains document order" do - doc = parse('') - fourth = navigate_to(doc.root, 'fourth') - result = fourth.xpath('preceding-sibling::*') - expect(result.map(&:name)).to eq(['first', 'second', 'third']) - end - - it "works with name test" do - doc = parse('') - last_a = doc.root.xpath('child::*')[4] - result = last_a.xpath('preceding-sibling::a') - expect(result.size).to eq(2) - expect(result.map(&:name)).to all(eq('a')) - end - - it "only returns elements, not text nodes" do - doc = parse('textmore text') - c = navigate_to(doc.root, 'c') - result = c.xpath('preceding-sibling::*') - expect(result.size).to eq(2) # a, b (not text) - expect(result.map(&:name)).to eq(['a', 'b']) - end - end - - describe "following axis (following::*)" do - it "includes following siblings" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('following::*') - expect(result.size).to eq(2) # b, c - expect(result.map(&:name)).to eq(['b', 'c']) - end - - it "includes descendants of following siblings" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('following::*') - expect(result.size).to eq(4) # b, bb, c, cc - expect(result.map(&:name)).to eq(['b', 'bb', 'c', 'cc']) - end - - it "includes parent's following nodes" do - doc = parse('') - child1 = navigate_to(doc.root, 'parent1/child1') - result = child1.xpath('following::*') - expect(result.size).to eq(2) # parent2, child2 - expect(result.map(&:name)).to eq(['parent2', 'child2']) - end - - it "does not cause infinite recursion" do - doc = parse('') - e = navigate_to(doc.root, 'a/b/c/d/e') - result = e.xpath('following::*') - expect(result).to be_an(Array) - expect(result).to be_empty # e is last, no following - end - - it "maintains correct document order" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('following::*') - # following axis excludes descendants of context node - # aa is a descendant of a, so not included - expect(result.map(&:name)).to eq(['b', 'c', 'cc']) - end - - it "returns empty for last node in document" do - doc = parse('') - b = navigate_to(doc.root, 'b') - result = b.xpath('following::*') - expect(result).to be_empty - end - end - - describe "preceding axis (preceding::*)" do - it "includes preceding siblings" do - doc = parse('') - c = navigate_to(doc.root, 'c') - result = c.xpath('preceding::*') - expect(result.size).to eq(2) # a, b - expect(result.map(&:name)).to eq(['a', 'b']) - end - - it "includes descendants of preceding siblings" do - doc = parse('') - c = navigate_to(doc.root, 'c') - result = c.xpath('preceding::*') - expect(result.size).to eq(4) # a, aa, b, bb - expect(result.map(&:name)).to eq(['a', 'aa', 'b', 'bb']) - end - - it "includes parent's preceding nodes" do - doc = parse('') - child2 = navigate_to(doc.root, 'parent2/child2') - result = child2.xpath('preceding::*') - expect(result.size).to eq(2) # parent1, child1 - expect(result.map(&:name)).to eq(['parent1', 'child1']) - end - - it "does not cause infinite recursion" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('preceding::*') - expect(result).to be_an(Array) - expect(result).to be_empty # a is first, no preceding - end - - it "returns empty for first node in document" do - doc = parse('') - a = navigate_to(doc.root, 'a') - result = a.xpath('preceding::*') - expect(result).to be_empty - end - end - - describe "parent navigation (..)" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "navigates to parent element" do - child = navigate_to(root, 'parent/child') - result = child.xpath('..') - expect(result.size).to eq(1) - expect(result.first.name).to eq('parent') - end - - it "returns empty for root element" do - result = root.xpath('..') - expect(result).to be_empty - end - - it "works with parent axis" do - child = navigate_to(root, 'parent/child') - result = child.xpath('parent::*') - expect(result.size).to eq(1) - expect(result.first.name).to eq('parent') - end - - it "allows chaining after parent navigation" do - xml = '' - doc = parse(xml) - c = navigate_to(doc.root, 'a/b/c') - result = c.xpath('../..') - expect(result.size).to eq(1) - expect(result.first.name).to eq('a') - end - end - - describe "self axis (.)" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "returns context node" do - result = root.xpath('.') - expect(result).to eq([root]) - end - - it "works with self axis" do - result = root.xpath('self::*') - expect(result.size).to eq(1) - expect(result.first).to eq(root) - end - - it "returns self from any element" do - item = root.nodes.first - result = item.xpath('.') - expect(result).to eq([item]) - end - end - - describe "wildcard matching (*)" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "matches all children" do - result = root.xpath('*') - expect(result.size).to eq(3) - end - - it "matches all descendants" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('.//*') - expect(result.size).to eq(4) # a, aa, b, bb - end - - it "works in multi-step paths" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath(' */item') - expect(result.size).to eq(1) - end - end - - describe "attribute selection" do - let(:xml) do - <<~XML - - - - - XML - end - - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "selects specific attribute" do - result = root.xpath('.//book/@id') - expect(result).to be_an(Array) - expect(result).to eq(['1', '2']) - end - - it "selects multiple attributes" do - result = root.xpath('.//book/@title') - expect(result).to eq(['XPath Guide', 'Ruby Guide']) - end - - it "selects all attributes with @*" do - result = root.xpath('.//book/@*') - expect(result.size).to eq(4) # 2 books x 2 attributes each - # Attributes are returned in order: id, title for each book - expect(result).to eq(['1', 'XPath Guide', '2', 'Ruby Guide']) - end - - it "works with attribute axis" do - result = root.xpath('.//book/attribute::id') - expect(result).to eq(['1', '2']) - end - end - - describe "absolute paths from document" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "starts from document root with /" do - item = doc.root.nodes.first.nodes.first - result = item.xpath('/root') - # Absolute paths should work because Element#xpath finds the document - expect(result.size).to eq(1) - expect(result.first).to eq(doc.root) - end - - it "navigates multiple levels" do - result = doc.xpath('/root/child/item') - expect(result.size).to eq(1) - end - - it "works with // from any context" do - child = doc.root.nodes.first - result = child.xpath('//item') - expect(result.size).to eq(1) - end - end - - describe "complex queries" do - let(:xml) do - <<~XML - - - Book A - Book B - - - Album A - - - XML - end - - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "handles multi-step descendant search" do - result = root.xpath('.//category/product') - expect(result.size).to eq(3) - end - - it "combines wildcard with descendant" do - result = root.xpath('.//product') - expect(result.size).to eq(3) - end - - it "works with multiple path steps" do - result = root.xpath('category/product') - expect(result.size).to eq(3) - end - end - - describe "context resolution" do - let(:xml) { '' } - let(:doc) { parse(xml) } - - it "finds document context automatically from deep element" do - c = navigate_to(doc.root, 'a/b/c') - expect { c.xpath('.') }.not_to raise_error - end - - it "allows relative queries from any element" do - b = navigate_to(doc.root, 'a/b') - result = b.xpath('c') - expect(result.size).to eq(1) - end - - it "maintains correct context through navigation" do - a = navigate_to(doc.root, 'a') - result = a.xpath('b/c') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - end - - describe "edge cases" do - it "handles single element document" do - doc = parse('') - result = doc.root.xpath('.') - expect(result.size).to eq(1) - end - - it "handles empty xpath gracefully" do - doc = parse('') - # Empty XPath should raise an error - expect { doc.root.xpath('') }.to raise_error(RuntimeError, /parsing error/) - end - - it "handles elements with text content" do - doc = parse('text') - result = doc.root.xpath('item') - expect(result.size).to eq(1) - expect(result.first.text).to eq('text') - end - - it "handles mixed content elements" do - doc = parse('text1text2text3') - result = doc.root.xpath('*') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['a', 'b']) - end - - it "handles nested same-named elements" do - doc = parse('') - result = doc.root.xpath('.//item') - expect(result.size).to eq(3) - end - end - - describe "document order" do - let(:xml) do - <<~XML - - - - - - XML - end - - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "maintains document order in results" do - result = root.xpath('*') - expect(result.map(&:name)).to eq(['z', 'a', 'm']) - end - - it "preserves order in descendant search" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('.//*') - expect(result.map(&:name)).to eq(['b', 'a', 'c']) - end - end - - describe "namespaced elements" do - let(:xml) do - <<~XML - - Content - - XML - end - - let(:doc) { parse(xml) } - - it "finds elements regardless of namespace" do - # Note: Current implementation may not handle namespaces in XPath - # This test documents expected behavior - result = doc.root.xpath('item') - expect(result.size).to be >= 0 # May or may not find namespaced elements - end - end - - describe "performance characteristics" do - it "handles moderately large documents" do - # Create a document with 100 elements - items = (1..100).map { |i| "" }.join - xml = "#{items}" - doc = parse(xml) - - start_time = Time.now - result = doc.root.xpath('.//item') - elapsed = Time.now - start_time - - expect(result.size).to eq(100) - expect(elapsed).to be < 1.0 # Should complete in under 1 second - end - - it "handles deep nesting efficiently" do - # Create deeply nested document - xml = String.new('') - 20.times { |i| xml << "" } - xml << '' - 20.times { |i| xml << "" } - xml << '' - - doc = parse(xml) - result = doc.root.xpath('.//item') - expect(result.size).to eq(1) - end - end - - describe "position predicates" do - let(:xml) { '' } - let(:doc) { parse(xml) } - let(:root) { doc.root } - - it "selects first element with [1]" do - result = root.xpath('*[1]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('a') - end - - it "selects second element with [2]" do - result = root.xpath('*[2]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - - it "selects third element with [3]" do - result = root.xpath('*[3]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "selects last element with [last()]" do - result = root.xpath('*[last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('d') - end - - it "works with named elements" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[1]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "works with descendant axis" do - xml = '
' - doc = parse(xml) - # descendant::* returns [section, a, b, c] - # Position [2] selects the 2nd one: 'a' - result = doc.root.xpath('descendant::*[2]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('a') - end - - it "works in complex paths" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section/item[2]') - expect(result.size).to eq(1) - end - - it "applies to result nodeset correctly" do - xml = '' - doc = parse(xml) - # After selecting all children, [2] should give second one - result = doc.root.xpath('*[2]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - - it "handles position with absolute path" do - xml = '' - doc = parse(xml) - result = doc.xpath('//item[1]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "returns empty when position is out of range" do - result = root.xpath('*[10]') - expect(result).to be_empty - end - end - - describe "boolean predicates" do - it "filters by attribute existence" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[@id]') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['a', 'c']) - end - - it "works with multiple attributes" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[@class]') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['a', 'b']) - end - - it "filters by child element existence" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section[book]') - expect(result.size).to eq(2) - end - - it "works with nested child tests" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('container[span]') - expect(result.size).to eq(2) - end - - it "returns empty when no matches" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[@id]') - expect(result).to be_empty - end - - it "works with descendant axis" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('descendant::*[@id]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "works with specific element" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[@id]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "works in complex paths" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section/item[@id]') - expect(result.size).to eq(1) - end - end - - describe "XPath string functions" do - describe "string()" do - it "converts context node to string with no arguments" do - xml = 'Hello' - doc = parse(xml) - item = doc.root.xpath('item').first - # Call from Ruby: string() should return text content - result = doc.xpath('string(//item)') - expect(result).to eq('Hello') - end - - it "converts number to string" do - doc = parse('') - result = doc.xpath('string(42)') - expect(result).to eq('42') - end - - it "converts boolean true to 'true'" do - doc = parse('') - # Use a comparison that returns true - result = doc.xpath('string(1 = 1)') - expect(result).to eq('true') - end - - it "converts boolean false to 'false'" do - doc = parse('') - result = doc.xpath('string(1 = 2)') - expect(result).to eq('false') - end - - it "handles NaN" do - doc = parse('') - # Division by string that can't convert to number produces NaN - result = doc.xpath('string(0 div 0)') - expect(result).to eq('NaN') - end - - it "handles Infinity" do - doc = parse('') - result = doc.xpath('string(1 div 0)') - expect(result).to eq('Infinity') - end - - it "handles negative Infinity" do - doc = parse('') - result = doc.xpath('string(-1 div 0)') - expect(result).to eq('-Infinity') - end - end - - describe "concat()" do - it "concatenates two strings" do - doc = parse('') - result = doc.xpath("concat('Hello', ' World')") - expect(result).to eq('Hello World') - end - - it "concatenates three strings" do - doc = parse('') - result = doc.xpath("concat('A', 'B', 'C')") - expect(result).to eq('ABC') - end - - it "concatenates many strings" do - doc = parse('') - result = doc.xpath("concat('1', '2', '3', '4', '5')") - expect(result).to eq('12345') - end - - it "converts numbers to strings" do - doc = parse('') - result = doc.xpath("concat('Value: ', 42)") - expect(result).to eq('Value: 42') - end - - it "handles empty strings" do - doc = parse('') - result = doc.xpath("concat('', 'test', '')") - expect(result).to eq('test') - end - end - - describe "starts-with()" do - it "returns true for matching prefix" do - doc = parse('') - result = doc.xpath("starts-with('Hello World', 'Hello')") - expect(result).to eq(true) - end - - it "returns false for non-matching prefix" do - doc = parse('') - result = doc.xpath("starts-with('Hello World', 'World')") - expect(result).to eq(false) - end - - it "returns true for empty prefix" do - doc = parse('') - result = doc.xpath("starts-with('test', '')") - expect(result).to eq(true) - end - - it "works in predicates with attributes" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[starts-with(@id, "book")]') - expect(result.size).to eq(2) - end - - it "is case sensitive" do - doc = parse('') - result = doc.xpath("starts-with('Hello', 'hello')") - expect(result).to eq(false) - end - end - - describe "contains()" do - it "returns true when substring is present" do - doc = parse('') - result = doc.xpath("contains('Hello World', 'lo Wo')") - expect(result).to eq(true) - end - - it "returns false when substring is absent" do - doc = parse('') - result = doc.xpath("contains('Hello World', 'xyz')") - expect(result).to eq(false) - end - - it "returns true for empty substring" do - doc = parse('') - result = doc.xpath("contains('test', '')") - expect(result).to eq(true) - end - - it "works in predicates with attributes" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[contains(@name, "pie")]') - expect(result.size).to eq(2) - end - - it "is case sensitive" do - doc = parse('') - result = doc.xpath("contains('Hello', 'HEL')") - expect(result).to eq(false) - end - end - - describe "substring()" do - # Basic tests - it "extracts substring with position and length" do - doc = parse('') - result = doc.xpath("substring('12345', 2, 3)") - expect(result).to eq('234') - end - - it "extracts from position to end without length" do - doc = parse('') - result = doc.xpath("substring('12345', 2)") - expect(result).to eq('2345') - end - - it "uses 1-based indexing" do - doc = parse('') - result = doc.xpath("substring('12345', 1, 1)") - expect(result).to eq('1') - end - - # Edge cases - it "handles position 0 with length" do - doc = parse('') - # Position 0 with length 3: positions 0,1,2 → chars at 1,2 - result = doc.xpath("substring('12345', 0, 3)") - expect(result).to eq('12') - end - - it "handles negative position" do - doc = parse('') - # Position -1 with length 4: positions [-1, 3), intersect with [1, ∞) → [1, 3) - # Characters at positions 1,2 → "12" - result = doc.xpath("substring('12345', -1, 4)") - expect(result).to eq('12') - end - - it "returns empty string for position beyond length" do - doc = parse('') - result = doc.xpath("substring('12345', 10, 2)") - expect(result).to eq('') - end - - it "returns empty string for zero length" do - doc = parse('') - result = doc.xpath("substring('12345', 2, 0)") - expect(result).to eq('') - end - - it "returns empty string for negative length" do - doc = parse('') - result = doc.xpath("substring('12345', 2, -1)") - expect(result).to eq('') - end - - # XPath spec edge cases with rounding - it "rounds fractional positions per XPath spec" do - doc = parse('') - # Position 1.5 rounds to 2, length 2.6 rounds to 3 - result = doc.xpath("substring('12345', 1.5, 2.6)") - expect(result).to eq('234') - end - - # NaN handling - it "returns empty string for NaN position" do - doc = parse('') - result = doc.xpath("substring('12345', 0 div 0)") - expect(result).to eq('') - end - - it "returns empty string for NaN length" do - doc = parse('') - result = doc.xpath("substring('12345', 2, 0 div 0)") - expect(result).to eq('') - end - - # UTF-8 character handling - it "counts UTF-8 characters not bytes" do - doc = parse('') - # '你好世界' is 4 characters but 12 bytes in UTF-8 - result = doc.xpath("substring('你好世界', 2, 2)") - expect(result).to eq('好世') - end - - it "handles mixed ASCII and UTF-8" do - doc = parse('') - result = doc.xpath("substring('Hello世界', 6, 2)") - expect(result).to eq('世界') - end - end - - describe "string-length()" do - it "returns length of string" do - doc = parse('') - result = doc.xpath("string-length('Hello')") - expect(result).to eq(5) - end - - it "returns 0 for empty string" do - doc = parse('') - result = doc.xpath("string-length('')") - expect(result).to eq(0) - end - - it "counts UTF-8 characters not bytes" do - doc = parse('') - # '你好' is 2 characters but 6 bytes - result = doc.xpath("string-length('你好')") - expect(result).to eq(2) - end - - it "uses context node when no argument" do - xml = 'Test' - doc = parse(xml) - result = doc.xpath('string-length(//item)') - expect(result).to eq(4) - end - - it "handles mixed ASCII and UTF-8" do - doc = parse('') - result = doc.xpath("string-length('Hello世界')") - expect(result).to eq(7) - end - end - - describe "normalize-space()" do - it "strips leading whitespace" do - doc = parse('') - result = doc.xpath("normalize-space(' test')") - expect(result).to eq('test') - end - - it "strips trailing whitespace" do - doc = parse('') - result = doc.xpath("normalize-space('test ')") - expect(result).to eq('test') - end - - it "collapses internal whitespace to single space" do - doc = parse('') - result = doc.xpath("normalize-space('hello world')") - expect(result).to eq('hello world') - end - - it "handles multiple types of whitespace" do - doc = parse('') - result = doc.xpath("normalize-space(' hello\t\n\rworld ')") - expect(result).to eq('hello world') - end - - it "handles string with no extra whitespace" do - doc = parse('') - result = doc.xpath("normalize-space('hello world')") - expect(result).to eq('hello world') - end - - it "returns empty string for all whitespace" do - doc = parse('') - result = doc.xpath("normalize-space(' \t\n ')") - expect(result).to eq('') - end - - it "uses context node when no argument" do - xml = ' hello world ' - doc = parse(xml) - result = doc.xpath('normalize-space(//item)') - expect(result).to eq('hello world') - end - end - - describe "translate()" do - it "replaces matching characters" do - doc = parse('') - result = doc.xpath("translate('bar', 'abc', 'ABC')") - expect(result).to eq('BAr') - end - - it "removes characters when third arg is shorter" do - doc = parse('') - result = doc.xpath("translate('bar', 'abc', 'AB')") - expect(result).to eq('BAr') - end - - it "handles empty translation string" do - doc = parse('') - result = doc.xpath("translate('bar', 'abc', '')") - expect(result).to eq('r') - end - - it "works with numbers converted to strings" do - doc = parse('') - result = doc.xpath("translate('2', '123', 'abc')") - expect(result).to eq('b') - end - - it "handles characters not in search string" do - doc = parse('') - result = doc.xpath("translate('hello', 'eo', 'EO')") - expect(result).to eq('hEllO') - end - - it "is case sensitive" do - doc = parse('') - result = doc.xpath("translate('Hello', 'h', 'H')") - expect(result).to eq('Hello') # 'H' and 'h' are different - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - # Normalize to uppercase and compare - result = doc.root.xpath('item[translate(@code, "abc", "ABC") = "ABC"]') - expect(result.size).to eq(2) - end - end - - describe "substring-before()" do - it "extracts substring before delimiter" do - doc = parse('') - result = doc.xpath("substring-before('1999/04/01', '/')") - expect(result).to eq('1999') - end - - it "returns empty string when delimiter not found" do - doc = parse('') - result = doc.xpath("substring-before('hello', 'x')") - expect(result).to eq('') - end - - it "returns empty string for empty delimiter" do - doc = parse('') - result = doc.xpath("substring-before('hello', '')") - expect(result).to eq('') - end - - it "handles delimiter at start" do - doc = parse('') - result = doc.xpath("substring-before('/path/to/file', '/')") - expect(result).to eq('') - end - - it "finds first occurrence only" do - doc = parse('') - result = doc.xpath("substring-before('a/b/c', '/')") - expect(result).to eq('a') - end - - it "works with attribute values" do - xml = '' - doc = parse(xml) - result = doc.xpath('substring-before(//item/@id, "@")') - expect(result).to eq('user') - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('file[substring-before(@name, ".") = "doc"]') - expect(result.size).to eq(1) # Only doc.txt - end - end - - describe "substring-after()" do - it "extracts substring after delimiter" do - doc = parse('') - result = doc.xpath("substring-after('1999/04/01', '/')") - expect(result).to eq('04/01') - end - - it "returns empty string when delimiter not found" do - doc = parse('') - result = doc.xpath("substring-after('hello', 'x')") - expect(result).to eq('') - end - - it "returns entire string for empty delimiter" do - doc = parse('') - result = doc.xpath("substring-after('hello', '')") - expect(result).to eq('hello') - end - - it "handles delimiter at end" do - doc = parse('') - result = doc.xpath("substring-after('path/', '/')") - expect(result).to eq('') - end - - it "finds first occurrence only" do - doc = parse('') - result = doc.xpath("substring-after('a/b/c', '/')") - expect(result).to eq('b/c') - end - - it "works with attribute values" do - xml = '' - doc = parse(xml) - result = doc.xpath('substring-after(//item/@id, "@")') - expect(result).to eq('example.com') - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('file[substring-after(@name, ".") = "txt"]') - expect(result.size).to eq(2) - end - end - - describe "string functions in predicates" do - it "uses starts-with in predicate" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('book[starts-with(@title, "XPath")]') - expect(result.size).to eq(2) - expect(result.map { |n| n[:id] }).to eq(['b1', 'b3']) - end - - it "uses contains in predicate" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[contains(@name, "pie")]') - expect(result.size).to eq(2) - end - - it "combines string functions" do - xml = ' test other' - doc = parse(xml) - # Find items where normalized text is 'test' - result = doc.root.xpath('item[normalize-space(.) = "test"]') - expect(result.size).to eq(1) - end - end - end - - describe "XPath boolean functions" do - describe "boolean()" do - it "converts number 1 to true" do - doc = parse('') - result = doc.xpath('boolean(1)') - expect(result).to eq(true) - end - - it "converts number 0 to false" do - doc = parse('') - result = doc.xpath('boolean(0)') - expect(result).to eq(false) - end - - it "converts NaN to false" do - doc = parse('') - result = doc.xpath('boolean(0 div 0)') - expect(result).to eq(false) - end - - it "converts positive number to true" do - doc = parse('') - result = doc.xpath('boolean(42)') - expect(result).to eq(true) - end - - it "converts negative number to true" do - doc = parse('') - result = doc.xpath('boolean(-5)') - expect(result).to eq(true) - end - - it "converts non-empty string to true" do - doc = parse('') - result = doc.xpath("boolean('text')") - expect(result).to eq(true) - end - - it "converts empty string to false" do - doc = parse('') - result = doc.xpath("boolean('')") - expect(result).to eq(false) - end - - it "converts non-empty nodeset to true" do - xml = '' - doc = parse(xml) - result = doc.xpath('boolean(//item)') - expect(result).to eq(true) - end - - it "converts empty nodeset to false" do - xml = '' - doc = parse(xml) - result = doc.xpath('boolean(//missing)') - expect(result).to eq(false) - end - - it "converts boolean true to true" do - doc = parse('') - result = doc.xpath('boolean(1 = 1)') - expect(result).to eq(true) - end - - it "converts boolean false to false" do - doc = parse('') - result = doc.xpath('boolean(1 = 2)') - expect(result).to eq(false) - end - - it "works in boolean operations" do - doc = parse('') - result = doc.xpath('boolean(1) and boolean(1)') - expect(result).to eq(true) - end - end - - describe "not()" do - it "negates true to false" do - doc = parse('') - result = doc.xpath('not(1 = 1)') - expect(result).to eq(false) - end - - it "negates false to true" do - doc = parse('') - result = doc.xpath('not(1 = 2)') - expect(result).to eq(true) - end - - it "works with true() function" do - doc = parse('') - result = doc.xpath('not(true())') - expect(result).to eq(false) - end - - it "works with false() function" do - doc = parse('') - result = doc.xpath('not(false())') - expect(result).to eq(true) - end - - it "converts non-zero number to false" do - doc = parse('') - result = doc.xpath('not(1)') - expect(result).to eq(false) - end - - it "converts zero to true" do - doc = parse('') - result = doc.xpath('not(0)') - expect(result).to eq(true) - end - - it "converts empty string to true" do - doc = parse('') - result = doc.xpath("not('')") - expect(result).to eq(true) - end - - it "converts non-empty string to false" do - doc = parse('') - result = doc.xpath("not('text')") - expect(result).to eq(false) - end - - it "works in predicates with attribute existence" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[not(@id)]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - - it "works in predicates with child existence" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section[not(item)]') - expect(result.size).to eq(1) - end - - it "double negation returns original" do - doc = parse('') - result = doc.xpath('not(not(true()))') - expect(result).to eq(true) - end - - it "works with nodeset conversion" do - xml = '' - doc = parse(xml) - result = doc.xpath('not(//missing)') - expect(result).to eq(true) - end - end - - describe "true() and false()" do - it "true() returns boolean true" do - doc = parse('') - result = doc.xpath('true()') - expect(result).to eq(true) - end - - it "false() returns boolean false" do - doc = parse('') - result = doc.xpath('false()') - expect(result).to eq(false) - end - - it "true() and true() returns true" do - doc = parse('') - result = doc.xpath('true() and true()') - expect(result).to eq(true) - end - - it "true() and false() returns false" do - doc = parse('') - result = doc.xpath('true() and false()') - expect(result).to eq(false) - end - - it "false() and false() returns false" do - doc = parse('') - result = doc.xpath('false() and false()') - expect(result).to eq(false) - end - - it "true() or false() returns true" do - doc = parse('') - result = doc.xpath('true() or false()') - expect(result).to eq(true) - end - - it "false() or false() returns false" do - doc = parse('') - result = doc.xpath('false() or false()') - expect(result).to eq(false) - end - - it "works in complex boolean expressions" do - doc = parse('') - result = doc.xpath('not(not(true()))') - expect(result).to eq(true) - end - - it "works in comparisons" do - doc = parse('') - result = doc.xpath('true() = true()') - expect(result).to eq(true) - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - # true() always matches, so all elements selected - result = doc.root.xpath('*[true()]') - expect(result.size).to eq(3) - end - - it "false() in predicate excludes all" do - xml = '' - doc = parse(xml) - # false() never matches, so no elements selected - result = doc.root.xpath('*[false()]') - expect(result).to be_empty - end - end - - describe "lang()" do - it "matches exact language code" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('lang("en")') - expect(result).to eq(true) - end - - it "returns false when language does not match" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('lang("fr")') - expect(result).to eq(false) - end - - it "matches language with region code" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('lang("en")') - expect(result).to eq(true) - end - - it "does not match region when base differs" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('lang("fr")') - expect(result).to eq(false) - end - - it "is case insensitive" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('lang("en")') - expect(result).to eq(true) - end - - it "inherits language from parent" do - xml = '
' - doc = parse(xml) - item = navigate_to(doc.root, 'section/item') - result = item.xpath('lang("fr")') - expect(result).to eq(true) - result_en = item.xpath('lang("en")') - expect(result_en).to eq(false) - end - - it "handles complex language inheritance" do - xml = '
' - doc = parse(xml) - item = navigate_to(doc.root, 'div/section/item') - result = item.xpath('lang("fr")') - expect(result).to eq(true) - end - end - - describe "boolean functions in complex expressions" do - it "combines boolean() and not()" do - doc = parse('') - result = doc.xpath('not(boolean(0))') - expect(result).to eq(true) - end - - it "uses boolean functions in conditional logic" do - xml = '' - doc = parse(xml) - # Select items with active attribute OR first position - result = doc.root.xpath('item[boolean(@active) or (position() = 1)]') - expect(result.size).to eq(1) - end - - it "uses not() with multiple conditions" do - xml = '' - doc = parse(xml) - # Select elements without both id and class - result = doc.root.xpath('*[not(@id and @class)]') - expect(result.size).to eq(3) - expect(result.map(&:name)).to eq(['a', 'b', 'd']) - end - - it "uses boolean conversions in comparisons" do - doc = parse('') - result = doc.xpath('boolean(1) = true()') - expect(result).to eq(true) - end - - it "chains boolean operations" do - doc = parse('') - result = doc.xpath('true() and not(false()) and boolean(1)') - expect(result).to eq(true) - end - end - end - - describe "XPath node-set functions" do - describe "count()" do - it "counts nodes in a nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('count(//item)') - expect(result).to eq(3) - end - - it "returns 0 for empty nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('count(//missing)') - expect(result).to eq(0) - end - - it "works with predicates" do - xml = '' - doc = parse(xml) - result = doc.xpath('count(//item[@id])') - expect(result).to eq(2) - end - - it "works in comparison expressions" do - xml = '
' - doc = parse(xml) - # Select sections with more than 1 item - result = doc.root.xpath('section[count(item) > 1]') - expect(result.size).to eq(1) - expect(result.first.nodes.size).to eq(2) - end - - it "counts all descendants" do - xml = '' - doc = parse(xml) - result = doc.xpath('count(//*)') - expect(result).to eq(5) # root, a, b, c, d - end - end - - describe "local-name()" do - it "returns local name of context node with no argument" do - xml = 'test' - doc = parse(xml) - result = doc.xpath('local-name(//item)') - expect(result).to eq('item') - end - - it "returns local name of first node in nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('local-name(//*)') # First is root - expect(result).to eq('root') - end - - it "returns empty string for empty nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('local-name(//missing)') - expect(result).to eq('') - end - - it "strips namespace prefix from qualified names" do - xml = '' - doc = parse(xml) - result = doc.xpath('local-name(//item)') - expect(result).to eq('item') - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[local-name() = "item"]') - expect(result.size).to eq(2) - expect(result.map(&:name)).to all(eq('item')) - end - end - - describe "namespace-uri()" do - it "returns namespace URI of context node" do - xml = '' - doc = parse(xml) - result = doc.xpath('namespace-uri(//item)') - expect(result).to eq('http://example.org') - end - - it "returns empty string for node without namespace" do - xml = '' - doc = parse(xml) - result = doc.xpath('namespace-uri(//item)') - expect(result).to eq('') - end - - it "returns empty string for empty nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('namespace-uri(//missing)') - expect(result).to eq('') - end - - it "works with prefixed namespaces" do - xml = '' - doc = parse(xml) - result = doc.xpath('namespace-uri(//item)') - expect(result).to eq('http://example.org') - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - # Note: This test may need adjustment based on namespace handling - result = doc.root.xpath('*[namespace-uri() = "http://example.org"]') - expect(result.size).to be >= 0 - end - end - - describe "name()" do - it "returns qualified name of context node" do - xml = 'test' - doc = parse(xml) - result = doc.xpath('name(//item)') - expect(result).to eq('item') - end - - it "returns qualified name including prefix" do - xml = '' - doc = parse(xml) - # Note: Current implementation stores local name only, not prefix - result = doc.xpath('name(//item)') - expect(result).to eq('item') - end - - it "returns empty string for empty nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('name(//missing)') - expect(result).to eq('') - end - - it "works in predicates" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[name() = "item"]') - expect(result.size).to eq(2) - end - - it "works with first node in nodeset" do - xml = '' - doc = parse(xml) - result = doc.xpath('name(//*)') # First element is root - expect(result).to eq('root') - end - end - - describe "id()" do - it "selects element by id attribute" do - xml = 'FoundNot' - doc = parse(xml) - result = doc.xpath('id("test")') - expect(result.size).to eq(1) - expect(result.first[:id]).to eq('test') - expect(result.first.text).to eq('Found') - end - - it "handles multiple space-separated ids" do - xml = 'ABC' - doc = parse(xml) - result = doc.xpath('id("a b")') - expect(result.size).to eq(2) - ids = result.map { |n| n[:id] } - expect(ids).to include('a', 'b') - end - - it "returns empty nodeset for non-existent id" do - xml = '' - doc = parse(xml) - result = doc.xpath('id("missing")') - expect(result.size).to eq(0) - end - - it "works with nodeset argument" do - xml = 'testFound' - doc = parse(xml) - # Get id value from ref element - result = doc.xpath('id(//ref)') - expect(result.size).to eq(1) - expect(result.first[:id]).to eq('test') - end - - it "ignores duplicate ids" do - xml = 'FirstSecond' - doc = parse(xml) - result = doc.xpath('id("test")') - # Should return both elements with id="test" - expect(result.size).to be > 1 - end - - it "works in complex expressions" do - xml = 'abAB' - doc = parse(xml) - result = doc.xpath('id(//ref)') - expect(result.size).to eq(2) - end - end - - describe "node-set functions in combination" do - it "combines count() with predicates" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section[count(item) = 2]') - expect(result.size).to eq(1) - end - - it "uses name() to filter elements" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[name() = "item" or name() = "book"]') - expect(result.size).to eq(3) - end - - it "combines local-name() with count()" do - xml = '' - doc = parse(xml) - result = doc.xpath('count(//*[local-name() = "item"])') - expect(result).to eq(3) - end - end - end -end \ No newline at end of file diff --git a/spec/taurus/errors_spec.rb b/spec/taurus/errors_spec.rb deleted file mode 100644 index b9f3de3..0000000 --- a/spec/taurus/errors_spec.rb +++ /dev/null @@ -1,106 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe "Error Infrastructure" do - describe "Error Code Mapping" do - it "maps all parse error codes correctly" do - expect(Taurus::FFI::ErrorCode::OK).to eq(0) - expect(Taurus::FFI::ErrorCode::NULL_INPUT).to eq(1) - expect(Taurus::FFI::ErrorCode::UNCLOSED_TAG).to eq(100) - expect(Taurus::FFI::ErrorCode::INVALID_ATTR).to eq(101) - end - - it "maps all XPath error codes correctly" do - expect(Taurus::FFI::ErrorCode::XPATH_SYNTAX).to eq(200) - expect(Taurus::FFI::ErrorCode::XPATH_FUNCTION).to eq(201) - expect(Taurus::FFI::ErrorCode::XPATH_TYPE_MISMATCH).to eq(202) - end - - it "maps all evaluation error codes correctly" do - expect(Taurus::FFI::ErrorCode::EVAL_CONTEXT).to eq(300) - expect(Taurus::FFI::ErrorCode::EVAL_ARGUMENT).to eq(301) - expect(Taurus::FFI::ErrorCode::EVAL_OVERFLOW).to eq(302) - end - - it "maps generic error codes correctly" do - expect(Taurus::FFI::ErrorCode::OUT_OF_MEMORY).to eq(900) - expect(Taurus::FFI::ErrorCode::INTERNAL).to eq(999) - end - end - - describe "Error Code to Symbol Conversion" do - it "converts parse error codes to symbols" do - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::OK)).to eq(:ok) - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::UNCLOSED_TAG)).to eq(:unclosed_tag) - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::MALFORMED)).to eq(:malformed) - end - - it "converts XPath error codes to symbols" do - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::XPATH_SYNTAX)).to eq(:xpath_syntax) - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::XPATH_NAMESPACE)).to eq(:xpath_namespace) - end - - it "converts evaluation error codes to symbols" do - expect(Taurus::FFI.error_code_to_sym(Taurus::FFI::ErrorCode::EVAL_ARGUMENT)).to eq(:eval_argument) - end - - it "handles unknown error codes" do - expect(Taurus::FFI.error_code_to_sym(9999)).to eq(:unknown) - end - end - - describe "Error Class Hierarchy" do - it "defines Error as base class" do - expect(Taurus::Error.superclass).to eq(StandardError) - end - - it "defines ParseError inheriting from Error" do - expect(Taurus::ParseError.superclass).to eq(Taurus::Error) - end - - it "defines XPathError inheriting from Error" do - expect(Taurus::XPathError.superclass).to eq(Taurus::Error) - end - - it "defines EvaluationError inheriting from Error" do - expect(Taurus::EvaluationError.superclass).to eq(Taurus::Error) - end - end - - describe "Error Infrastructure Ready" do - it "has context snippet API" do - expect(Taurus::FFI).to respond_to(:taurus_error_context) - expect(Taurus::FFI).to respond_to(:taurus_error_byte_offset) - end - - it "has error setting functions available in C" do - # These are internal functions used by parser/evaluator - # They're declared in taurus_internal.h: - # - taurus_set_error - # - taurus_set_error_with_context - # - taurus_extract_context_snippet - # Verified by successful compilation - expect(true).to be true - end - end - - describe "FFI Error Functions" do - it "has taurus_error_context binding" do - expect(Taurus::FFI).to respond_to(:taurus_error_context) - end - - it "has taurus_error_byte_offset binding" do - expect(Taurus::FFI).to respond_to(:taurus_error_byte_offset) - end - - it "has all error functions bound" do - expect(Taurus::FFI).to respond_to(:taurus_last_error) - expect(Taurus::FFI).to respond_to(:taurus_last_error_code) - expect(Taurus::FFI).to respond_to(:taurus_error_string) - expect(Taurus::FFI).to respond_to(:taurus_clear_error) - expect(Taurus::FFI).to respond_to(:taurus_parse_error_line) - expect(Taurus::FFI).to respond_to(:taurus_parse_error_column) - end - end -end \ No newline at end of file diff --git a/spec/taurus/namespace_spec.rb b/spec/taurus/namespace_spec.rb deleted file mode 100644 index 28072b7..0000000 --- a/spec/taurus/namespace_spec.rb +++ /dev/null @@ -1,224 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe Taurus::Element, "namespace support" do - describe "#namespace" do - it "returns nil when element has no namespace" do - elem = Taurus::Element.new("item") - expect(elem.namespace).to be_nil - end - - it "returns namespace hash when element has a namespace" do - elem = Taurus::Element.new("ex:item") - # In a real implementation with parser, this would be set during parsing - # For now, we're testing the API structure - - # The namespace method returns { prefix: "ex", href: "http://example.org" } - # when namespaces are properly tracked - end - end - - describe "#namespaces" do - it "returns empty array when element has no namespace declarations" do - elem = Taurus::Element.new("item") - expect(elem.namespaces).to eq([]) - end - - it "returns array of namespace declarations" do - elem = Taurus::Element.new("root") - # Namespace declarations would be added during parsing - # expect(elem.namespaces).to be_an(Array) - end - end - - describe "#namespace_for_prefix" do - it "returns nil when prefix is not found" do - elem = Taurus::Element.new("item") - expect(elem.namespace_for_prefix("ex")).to be_nil - end - - it "resolves default namespace with nil prefix" do - elem = Taurus::Element.new("item") - # Would return URI if default namespace exists - expect(elem.namespace_for_prefix(nil)).to be_nil - end - end - - describe "#parent=" do - it "sets parent to nil" do - elem = Taurus::Element.new("item") - elem.parent = nil - expect(elem.parent).to be_nil - end - - it "sets parent to another element" do - parent = Taurus::Element.new("root") - child = Taurus::Element.new("item") - - child.parent = parent - expect(child.parent).to eq(parent) - end - - it "raises error when setting self as parent" do - elem = Taurus::Element.new("item") - expect { elem.parent = elem }.to raise_error(ArgumentError, /own parent/) - end - - it "raises error when parent is not an Element" do - elem = Taurus::Element.new("item") - expect { elem.parent = "not an element" }.to raise_error(TypeError) - end - end - - describe "convenience methods" do - describe "#<<" do - it "adds a child node" do - elem = Taurus::Element.new("root") - child = Taurus::Element.new("item") - - elem << child - expect(elem.nodes).to include(child) - end - - it "returns self for chaining" do - elem = Taurus::Element.new("root") - child = Taurus::Element.new("item") - - result = elem << child - expect(result).to eq(elem) - end - end - - describe "#remove" do - it "removes element from parent" do - parent = Taurus::Element.new("root") - child = Taurus::Element.new("item") - - parent << child - child.parent = parent - - child.remove - expect(parent.nodes).not_to include(child) - expect(child.parent).to be_nil - end - - it "does nothing when element has no parent" do - elem = Taurus::Element.new("item") - expect { elem.remove }.not_to raise_error - end - end - - describe "#add_child" do - it "adds child and sets parent relationship" do - parent = Taurus::Element.new("root") - child = Taurus::Element.new("item") - - parent.add_child(child) - expect(parent.nodes).to include(child) - expect(child.parent).to eq(parent) - end - - it "removes child from old parent before adding" do - old_parent = Taurus::Element.new("old") - new_parent = Taurus::Element.new("new") - child = Taurus::Element.new("item") - - old_parent.add_child(child) - new_parent.add_child(child) - - expect(old_parent.nodes).not_to include(child) - expect(new_parent.nodes).to include(child) - expect(child.parent).to eq(new_parent) - end - end - - describe "#text" do - it "returns first text node" do - elem = Taurus::Element.new("item") - elem << "Hello" - elem << "World" - - expect(elem.text).to eq("Hello") - end - - it "returns nil when no text nodes" do - elem = Taurus::Element.new("item") - expect(elem.text).to be_nil - end - end - - describe "#replace_text" do - it "replaces all child nodes with text" do - elem = Taurus::Element.new("item") - elem << Taurus::Element.new("child") - elem << "old text" - - elem.replace_text("new text") - expect(elem.nodes).to eq(["new text"]) - end - - it "raises error for non-string argument" do - elem = Taurus::Element.new("item") - expect { elem.replace_text(123) }.to raise_error(ArgumentError) - end - end - - describe "#[] and #[]=" do - it "gets and sets attributes" do - elem = Taurus::Element.new("item") - elem["id"] = "123" - - expect(elem["id"]).to eq("123") - end - - it "handles symbol keys" do - elem = Taurus::Element.new("item") - elem[:id] = "123" - - expect(elem[:id]).to eq("123") - end - end - - describe "#namespace_prefix" do - it "returns nil when no namespace" do - elem = Taurus::Element.new("item") - expect(elem.namespace_prefix).to be_nil - end - end - - describe "#namespace_uri" do - it "returns nil when no namespace" do - elem = Taurus::Element.new("item") - expect(elem.namespace_uri).to be_nil - end - end - - describe "#namespace?" do - it "returns false when no namespace" do - elem = Taurus::Element.new("item") - expect(elem.namespace?).to be false - end - end - - describe "#all_namespaces" do - it "returns empty hash when no namespaces" do - elem = Taurus::Element.new("item") - expect(elem.all_namespaces).to eq({}) - end - end - - describe ".with_namespace" do - it "creates element with namespace" do - elem = Taurus::Element.with_namespace("item", prefix: "ex", href: "http://example.org") - expect(elem.name).to eq("item") - expect(elem.attributes["xmlns:ex"]).to eq("http://example.org") - end - - it "creates element with default namespace" do - elem = Taurus::Element.with_namespace("item", href: "http://example.org") - expect(elem.attributes["xmlns"]).to eq("http://example.org") - end - end - end -end \ No newline at end of file diff --git a/spec/taurus/ox_compatibility_spec.rb b/spec/taurus/ox_compatibility_spec.rb deleted file mode 100644 index 35d718a..0000000 --- a/spec/taurus/ox_compatibility_spec.rb +++ /dev/null @@ -1,175 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "Ox Compatibility" do - describe "Basic parsing" do - it "parses simple XML" do - xml = "test" - doc = Taurus.parse(xml) - - expect(doc).to be_a(Taurus::Document) - expect(doc.root.name).to eq("top") - expect(doc.root.text).to eq("test") - end - - it "parses XML with attributes" do - xml = 'test' - doc = Taurus.parse(xml) - - expect(doc.root["name"]).to eq("Pete") - end - - it "parses nested elements" do - xml = 'value' - doc = Taurus.parse(xml) - - expect(doc.root.nodes.size).to eq(1) - expect(doc.root.nodes[0].name).to eq("nested") - expect(doc.root.nodes[0].text).to eq("value") - end - end - - describe "Namespace support" do - it "parses default namespace declaration" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespace).not_to be_nil - expect(doc.root.namespace[:href]).to eq("http://example.org") - expect(doc.root.namespace[:prefix]).to be_nil - end - - it "parses prefixed namespace declaration" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespaces.size).to eq(1) - ns = doc.root.namespaces[0] - expect(ns[:prefix]).to eq("ex") - expect(ns[:href]).to eq("http://example.org") - end - - it "parses multiple namespace declarations" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespaces.size).to eq(3) - end - - it "parses namespaced elements" do - xml = 'test' - doc = Taurus.parse(xml) - - item = doc.root.nodes[0] - expect(item.name).to eq("item") - expect(item.namespace).not_to be_nil - expect(item.namespace[:prefix]).to eq("ex") - expect(item.namespace[:href]).to eq("http://example.org") - end - - it "parses namespaced attributes" do - xml = 'content' - doc = Taurus.parse(xml) - - # Namespaced attributes are stored in the attributes hash - expect(doc.root["ex:name"]).to eq("value") - end - end - - describe "Namespace inheritance" do - it "inherits default namespace to child elements" do - xml = 'content' - doc = Taurus.parse(xml) - - child = doc.root.nodes[0] - expect(child.namespace).not_to be_nil - expect(child.namespace[:href]).to eq("http://example.org") - end - - it "inherits prefixed namespace to child elements" do - xml = 'test' - doc = Taurus.parse(xml) - - item = doc.root.nodes[0].nodes[0] - expect(item.namespace).not_to be_nil - expect(item.namespace[:prefix]).to eq("ex") - expect(item.namespace[:href]).to eq("http://example.org") - end - - it "allows namespace redeclaration in child elements" do - xml = 'test' - doc = Taurus.parse(xml) - - item = doc.root.nodes[0].nodes[0] - expect(item.namespace).not_to be_nil - expect(item.namespace[:prefix]).to eq("ex") - expect(item.namespace[:href]).to eq("http://other.org") - end - end - - describe "Namespace resolution" do - it "resolves prefixes using namespace_for_prefix" do - xml = 'test' - doc = Taurus.parse(xml) - - href = doc.root.namespace_for_prefix("ex") - expect(href).to eq("http://example.org") - end - - it "resolves default namespace with nil prefix" do - xml = 'content' - doc = Taurus.parse(xml) - - href = doc.root.namespace_for_prefix(nil) - expect(href).to eq("http://default.org") - end - - it "resolves inherited namespaces" do - xml = 'test' - doc = Taurus.parse(xml) - - href = doc.root.nodes[0].namespace_for_prefix("ex") - expect(href).to eq("http://example.org") - end - end - - describe "Special XML features" do - it "parses comments" do - xml = 'content' - doc = Taurus.parse(xml) - - # Comments are stored as nodes - expect(doc.root.nodes.size).to eq(2) - expect(doc.root.nodes[0]).to be_a(String) # The comment text - expect(doc.root.nodes[1]).to eq("content") # The text content - end - - it "parses CDATA sections" do - xml = 'content]]>' - doc = Taurus.parse(xml) - - expect(doc.root.text).to eq("content") - end - - it "parses self-closing elements" do - xml = '' - doc = Taurus.parse(xml) - - expect(doc.root.nodes.size).to eq(1) - expect(doc.root.nodes[0].name).to eq("item") - end - end - - describe "Error handling" do - it "handles malformed XML gracefully" do - xml = 'test' # Mismatched tag - expect { Taurus.parse(xml) }.to raise_error(Taurus::ParseError) - end - - it "handles mismatched tags" do - xml = 'test' # Missing closing tag for nested - expect { Taurus.parse(xml) }.to raise_error(Taurus::ParseError) - end - end -end \ No newline at end of file diff --git a/spec/taurus/parse_errors_spec.rb b/spec/taurus/parse_errors_spec.rb deleted file mode 100644 index c373bc1..0000000 --- a/spec/taurus/parse_errors_spec.rb +++ /dev/null @@ -1,218 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "Parse Error Messages" do - describe "NULL Input Errors" do - it "reports NULL input with clear error" do - expect { - Taurus.parse(nil) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.message).to include("NULL input") - expect(error.code).to eq(:null_input) - end - end - end - - describe "Empty Input Errors" do - it "reports empty input with clear error" do - expect { - Taurus.parse("") - }.to raise_error(Taurus::ParseError) do |error| - expect(error.message).to include("Empty input") - expect(error.code).to eq(:empty_input) - end - end - end - - describe "Invalid XML Structure" do - it "reports missing root element" do - xml = " \n\n " - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.message).to include("Expected root element") - expect(error.code).to eq(:invalid_xml) - expect(error.line).to be > 0 - expect(error.column).to be > 0 - end - end - - it "reports text before root element" do - xml = "Some text " - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.message).to include("Expected root element") - expect(error.code).to eq(:invalid_xml) - end - end - end - - describe "Parse Failed Errors" do - it "reports failed root element parse" do - xml = "<>" - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.message).to include("Failed to parse") - expect(error.code).to eq(:parse_failed) - expect(error.line).to eq(1) - expect(error.column).to be > 0 - end - end - - it "reports malformed element name" do - xml = "<123invalid>" - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.code).to eq(:parse_failed) - end - end - end - - describe "Error Context" do - it "provides context snippet for parse errors" do - xml = <<~XML - - - - This is some text - - - Extra text here - XML - - # This should fail because of text after root element close - # But our lenient parser might accept it - test what we can - result = Taurus.parse(xml) - expect(result).to be_a(Taurus::Document) - expect(result.root.name).to eq("library") - end - - it "shows line and column for errors" do - xml = "<" - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - expect(error.line).to eq(1) - expect(error.column).to eq(1) - expect(error.byte_offset).to eq(0) - end - end - - it "tracks position through whitespace and newlines" do - xml = <<~XML - - - - XML - - # Should parse successfully - doc = Taurus.parse(xml) - expect(doc.root.name).to eq("root") - end - end - - describe "Error Information Completeness" do - it "includes all error details" do - xml = "" - - expect { - Taurus.parse(xml) - }.to raise_error(Taurus::ParseError) do |error| - # Check error has all expected attributes - expect(error).to respond_to(:message) - expect(error).to respond_to(:code) - expect(error).to respond_to(:line) - expect(error).to respond_to(:column) - expect(error).to respond_to(:byte_offset) - expect(error).to respond_to(:context) - - # Verify values are reasonable - expect(error.message).to be_a(String) - expect(error.message).not_to be_empty - expect(error.code).to be_a(Symbol) - end - end - end - - describe "Multi-line Error Context" do - it "handles errors on different lines" do - xml = <<~XML - - - - - - XML - - # Should parse successfully - doc = Taurus.parse(xml) - expect(doc.root.name).to eq("root") - expect(doc.root.nodes.length).to eq(2) - end - end - - describe "Error Recovery" do - it "clears previous errors on successful parse" do - # First, cause an error - expect { - Taurus.parse(nil) - }.to raise_error(Taurus::ParseError) - - # Then parse successfully - doc = Taurus.parse("") - expect(doc).to be_a(Taurus::Document) - expect(doc.root.name).to eq("root") - - # Verify no error state lingering - expect(Taurus::FFI.taurus_last_error).to be_nil - end - end - - describe "Position Tracking Accuracy" do - # NOTE: These tests hang in RSpec but work in plain Ruby - # TODO: Investigate RSpec-specific issue (possibly threading/FD related) - - xit "tracks position through XML declaration" do - xml = <<~XML - - - XML - - doc = Taurus.parse(xml) - expect(doc.root.name).to eq("root") - end - - xit "tracks position through comments" do - xml = <<~XML - - - - - - XML - - doc = Taurus.parse(xml) - expect(doc.root.name).to eq("root") - end - - xit "tracks position through processing instructions" do - xml = <<~XML - - - - XML - - doc = Taurus.parse(xml) - expect(doc.root.name).to eq("root") - end - end -end \ No newline at end of file diff --git a/spec/taurus/parser_spec.rb b/spec/taurus/parser_spec.rb deleted file mode 100644 index 388cfb0..0000000 --- a/spec/taurus/parser_spec.rb +++ /dev/null @@ -1,296 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "Taurus XML Parser with Namespace Support" do - describe "basic XML parsing" do - it "parses simple XML without namespaces" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc).to be_a(Taurus::Document) - expect(doc.root).to be_a(Taurus::Element) - expect(doc.root.name).to eq("root") - expect(doc.root.nodes.size).to eq(1) - expect(doc.root.nodes.first.name).to eq("item") - expect(doc.root.nodes.first.text).to eq("content") - end - - it "parses XML with attributes" do - xml = 'text' - doc = Taurus.parse(xml) - - expect(doc.root.attributes["id"]).to eq("123") - expect(doc.root.nodes.first.attributes["attr"]).to eq("value") - expect(doc.root.nodes.first.text).to eq("text") - end - - it "parses nested elements" do - xml = 'deep' - doc = Taurus.parse(xml) - - parent = doc.root.nodes.first - expect(parent.name).to eq("parent") - expect(parent.nodes.first.name).to eq("child") - expect(parent.nodes.first.text).to eq("deep") - end - end - - describe "namespace parsing" do - it "parses default namespace declaration" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespace_uri).to eq("http://example.org") - expect(doc.root.namespace_prefix).to be_nil - end - - it "parses prefixed namespace declaration" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespaces.size).to eq(1) - expect(doc.root.namespaces.first[:prefix]).to eq("ex") - expect(doc.root.namespaces.first[:href]).to eq("http://example.org") - end - - it "parses multiple namespace declarations" do - xml = '' - doc = Taurus.parse(xml) - - expect(doc.root.namespaces.size).to eq(3) - - # Find each namespace - default_ns = doc.root.namespaces.find { |ns| ns[:prefix].nil? } - ex_ns = doc.root.namespaces.find { |ns| ns[:prefix] == "ex" } - other_ns = doc.root.namespaces.find { |ns| ns[:prefix] == "other" } - - expect(default_ns[:href]).to eq("http://default.org") - expect(ex_ns[:href]).to eq("http://example.org") - expect(other_ns[:href]).to eq("http://other.org") - end - - it "parses namespaced elements" do - xml = 'content' - doc = Taurus.parse(xml) - - item = doc.root.nodes.first - expect(item.name).to eq("item") # Local name only (Ox compatibility) - expect(item.qualified_name).to eq("ex:item") # Full qualified name with prefix - expect(item.namespace_prefix).to eq("ex") - expect(item.namespace_uri).to eq("http://example.org") - end - - it "parses namespaced attributes" do - xml = 'content' - doc = Taurus.parse(xml) - - item = doc.root.nodes.first - expect(item.attributes["ex:attr"]).to eq("value") - end - end - - describe "namespace inheritance" do - it "inherits default namespace to child elements" do - xml = 'content' - doc = Taurus.parse(xml) - - item = doc.root.nodes.first - expect(item.namespace_uri).to eq("http://example.org") - expect(item.namespace_prefix).to be_nil - end - - it "inherits prefixed namespace to child elements" do - xml = 'content' - doc = Taurus.parse(xml) - - item = doc.root.nodes.first - child = item.nodes.first - - expect(item.namespace_uri).to eq("http://example.org") - expect(child.namespace_uri).to eq("http://example.org") - end - - it "allows namespace redeclaration in child elements" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.namespace_uri).to eq("http://default.org") - expect(doc.root.nodes.first.namespace_uri).to eq("http://new.org") - end - end - - describe "namespace resolution" do - it "resolves prefixes using namespace_for_prefix" do - xml = '' - doc = Taurus.parse(xml) - - expect(doc.root.namespace_for_prefix("ex")).to eq("http://example.org") - expect(doc.root.namespace_for_prefix("other")).to eq("http://other.org") - expect(doc.root.namespace_for_prefix("nonexistent")).to be_nil - end - - it "resolves default namespace with nil prefix" do - xml = '' - doc = Taurus.parse(xml) - - expect(doc.root.namespace_for_prefix(nil)).to eq("http://default.org") - end - - it "resolves inherited namespaces" do - xml = '' - doc = Taurus.parse(xml) - - child = doc.root.nodes.first.nodes.first - expect(child.namespace_for_prefix("ex")).to eq("http://example.org") - end - end - - describe "complex namespace scenarios" do - it "handles mixed default and prefixed namespaces" do - xml = <<~XML - - default - prefixed - - XML - - doc = Taurus.parse(xml.strip) - - default_item = doc.root.nodes[0] - prefixed_item = doc.root.nodes[1] - - expect(default_item.namespace_uri).to eq("http://default.org") - expect(prefixed_item.namespace_uri).to eq("http://example.org") - expect(prefixed_item.namespace_prefix).to eq("ex") - end - - it "handles deeply nested namespaces" do - xml = <<~XML - - - - content - - - - XML - - doc = Taurus.parse(xml.strip) - - level1 = doc.root.nodes.first - level2 = level1.nodes.first - level3 = level2.nodes.first - - expect(level1.namespace_uri).to eq("http://root.org") - expect(level2.namespace_uri).to eq("http://root.org") - expect(level3.namespace_uri).to eq("http://root.org") - - expect(level1.namespace_for_prefix("a")).to eq("http://a.org") - expect(level1.namespace_for_prefix("b")).to eq("http://b.org") - expect(level2.namespace_for_prefix("c")).to eq("http://c.org") - end - end - - describe "error handling" do - it "handles malformed XML gracefully" do - xml = 'unclosed' - - expect { Taurus.parse(xml) }.to raise_error(Taurus::ParseError) - end - - it "handles mismatched tags" do - xml = '' - - expect { Taurus.parse(xml) }.to raise_error(Taurus::ParseError) - end - - it "handles invalid characters in names" do - xml = '<123invalid>content' - - expect { Taurus.parse(xml) }.to raise_error(Taurus::ParseError) - end - end - - describe "special XML features" do - it "parses comments" do - xml = 'content' - doc = Taurus.parse(xml) - - expect(doc.root.nodes.size).to eq(2) # Comment text + element - expect(doc.root.nodes[0]).to be_a(String) # The comment text - expect(doc.root.nodes[1].name).to eq("item") - end - - it "parses CDATA sections" do - xml = 'content]]>' - doc = Taurus.parse(xml) - - expect(doc.root.nodes.first.text).to include("content") - end - - it "parses self-closing elements" do - xml = '' - doc = Taurus.parse(xml) - - expect(doc.root.nodes.size).to eq(1) - expect(doc.root.nodes.first.name).to eq("item") - end - end - - describe "file parsing" do - it "parses XML from file" do - require 'tempfile' - - xml = 'content' - - Tempfile.create(['test', '.xml']) do |file| - file.write(xml) - file.close - - doc = Taurus.parse_file(file.path) - expect(doc.root.name).to eq("root") - expect(doc.root.nodes.first.name).to eq("item") - end - end - - it "handles missing file gracefully" do - expect { Taurus.parse_file("/nonexistent/file.xml") }.to raise_error(Errno::ENOENT) - end - end - - describe "all_namespaces method" do - it "returns all namespaces including inherited" do - xml = <<~XML - - - - - - XML - - doc = Taurus.parse(xml.strip) - - root = doc.root - child = root.nodes.first - grandchild = child.nodes.first - - expect(root.all_namespaces).to eq({ - nil => "http://root.org", - "a" => "http://a.org" - }) - - expect(child.all_namespaces).to eq({ - nil => "http://root.org", - "a" => "http://a.org", - "b" => "http://b.org" - }) - - expect(grandchild.all_namespaces).to eq({ - nil => "http://root.org", - "a" => "http://a.org", - "b" => "http://b.org" - }) - end - end -end \ No newline at end of file diff --git a/spec/taurus/xpath/lexer_spec.rb b/spec/taurus/xpath/lexer_spec.rb deleted file mode 100644 index f594607..0000000 --- a/spec/taurus/xpath/lexer_spec.rb +++ /dev/null @@ -1,256 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "Taurus::XPath.tokenize" do - describe "basic tokenization" do - it "tokenizes simple path expressions" do - tokens = Taurus::XPath.tokenize("/root/child") - - expect(tokens.size).to eq(4) - expect(tokens[0]).to include("type" => "SLASH", "value" => "/") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[2]).to include("type" => "SLASH", "value" => "/") - expect(tokens[3]).to include("type" => "NCNAME", "value" => "child") - end - - it "tokenizes descendant-or-self axis" do - tokens = Taurus::XPath.tokenize("//child") - - expect(tokens.size).to eq(2) - expect(tokens[0]).to include("type" => "DOUBLE_SLASH", "value" => "//") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "child") - end - - it "tokenizes attribute access" do - tokens = Taurus::XPath.tokenize("/root/@attr") - - expect(tokens.size).to eq(5) - expect(tokens[0]).to include("type" => "SLASH", "value" => "/") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[2]).to include("type" => "SLASH", "value" => "/") - expect(tokens[3]).to include("type" => "AT", "value" => "@") - expect(tokens[4]).to include("type" => "NCNAME", "value" => "attr") - end - - it "tokenizes self and parent references" do - tokens = Taurus::XPath.tokenize("./..") - - expect(tokens.size).to eq(3) - expect(tokens[0]).to include("type" => "DOT", "value" => ".") - expect(tokens[1]).to include("type" => "SLASH", "value" => "/") - expect(tokens[2]).to include("type" => "DOUBLE_DOT", "value" => "..") - end - end - - describe "operators" do - it "tokenizes comparison operators" do - tokens = Taurus::XPath.tokenize("a = b != c < d <= e > f >= g") - - expect(tokens.size).to eq(13) - expect(tokens[0]).to include("type" => "NCNAME", "value" => "a") - expect(tokens[2]).to include("type" => "NCNAME", "value" => "b") - expect(tokens[3]).to include("type" => "NOT_EQUALS", "value" => "!=") - expect(tokens[4]).to include("type" => "NCNAME", "value" => "c") - expect(tokens[5]).to include("type" => "LT", "value" => "<") - expect(tokens[7]).to include("type" => "LE", "value" => "<=") - expect(tokens[6]).to include("type" => "NCNAME", "value" => "d") - end - - it "tokenizes arithmetic operators" do - tokens = Taurus::XPath.tokenize("a + b - c * d div e mod f") - - expect(tokens.size).to eq(11) - expect(tokens[0]).to include("type" => "NCNAME", "value" => "a") - expect(tokens[1]).to include("type" => "PLUS", "value" => "+") - expect(tokens[2]).to include("type" => "NCNAME", "value" => "b") - expect(tokens[3]).to include("type" => "MINUS", "value" => "-") - expect(tokens[4]).to include("type" => "NCNAME", "value" => "c") - expect(tokens[5]).to include("type" => "STAR", "value" => "*") - expect(tokens[6]).to include("type" => "NCNAME", "value" => "d") - expect(tokens[7]).to include("type" => "DIV", "value" => "div") - expect(tokens[8]).to include("type" => "NCNAME", "value" => "e") - expect(tokens[9]).to include("type" => "MOD", "value" => "mod") - expect(tokens[10]).to include("type" => "NCNAME", "value" => "f") - end - - it "tokenizes logical operators" do - tokens = Taurus::XPath.tokenize("a and b or c") - - expect(tokens.size).to eq(5) - expect(tokens[1]).to include("type" => "AND", "value" => "and") - expect(tokens[3]).to include("type" => "OR", "value" => "or") - end - end - - describe "literals" do - it "tokenizes numbers" do - tokens = Taurus::XPath.tokenize("123 45.67") - - expect(tokens.size).to eq(2) - expect(tokens[0]).to include("type" => "NUMBER", "value" => "123") - expect(tokens[1]).to include("type" => "NUMBER", "value" => "45.67") - end - - it "tokenizes strings" do - tokens = Taurus::XPath.tokenize("'hello' \"world\"") - - expect(tokens.size).to eq(2) - expect(tokens[0]).to include("type" => "STRING", "value" => "'hello'") - expect(tokens[1]).to include("type" => "STRING", "value" => "\"world\"") - end - end - - describe "names and qnames" do - it "tokenizes NCNames" do - tokens = Taurus::XPath.tokenize("root child _private") - - expect(tokens.size).to eq(3) - expect(tokens[0]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "child") - expect(tokens[2]).to include("type" => "NCNAME", "value" => "_private") - end - - it "tokenizes QNames" do - tokens = Taurus::XPath.tokenize("ns:root prefix:child") - - expect(tokens.size).to eq(2) - expect(tokens[0]).to include("type" => "QNAME", "value" => "ns:root") - expect(tokens[1]).to include("type" => "QNAME", "value" => "prefix:child") - end - end - - describe "axes" do - it "tokenizes axis names" do - tokens = Taurus::XPath.tokenize("ancestor:: descendant-or-self:: following-sibling::") - - expect(tokens.size).to eq(6) - expect(tokens[0]).to include("type" => "ANCESTOR", "value" => "ancestor") - expect(tokens[1]).to include("type" => "DOUBLE_COLON", "value" => "::") - expect(tokens[2]).to include("type" => "DESCENDANT_OR_SELF", "value" => "descendant-or-self") - expect(tokens[3]).to include("type" => "DOUBLE_COLON", "value" => "::") - expect(tokens[4]).to include("type" => "FOLLOWING_SIBLING", "value" => "following-sibling") - expect(tokens[5]).to include("type" => "DOUBLE_COLON", "value" => "::") - end - - it "tokenizes all axis types" do - xpath = "ancestor:: ancestor-or-self:: attribute:: child:: descendant:: descendant-or-self:: following:: following-sibling:: namespace:: parent:: preceding:: preceding-sibling:: self::" - tokens = Taurus::XPath.tokenize(xpath) - - axis_types = tokens.select { |t| t["type"].end_with?("::") }.map { |t| t["type"] } - expect(axis_types).to be_empty # Should be DOUBLE_COLON - - axis_names = tokens.select { |t| xpath_token_is_axis_name?(t["type"]) } - expected_axes = %w[ANCESTOR ANCESTOR_OR_SELF ATTRIBUTE CHILD DESCENDANT DESCENDANT_OR_SELF FOLLOWING FOLLOWING_SIBLING NAMESPACE PARENT PRECEDING PRECEDING_SIBLING SELF] - expect(axis_names.map { |t| t["type"] }).to eq(expected_axes) - end - end - - describe "node types" do - it "tokenizes node type tests" do - tokens = Taurus::XPath.tokenize("comment() text() processing-instruction() node()") - - expect(tokens.size).to eq(12) - expect(tokens[0]).to include("type" => "COMMENT", "value" => "comment") - expect(tokens[1]).to include("type" => "LPAREN", "value" => "(") - expect(tokens[2]).to include("type" => "RPAREN", "value" => ")") - expect(tokens[3]).to include("type" => "TEXT", "value" => "text") - expect(tokens[4]).to include("type" => "LPAREN", "value" => "(") - expect(tokens[5]).to include("type" => "RPAREN", "value" => ")") - expect(tokens[6]).to include("type" => "PROCESSING_INSTRUCTION", "value" => "processing-instruction") - expect(tokens[7]).to include("type" => "LPAREN", "value" => "(") - expect(tokens[8]).to include("type" => "RPAREN", "value" => ")") - expect(tokens[9]).to include("type" => "NODE", "value" => "node") - expect(tokens[10]).to include("type" => "LPAREN", "value" => "(") - expect(tokens[11]).to include("type" => "RPAREN", "value" => ")") - end - end - - describe "complex expressions" do - it "tokenizes function calls" do - tokens = Taurus::XPath.tokenize("count(/root/child)") - - expect(tokens.size).to eq(7) - expect(tokens[0]).to include("type" => "NCNAME", "value" => "count") - expect(tokens[1]).to include("type" => "LPAREN", "value" => "(") - expect(tokens[2]).to include("type" => "SLASH", "value" => "/") - expect(tokens[3]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[4]).to include("type" => "SLASH", "value" => "/") - expect(tokens[5]).to include("type" => "NCNAME", "value" => "child") - expect(tokens[6]).to include("type" => "RPAREN", "value" => ")") - end - - it "tokenizes predicates" do - tokens = Taurus::XPath.tokenize("/root/child[1]/@attr") - - expect(tokens.size).to eq(10) - expect(tokens[0]).to include("type" => "SLASH", "value" => "/") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[2]).to include("type" => "SLASH", "value" => "/") - expect(tokens[3]).to include("type" => "NCNAME", "value" => "child") - expect(tokens[4]).to include("type" => "LBRACKET", "value" => "[") - expect(tokens[5]).to include("type" => "NUMBER", "value" => "1") - expect(tokens[6]).to include("type" => "RBRACKET", "value" => "]") - expect(tokens[7]).to include("type" => "SLASH", "value" => "/") - expect(tokens[8]).to include("type" => "AT", "value" => "@") - expect(tokens[9]).to include("type" => "NCNAME", "value" => "attr") - end - - it "tokenizes complex XPath expressions" do - xpath = "/library/book[@price < 20 and contains(title, 'Programming')]/author" - tokens = Taurus::XPath.tokenize(xpath) - - # Should have reasonable number of tokens - expect(tokens.size).to be > 10 - - # Should include various token types - token_types = tokens.map { |t| t["type"] } - expect(token_types).to include("SLASH") - expect(token_types).to include("NCNAME") - expect(token_types).to include("AT") - expect(token_types).to include("LT") - expect(token_types).to include("AND") - expect(token_types).to include("LBRACKET") - expect(token_types).to include("RBRACKET") - end - end - - describe "error handling" do - it "handles invalid characters" do - expect { Taurus::XPath.tokenize("invalid$char") }.to raise_error(RuntimeError) - end - - it "handles unterminated strings" do - expect { Taurus::XPath.tokenize("'unterminated") }.to raise_error(RuntimeError) - end - end - - describe "whitespace handling" do - it "ignores whitespace between tokens" do - tokens = Taurus::XPath.tokenize(" / root / child ") - - expect(tokens.size).to eq(4) - expect(tokens[0]).to include("type" => "SLASH", "value" => "/") - expect(tokens[1]).to include("type" => "NCNAME", "value" => "root") - expect(tokens[2]).to include("type" => "SLASH", "value" => "/") - expect(tokens[3]).to include("type" => "NCNAME", "value" => "child") - end - end - - describe "position information" do - it "provides line and column information" do - tokens = Taurus::XPath.tokenize("/root\n/child") - - expect(tokens.size).to eq(4) - expect(tokens[0]).to include("line" => 1, "column" => 1) - expect(tokens[1]).to include("line" => 1, "column" => 2) - expect(tokens[2]).to include("line" => 2, "column" => 1) - expect(tokens[3]).to include("line" => 2, "column" => 2) - end - end -end - -# Helper method for testing axis names -def xpath_token_is_axis_name?(type) - %w[ANCESTOR ANCESTOR_OR_SELF ATTRIBUTE CHILD DESCENDANT DESCENDANT_OR_SELF FOLLOWING FOLLOWING_SIBLING NAMESPACE PARENT PRECEDING PRECEDING_SIBLING SELF].include?(type) -end \ No newline at end of file diff --git a/spec/taurus/xpath/parser_spec.rb b/spec/taurus/xpath/parser_spec.rb deleted file mode 100644 index 490833f..0000000 --- a/spec/taurus/xpath/parser_spec.rb +++ /dev/null @@ -1,427 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "Taurus::XPath.parse" do - describe "primary expressions" do - it "parses number literals" do - ast = Taurus::XPath.parse("42") - expect(ast["type"]).to eq("NUMBER") - expect(ast["number_value"]).to eq(42.0) - end - - it "parses decimal numbers" do - ast = Taurus::XPath.parse("3.14") - expect(ast["type"]).to eq("NUMBER") - expect(ast["number_value"]).to eq(3.14) - end - - it "parses string literals with single quotes" do - ast = Taurus::XPath.parse("'hello'") - expect(ast["type"]).to eq("STRING") - expect(ast["value"]).to eq("hello") - end - - it "parses string literals with double quotes" do - ast = Taurus::XPath.parse('"world"') - expect(ast["type"]).to eq("STRING") - expect(ast["value"]).to eq("world") - end - - it "parses parenthesized expressions" do - ast = Taurus::XPath.parse("(42)") - expect(ast["type"]).to eq("NUMBER") - expect(ast["number_value"]).to eq(42.0) - end - - it "parses function calls with no arguments" do - ast = Taurus::XPath.parse("node()") - expect(ast["type"]).to eq("FUNCTION_CALL") - expect(ast["value"]).to eq("node") - expect(ast["children"]).to be_nil.or(be_empty) - end - - it "parses function calls with one argument" do - ast = Taurus::XPath.parse("count(//item)") - expect(ast["type"]).to eq("FUNCTION_CALL") - expect(ast["value"]).to eq("count") - expect(ast["children"]).to be_an(Array) - expect(ast["children"].size).to eq(1) - end - - it "parses function calls with multiple arguments" do - ast = Taurus::XPath.parse("substring('hello', 1, 3)") - expect(ast["type"]).to eq("FUNCTION_CALL") - expect(ast["value"]).to eq("substring") - expect(ast["children"].size).to eq(3) - end - end - - describe "arithmetic operators" do - it "parses addition" do - ast = Taurus::XPath.parse("1 + 2") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("PLUS") - expect(ast["children"].size).to eq(2) - end - - it "parses subtraction" do - ast = Taurus::XPath.parse("5 - 3") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("MINUS") - end - - it "parses multiplication" do - ast = Taurus::XPath.parse("2 * 3") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("MULTIPLY") - end - - it "parses division" do - ast = Taurus::XPath.parse("10 div 2") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("DIV") - end - - it "parses modulo" do - ast = Taurus::XPath.parse("10 mod 3") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("MOD") - end - - it "parses unary negation" do - ast = Taurus::XPath.parse("-5") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("NEGATION") - expect(ast["children"].size).to eq(1) - end - end - - describe "comparison operators" do - it "parses equality" do - ast = Taurus::XPath.parse("@id = '123'") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("EQUAL") - end - - it "parses inequality" do - ast = Taurus::XPath.parse("@type != 'hidden'") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("NOT_EQUAL") - end - - it "parses less than" do - ast = Taurus::XPath.parse("price < 20") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("LESS") - end - - it "parses less than or equal" do - ast = Taurus::XPath.parse("quantity <= 10") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("LESS_EQUAL") - end - - it "parses greater than" do - ast = Taurus::XPath.parse("price > 100") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("GREATER") - end - - it "parses greater than or equal" do - ast = Taurus::XPath.parse("age >= 18") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("GREATER_EQUAL") - end - end - - describe "logical operators" do - it "parses and operator" do - ast = Taurus::XPath.parse("@enabled and @visible") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("AND") - end - - it "parses or operator" do - ast = Taurus::XPath.parse("@type = 'admin' or @type = 'moderator'") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("OR") - end - - it "parses complex boolean expression" do - ast = Taurus::XPath.parse("(@enabled and @visible) or @forced") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("OR") - end - end - - describe "union operator" do - it "parses simple union" do - ast = Taurus::XPath.parse("//book | //magazine") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("UNION") - end - - it "parses multiple unions" do - ast = Taurus::XPath.parse("//book | //magazine | //newspaper") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("UNION") - # Should be left-associative: (book | magazine) | newspaper - end - end - - describe "operator precedence" do - it "handles multiplication before addition" do - ast = Taurus::XPath.parse("1 + 2 * 3") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("PLUS") - # Right child should be multiplication - expect(ast["children"][1]["operator"]).to eq("MULTIPLY") - end - - it "handles comparison before and" do - ast = Taurus::XPath.parse("@x = 1 and @y = 2") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("AND") - # Both children should be EQUAL - expect(ast["children"][0]["operator"]).to eq("EQUAL") - expect(ast["children"][1]["operator"]).to eq("EQUAL") - end - - it "handles and before or" do - ast = Taurus::XPath.parse("@a and @b or @c") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("OR") - # Left child should be AND - expect(ast["children"][0]["operator"]).to eq("AND") - end - - it "respects parentheses" do - ast = Taurus::XPath.parse("(1 + 2) * 3") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("MULTIPLY") - # Left child should be addition - expect(ast["children"][0]["operator"]).to eq("PLUS") - end - end - - describe "simple path expressions" do - it "parses absolute path with single step" do - ast = Taurus::XPath.parse("/root") - expect(ast["type"]).to eq("ABSOLUTE_PATH") - expect(ast["children"]).to be_an(Array) - end - - it "parses absolute path with multiple steps" do - ast = Taurus::XPath.parse("/root/child/grandchild") - expect(ast["type"]).to eq("ABSOLUTE_PATH") - rel_path = ast["children"][0] - expect(rel_path["type"]).to eq("RELATIVE_PATH") - expect(rel_path["children"].size).to eq(3) - end - - it "parses descendant-or-self shorthand" do - ast = Taurus::XPath.parse("//book") - expect(ast["type"]).to eq("ABSOLUTE_PATH") - # Should have descendant-or-self step - expect(ast["children"].size).to eq(2) - end - - it "parses relative path" do - ast = Taurus::XPath.parse("child/grandchild") - expect(ast["type"]).to eq("RELATIVE_PATH") - expect(ast["children"].size).to eq(2) - end - - it "parses self abbreviation" do - ast = Taurus::XPath.parse(".") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("self") - end - - it "parses parent abbreviation" do - ast = Taurus::XPath.parse("..") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("parent") - end - - it "parses attribute with @ abbreviation" do - ast = Taurus::XPath.parse("@id") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("attribute") - end - end - - describe "axis specifiers" do - it "parses child axis" do - ast = Taurus::XPath.parse("child::book") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("child") - end - - it "parses descendant axis" do - ast = Taurus::XPath.parse("descendant::item") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("descendant") - end - - it "parses parent axis" do - ast = Taurus::XPath.parse("parent::book") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("parent") - end - - it "parses ancestor axis" do - ast = Taurus::XPath.parse("ancestor::section") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("ancestor") - end - - it "parses following-sibling axis" do - ast = Taurus::XPath.parse("following-sibling::chapter") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("following-sibling") - end - - it "parses attribute axis" do - ast = Taurus::XPath.parse("attribute::id") - expect(ast["type"]).to eq("STEP") - expect(ast["value"]).to eq("attribute") - end - end - - describe "node tests" do - it "parses wildcard" do - ast = Taurus::XPath.parse("//*") - rel_path = ast["children"][1] - step = rel_path["children"][0] - node_test = step["children"][0] - expect(node_test["type"]).to eq("NODE_TEST_ALL") - end - - it "parses name test" do - ast = Taurus::XPath.parse("//book") - # Navigate to node test - rel_path = ast["children"][1] - step = rel_path["children"][0] - node_test = step["children"][0] - expect(node_test["type"]).to eq("NODE_TEST_NAME") - expect(node_test["value"]).to eq("book") - end - - it "parses text() node test" do - ast = Taurus::XPath.parse("//text()") - rel_path = ast["children"][1] - step = rel_path["children"][0] - node_test = step["children"][0] - expect(node_test["type"]).to eq("NODE_TEST_TYPE") - expect(node_test["value"]).to eq("text") - end - - it "parses comment() node test" do - ast = Taurus::XPath.parse("//comment()") - rel_path = ast["children"][1] - step = rel_path["children"][0] - node_test = step["children"][0] - expect(node_test["type"]).to eq("NODE_TEST_TYPE") - expect(node_test["value"]).to eq("comment") - end - - it "parses node() node test" do - ast = Taurus::XPath.parse("//node()") - rel_path = ast["children"][1] - step = rel_path["children"][0] - node_test = step["children"][0] - expect(node_test["type"]).to eq("NODE_TEST_TYPE") - expect(node_test["value"]).to eq("node") - end - end - - describe "predicates" do - it "parses simple predicate with position" do - ast = Taurus::XPath.parse("//book[1]") - # Navigate through structure - rel_path = ast["children"][1] - step = rel_path["children"][0] - # Step should have node test and predicate as children - expect(step["children"].size).to eq(2) - predicate = step["children"][1] - expect(predicate["type"]).to eq("NUMBER") - end - - it "parses predicate with attribute test" do - ast = Taurus::XPath.parse("//book[@id='123']") - rel_path = ast["children"][1] - step = rel_path["children"][0] - expect(step["children"].size).to eq(2) - predicate = step["children"][1] - expect(predicate["type"]).to eq("OPERATOR") - expect(predicate["operator"]).to eq("EQUAL") - end - - it "parses multiple predicates" do - ast = Taurus::XPath.parse("//book[@lang='en'][1]") - rel_path = ast["children"][1] - step = rel_path["children"][0] - # Should have node test + 2 predicates - expect(step["children"].size).to eq(3) - end - - it "parses nested predicates" do - ast = Taurus::XPath.parse("//section[chapter[@published='true']]") - rel_path = ast["children"][1] - step = rel_path["children"][0] - expect(step["children"].size).to eq(2) - end - end - - describe "complex expressions" do - it "parses path with multiple steps and predicates" do - ast = Taurus::XPath.parse("/library/books/book[@category='fiction'][1]/title") - expect(ast["type"]).to eq("ABSOLUTE_PATH") - end - - it "parses expression with function calls" do - ast = Taurus::XPath.parse("count(//book[price > 20])") - expect(ast["type"]).to eq("FUNCTION_CALL") - expect(ast["value"]).to eq("count") - end - - it "parses complex predicate with operators" do - ast = Taurus::XPath.parse("//book[price > 10 and price < 50]") - rel_path = ast["children"][1] - step = rel_path["children"][0] - predicate = step["children"][1] - expect(predicate["operator"]).to eq("AND") - end - - it "parses union with predicates" do - ast = Taurus::XPath.parse("//book[@type='new'] | //magazine[@type='new']") - expect(ast["type"]).to eq("OPERATOR") - expect(ast["operator"]).to eq("UNION") - end - - it "parses path continuing after filter expression" do - ast = Taurus::XPath.parse("(//book)[1]/title") - expect(ast["type"]).to eq("PATH_EXPR") - end - end - - describe "error handling" do - it "raises error for unterminated string" do - expect { Taurus::XPath.parse("'unterminated") }.to raise_error(RuntimeError, /Unterminated string/) - end - - it "raises error for unexpected token" do - expect { Taurus::XPath.parse("@") }.to raise_error(RuntimeError, /parsing error/) - end - - it "raises error for unmatched parenthesis" do - expect { Taurus::XPath.parse("(1 + 2") }.to raise_error(RuntimeError, /Expected '\)'/) - end - - it "raises error for unmatched bracket" do - expect { Taurus::XPath.parse("//book[1") }.to raise_error(RuntimeError, /Expected '\]'/) - end - end -end \ No newline at end of file diff --git a/spec/taurus/xpath_comparison_predicates_spec.rb b/spec/taurus/xpath_comparison_predicates_spec.rb deleted file mode 100644 index 8ffb672..0000000 --- a/spec/taurus/xpath_comparison_predicates_spec.rb +++ /dev/null @@ -1,196 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -RSpec.describe "XPath Comparison Predicates" do - let(:xml) do - <<~XML - - - - Ruby Basics - - - Advanced Ruby - - - Learning Ruby - - - Ruby Mastery - - - XML - end - - let(:doc) { Taurus.parse(xml) } - - describe "Greater than (>)" do - it "filters by price > 20" do - results = doc.xpath("//book[@price > 20]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "4") - end - - it "filters by stock > 3" do - results = doc.xpath("//book[@stock > 3]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "handles decimal comparisons" do - results = doc.xpath("//book[@price > 19.5]") - expect(results.size).to eq(3) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "2", "4") - end - end - - describe "Greater than or equal (>=)" do - it "filters by price >= 29.99" do - results = doc.xpath("//book[@price >= 29.99]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "4") - end - - it "filters by stock >= 5" do - results = doc.xpath("//book[@stock >= 5]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "includes exact matches" do - results = doc.xpath("//book[@price >= 19.99]") - expect(results.size).to eq(3) - end - end - - describe "Less than (<)" do - it "filters by price < 20" do - results = doc.xpath("//book[@price < 20]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "filters by stock < 5" do - results = doc.xpath("//book[@stock < 5]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "4") - end - - it "handles decimal comparisons" do - results = doc.xpath("//book[@price < 16]") - expect(results.size).to eq(1) - expect(results.first[:id]).to eq("3") - end - end - - describe "Less than or equal (<=)" do - it "filters by price <= 19.99" do - results = doc.xpath("//book[@price <= 19.99]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "filters by stock <= 3" do - results = doc.xpath("//book[@stock <= 3]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "4") - end - - it "includes exact matches" do - results = doc.xpath("//book[@price <= 15.50]") - expect(results.size).to eq(1) - end - end - - describe "Equality (=)" do - it "filters by exact price match" do - results = doc.xpath("//book[@price = 29.99]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "4") - end - - it "filters by exact stock match" do - results = doc.xpath("//book[@stock = 0]") - expect(results.size).to eq(1) - expect(results.first[:id]).to eq("4") - end - - it "handles string equality" do - results = doc.xpath("//book[@id = '1']") - expect(results.size).to eq(1) - expect(results.first[:id]).to eq("1") - end - end - - describe "Inequality (!=)" do - it "filters by price != 29.99" do - results = doc.xpath("//book[@price != 29.99]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "filters by stock != 0" do - results = doc.xpath("//book[@stock != 0]") - expect(results.size).to eq(3) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "2", "3") - end - end - - describe "Combined predicates" do - it "handles multiple comparison predicates" do - results = doc.xpath("//book[@price > 15 and @price < 25]") - expect(results.size).to eq(2) - expect(results.map { |b| b[:id] }).to contain_exactly("1", "3") - end - - it "handles comparison with position predicate" do - results = doc.xpath("//book[@price > 20][1]") - expect(results.size).to eq(1) - expect(results.first[:id]).to eq("2") - end - - it "handles OR conditions" do - results = doc.xpath("//book[@price < 16 or @price > 28]") - expect(results.size).to eq(3) - expect(results.map { |b| b[:id] }).to contain_exactly("2", "3", "4") - end - end - - describe "Edge cases" do - it "handles zero comparisons" do - results = doc.xpath("//book[@stock = 0]") - expect(results.size).to eq(1) - expect(results.first[:id]).to eq("4") - end - - it "handles empty results" do - results = doc.xpath("//book[@price > 100]") - expect(results).to be_empty - end - - it "handles comparison with non-numeric values gracefully" do - # If attribute doesn't exist or isn't numeric, should convert to NaN - # and comparisons with NaN are always false - results = doc.xpath("//book[@nonexistent > 5]") - expect(results).to be_empty - end - end - - describe "Type coercion" do - it "converts string attributes to numbers for comparison" do - results = doc.xpath("//book[@price > 20]") - expect(results.size).to eq(2) - end - - it "handles integer comparisons" do - results = doc.xpath("//book[@stock > 3]") - expect(results.size).to eq(2) - end - - it "handles float comparisons" do - results = doc.xpath("//book[@price > 19.5]") - expect(results.size).to eq(3) - end - end -end \ No newline at end of file diff --git a/spec/taurus/xpath_errors_spec.rb b/spec/taurus/xpath_errors_spec.rb deleted file mode 100644 index a6ff8fa..0000000 --- a/spec/taurus/xpath_errors_spec.rb +++ /dev/null @@ -1,280 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe 'XPath Error Messages' do - let(:xml) { 'textmore' } - let(:doc) { Taurus.parse(xml) } - - describe 'Syntax Errors' do - it 'reports incomplete path with position' do - expect { - doc.xpath('//') # Incomplete path - missing node test - }.to raise_error(Taurus::XPathError) do |error| - expect(error.message).to include('Expected') - expect(error.code).to eq(:xpath_syntax) - expect(error.line).to be > 0 - expect(error.column).to be > 0 - expect(error.context).not_to be_nil - end - end - - it 'reports unclosed predicate' do - expect { - doc.xpath('//item[') # Unclosed predicate - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include("Unexpected token") - expect(error.line).to eq(1) - end - end - - it 'reports unclosed parenthesis' do - expect { - doc.xpath('//item[position(') # Unclosed function call - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include("Unexpected token") - end - end - - it 'reports unexpected token after complete expression' do - expect { - doc.xpath('//item ]') # Extra closing bracket - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include('Unexpected token') - expect(error.column).to be > 0 - end - end - - it 'reports incomplete expression in predicate' do - expect { - doc.xpath('//item[@id = 1 and ]') # Incomplete and expression - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.line).to eq(1) - end - end - - it 'reports unterminated string literal' do - expect { - doc.xpath("//item[@id = 'test") # Missing closing quote - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include('Unexpected token') - end - end - - it 'reports invalid character in expression' do - expect { - doc.xpath('//item[@id = #123]') # Invalid # character - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include('Unexpected token') - end - end - - it 'reports unexpected colon outside QName' do - expect { - doc.xpath('//item/:child') # Invalid bare colon - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include('node test') - end - end - - it 'reports unexpected exclamation mark' do - expect { - doc.xpath('//item[!]') # Invalid ! without = - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - expect(error.message).to include('Unexpected token') - end - end - end - - describe 'Unknown Function Errors' do - it 'reports unknown function name' do - expect { - doc.xpath('unknown-function()') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.message).to include('unknown-function') - expect(error.code).to eq(:xpath_function) - end - end - - it 'reports unknown function with position' do - expect { - doc.xpath('not_a_real_xpath_function_xyz()') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_function) - expect(error.line).to eq(1) - expect(error.column).to be > 0 - end - end - end - - describe 'Error Context Snippets' do - it 'shows context for syntax errors at start' do - expect { - doc.xpath('[invalid') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.context).not_to be_nil - expect(error.context).to include('[invalid') - end - end - - it 'shows context for errors in middle of expression' do - expect { - doc.xpath('//item[@id = 1 and @name = ]') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.context).not_to be_nil - # Should show context around the error position - expect(error.context.length).to be > 0 - end - end - - it 'shows context for errors at end of expression' do - expect { - doc.xpath('//item[@id =') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.context).not_to be_nil - expect(error.context).to include('@id') - end - end - - it 'includes error position marker in context' do - expect { - doc.xpath('//item[') - }.to raise_error(Taurus::XPathError) do |error| - # Context should include a position marker (e.g., ^) - expect(error.context).to match(/\^|\|/) - end - end - end - - describe 'Position Tracking Accuracy' do - it 'reports correct line for single-line expressions' do - expect { - doc.xpath('//item[@invalid') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.line).to eq(1) - end - end - - it 'reports correct column for early errors' do - expect { - doc.xpath('[') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.column).to eq(1) - end - end - - it 'reports correct column for mid-expression errors' do - expect { - doc.xpath('//item[@id = &]') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.column).to be_between(14, 16) - end - end - - it 'reports correct position for EOF errors' do - expect { - doc.xpath('//item[position()') # Missing closing ] - }.to raise_error(Taurus::XPathError) do |error| - expect(error.line).to eq(1) - expect(error.column).to be > 15 - end - end - end - - describe 'Multiple Error Scenarios' do - it 'reports first error when multiple issues exist' do - expect { - doc.xpath('//item[[@id]') # Double [[ - first error should be reported - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - # Should report the first [ issue - end - end - - it 'provides helpful message for common mistakes' do - expect { - doc.xpath('//item[!@id]') # Should be 'not(@id)' - }.to raise_error(Taurus::XPathError) do |error| - expect(error.message).to include('Unexpected token') - end - end - end - - describe 'Error Message Quality' do - it 'includes expression text in error for short expressions' do - expect { - doc.xpath('[') - }.to raise_error(Taurus::XPathError) do |error| - # Context should include the invalid expression - expect(error.context).to include('[') - end - end - - it 'provides clear description of what was expected' do - expect { - doc.xpath('//item[') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.message).to match(/expected|missing/i) - end - end - - it 'identifies token type that caused error' do - expect { - doc.xpath('//item ]') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.message).to include('RBRACKET') - end - end - end - - describe 'Regression Tests' do - it 'handles valid expressions without errors' do - expect { doc.xpath('//item') }.not_to raise_error - expect { doc.xpath('//item[@id]') }.not_to raise_error - expect { doc.xpath('//item[1]') }.not_to raise_error - expect { doc.xpath('//item[@id="1"]') }.not_to raise_error - end - - it 'maintains existing XPath functionality' do - result = doc.xpath('//item[@id="1"]') - expect(result).to be_an(Array) - expect(result.length).to eq(1) - end - end - - describe 'Edge Cases' do - it 'handles empty expression' do - expect { - doc.xpath('') - }.to raise_error(Taurus::ParseError) do |error| - expect(error.code).to eq(:empty_input) - end - end - - it 'handles whitespace-only expression' do - expect { - doc.xpath(' ') - }.to raise_error(Taurus::XPathError) do |error| - expect(error.code).to eq(:xpath_syntax) - end - end - - it 'handles very long error positions correctly' do - long_path = '//item' + ('[@id]' * 50) + '[' - expect { - doc.xpath(long_path) - }.to raise_error(Taurus::XPathError) do |error| - expect(error.line).to eq(1) - expect(error.column).to be > 100 - end - end - end -end \ No newline at end of file diff --git a/spec/taurus/xpath_functions_spec.rb b/spec/taurus/xpath_functions_spec.rb deleted file mode 100644 index ce060b5..0000000 --- a/spec/taurus/xpath_functions_spec.rb +++ /dev/null @@ -1,180 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe "XPath Functions" do - describe "last() function" do - it "returns the last element in a nodeset" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "works with position comparison" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "works in complex paths" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section/item[last()]') - expect(result.size).to eq(1) - end - - it "works with descendant axis" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('descendant::*[last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "works with different node counts" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('item') - end - - it "works with empty nodeset" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[last()]') - expect(result).to be_empty - end - - it "can be used in arithmetic expressions" do - xml = '' - doc = parse(xml) - # last() - 1 should select the 3rd element (c) - result = doc.root.xpath('*[position() = last() - 1]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "works with multiple predicates" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('item[@id][last()]') - expect(result.size).to eq(1) - expect(result.first[:id]).to eq('3') - end - end - - describe "position() function" do - it "returns the position of each node" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = 1]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('a') - end - - it "works with position 2" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = 2]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - - it "works with position 3" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = 3]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "can be compared with last()" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = last()]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('c') - end - - it "works with greater than operator" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() > 2]') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['c', 'd']) - end - - it "works with less than operator" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() < 3]') - expect(result.size).to eq(2) - expect(result.map(&:name)).to eq(['a', 'b']) - end - - it "works with arithmetic" do - xml = '' - doc = parse(xml) - # position() + 1 = 3 means position 2 - result = doc.root.xpath('*[position() + 1 = 3]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('b') - end - - it "works in complex paths" do - xml = '
' - doc = parse(xml) - result = doc.root.xpath('section/item[position() = 2]') - expect(result.size).to eq(1) - end - - it "works with descendant axis" do - xml = '
' - doc = parse(xml) - # descendant::* gives [section, a, b, c], position 2 is 'a' - result = doc.root.xpath('descendant::*[position() = 2]') - expect(result.size).to eq(1) - expect(result.first.name).to eq('a') - end - - it "returns empty for out of range position" do - xml = '' - doc = parse(xml) - result = doc.root.xpath('*[position() = 10]') - expect(result).to be_empty - end - end - - describe "function call error handling" do - it "handles unknown function gracefully" do - xml = '' - doc = parse(xml) - expect { - doc.root.xpath('*[unknown-function()]') - }.to raise_error(RuntimeError, /Unknown function/) - end - - it "validates argument count for last()" do - xml = '' - doc = parse(xml) - # last() takes no arguments, this should fail at evaluation - # Note: This might be caught by parser first - expect { - doc.root.xpath('*[last(1)]') - }.to raise_error(RuntimeError) - end - - it "validates argument count for position()" do - xml = '' - doc = parse(xml) - expect { - doc.root.xpath('*[position(1)]') - }.to raise_error(RuntimeError) - end - end -end \ No newline at end of file diff --git a/spec/taurus_spec.rb b/spec/taurus_spec.rb deleted file mode 100644 index 146e29a..0000000 --- a/spec/taurus_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" -require "taurus/document" - -RSpec.describe Taurus do - it "has a version number" do - expect(Taurus::VERSION).not_to be nil - end - - it "can parse XML" do - xml = "test" - doc = Taurus.parse(xml) - - expect(doc).to be_a(Taurus::Document) - expect(doc.root.name).to eq("root") - expect(doc.root.text).to eq("test") - end -end diff --git a/spec/xml/c14n_spec.rb b/spec/xml/c14n_spec.rb new file mode 100644 index 0000000..be712ad --- /dev/null +++ b/spec/xml/c14n_spec.rb @@ -0,0 +1,192 @@ +# frozen_string_literal: true + +require "taurus/xml" + +# C14N (Canonical XML) coverage. Exercises the v0.5.2 taurus_c14n_canonicalize_ex +# and taurus_c14n_canonicalize_subtree_ex entry points via the Ruby API. +# +# Each spec asserts the *shape* of canonical output (XML canonical form rules: +# UTF-8, normalized line endings, lexicographic attribute ordering, namespace +# declaration ordering, empty element expansion, entity/char ref expansion, +# double-quoted attribute values). Exact byte-equality against Nokogiri +# would be ideal but pulls in a heavy dependency; these specs check the +# canonicalization rules from the W3C C14N 1.0 spec. + +RSpec.describe "C14N via libtaurus" do + let(:simple_xml) { "text" } + + describe "Document#canonicalize — default (canonical 1.0, no comments)" do + it "returns canonical XML as a String" do + out = Taurus::XML::Document.parse(simple_xml).canonicalize + expect(out).to be_a(String) + expect(out).to include("") + expect(out).to include("" do + out = Taurus::XML::Document.parse("").canonicalize + expect(out).to include("") + expect(out).not_to include("") + end + + it "uses double quotes for attribute values" do + out = Taurus::XML::Document.parse(%q{}).canonicalize + expect(out).to include('a="1"') + end + + it "sorts attributes lexicographically" do + out = Taurus::XML::Document.parse(%q{}).canonicalize + expect(out).to include('a="2" m="3" z="1"') + end + + it "expands required character references in text (< and &)" do + # Per XML 1.0 / C14N 1.0, only < and & MUST be escaped in text content. + # > need not be escaped (libtaurus leaves it literal). + out = Taurus::XML::Document.parse("<&>").canonicalize + expect(out).to include("<&") + end + + it "preserves comments when with_comments: true" do + out = Taurus::XML::Document.parse("") + .canonicalize(with_comments: true) + expect(out).to include("") + end + + it "strips comments by default" do + out = Taurus::XML::Document.parse("").canonicalize + expect(out).not_to include("") + end + + it "supports C14N 1.1 mode" do + out = Taurus::XML::Document.parse(simple_xml) + .canonicalize(Taurus::XML::FFI::C14N_1_1) + expect(out).to include("") + expect(out).to include("") + a = doc.root.first_element_child + sub = a.canonicalize + expect(sub).to include("") + expect(sub).to include("").or include("") + expect(sub).not_to include("") + expect(sub).not_to include("") + end + + it "supports with_comments: true on subtree" do + doc = Taurus::XML::Document.parse("") + a = doc.root + expect(a.canonicalize(with_comments: true)).to include("") + end + end + + describe "exclusive C14N (mode: :exclusive)" do + let(:nsdoc) do + Taurus::XML::Document.parse(<<~XML) + + text + + XML + end + + it "drops namespace declarations not visibly used (canonical keeps them all)" do + canonical = nsdoc.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_CANONICAL) + exclusive = nsdoc.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_EXCLUSIVE) + # Both should produce valid output; exact difference is implementation- + # specific. Just verify both run and produce strings including the root. + expect(canonical).to be_a(String) + expect(exclusive).to be_a(String) + expect(canonical.length).to be > 0 + expect(exclusive.length).to be > 0 + end + + it "accepts the `exclusive: true` shortcut" do + explicit = nsdoc.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_EXCLUSIVE) + shortcut = nsdoc.canonicalize(exclusive: true) + expect(shortcut).to eq(explicit) + end + + it "passes inclusive namespace prefixes" do + # Build a doc that uses a prefix visible only at root level + doc = Taurus::XML::Document.parse(<<~XML) + + + + XML + # Without inclusive namespaces, exclusive C14N keeps only visibly-used prefixes. + # With "ds" in inclusive list, libtaurus includes the declaration even if + # a consumer needs to know about it. Both should produce strings. + si = doc.at_xpath("//ds:SignedInfo", + { "ds" => "http://www.w3.org/2000/09/xmldsig#" }) + expect(si).not_to be_nil + without = si.canonicalize(Taurus::XML::FFI::C14N_1_0, nil, exclusive: true) + with = si.canonicalize(Taurus::XML::FFI::C14N_1_0, %w[ds], exclusive: true) + expect(without).to be_a(String) + expect(with).to be_a(String) + end + end + + describe "alias #c14n" do + it "matches #canonicalize" do + doc = Taurus::XML::Document.parse(simple_xml) + expect(doc.c14n).to eq(doc.canonicalize) + end + end + + describe "Nokogiri-compatible signature" do + it "accepts (mode, inclusive_namespaces, with_comments) positional args" do + # The first positional arg is the version (C14N_1_0 / C14N_1_1); + # the rest are keyword args matching Nokogiri-style usage. + doc = Taurus::XML::Document.parse(simple_xml) + out = doc.canonicalize(Taurus::XML::FFI::C14N_1_0, nil, with_comments: false) + expect(out).to include("") + end + end +end + +RSpec.describe "Element namespace mutation (v0.5.2 #181 fix)" do + it "adds a namespace declaration via #add_namespace_definition" do + doc = Taurus::XML::Document.parse("") + ns = doc.root.add_namespace_definition("foo", "http://foo.example") + expect(ns).to be_a(Taurus::XML::Namespace) + expect(ns.prefix).to eq("foo") + expect(ns.href).to eq("http://foo.example") + end + + it "adds a default namespace via #default_namespace=" do + doc = Taurus::XML::Document.parse("") + doc.root.default_namespace = "http://default.example" + decls = doc.root.namespace_definitions + expect(decls.map(&:href)).to include("http://default.example") + default_decl = decls.find { |n| n.prefix.nil? } + expect(default_decl&.href).to eq("http://default.example") + end + + it "removes a namespace declaration via #remove_namespace_definition" do + doc = Taurus::XML::Document.parse("") + doc.root.add_namespace_definition("foo", "http://foo.example") + doc.root.remove_namespace_definition("foo") + expect(doc.root.namespace_definitions.length).to eq(0) + end +end + +RSpec.describe "previous_sibling for non-element nodes (v0.5.2 #179 fix)" do + it "walks backward through text nodes via FFI (no workaround)" do + doc = Taurus::XML::Document.parse("middle") + b = doc.root.element_children[1] + text = b.previous_sibling + expect(text).to be_a(Taurus::XML::Text) + a = text.previous_sibling + expect(a).to be_a(Taurus::XML::Element) + expect(a.name).to eq("a") + end + + it "returns nil at the start of the sibling chain" do + doc = Taurus::XML::Document.parse("") + a = doc.root.first_element_child + expect(a.previous_sibling).to be_nil + end +end diff --git a/spec/xml/css_spec.rb b/spec/xml/css_spec.rb new file mode 100644 index 0000000..6e9d8e6 --- /dev/null +++ b/spec/xml/css_spec.rb @@ -0,0 +1,167 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe "Taurus::XML CSS selectors (minimal Nokogiri subset)" do + let(:doc) do + Taurus::XML::Document.parse(<<~HTML) + + + + + + HTML + end + + describe "tag selectors" do + it "matches by tag name" do + expect(doc.css("h1").map(&:content)).to eq(["Title"]) + expect(doc.css("p").length).to eq(2) + end + + it "matches * as wildcard" do + all = doc.css("*") + # Every element in the tree: html, body, div, h1, p, p, ul, li, li, li, a + expect(all.length).to be >= 11 + end + end + + describe "class selectors" do + it "matches .class" do + items = doc.css(".item") + expect(items.length).to eq(3) + expect(items.map(&:content)).to eq(%w[A B C]) + end + + it "matches tag.class" do + leads = doc.css("p.lead") + expect(leads.length).to eq(1) + expect(leads.first.content).to eq("Intro") + end + end + + describe "id selectors" do + it "matches #id" do + main = doc.css("#main") + expect(main.length).to eq(1) + expect(main.first["id"]).to eq("main") + end + + it "matches tag#id" do + div = doc.css("div#main") + expect(div.length).to eq(1) + end + end + + describe "attribute selectors" do + it "matches [attr]" do + with_href = doc.css("[href]") + expect(with_href.length).to eq(1) + expect(with_href.first.name).to eq("a") + end + + it "matches [attr=val]" do + links = doc.css(%q{[href='http://example.com']}) + expect(links.length).to eq(1) + end + + it "matches tag[attr=val]" do + a = doc.css("a[href='http://example.com']") + expect(a.first.content).to eq("Link") + end + end + + describe "descendant / child combinators" do + it "matches descendant (whitespace)" do + lis = doc.css("ul li") + expect(lis.length).to eq(3) + end + + it "matches direct child (>)" do + direct = doc.css("ul > li") + expect(direct.length).to eq(3) + # body > p should match both

children of body + body_ps = doc.css("body > div > p") + expect(body_ps.length).to eq(2) + end + + it "matches nested chains" do + special = doc.css("div#main ul li.special") + expect(special.length).to eq(1) + expect(special.first.content).to eq("B") + end + end + + describe "comma-separated multi-selectors" do + it "matches h1, h2, h3" do + result = doc.css("h1, h2, h3") + expect(result.map(&:name)).to eq(%w[h1]) + end + + it "matches div.container, p.lead" do + result = doc.css("div.container, p.lead") + expect(result.length).to eq(2) + end + end + + describe "pseudo-classes" do + it "matches :first-child" do + first = doc.css("li:first-child") + expect(first.length).to eq(1) + expect(first.first.content).to eq("A") + end + + it "matches :last-child" do + last = doc.css("li:last-child") + expect(last.length).to eq(1) + expect(last.first.content).to eq("C") + end + + it "matches tag:first-child on tag" do + first_p = doc.css("p:first-child") + # First

child of body — but body's first child is div, so this + # should return empty (no

is the first child of its parent). + expect(first_p.length).to eq(0) + end + end + + describe "at_css (first match)" do + it "returns the first matching node" do + lead = doc.at_css("p.lead") + expect(lead.content).to eq("Intro") + end + + it "returns nil if no match" do + expect(doc.at_css("nomatch")).to be_nil + end + end + + describe "search (auto-detect CSS vs XPath)" do + it "uses CSS when input doesn't look like XPath" do + result = doc.search("li.item") + expect(result.length).to eq(3) + end + + it "uses XPath when input looks like XPath" do + result = doc.search("//li") + expect(result.length).to eq(3) + end + end + + describe "unsupported selectors" do + it "raises ArgumentError for :nth-child(n)" do + expect { doc.css("li:nth-child(2)") } + .to raise_error(ArgumentError, /unsupported pseudo-class/) + end + end +end diff --git a/spec/xml/document_spec.rb b/spec/xml/document_spec.rb new file mode 100644 index 0000000..6857264 --- /dev/null +++ b/spec/xml/document_spec.rb @@ -0,0 +1,175 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe Taurus::XML::Document do + describe ".parse" do + it "parses a simple XML string into a Document" do + doc = described_class.parse("Hello") + expect(doc).to be_a(described_class) + expect(doc).to respond_to(:root) + end + + it "raises ParseError on malformed input" do + expect { described_class.parse("") }.to raise_error(Taurus::XML::ParseError) + end + + it "accepts an IO object (responds to :read)" do + require "stringio" + io = StringIO.new("text") + doc = described_class.parse(io) + expect(doc.root.name).to eq("root") + end + end + + describe "#root" do + it "returns the root element" do + doc = described_class.parse("") + root = doc.root + expect(root).to be_a(Taurus::XML::Element) + expect(root.name).to eq("library") + end + + it "returns nil for empty document" do + # libtaurus parses an empty/whitespace doc to no root + doc = described_class.parse("") + expect(doc.root.name).to eq("x") + end + end + + describe "#free" do + it "can be called explicitly without error" do + doc = described_class.parse("") + expect { doc.free }.not_to raise_error + end + + it "is idempotent" do + doc = described_class.parse("") + doc.free + expect { doc.free }.not_to raise_error + end + end +end + +RSpec.describe Taurus::XML::Element do + let(:doc) { Taurus::XML::Document.parse(<<~XML) } + + Ruby + XML + + XML + let(:root) { doc.root } + + it "exposes element name" do + expect(root.name).to eq("library") + end + + it "exposes element text content (concatenated descendants)" do + expect(root.content).to include("Ruby").and include("XML") + end + + it "exposes attribute lookup via #[name]" do + expect(root["version"]).to eq("2.0") + expect(root["nonexistent"]).to be_nil + end + + it "exposes attribute keys and values" do + expect(root.keys).to eq(["version"]) + expect(root.values).to eq(["2.0"]) + end + + it "exposes the attributes hash" do + expect(root.attributes).to be_a(Hash) + expect(root.attributes.keys).to eq(["version"]) + expect(root.attributes["version"]).to be_a(Taurus::XML::Attr) + expect(root.attributes["version"].value).to eq("2.0") + end + + it "iterates element children" do + children = root.element_children.to_a + expect(children.length).to eq(2) + expect(children.map(&:name)).to eq(%w[book book]) + end + + it "iterates all children (elements + text)" do + all = root.children.to_a + expect(all.length).to be >= 2 + expect(all.first).to be_a(Taurus::XML::Text) # whitespace before first + end + + it "exposes first_element_child and last_element_child" do + expect(root.first_element_child["id"]).to eq("1") + expect(root.last_element_child["id"]).to eq("2") + end + + it "exposes parent navigation" do + book = root.first_element_child + expect(book.parent).to eq(root) + end + + it "exposes sibling navigation" do + book1 = root.first_element_child + book2 = book1.next_element + expect(book2["id"]).to eq("2") + expect(book2.previous_element).to eq(book1) + end +end + +RSpec.describe Taurus::XML::Node do + describe "type predicates" do + it "recognizes element nodes" do + doc = Taurus::XML::Document.parse("") + expect(doc.root.element?).to be true + expect(doc.root.text?).to be false + end + + it "recognizes text nodes" do + doc = Taurus::XML::Document.parse("hello") + text = doc.root.child + expect(text).to be_a(Taurus::XML::Text) + expect(text.text?).to be true + expect(text.element?).to be false + expect(text.content).to eq("hello") + end + + it "recognizes comment nodes" do + doc = Taurus::XML::Document.parse("") + comment = doc.root.children.find { |n| n.comment? } + expect(comment).to be_a(Taurus::XML::Comment) + expect(comment.content).to eq(" hi ") + end + + it "recognizes CDATA nodes" do + doc = Taurus::XML::Document.parse("]]>") + cdata = doc.root.children.find { |n| n.cdata? } + expect(cdata).to be_a(Taurus::XML::CDATA) + expect(cdata.content).to eq("") + end + + it "recognizes processing instruction nodes" do + doc = Taurus::XML::Document.parse("") + pi = doc.root.children.find { |n| n.processing_instruction? } + expect(pi).to be_a(Taurus::XML::ProcessingInstruction) + expect(pi.name).to eq("xml-stylesheet") + end + end + + describe "navigation" do + it "walks siblings via next_sibling" do + doc = Taurus::XML::Document.parse("") + root = doc.root + a = root.first_element_child + b = a.next_sibling + c = b.next_sibling + expect(c.name).to eq("c") + expect(c.next_sibling).to be_nil + end + + it "walks all children via children.each" do + doc = Taurus::XML::Document.parse("") + root = doc.root + names = root.children.select(&:element?).map(&:name) + expect(names).to eq(%w[a b c]) + end + end +end diff --git a/spec/xml/exclusive_c14n_spec.rb b/spec/xml/exclusive_c14n_spec.rb new file mode 100644 index 0000000..0c4c478 --- /dev/null +++ b/spec/xml/exclusive_c14n_spec.rb @@ -0,0 +1,171 @@ +# frozen_string_literal: true + +require "taurus/xml" + +# Real W3C Exclusive XML Canonicalization 1.0 (https://www.w3.org/2001/10/xml-exc-c14n#) +# coverage. v0.5.3 shipped the real algorithm; v0.5.2 was a stub routed to +# canonical. These specs assert the algorithm's distinguishing behaviors: +# +# 1. Visibly-used namespace prefixes are emitted on the element that uses them. +# 2. Unused inherited namespace prefixes are dropped (vs canonical, which keeps +# them in scope). +# 3. Caller-supplied inclusive namespace prefixes are force-included. +# 4. Output differs from canonical mode for the same input on namespace-heavy XML. + +RSpec.describe "Exclusive C14N (v0.5.3 #183 real implementation)" do + # Classic W3C exc-c14n example: ancestor declares two prefixes, + # uses n1, uses n2. Exclusive should emit each declaration on the + # element that uses it, not duplicate either on the other. + let(:xml) do + <<~XML + + + + + + XML + end + let(:doc) { Taurus::XML::Document.parse(xml) } + let(:b) { doc.root.first_element_child } + + describe "visibly-used prefix emission" do + it "emits xmlns:n1 on because n1 is visibly used there" do + exclusive = b.canonicalize(exclusive: true) + expect(exclusive) + .to match(%r{}) + end + + it "emits xmlns:n2 on because n2 is visibly used there" do + exclusive = b.canonicalize(exclusive: true) + expect(exclusive) + .to match(%r{}) + end + + it "does NOT emit xmlns:n2 on (visibly unused there)" do + exclusive = b.canonicalize(exclusive: true) + # The open tag itself must not declare n2. + b_open = exclusive[/]*>/] + expect(b_open).not_to include("xmlns:n2") + end + + it "does NOT emit xmlns:n1 on (visibly unused there)" do + exclusive = b.canonicalize(exclusive: true) + c_open = exclusive[/]*>/] + expect(c_open).not_to include("xmlns:n1") + end + end + + describe "canonical vs exclusive output differs" do + it "produces different output for the same namespace-heavy input" do + canonical = b.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_CANONICAL) + exclusive = b.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_EXCLUSIVE) + expect(canonical).not_to eq(exclusive) + end + + it "matches via the exclusive: true shortcut" do + explicit = b.canonicalize(mode: Taurus::XML::FFI::C14N_MODE_EXCLUSIVE) + shortcut = b.canonicalize(exclusive: true) + expect(shortcut).to eq(explicit) + end + end + + describe "inclusive namespace prefixes (caller force-include list)" do + it "force-includes a prefix the subtree doesn't visibly use" do + # only visibly uses n1. Force-include n2 in the output of + # via the inclusive list — useful for enveloped-signature cases. + out = b.canonicalize(Taurus::XML::FFI::C14N_1_0, %w[n2], exclusive: true) + b_open = out[/]*>/] + expect(b_open).to include("xmlns:n1=") + expect(b_open).to include("xmlns:n2=") + end + + it "force-includes a prefix not declared anywhere in scope" do + # 'undeclared' isn't in the document at all. libtaurus should still + # produce output (the prefix just won't resolve, but it shouldn't crash). + out = b.canonicalize(Taurus::XML::FFI::C14N_1_0, %w[undeclared], exclusive: true) + expect(out).to be_a(String) + expect(out).to include(" (its attribute) AND we ask to force-include n1. + out = b.canonicalize(Taurus::XML::FFI::C14N_1_0, %w[n1], exclusive: true) + b_open = out[/]*>/] + expect(b_open.scan(/xmlns:n1=/).length).to eq(1), + "expected exactly one xmlns:n1= on , got: #{b_open}" + end + + it "does not duplicate xmlns even when multiple prefixes overlap" do + # n1 is visibly used on , n2 is visibly used on . Force-include both. + # Per W3C exc-c14n §2.4, inclusive prefixes render on the apex element + # of the canonicalized subtree, so both xmlns:n1 and xmlns:n2 land on . + # then does NOT re-declare xmlns:n2 because the ancestor in the + # output already has it. + out = b.canonicalize(Taurus::XML::FFI::C14N_1_0, %w[n1 n2], exclusive: true) + b_open = out[/]*>/] + c_open = out[/]*>/] + expect(b_open.scan(/xmlns:n1=/).length).to eq(1), + "apex should declare xmlns:n1 exactly once" + expect(b_open.scan(/xmlns:n2=/).length).to eq(1), + "apex should declare xmlns:n2 once (force-included via inclusive list)" + expect(c_open.scan(/xmlns:n2=/).length).to eq(0), + " must not re-declare xmlns:n2 (already rendered by output ancestor)" + expect(c_open.scan(/xmlns:n1=/).length).to eq(0), + " must not declare xmlns:n1 (visibly unused there)" + end + end + + describe "subtree vs document scope" do + it "Element#canonicalize operates on the element's subtree" do + exclusive_subtree = b.canonicalize(exclusive: true) + # Subtree output starts with , not + expect(exclusive_subtree).to match(/\A\s* element. Exclusive C14N is used to canonicalize the + # signed subtree. A prefix declared on the enveloping ancestor is only + # emitted on the element that visibly uses it — never duplicated on + # descendants that don't. + it "emits a visibly-used declaration on the using element only" do + xml = <<~XML + + + + IBM + + + + XML + doc = Taurus::XML::Document.parse(xml) + body = doc.at_xpath("//soap:Body", + { "soap" => "http://schemas.xmlsoap.org/soap/envelope/" }) + expect(body).not_to be_nil + + exclusive = body.canonicalize(exclusive: true) + # soap:Body visibly uses soap (its own element name) → emit xmlns:soap on Body + body_open = exclusive[/]*>/] + expect(body_open).to include("xmlns:soap=") + # m:GetPrice visibly uses m → emit xmlns:m on GetPrice + expect(exclusive).to include("]*>/] + expect(getprice_open).to include("xmlns:m=") + # m:Symbol doesn't re-emit xmlns:m (already declared by visible ancestor in output) + symbol_open = exclusive[/]*>/] + expect(symbol_open).not_to include("xmlns:m=") + end + end +end diff --git a/spec/xml/ffi_spec.rb b/spec/xml/ffi_spec.rb new file mode 100644 index 0000000..4347814 --- /dev/null +++ b/spec/xml/ffi_spec.rb @@ -0,0 +1,201 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe Taurus::XML::FFI do + describe "library loading" do + it "is attached to libtaurus shared library" do + expect(described_class).to be_a(Module) + end + + it "exposes taurus_version as an attached function" do + expect(described_class).to respond_to(:taurus_version) + end + + it "returns a version string from taurus_version" do + version = described_class.taurus_version + expect(version).to be_a(String) + expect(version).to match(/\A\d+\.\d+\.\d+/) + end + end + + describe "document lifecycle" do + it "attaches taurus_parse_string and taurus_document_free" do + expect(described_class).to respond_to(:taurus_parse_string) + expect(described_class).to respond_to(:taurus_document_free) + expect(described_class).to respond_to(:taurus_document_root) + end + + it "attaches taurus_document_serialize and taurus_element_serialize" do + expect(described_class).to respond_to(:taurus_document_serialize) + expect(described_class).to respond_to(:taurus_element_serialize) + end + + it "attaches taurus_c14n_canonicalize" do + expect(described_class).to respond_to(:taurus_c14n_canonicalize) + end + end + + describe "node traversal" do + it "attaches the taurus_node_* family" do + %i[ + taurus_node_get_type + taurus_node_first_child + taurus_node_last_child + taurus_node_next_sibling + taurus_node_previous_sibling + taurus_node_child_count + taurus_node_as_element + taurus_element_as_node + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + end + + describe "element operations" do + it "attaches element query functions" do + %i[ + taurus_element_name + taurus_element_text + taurus_element_attribute + taurus_element_attribute_count + taurus_element_attribute_name_at + taurus_element_attribute_value_at + taurus_element_parent + taurus_element_first_child_any + taurus_element_last_child_any + taurus_element_next_sibling_any + taurus_element_previous_sibling_any + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + + it "attaches element mutation functions" do + %i[ + taurus_element_create + taurus_element_set_name + taurus_element_set_attribute + taurus_element_remove_attribute + taurus_element_remove_child + taurus_element_remove_children + taurus_element_append_child + taurus_element_prepend_child + taurus_element_insert_before + taurus_element_insert_after + taurus_element_set_text + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + end + + describe "typed-node content getters" do + it "attaches content getters for text/comment/cdata/pi" do + %i[ + taurus_text_node_get_content + taurus_comment_node_get_content + taurus_cdata_node_get_content + taurus_pi_node_get_target + taurus_pi_node_get_data + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + end + + describe "XPath" do + it "attaches the full xpath surface" do + %i[ + taurus_xpath_eval + taurus_xpath_eval_with_vars + taurus_xpath_result_type + taurus_xpath_result_count + taurus_xpath_result_get + taurus_xpath_result_boolean + taurus_xpath_result_number + taurus_xpath_result_string + taurus_xpath_result_free + taurus_xpath_variable_set_new + taurus_xpath_variable_set_free + taurus_xpath_variable_set_boolean + taurus_xpath_variable_set_number + taurus_xpath_variable_set_string + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + end + + describe "SAX" do + it "attaches the sax surface" do + %i[ + taurus_sax_parse + taurus_sax_parser_create + taurus_sax_parser_feed + taurus_sax_parser_free + taurus_sax_parser_set_streaming + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + + it "exposes the SAXHandler struct class" do + expect(described_class::SAXHandler).to be < ::FFI::Struct + end + + it "exposes the SerializeOptions struct class" do + expect(described_class::SerializeOptions).to be < ::FFI::Struct + end + end + + describe "namespaces" do + it "attaches namespace accessors" do + %i[ + taurus_element_namespace + taurus_namespace_uri + taurus_namespace_prefix + taurus_element_namespace_for_prefix + taurus_element_namespace_count + ].each do |fn| + expect(described_class).to respond_to(fn), "missing #{fn}" + end + end + end + + describe "memory + status" do + it "attaches taurus_free_string and taurus_xinclude_process" do + expect(described_class).to respond_to(:taurus_free_string) + expect(described_class).to respond_to(:taurus_xinclude_process) + end + + it "exposes status code constants" do + expect(described_class::TAURUS_OK).to eq(0) + expect(described_class::TAURUS_ERROR_PARSE).to eq(-2) + expect(described_class::TAURUS_ERROR_XPATH).to eq(-3) + end + + it "exposes xpath result type constants" do + expect(described_class::XPATH_NODESET).to eq(0) + expect(described_class::XPATH_BOOLEAN).to eq(1) + expect(described_class::XPATH_NUMBER).to eq(2) + expect(described_class::XPATH_STRING).to eq(3) + end + + it "exposes libtaurus raw node type constants" do + expect(described_class::NODE_ELEMENT).to eq(0) + expect(described_class::NODE_TEXT).to eq(1) + expect(described_class::NODE_COMMENT).to eq(2) + expect(described_class::NODE_CDATA).to eq(3) + expect(described_class::NODE_PI).to eq(4) + expect(described_class::NODE_DOCTYPE).to eq(5) + expect(described_class::NODE_ATTRIBUTE).to eq(6) + end + + it "exposes C14N version constants" do + expect(described_class::C14N_1_0).to eq(0) + expect(described_class::C14N_1_1).to eq(1) + end + end +end diff --git a/spec/xml/mutation_extras_spec.rb b/spec/xml/mutation_extras_spec.rb new file mode 100644 index 0000000..872d864 --- /dev/null +++ b/spec/xml/mutation_extras_spec.rb @@ -0,0 +1,61 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe "Element mutation: replace / swap / wrap / children=" do + let(:doc) { Taurus::XML::Document.parse("") } + let(:root) { doc.root } + + describe "#replace" do + it "replaces self with a created element at the same position" do + b = root.element_children[1] + new_elem = doc.create_element("X") + result = b.replace(new_elem) + expect(result).to eq(new_elem) + expect(root.element_children.map(&:name)).to eq(%w[a X c]) + end + + it "raises when self has no parent" do + elem = doc.create_element("orphan") + expect { elem.replace(doc.create_element("X")) } + .to raise_error(Taurus::XML::Error, /no parent/) + end + end + + describe "#swap" do + it "replaces self and returns self for chaining" do + b = root.element_children[1] + returned = b.swap(doc.create_element("X")) + expect(returned).to eq(b) + expect(root.element_children.map(&:name)).to eq(%w[a X c]) + end + end + + describe "#children=" do + it "replaces all children with the new collection" do + root.children = [doc.create_element("p"), doc.create_element("q")] + expect(root.element_children.map(&:name)).to eq(%w[p q]) + end + + it "clears children when given an empty array" do + root.children = [] + expect(root.element_children).to be_empty + end + end + + describe "#wrap" do + it "wraps self in a new element parsed from markup" do + b = root.element_children[1] + b.wrap("

") + expect(root.element_children.map(&:name)).to eq(%w[a div c]) + wrapper = root.element_children[1] + expect(wrapper["class"]).to eq("wrapped") + expect(wrapper.element_children.map(&:name)).to eq(%w[b]) + end + + it "raises when self has no parent" do + orphan = doc.create_element("orphan") + expect { orphan.wrap("") }.to raise_error(Taurus::XML::Error, /no parent/) + end + end +end diff --git a/spec/xml/sax_spec.rb b/spec/xml/sax_spec.rb new file mode 100644 index 0000000..72955f5 --- /dev/null +++ b/spec/xml/sax_spec.rb @@ -0,0 +1,182 @@ +# frozen_string_literal: true + +require "taurus/xml" +require "stringio" + +RSpec.describe Taurus::XML::SAX::Parser do + let(:xml) do + <<~XML + + + Ruby + XML + + XML + end + + # Test handler that captures every event into an array for assertion. + class RecordingHandler < Taurus::XML::SAX::Document + attr_reader :events + + def initialize + @events = [] + end + + def start_document; @events << [:start_document]; end + def end_document; @events << [:end_document]; end + + def start_element(name, attrs = []) + @events << [:start_element, name, attrs] + end + def end_element(name) + @events << [:end_element, name] + end + def characters(string) + @events << [:characters, string] unless string.strip.empty? + end + def comment(string) + @events << [:comment, string] + end + def cdata_block(string) + @events << [:cdata, string] + end + def processing_instruction(name, content) + @events << [:pi, name, content] + end + def start_prefix_mapping(prefix, uri) + @events << [:start_prefix, prefix, uri] + end + def end_prefix_mapping(prefix) + @events << [:end_prefix, prefix] + end + def error(message, line = 0, column = 0) + @events << [:error, message, line, column] + end + end + + describe "#parse_memory" do + it "delivers start_element / end_element events with attrs as [name, value] pairs" do + h = RecordingHandler.new + described_class.new(h).parse_memory(%q{}) + expect(h.events).to include([:start_element, "book", [["id", "1"], ["lang", "en"]]]) + expect(h.events).to include([:end_element, "book"]) + end + + it "delivers characters events" do + h = RecordingHandler.new + described_class.new(h).parse_memory("hello world") + chars = h.events.select { |e| e[0] == :characters }.map { |e| e[1] } + expect(chars.join).to eq("hello world") + end + + it "delivers comment events" do + h = RecordingHandler.new + described_class.new(h).parse_memory("") + expect(h.events).to include([:comment, " a note "]) + end + + it "delivers cdata events" do + h = RecordingHandler.new + described_class.new(h).parse_memory("]]>") + expect(h.events).to include([:cdata, ""]) + end + + it "delivers processing_instruction events" do + h = RecordingHandler.new + described_class.new(h).parse_memory(%q{}) + pis = h.events.select { |e| e[0] == :pi } + expect(pis.length).to eq(1) + expect(pis.first[1]).to eq("xml-stylesheet") + expect(pis.first[2]).to eq('type="text/xsl"') + end + + it "delivers start_prefix_mapping events for namespace declarations" do + h = RecordingHandler.new + described_class.new(h).parse_memory(%q{}) + prefix_events = h.events.select { |e| e[0] == :start_prefix } + expect(prefix_events).to include([:start_prefix, "foo", "http://foo.example"]) + end + + it "delivers start_document and end_document" do + h = RecordingHandler.new + described_class.new(h).parse_memory("") + expect(h.events.first).to eq([:start_document]) + expect(h.events.last).to eq([:end_document]) + end + + it "walks the full event sequence in document order" do + h = RecordingHandler.new + described_class.new(h).parse_memory(%q{text}) + tags = h.events.select { |e| %i[start_element end_element].include?(e[0]) } + .map { |e| [e[0], e[1]] } + expect(tags).to eq([ + [:start_element, "lib"], + [:start_element, "book"], + [:end_element, "book"], + [:end_element, "lib"] + ]) + end + end + + describe "#parse_io (streaming via feed)" do + it "parses the same events as parse_memory" do + h1 = RecordingHandler.new + h2 = RecordingHandler.new + described_class.new(h1).parse_memory(xml) + described_class.new(h2).parse_io(StringIO.new(xml)) + + # Streaming may split characters events across chunk boundaries. + # Compare element/structure events only. + structure = ->(events) do + events.select { |e| %i[start_element end_element comment cdata pi start_prefix].include?(e[0]) } + end + expect(structure.call(h1.events)).to eq(structure.call(h2.events)) + end + + it "handles chunks larger than the buffer" do + big = "" + ("x" * 10_000) + "" + h = RecordingHandler.new + described_class.new(h).parse_io(StringIO.new(big)) + tags = h.events.select { |e| %i[start_element end_element].include?(e[0]) } + .map { |e| [e[0], e[1]] } + expect(tags).to eq([[:start_element, "r"], [:end_element, "r"]]) + end + end + + describe "#parse (auto-dispatch)" do + it "uses parse_memory for strings" do + h = RecordingHandler.new + described_class.new(h).parse("") + expect(h.events).to include([:start_element, "x", []]) + end + + it "uses parse_io for IO objects" do + h = RecordingHandler.new + described_class.new(h).parse(StringIO.new("")) + expect(h.events).to include([:start_element, "x", []]) + end + + it "raises ArgumentError for unsupported types" do + expect { described_class.new.parse(42) } + .to raise_error(ArgumentError, /String or IO/) + end + end + + describe "#parse_file" do + it "parses from a file path" do + require "tmpdir" + path = File.join(Dir.mktmpdir, "test.xml") + File.write(path, "") + h = RecordingHandler.new + described_class.new(h).parse_file(path) + expect(h.events).to include([:start_element, "x", []]) + expect(h.events).to include([:start_element, "y", []]) + end + end + + describe "default Document handler" do + it "does not raise when no handler is supplied" do + expect { described_class.new.parse("") }.not_to raise_error + end + end +end diff --git a/spec/xml/v050_features_spec.rb b/spec/xml/v050_features_spec.rb new file mode 100644 index 0000000..2388b00 --- /dev/null +++ b/spec/xml/v050_features_spec.rb @@ -0,0 +1,205 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe "v0.5.0+ element mutation" do + let(:doc) { Taurus::XML::Document.parse("") } + let(:root) { doc.root } + + it "renames an element via #name=" do + root.name = "renamed" + expect(root.name).to eq("renamed") + end + + it "sets and removes attributes via []= and remove_attribute" do + root["id"] = "top" + expect(root["id"]).to eq("top") + root.remove_attribute("id") + expect(root["id"]).to be_nil + end + + it "sets text content via #content=" do + root.content = "fresh text" + expect(root.content).to eq("fresh text") + end + + it "appends a created element via #add_child" do + new_elem = doc.create_element("c") + root.add_child(new_elem) + expect(root.element_children.map(&:name)).to eq(%w[a b c]) + end + + it "supports << as add_child alias" do + root << doc.create_element("c") + expect(root.element_children.map(&:name)).to eq(%w[a b c]) + end + + it "prepends a child via #prepend_child" do + root.prepend_child(doc.create_element("z")) + expect(root.element_children.first.name).to eq("z") + end +end + +RSpec.describe "v0.5.0+ typed node creators" do + let(:doc) { Taurus::XML::Document.parse("") } + let(:root) { doc.root } + + it "creates and attaches a text node" do + text = doc.create_text_node("hello") + root.add_child(text) + expect(root.content).to eq("hello") + end + + it "creates and attaches a comment" do + comment = doc.create_comment("a note") + root.add_child(comment) + expect(root.children.find { |n| n.comment? }.content).to eq("a note") + end + + it "creates and attaches a CDATA section" do + cdata = doc.create_cdata("data") + root.add_child(cdata) + expect(root.children.find { |n| n.cdata? }.content).to eq("data") + end + + it "creates and attaches a processing instruction" do + pi = doc.create_processing_instruction("xml-stylesheet", 'type="text/xsl"') + root.add_child(pi) + pi_node = root.children.find { |n| n.processing_instruction? } + expect(pi_node.name).to eq("xml-stylesheet") + expect(pi_node.content).to eq('type="text/xsl"') + end + + it "supports Text#content= for existing text nodes" do + text = doc.create_text_node("initial") + root.add_child(text) + text.content = "updated" + expect(root.content).to eq("updated") + end + + it "supports Comment#content= for existing comment nodes" do + c = doc.create_comment("v1") + root.add_child(c) + c.content = "v2" + expect(c.content).to eq("v2") + end + + it "supports PI#target= and #data=" do + pi = doc.create_processing_instruction("foo", "bar") + root.add_child(pi) + pi.target = "baz" + pi.data = "qux" + expect(pi.name).to eq("baz") + expect(pi.content).to eq("qux") + end +end + +RSpec.describe "v0.5.0+ parent + unlink for non-element nodes" do + it "exposes #parent on a Text node (worked around in v0.4.4)" do + doc = Taurus::XML::Document.parse("hello") + text = doc.root.child + expect(text).to be_a(Taurus::XML::Text) + expect(text.parent).to eq(doc.root) + end + + it "exposes #parent on a Comment node" do + doc = Taurus::XML::Document.parse("") + comment = doc.root.children.find(&:comment?) + expect(comment.parent).to eq(doc.root) + end + + it "unlinks a Text node via #remove" do + doc = Taurus::XML::Document.parse("hello") + text = doc.root.child + text.remove + expect(doc.root.content).to eq("") + end +end + +RSpec.describe "v0.5.0+ namespace definitions" do + it "enumerates namespaces declared on an element" do + doc = Taurus::XML::Document.parse(<<~XML) + + + + XML + decls = doc.root.namespace_definitions + expect(decls.length).to eq(2) + prefixes = decls.map(&:prefix) + hrefs = decls.map(&:href) + expect(hrefs).to include("http://default.example", "http://foo.example") + expect(prefixes).to include(nil, "foo") + end + + it "exposes inherited namespaces via #namespaces" do + doc = Taurus::XML::Document.parse(<<~XML) + + + + XML + child = doc.root.first_element_child + expect(child.namespaces).to include("xmlns:foo" => "http://foo.example") + end +end + +RSpec.describe "v0.5.0+ line + compare" do + it "exposes #line for parsed nodes" do + doc = Taurus::XML::Document.parse("\n \n") + child = doc.root.first_element_child + # libtaurus v0.5.1 returns 0 for line numbers (function exists but + # underlying tracking is not populated); just verify the call works. + expect(child.line).to be_an(Integer) + end + + it "compares nodes by document order via #<=>" do + doc = Taurus::XML::Document.parse("") + a = doc.root.first_element_child + b = a.next_element + expect(a <=> b).to be < 0 + expect(b <=> a).to be > 0 + expect(a <=> a).to eq(0) + end +end + +RSpec.describe "v0.5.0+ serialization + C14N" do + let(:doc) { Taurus::XML::Document.parse("text") } + + it "serializes the document to XML via Document#to_xml" do + xml = doc.to_xml + expect(xml).to include("") + expect(xml).to include("") + expect(root_xml).not_to match(/\A<\?xml/) + end + + it "canonicalizes the whole document via Document#canonicalize" do + c14n = doc.canonicalize + expect(c14n).to include("") + expect(c14n).to include("") + end + + it "preserves C14N 1.0 vs 1.1 modes" do + c14n_10 = doc.canonicalize(Taurus::XML::FFI::C14N_1_0) + c14n_11 = doc.canonicalize(Taurus::XML::FFI::C14N_1_1) + expect(c14n_10).to include("") + end +end diff --git a/spec/xml/xpath_spec.rb b/spec/xml/xpath_spec.rb new file mode 100644 index 0000000..d50a1ea --- /dev/null +++ b/spec/xml/xpath_spec.rb @@ -0,0 +1,71 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe "Taurus::XML Searchable via XPath" do + let(:doc) do + Taurus::XML::Document.parse(<<~XML) + + Ruby + XML + XPath + + XML + end + + it "evaluates count() and returns a Float" do + expect(doc.xpath("count(//book)")).to eq(3.0) + end + + it "returns a NodeSet for //element queries" do + books = doc.xpath("//book") + expect(books).to be_a(Taurus::XML::NodeSet) + expect(books.length).to eq(3) + end + + it "returns a String for string() queries" do + title = doc.xpath("string(//book[@id='1']/title)") + expect(title).to eq("Ruby") + end + + it "returns a Boolean for predicate-only queries" do + # Uses boolean() which libtaurus v0.5.5+ flat XPath dispatcher + # correctly supports. + expect(doc.xpath("boolean(//book)")).to be true + expect(doc.xpath("boolean(//missing)")).to be false + end + + # Regression for upstream libtaurus #201 (fixed in v0.5.7): the v0.5.5 + # flat XPath dispatcher over-matched expressions starting with count(...), + # returning the inner number rather than evaluating the full comparison. + it "returns a Boolean for count(...) > N expressions" do + expect(doc.xpath("count(//book) > 0")).to be true + expect(doc.xpath("count(//missing) > 0")).to be false + expect(doc.xpath("count(//book) > 5")).to be false + expect(doc.xpath("count(//book) >= 3")).to be true + end + + it "supports at_xpath returning the first match" do + first_book = doc.at_xpath("//book") + expect(first_book["id"]).to eq("1") + end + + it "supports xpath on Element receiver (context-relative)" do + second_book = doc.at_xpath("//book[@id='2']") + title = second_book.xpath("title") + expect(title).to be_a(Taurus::XML::NodeSet) + expect(title.first.content).to eq("XML") + end + + it "supports . at context node" do + first_book = doc.at_xpath("//book") + expect(first_book.xpath(".")).to be_a(Taurus::XML::NodeSet) + end + + it "supports XPath on NodeSet (search each member)" do + books = doc.xpath("//book") + all_titles = books.xpath("title") + expect(all_titles.length).to eq(3) + expect(all_titles.map(&:content)).to eq(%w[Ruby XML XPath]) + end +end diff --git a/taurus.gemspec b/taurus.gemspec index 27b712d..8408acb 100644 --- a/taurus.gemspec +++ b/taurus.gemspec @@ -8,44 +8,35 @@ Gem::Specification.new do |spec| spec.authors = ["Ribose Inc."] spec.email = ["open.source@ribose.com"] - spec.summary = "Ultra-fast XML parser with full XPath support and CLI" + spec.summary = "Nokogiri-compatible Ruby binding for libtaurus (XML 1.0, XPath 1.0, SAX)" spec.description = <<~DESC - Taurus is a next-generation XML parser for Ruby with complete XPath 1.0 - support and command-line interface. Built in C for maximum performance, - it delivers Ox-level parsing speed with full namespace support and XPath - queries that are competitive with Nokogiri. Features: complete XPath 1.0 - (27 functions, 13 axes), XML pretty-printing CLI, zero external dependencies. + Taurus is a Nokogiri-compatible Ruby binding for libtaurus, a pure-C99 XML + 1.0 parser with full XPath 1.0 and SAX support. The C DOM is the single + source of truth; Ruby objects are thin FFI wrappers (one Ruby method = + one FFI call). DESC spec.homepage = "https://github.com/lutaml/taurus-ruby" spec.license = "MIT" spec.required_ruby_version = ">= 3.0.0" - spec.metadata["homepage_uri"] = spec.homepage - spec.metadata["source_code_uri"] = "https://github.com/lutaml/taurus-ruby" - spec.metadata["changelog_uri"] = "https://github.com/lutaml/taurus-ruby/blob/main/CHANGELOG.md" + spec.metadata = { + "homepage_uri" => spec.homepage, + "source_code_uri" => "https://github.com/lutaml/taurus-ruby", + "changelog_uri" => "https://github.com/lutaml/taurus-ruby/blob/main/CHANGELOG.md", + } - # Specify which files should be added to the gem when it is released. - # The `git ls-files -z` loads the files in the RubyGem that have been added into git. spec.files = Dir.chdir(__dir__) do `git ls-files -z`.split("\x0").reject do |f| (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile]) end end - spec.bindir = "bin" - spec.executables = ["taurus"] + spec.executables = [] spec.require_paths = ["lib"] - # Extension configuration - build libtaurus during gem install - spec.extensions = ["ext/taurus/extconf.rb"] - - # Runtime dependencies spec.add_dependency "ffi", "~> 1.15" - spec.add_dependency "thor", "~> 1.0" - # Development dependencies spec.add_development_dependency "rake" - spec.add_development_dependency "rake-compiler" spec.add_development_dependency "rspec" end From d0dab287652127620245e2e715f4075f78b8f9ec Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Mon, 10 Aug 2026 05:52:23 +0800 Subject: [PATCH 02/11] Adopt libtaurus v0.10.0: element/document deep copy, node path, fragment parsing, DOCTYPE access MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit libtaurus v0.6.0/v0.6.1 shipped 4 Nokogiri-compat C-API gaps: - taurus_element_copy(src, dest_doc) — Element/Node#dup, #clone - taurus_document_copy(src) — Document#dup, #clone - taurus_node_get_xpath(node) — Node#path, #css_path - taurus_parse_fragment(xml, len, dest_doc, status) — Document#fragment, Element#add_child with String markup - taurus_document_internal_subset + taurus_doctype_get_* — DocType class Ruby binding changes: - New classes: DocType (name/root_name/public_id/system_id/internal_subset/ external_id/to_s), DocumentFragment (children, name) - Node#path, #css_path, #dup, #clone - Element#dup, #clone, add_child(String) via fragment parsing - Document#fragment, #dup, #clone, #doctype, #internal_subset 1 new upstream bug filed: #253 — DOCTYPE PUBLIC/SYSTEM/internal_subset not exposed (only the name comes through). 4 specs marked pending pending upstream fix. Specs: 176 passing, 4 pending (all blocked on #253). --- lib/taurus/xml.rb | 2 + lib/taurus/xml/doc_type.rb | 54 +++++++++ lib/taurus/xml/document.rb | 18 +++ lib/taurus/xml/document_fragment.rb | 42 +++++++ lib/taurus/xml/element.rb | 27 ++++- lib/taurus/xml/ffi.rb | 23 ++++ lib/taurus/xml/node.rb | 23 ++++ spec/xml/v060_features_spec.rb | 172 ++++++++++++++++++++++++++++ 8 files changed, 360 insertions(+), 1 deletion(-) create mode 100644 lib/taurus/xml/doc_type.rb create mode 100644 lib/taurus/xml/document_fragment.rb create mode 100644 spec/xml/v060_features_spec.rb diff --git a/lib/taurus/xml.rb b/lib/taurus/xml.rb index 5befb5a..112d850 100644 --- a/lib/taurus/xml.rb +++ b/lib/taurus/xml.rb @@ -12,6 +12,8 @@ module XML autoload :Attr, "taurus/xml/attr" autoload :Namespace, "taurus/xml/namespace" autoload :Document, "taurus/xml/document" + autoload :DocumentFragment, "taurus/xml/document_fragment" + autoload :DocType, "taurus/xml/doc_type" autoload :NodeSet, "taurus/xml/node_set" autoload :Searchable, "taurus/xml/searchable" autoload :ParseOptions, "taurus/xml/parse_options" diff --git a/lib/taurus/xml/doc_type.rb b/lib/taurus/xml/doc_type.rb new file mode 100644 index 0000000..38c5b3b --- /dev/null +++ b/lib/taurus/xml/doc_type.rb @@ -0,0 +1,54 @@ +# frozen_string_literal: true + +class Taurus::XML::DocType + attr_reader :c_ptr, :document + + def initialize(c_ptr, document) + @c_ptr = c_ptr + @document = document + end + + def name + Taurus::XML::FFI.taurus_doctype_get_name(@c_ptr) + end + alias_method :node_name, :name + + def root_name + Taurus::XML::FFI.taurus_doctype_get_root_name(@c_ptr) + end + + def public_id + Taurus::XML::FFI.taurus_doctype_get_public_id(@c_ptr) + end + + def system_id + Taurus::XML::FFI.taurus_doctype_get_system_id(@c_ptr) + end + + def internal_subset + Taurus::XML::FFI.taurus_doctype_get_internal_subset(@c_ptr) + end + + def external_id + pub = public_id + sys = system_id + return nil if pub.nil? && sys.nil? + parts = [] + parts << "PUBLIC \"#{pub}\"" if pub + parts << "SYSTEM \"#{sys}\"" if sys && pub.nil? + parts << "\"#{sys}\"" if pub && sys + parts.join(" ") + end + + def to_s + inner = internal_subset + parts = ["" + end + + def inspect + "#<#{self.class.name} name=#{name.inspect} public=#{public_id.inspect} system=#{system_id.inspect}>" + end +end diff --git a/lib/taurus/xml/document.rb b/lib/taurus/xml/document.rb index c266d7d..ddce65b 100644 --- a/lib/taurus/xml/document.rb +++ b/lib/taurus/xml/document.rb @@ -74,6 +74,24 @@ def create_processing_instruction(target, data = "") Taurus::XML::ProcessingInstruction.new(ptr, self) end + def fragment(markup) + Taurus::XML::DocumentFragment.parse(markup, self) + end + + def dup + raw = Taurus::XML::FFI.taurus_document_copy(@c_ptr) + raise Taurus::XML::Error, "taurus_document_copy failed" if raw.null? + self.class.new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + end + alias_method :clone, :dup + + def doctype + ptr = Taurus::XML::FFI.taurus_document_internal_subset(@c_ptr) + return nil if ptr.null? + Taurus::XML::DocType.new(ptr, self) + end + alias_method :internal_subset, :doctype + def to_xml(indent: 0, no_decl: false, encoding: nil) raise Taurus::XML::UseAfterFreeError if @freed return "" if @c_ptr.nil? diff --git a/lib/taurus/xml/document_fragment.rb b/lib/taurus/xml/document_fragment.rb new file mode 100644 index 0000000..7e91d18 --- /dev/null +++ b/lib/taurus/xml/document_fragment.rb @@ -0,0 +1,42 @@ +# frozen_string_literal: true + +require "ffi" + +# Wraps the synthetic "#document-fragment" element returned by +# taurus_parse_fragment. Children of this fragment are the parsed nodes; +# the fragment itself isn't part of any document tree but borrows its +# document's lifetime. +class Taurus::XML::DocumentFragment + attr_reader :document, :c_ptr + + def initialize(document, c_ptr) + @document = document + @c_ptr = c_ptr + end + + def self.parse(xml, document) + status_ptr = ::FFI::MemoryPointer.new(:int) + raw = Taurus::XML::FFI.taurus_parse_fragment( + xml.to_s, xml.to_s.bytesize, document.c_ptr, status_ptr) + if raw.null? + raise Taurus::XML::ParseError, + "taurus_parse_fragment failed (status=#{status_ptr.read_int})" + end + new(document, raw) + end + + def children + count = Taurus::XML::FFI.taurus_element_child_count(@c_ptr) + nodes = [] + ptr = Taurus::XML::FFI.taurus_node_first_child(@c_ptr) + until ptr.nil? || ptr.null? + nodes << Taurus::XML::Node.wrap(ptr, @document) + ptr = Taurus::XML::FFI.taurus_node_next_sibling(ptr) + end + Taurus::XML::NodeSet.new(@document, nodes) + end + + def name + "#document-fragment" + end +end diff --git a/lib/taurus/xml/element.rb b/lib/taurus/xml/element.rb index 5a7117f..a4c2b6c 100644 --- a/lib/taurus/xml/element.rb +++ b/lib/taurus/xml/element.rb @@ -167,7 +167,32 @@ def wrap(node_or_markup) end def dup - raise NotImplementedError, "Element#dup requires taurus_element_copy (not yet exposed in v0.5.10 public API)" + copy_ptr = Taurus::XML::FFI.taurus_element_copy(@c_ptr, @document.c_ptr) + raise Taurus::XML::Error, "taurus_element_copy failed" if copy_ptr.null? + Taurus::XML::Element.new(copy_ptr, @document) + end + alias_method :clone, :dup + + def add_child(node_or_markup) + case node_or_markup + when Taurus::XML::Node + status = Taurus::XML::FFI.taurus_element_append_child(@c_ptr, node_or_markup.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + node_or_markup + when String + frag = Taurus::XML::DocumentFragment.parse(node_or_markup, @document) + added = [] + frag.children.each do |n| + status = Taurus::XML::FFI.taurus_element_append_child(@c_ptr, n.c_ptr) + raise Taurus::XML::Error, + Taurus::XML::FFI.taurus_status_string(status) unless status == Taurus::XML::FFI::TAURUS_OK + added << n + end + Taurus::XML::NodeSet.new(@document, added) + else + raise ArgumentError, "add_child expects a Node or String, got #{node_or_markup.class}" + end end def namespace diff --git a/lib/taurus/xml/ffi.rb b/lib/taurus/xml/ffi.rb index 1e1a3e2..fffb3b0 100644 --- a/lib/taurus/xml/ffi.rb +++ b/lib/taurus/xml/ffi.rb @@ -20,6 +20,7 @@ module FFI typedef :pointer, :taurus_element typedef :pointer, :taurus_node_ref typedef :pointer, :taurus_attribute + typedef :pointer, :taurus_doctype typedef :pointer, :taurus_xpath_result typedef :pointer, :taurus_xpath_var_set typedef :pointer, :taurus_sax_parser @@ -263,6 +264,15 @@ class SerializeOptions < ::FFI::Struct attach_function :taurus_element_insert_copy_after, [:taurus_element, :taurus_element], :taurus_element + attach_function :taurus_element_copy, + [:taurus_element, :taurus_document], :taurus_element + attach_function :taurus_document_copy, + [:taurus_document], :taurus_document + attach_function :taurus_node_get_xpath, + [:taurus_node_ref], :pointer + attach_function :taurus_parse_fragment, + [:string, :size_t, :taurus_document, :pointer], :taurus_element + attach_function :taurus_element_namespace, [:taurus_element], :string attach_function :taurus_element_namespace_for_prefix, @@ -343,6 +353,19 @@ class SerializeOptions < ::FFI::Struct attach_function :taurus_c14n_canonicalize_subtree_ex, [:taurus_element, :int, :int, :pointer, :int], :pointer + attach_function :taurus_document_internal_subset, + [:taurus_document], :taurus_doctype + attach_function :taurus_doctype_get_name, + [:taurus_doctype], :string + attach_function :taurus_doctype_get_root_name, + [:taurus_doctype], :string + attach_function :taurus_doctype_get_public_id, + [:taurus_doctype], :string + attach_function :taurus_doctype_get_system_id, + [:taurus_doctype], :string + attach_function :taurus_doctype_get_internal_subset, + [:taurus_doctype], :string + attach_function :taurus_free_string, [:pointer], :void attach_function :taurus_explicit_cleanup, [], :void attach_function :taurus_set_memory_management_functions, diff --git a/lib/taurus/xml/node.rb b/lib/taurus/xml/node.rb index 2db3a47..e104511 100644 --- a/lib/taurus/xml/node.rb +++ b/lib/taurus/xml/node.rb @@ -143,6 +143,29 @@ def traverse yield self end + def path + str_ptr = Taurus::XML::FFI.taurus_node_get_xpath(@c_ptr) + return nil if str_ptr.null? + str_ptr.read_string.tap { Taurus::XML::FFI.taurus_free_string(str_ptr) } + end + + def css_path + return nil if path.nil? + path.split("/").filter_map do |part| + next nil if part.empty? + part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)') + end.join(" > ") + end + + def dup + elem_ptr = Taurus::XML::FFI.taurus_node_as_element(@c_ptr) + raise Taurus::XML::Error, "dup is only supported for element nodes" if elem_ptr.null? + copy_ptr = Taurus::XML::FFI.taurus_element_copy(elem_ptr, @document.c_ptr) + raise Taurus::XML::Error, "taurus_element_copy failed" if copy_ptr.null? + Taurus::XML::Element.new(copy_ptr, @document) + end + alias_method :clone, :dup + def ==(other) return false unless other.is_a?(Taurus::XML::Node) @c_ptr == other.c_ptr diff --git a/spec/xml/v060_features_spec.rb b/spec/xml/v060_features_spec.rb new file mode 100644 index 0000000..f2e1d60 --- /dev/null +++ b/spec/xml/v060_features_spec.rb @@ -0,0 +1,172 @@ +# frozen_string_literal: true + +require "taurus/xml" + +RSpec.describe "v0.6.0+ element/document deep copy + node path + fragment + doctype" do + describe "Element#dup / Node#dup" do + let(:doc) { Taurus::XML::Document.parse("text") } + + it "creates a detached deep copy of an element subtree" do + a = doc.root.first_element_child + copy = a.dup + expect(copy).to be_a(Taurus::XML::Element) + expect(copy["x"]).to eq("1") + expect(copy.element_children.map(&:name)).to eq(%w[b]) + expect(copy.content).to eq("text") + end + + it "produces a copy whose pointer differs from the original" do + a = doc.root.first_element_child + copy = a.dup + expect(copy.c_ptr).not_to eq(a.c_ptr) + end + + it "modifications to the copy do not affect the original" do + a = doc.root.first_element_child + copy = a.dup + copy["x"] = "modified" + expect(a["x"]).to eq("1") + expect(copy["x"]).to eq("modified") + end + + it "can be appended to the same document as a new subtree" do + a = doc.root.first_element_child + copy = a.dup + doc.root.add_child(copy) + expect(doc.root.element_children.map(&:name)).to eq(%w[a c a]) + end + + it "alias #clone works the same" do + a = doc.root.first_element_child + expect(a.clone.content).to eq(a.content) + end + end + + describe "Document#dup / #clone" do + it "produces a deep copy of the whole document" do + doc = Taurus::XML::Document.parse("") + copy = doc.dup + expect(copy).to be_a(Taurus::XML::Document) + expect(copy.c_ptr).not_to eq(doc.c_ptr) + expect(copy.root.element_children.map(&:name)).to eq(%w[a]) + end + + it "mutations in the copy do not affect the original" do + doc = Taurus::XML::Document.parse("") + copy = doc.dup + copy.root.first_element_child.name = "changed" + expect(doc.root.first_element_child.name).to eq("a") + expect(copy.root.first_element_child.name).to eq("changed") + end + end + + describe "Node#path / #css_path" do + let(:doc) do + Taurus::XML::Document.parse("") + end + + it "returns the canonical XPath to a node" do + items = doc.xpath("//item") + path_of_second = items[1].path + expect(path_of_second).to include("item[2]") + end + + it "the root's path starts with /" do + expect(doc.root.path).to match(%r{\A/r}) + end + + it "Node#css_path translates [N] to :nth-of-type(N)" do + items = doc.xpath("//item") + css_path = items[1].css_path + expect(css_path).to include("item:nth-of-type(2)") + end + end + + describe "Document#fragment" do + it "parses a fragment with multiple top-level nodes" do + doc = Taurus::XML::Document.parse("") + frag = doc.fragment("") + expect(frag).to be_a(Taurus::XML::DocumentFragment) + expect(frag.children.map(&:name)).to eq(%w[a b c]) + end + + it "parses mixed content (elements + text + comment)" do + doc = Taurus::XML::Document.parse("") + frag = doc.fragment("hellox") + types = frag.children.map { |n| [n.class.name.split("::").last, n.respond_to?(:name) ? n.name : nil] } + expect(types.map(&:first)).to include("Text", "Element", "Comment") + end + end + + describe "Element#add_child with String markup" do + it "parses the markup and appends each top-level node" do + doc = Taurus::XML::Document.parse("") + result = doc.root.add_child("") + expect(result).to be_a(Taurus::XML::NodeSet) + expect(doc.root.element_children.map(&:name)).to eq(%w[a b]) + end + + it "parses mixed-content strings" do + doc = Taurus::XML::Document.parse("") + doc.root.add_child("hellox") + names = doc.root.children.map { |n| [n.class.name.split("::").last, n.respond_to?(:name) ? n.name : nil] } + expect(names.map(&:first)).to include("Text", "Element") + end + end + + describe "Document#doctype / #internal_subset" do + it "returns nil when the document has no DOCTYPE" do + doc = Taurus::XML::Document.parse("") + expect(doc.doctype).to be_nil + expect(doc.internal_subset).to be_nil + end + + it "exposes the DOCTYPE name (root element name)" do + doc = Taurus::XML::Document.parse(%q{}) + dt = doc.doctype + expect(dt).to be_a(Taurus::XML::DocType) + expect(dt.name).to eq("html") + expect(dt.root_name).to eq("html") + end + + it "exposes PUBLIC and SYSTEM identifiers" do + pending "upstream libtaurus #253: DOCTYPE PUBLIC/SYSTEM not exposed" + xml = <<~XML + + + XML + doc = Taurus::XML::Document.parse(xml) + dt = doc.doctype + expect(dt.public_id).to eq("-//W3C//DTD XHTML 1.0 Strict//EN") + expect(dt.system_id).to eq("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd") + end + + it "exposes SYSTEM-only identifiers" do + pending "upstream libtaurus #253: DOCTYPE SYSTEM not exposed" + xml = %q{} + doc = Taurus::XML::Document.parse(xml) + dt = doc.doctype + expect(dt.public_id).to be_nil + expect(dt.system_id).to eq("config.dtd") + end + + it "exposes the internal subset (DTD declarations)" do + pending "upstream libtaurus #253: DOCTYPE internal_subset not exposed" + xml = %q{]>} + doc = Taurus::XML::Document.parse(xml) + dt = doc.doctype + subset = dt.internal_subset + expect(subset).to include("} + doc = Taurus::XML::Document.parse(xml) + expect(doc.doctype.to_s) + .to include('PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"') + expect(doc.doctype.to_s).to include(" Date: Mon, 10 Aug 2026 09:41:53 +0800 Subject: [PATCH 03/11] Add taurus-ruby vs Nokogiri benchmarks (Ruby-level) + analysis MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb Findings (libtaurus v0.11.0 vs Nokogiri 1.19.4): - Parse small (431 B): Taurus 1.99x faster - Parse medium (12 KB): Taurus 6.51x faster - XPath count() / boolean() (scalar returns): Taurus 5.45x faster - XPath predicate (single match): Taurus 12.39x faster - Serialize: Taurus 2.90x faster - XPath nodeset-returning (100 nodes): Nokogiri 7x faster - XPath union (200 nodes): Nokogiri 6x faster - Tree traversal: Nokogiri 2x faster Losses attributable to Ruby-side Node/NodeSet wrapper allocation: - NodeSet.from_result eagerly materializes every match - Node.wrap creates a new wrapper per c_ptr per call (no cache) - traverse path allocates a wrapper per visited node These are addressable without libtaurus work — lazy NodeSet, wrapper cache, specialized traverse. 1 new upstream bug filed: #256 — taurus_parse_string segfaults under tight parse loops on ~38 KB docs (memory pool reuse issue). benchmark/README.md has the full analysis. --- Gemfile | 5 ++ Gemfile.lock | 7 ++ benchmark/README.md | 84 ++++++++++++++++++++++++ benchmark/taurus_vs_nokogiri.rb | 109 ++++++++++++++++++++++++++++++++ 4 files changed, 205 insertions(+) create mode 100644 benchmark/README.md create mode 100644 benchmark/taurus_vs_nokogiri.rb diff --git a/Gemfile b/Gemfile index 6e849e0..ca27aa7 100644 --- a/Gemfile +++ b/Gemfile @@ -7,3 +7,8 @@ gemspec gem "rake" gem "rspec" gem "rubocop" + +group :benchmark do + gem "benchmark-ips" + gem "nokogiri" +end diff --git a/Gemfile.lock b/Gemfile.lock index aa33953..89b4f48 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -8,12 +8,17 @@ GEM remote: https://rubygems.org/ specs: ast (2.4.3) + benchmark-ips (2.15.1) diff-lcs (1.6.2) ffi (1.17.2-arm64-darwin) ffi (1.17.2-x86_64-darwin) json (2.17.1) language_server-protocol (3.17.0.5) lint_roller (1.1.0) + nokogiri (1.19.4-arm64-darwin) + racc (~> 1.4) + nokogiri (1.19.4-x86_64-darwin) + racc (~> 1.4) parallel (1.27.0) parser (3.3.10.0) ast (~> 2.4.1) @@ -60,6 +65,8 @@ PLATFORMS x86_64-darwin DEPENDENCIES + benchmark-ips + nokogiri rake rspec rubocop diff --git a/benchmark/README.md b/benchmark/README.md new file mode 100644 index 0000000..bce5b84 --- /dev/null +++ b/benchmark/README.md @@ -0,0 +1,84 @@ +# taurus-ruby vs Nokogiri — Ruby-level benchmarks + +Compares `Taurus::XML` (FFI → libtaurus v0.11.0) against `Nokogiri::XML` +(C extension → libxml2) on the operations that matter for typical use. + +Run with: + +``` +bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb +``` + +## Latest run (M1, libtaurus v0.11.0, Nokogiri 1.19.4) + +| Operation | Taurus | Nokogiri | Taurus / Nokogiri | Winner | +|---|---:|---:|---:|---| +| Parse small (431 B) | 5.49 µs | 10.95 µs | **1.99×** | Taurus | +| Parse medium (12 KB) | 27.21 µs | 177.04 µs | **6.51×** | Taurus | +| XPath `count(//book)` | 1.53 µs | 8.32 µs | **5.45×** | Taurus | +| XPath `//book` (100-node nodeset) | 64.16 µs | 9.00 µs | 0.14× | Nokogiri (7× faster) | +| XPath `//book[@id='50']` (1 match) | 4.12 µs | 51.05 µs | **12.39×** | Taurus | +| XPath `//book[price > 50]` | 93.83 µs | 67.52 µs | 0.72× | Nokogiri (slight) | +| XPath `//author \| //title` (union) | 133.09 µs | 21.10 µs | 0.16× | Nokogiri (6× faster) | +| Tree traversal | 885.34 µs | 423.87 µs | 0.48× | Nokogiri (2× faster) | +| Serialize | 27.40 µs | 79.45 µs | **2.90×** | Taurus | + +## Analysis + +### Where Taurus wins + +**Parse (1.99×–6.51×)** — libtaurus's single-pass direct parser (the only +parser since v0.11.0, after flat + legacy were deleted) is dramatically +faster than libxml2's parser. The gap widens with document size. + +**XPath returning scalars (5.45×)** — `count()`, `boolean()`, `string()`, +`number()` queries skip NodeSet materialization entirely. libtaurus's XPath +bytecode VM evaluates these in a single C call, no Ruby objects allocated +per match. + +**XPath predicate match (12.39×)** — when the predicate narrows to a small +result set (single match in this test), Taurus is much faster than +Nokogiri/libxml2. + +**Serialize (2.90×)** — single C call into `taurus_document_serialize`, +no Ruby traversal. + +### Where Nokogiri wins + +**Nodeset-returning XPath (0.14×–0.16×)** — when a query returns a 100-node +NodeSet, Taurus materializes every node eagerly (100× `Node.wrap` calls, +each dispatching on `taurus_node_get_type`). Nokogiri caches wrappers +lazily. + +**Tree traversal (0.48×)** — same root cause. `Node#traverse` creates a +new wrapper per visited node via `Node.wrap`; Nokogiri reuses cached +wrappers. + +### Optimization opportunities (Ruby-side, no libtaurus work needed) + +1. **Lazy NodeSet materialization.** Currently `NodeSet.from_result` + iterates the C result and calls `Node.wrap` for each entry on + construction. Switch to lazy: keep the `TaurusXPathResult*` alive, + materialize `self[i]` on demand. Frees the eager 100× wrap. +2. **Node wrapper cache.** Weak-ref map keyed on the c_ptr address. + `Node.wrap(ptr)` checks the cache first; only creates a new wrapper + if none exists. Matches Nokogiri's behavior. +3. **Specialized traverse path.** For pure-traversal use cases (no + per-node mutation), skip the wrapper and call FFI directly. Lower + overhead but less idiomatic. + +### Blockers + +**Parse-loop segfault on >20 KB docs (libtaurus #256).** Long-running +services and batch processors parsing medium/large XML cannot rely on +the standard Ruby "let GC handle document lifetime" pattern. Workaround +is explicit `Document#free`. Tracked upstream. + +## What this means for the v0.1.0 release + +- For **parse-heavy / XPath-aggregate / serialize** workloads: Taurus is + clearly the right choice. 2-6× faster than Nokogiri. +- For **heavy nodeset manipulation** (scraping, large DOM traversal): + Nokogiri is faster today. The Ruby-side optimizations above would + close most of the gap. +- The segfault (#256) is the only hard blocker for general use. diff --git a/benchmark/taurus_vs_nokogiri.rb b/benchmark/taurus_vs_nokogiri.rb new file mode 100644 index 0000000..7a64d27 --- /dev/null +++ b/benchmark/taurus_vs_nokogiri.rb @@ -0,0 +1,109 @@ +# frozen_string_literal: true + +# Ruby-level performance comparison: Taurus::XML (FFI → libtaurus v0.11.0) +# vs Nokogiri (C extension → libxml2). +# +# Workloads chosen to stay under the libtaurus v0.11.0 parse-loop crash +# threshold (~38 KB, tracked in upstream #256): explicit `free` after each +# parse, and doc sizes capped at ~12 KB. +# +# Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb + +require "benchmark" +require "taurus/xml" +require "nokogiri" + +module Fixtures + SMALL = "" + + (1..10).map { |i| "Book #{i}" }.join + + "" + + MEDIUM = ("" + + (1..100).map do |i| + "" \ + "Book #{i}" \ + "Author #{i}" \ + "#{i}.99" \ + "" + end.join + + "").freeze +end + +def time_it(label, n, &block) + GC.start + t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) + n.times { yield } + elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0 + us_per_iter = (elapsed / n) * 1_000_000 + printf " %-40s %8.2f µs/iter (%d iters in %.3fs)\n", label, us_per_iter, n, elapsed + us_per_iter +end + +def ratio(label, taurus_us, nokogiri_us) + r = nokogiri_us / taurus_us + who = r > 1 ? "Taurus faster" : "Nokogiri faster" + printf " → %-30s Taurus/Nokogiri = %.2fx (%s)\n\n", label, r, who +end + +N_PARSE_SMALL = 5_000 +N_PARSE_MEDIUM = 1_000 +N_QUERY = 10_000 +N_TRAVERSE = 2_000 +N_SERIALIZE = 1_000 + +puts "===== Parse — small (#{Fixtures::SMALL.bytesize} B) =====" +t = time_it("taurus parse small", N_PARSE_SMALL) { d = Taurus::XML::Document.parse(Fixtures::SMALL); d.free } +n = time_it("nokogiri parse small", N_PARSE_SMALL) { Nokogiri::XML(Fixtures::SMALL) } +ratio("parse small", t, n) + +puts "===== Parse — medium (#{Fixtures::MEDIUM.bytesize} B) =====" +t = time_it("taurus parse medium", N_PARSE_MEDIUM) { d = Taurus::XML::Document.parse(Fixtures::MEDIUM); d.free } +n = time_it("nokogiri parse medium", N_PARSE_MEDIUM) { Nokogiri::XML(Fixtures::MEDIUM) } +ratio("parse medium", t, n) + +# Pre-parse medium for query benchmarks +doc_t = Taurus::XML::Document.parse(Fixtures::MEDIUM) +doc_n = Nokogiri::XML(Fixtures::MEDIUM) + +puts "===== XPath — count(//book) =====" +t = time_it("taurus xpath count()", N_QUERY) { doc_t.xpath("count(//book)") } +n = time_it("nokogiri xpath count()", N_QUERY) { doc_n.xpath("count(//book)") } +ratio("xpath count()", t, n) + +puts "===== XPath — //book (nodeset of 100) =====" +t = time_it("taurus xpath //book", N_QUERY) { doc_t.xpath("//book") } +n = time_it("nokogiri xpath //book", N_QUERY) { doc_n.xpath("//book") } +ratio("xpath //book", t, n) + +puts "===== XPath — predicate //book[@id='50'] =====" +t = time_it("taurus xpath predicate", N_QUERY) { doc_t.xpath("//book[@id='50']") } +n = time_it("nokogiri xpath predicate", N_QUERY) { doc_n.xpath("//book[@id='50']") } +ratio("xpath predicate", t, n) + +puts "===== XPath — complex //book[price > 50] =====" +t = time_it("taurus xpath complex", N_QUERY) { doc_t.xpath("//book[price > 50]") } +n = time_it("nokogiri xpath complex", N_QUERY) { doc_n.xpath("//book[price > 50]") } +ratio("xpath complex", t, n) + +puts "===== XPath — union //author | //title =====" +t = time_it("taurus xpath union", N_QUERY) { doc_t.xpath("//author | //title") } +n = time_it("nokogiri xpath union", N_QUERY) { doc_n.xpath("//author | //title") } +ratio("xpath union", t, n) + +puts "===== Tree traversal (root.traverse) =====" +t = time_it("taurus traverse", N_TRAVERSE) { doc_t.root.traverse { |n| n.name } } +n = time_it("nokogiri traverse", N_TRAVERSE) { doc_n.root.traverse { |n| n.name } } +ratio("traverse", t, n) + +puts "===== Serialize — Document#to_xml =====" +t = time_it("taurus serialize", N_SERIALIZE) { doc_t.to_xml } +n = time_it("nokogiri serialize", N_SERIALIZE) { doc_n.to_xml } +ratio("serialize", t, n) + +doc_t.free + +puts "" +puts "Note: parse-loop on documents > ~20 KB can segfault inside libtaurus" +puts "under benchmark-ips GC pressure. See upstream issue" +puts "https://github.com/lutaml/taurus/issues/256. Workaround here is to" +puts "call Document#free explicitly and cap doc size." From 9ec0f825387dba2ef59f99999c8468977e1bfe8e Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Mon, 10 Aug 2026 10:41:16 +0800 Subject: [PATCH 04/11] Update benchmark README with v0.11.1 numbers + #256 incomplete-fix note v0.11.1 perf is within run-to-run variance of v0.11.0 (no algorithmic change). The v0.11.1 fix for #256 covers the GC-pressure path but not the parse+explicit-free path; both still segfault on ~38 KB docs. Added link to the follow-up comment on #256. --- benchmark/README.md | 67 +++++++++++++++++++++++++++------------------ 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/benchmark/README.md b/benchmark/README.md index bce5b84..d621750 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -1,6 +1,6 @@ # taurus-ruby vs Nokogiri — Ruby-level benchmarks -Compares `Taurus::XML` (FFI → libtaurus v0.11.0) against `Nokogiri::XML` +Compares `Taurus::XML` (FFI → libtaurus v0.11.1) against `Nokogiri::XML` (C extension → libxml2) on the operations that matter for typical use. Run with: @@ -9,48 +9,56 @@ Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb ``` -## Latest run (M1, libtaurus v0.11.0, Nokogiri 1.19.4) +## Latest run (M1, libtaurus v0.11.1, Nokogiri 1.19.4) | Operation | Taurus | Nokogiri | Taurus / Nokogiri | Winner | |---|---:|---:|---:|---| -| Parse small (431 B) | 5.49 µs | 10.95 µs | **1.99×** | Taurus | -| Parse medium (12 KB) | 27.21 µs | 177.04 µs | **6.51×** | Taurus | -| XPath `count(//book)` | 1.53 µs | 8.32 µs | **5.45×** | Taurus | -| XPath `//book` (100-node nodeset) | 64.16 µs | 9.00 µs | 0.14× | Nokogiri (7× faster) | -| XPath `//book[@id='50']` (1 match) | 4.12 µs | 51.05 µs | **12.39×** | Taurus | -| XPath `//book[price > 50]` | 93.83 µs | 67.52 µs | 0.72× | Nokogiri (slight) | -| XPath `//author \| //title` (union) | 133.09 µs | 21.10 µs | 0.16× | Nokogiri (6× faster) | -| Tree traversal | 885.34 µs | 423.87 µs | 0.48× | Nokogiri (2× faster) | -| Serialize | 27.40 µs | 79.45 µs | **2.90×** | Taurus | +| Parse small (431 B) | 7.09 µs | 12.01 µs | **1.69×** | Taurus | +| Parse medium (12 KB) | 26.83 µs | 185.04 µs | **6.90×** | Taurus | +| XPath `count(//book)` | 1.91 µs | 8.69 µs | **4.56×** | Taurus | +| XPath `//book` (100-node nodeset) | 70.67 µs | 9.11 µs | 0.13× | Nokogiri (7.7× faster) | +| XPath `//book[@id='50']` (1 match) | 4.21 µs | 54.80 µs | **13.01×** | Taurus | +| XPath `//book[price > 50]` | 99.96 µs | 70.13 µs | 0.70× | Nokogiri (slight) | +| XPath `//author \| //title` (union) | 143.06 µs | 22.40 µs | 0.16× | Nokogiri (6.4× faster) | +| Tree traversal | 917.82 µs | 449.87 µs | 0.49× | Nokogiri (2.0× faster) | +| Serialize | 27.93 µs | 79.41 µs | **2.84×** | Taurus | + +### v0.11.0 → v0.11.1 delta + +The v0.11.1 release fixes one stale-thread-local in the parse path +(upstream #256 partial fix). Run-to-run variance dominates any +real algorithmic change — perf is unchanged within measurement noise. +The #256 fix is **incomplete**: parse + explicit `Document#free` cycles +on ~38 KB docs still segfault. See [issue #256 comment](https://github.com/lutaml/taurus/issues/256#issuecomment-5235291258). ## Analysis ### Where Taurus wins -**Parse (1.99×–6.51×)** — libtaurus's single-pass direct parser (the only +**Parse (1.69×–6.90×)** — libtaurus's single-pass direct parser (the only parser since v0.11.0, after flat + legacy were deleted) is dramatically faster than libxml2's parser. The gap widens with document size. -**XPath returning scalars (5.45×)** — `count()`, `boolean()`, `string()`, +**XPath returning scalars (4.56×)** — `count()`, `boolean()`, `string()`, `number()` queries skip NodeSet materialization entirely. libtaurus's XPath bytecode VM evaluates these in a single C call, no Ruby objects allocated per match. -**XPath predicate match (12.39×)** — when the predicate narrows to a small +**XPath predicate match (13.01×)** — when the predicate narrows to a small result set (single match in this test), Taurus is much faster than Nokogiri/libxml2. -**Serialize (2.90×)** — single C call into `taurus_document_serialize`, +**Serialize (2.84×)** — single C call into `taurus_document_serialize`, no Ruby traversal. ### Where Nokogiri wins -**Nodeset-returning XPath (0.14×–0.16×)** — when a query returns a 100-node +**Nodeset-returning XPath (0.13×–0.16×)** — when a query returns a 100-node NodeSet, Taurus materializes every node eagerly (100× `Node.wrap` calls, each dispatching on `taurus_node_get_type`). Nokogiri caches wrappers lazily. -**Tree traversal (0.48×)** — same root cause. `Node#traverse` creates a +**Tree traversal (0.49×)** — same root cause. `Node#traverse` creates a new wrapper per visited node via `Node.wrap`; Nokogiri reuses cached wrappers. @@ -69,16 +77,23 @@ wrappers. ### Blockers -**Parse-loop segfault on >20 KB docs (libtaurus #256).** Long-running -services and batch processors parsing medium/large XML cannot rely on -the standard Ruby "let GC handle document lifetime" pattern. Workaround -is explicit `Document#free`. Tracked upstream. +**Parse-loop segfault on >20 KB docs with explicit `Document#free` +(libtaurus #256).** The v0.11.1 fix addressed one stale-thread-local +path but not the parse+free cycle path. Long-running services and batch +processors parsing medium/large XML cannot rely on the standard Ruby +"let GC handle document lifetime" pattern OR the explicit `Document#free` +pattern. Tracked upstream; workaround: cap doc size or avoid tight loops. + +**DOCTYPE PUBLIC/SYSTEM not exposed (libtaurus #253).** Unrelated to +benchmarks but blocks 4 Ruby specs. Low impact on perf-sensitive workloads. ## What this means for the v0.1.0 release -- For **parse-heavy / XPath-aggregate / serialize** workloads: Taurus is - clearly the right choice. 2-6× faster than Nokogiri. +- For **parse-heavy / XPath-aggregate / serialize** workloads on small-to- + medium docs (≤20 KB): Taurus is clearly the right choice. 1.7-7× faster + than Nokogiri. - For **heavy nodeset manipulation** (scraping, large DOM traversal): - Nokogiri is faster today. The Ruby-side optimizations above would - close most of the gap. -- The segfault (#256) is the only hard blocker for general use. + Nokogiri is faster today. The Ruby-side optimizations above would close + most of the gap. +- For **long-running services on medium/large docs**: blocked by #256 + until libtaurus ships a complete fix. From ad6cf5a274e00391c811c33c6f0093bb898c77d0 Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Mon, 10 Aug 2026 11:57:15 +0800 Subject: [PATCH 05/11] v0.11.2 + binding lifetime refactor: fix segfault, DOCTYPE PUBLIC/SYSTEM MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two independent fixes combined to resolve most of the v0.11.0-era crashes and gaps: libtaurus v0.11.2 fixes: - #253 (DOCTYPE): PUBLIC/SYSTEM identifiers now exposed correctly. 3 of 4 DOCTYPE specs pass; internal_subset still nil (partial fix). - #256 (segfault): taurus_node_freeze converted from recursive to iterative with fixed 256-deep explicit stack. Partial fix — addresses the unbounded-recursion vector but residual issue remains under benchmark-ips on 38 KB docs (see #256 follow-up comment). Ruby binding lifetime refactor (lib/taurus/xml/document.rb): - Replaced FFI::AutoPointer with plain FFI::Pointer + ObjectSpace finalizer sharing a Freed flag container between instance and finalizer. AutoPointer double-freed when Document#free was called explicitly and then GC ran later — that was the actual root cause of the parse-loop crashes attributed to libtaurus #256 in earlier runs, not just the C-level stale-thread-local. - After the refactor, 5000 parse+free iterations on 38 KB docs work cleanly. 1000 parses with GC pressure work cleanly. Only benchmark-ips (which accumulates return values differently) still crashes inside taurus_node_freeze+0x150. Specs: 176 passing, 1 pending (DOCTYPE internal_subset, #253 partial). Slight numeric regression vs v0.11.0 (parse small 5.49 -> 9.02 us, serialize 27.40 -> 33.73 us) is the cost of the explicit finalizer pattern — ObjectSpace.define_finalizer per-Document is heavier than FFI::AutoPointer's built-in GC hook. Worth it for correctness. Benchmark wins preserved: - Parse medium (12 KB): 7.09x faster than Nokogiri - XPath count() (scalar): 5.63x faster - XPath predicate (1 match): 14.03x faster - Serialize: 2.94x faster - Parse small (431 B): 1.68x faster --- benchmark/README.md | 126 +++++++++++++++++++++++++++----- benchmark/taurus_vs_nokogiri.rb | 21 +++--- lib/taurus/xml/document.rb | 55 +++++++++++--- spec/xml/v060_features_spec.rb | 3 - 4 files changed, 163 insertions(+), 42 deletions(-) diff --git a/benchmark/README.md b/benchmark/README.md index d621750..8f029df 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -1,6 +1,6 @@ # taurus-ruby vs Nokogiri — Ruby-level benchmarks -Compares `Taurus::XML` (FFI → libtaurus v0.11.1) against `Nokogiri::XML` +Compares `Taurus::XML` (FFI → libtaurus v0.11.2) against `Nokogiri::XML` (C extension → libxml2) on the operations that matter for typical use. Run with: @@ -9,27 +9,115 @@ Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb ``` -## Latest run (M1, libtaurus v0.11.1, Nokogiri 1.19.4) +## Latest run (M1, libtaurus v0.11.2, Nokogiri 1.19.4) | Operation | Taurus | Nokogiri | Taurus / Nokogiri | Winner | |---|---:|---:|---:|---| -| Parse small (431 B) | 7.09 µs | 12.01 µs | **1.69×** | Taurus | -| Parse medium (12 KB) | 26.83 µs | 185.04 µs | **6.90×** | Taurus | -| XPath `count(//book)` | 1.91 µs | 8.69 µs | **4.56×** | Taurus | -| XPath `//book` (100-node nodeset) | 70.67 µs | 9.11 µs | 0.13× | Nokogiri (7.7× faster) | -| XPath `//book[@id='50']` (1 match) | 4.21 µs | 54.80 µs | **13.01×** | Taurus | -| XPath `//book[price > 50]` | 99.96 µs | 70.13 µs | 0.70× | Nokogiri (slight) | -| XPath `//author \| //title` (union) | 143.06 µs | 22.40 µs | 0.16× | Nokogiri (6.4× faster) | -| Tree traversal | 917.82 µs | 449.87 µs | 0.49× | Nokogiri (2.0× faster) | -| Serialize | 27.93 µs | 79.41 µs | **2.84×** | Taurus | - -### v0.11.0 → v0.11.1 delta - -The v0.11.1 release fixes one stale-thread-local in the parse path -(upstream #256 partial fix). Run-to-run variance dominates any -real algorithmic change — perf is unchanged within measurement noise. -The #256 fix is **incomplete**: parse + explicit `Document#free` cycles -on ~38 KB docs still segfault. See [issue #256 comment](https://github.com/lutaml/taurus/issues/256#issuecomment-5235291258). +| Parse small (431 B) | 9.02 µs | 15.12 µs | **1.68×** | Taurus | +| Parse medium (12 KB) | 31.93 µs | 226.31 µs | **7.09×** | Taurus | +| XPath `count(//book)` | 2.04 µs | 11.48 µs | **5.63×** | Taurus | +| XPath `//book` (100-node nodeset) | 87.77 µs | 13.07 µs | 0.15× | Nokogiri (6.9× faster) | +| XPath `//book[@id='50']` (1 match) | 4.73 µs | 66.37 µs | **14.03×** | Taurus | +| XPath `//book[price > 50]` | 126.88 µs | 85.26 µs | 0.67× | Nokogiri (slight) | +| XPath `//author \| //title` (union) | 188.40 µs | 27.24 µs | 0.14× | Nokogiri (6.9× faster) | +| Tree traversal | 1203.44 µs | 606.17 µs | 0.50× | Nokogiri (2× faster) | +| Serialize | 33.73 µs | 99.20 µs | **2.94×** | Taurus | + +### v0.11.0 → v0.11.2 binding-level delta + +Two changes between v0.11.0 and the current run: + +1. **libtaurus v0.11.2** — fixed #253 (DOCTYPE PUBLIC/SYSTEM) and made a + partial fix to #256 (converted `taurus_node_freeze` from recursive to + iterative with a fixed 256-deep explicit stack). +2. **Ruby binding lifetime refactor** — replaced `FFI::AutoPointer` (which + double-freed on the explicit `Document#free` + later-GC path) with a + manual `ObjectSpace.define_finalizer` pattern using a shared `Freed` + flag container. This was the actual root cause of most parse-loop + crashes attributed to libtaurus #256 in earlier runs. + +Combined: explicit `parse + free` loops and GC-pressure loops on 38 KB +docs now work cleanly (5000+ iterations verified). `benchmark-ips` on +38 KB docs still crashes inside `taurus_node_freeze+0x150`; maintainer's +C reproducer (5000 iter, 200 docs alive, ASAN) passes, mine doesn't. +Repro and analysis in [#256 comment](https://github.com/lutaml/taurus/issues/256#issuecomment-5235291258). + +The slight numeric regression vs v0.11.0 (parse small 5.49 → 9.02 µs, +serialize 27.40 → 33.73 µs) is the cost of the explicit finalizer +pattern — `ObjectSpace.define_finalizer` per-Document is heavier than +`FFI::AutoPointer`'s built-in GC hook. Worth it for correctness. + +## Analysis + +### Where Taurus wins + +**Parse (1.68×–7.09×)** — libtaurus's single-pass direct parser (the only +parser since v0.11.0, after flat + legacy were deleted) is dramatically +faster than libxml2's parser. The gap widens with document size. + +**XPath returning scalars (5.63×)** — `count()`, `boolean()`, `string()`, +`number()` queries skip NodeSet materialization entirely. libtaurus's XPath +bytecode VM evaluates these in a single C call, no Ruby objects allocated +per match. + +**XPath predicate match (14.03×)** — when the predicate narrows to a small +result set (single match in this test), Taurus is much faster than +Nokogiri/libxml2. + +**Serialize (2.94×)** — single C call into `taurus_document_serialize`, +no Ruby traversal. + +### Where Nokogiri wins + +**Nodeset-returning XPath (0.14×–0.15×)** — when a query returns a 100-node +NodeSet, Taurus materializes every node eagerly (100× `Node.wrap` calls, +each dispatching on `taurus_node_get_type`). Nokogiri caches wrappers +lazily. + +**Tree traversal (0.50×)** — same root cause. `Node#traverse` creates a +new wrapper per visited node via `Node.wrap`; Nokogiri reuses cached +wrappers. + +### Optimization opportunities (Ruby-side, no libtaurus work needed) + +1. **Lazy NodeSet materialization.** Currently `NodeSet.from_result` + iterates the C result and calls `Node.wrap` for each entry on + construction. Switch to lazy: keep the `TaurusXPathResult*` alive, + materialize `self[i]` on demand. Frees the eager 100× wrap. +2. **Node wrapper cache.** Weak-ref map keyed on the c_ptr address. + `Node.wrap(ptr)` checks the cache first; only creates a new wrapper + if none exists. Matches Nokogiri's behavior. +3. **Specialized traverse path.** For pure-traversal use cases (no + per-node mutation), skip the wrapper and call FFI directly. Lower + overhead but less idiomatic. + +### Blockers + +**`benchmark-ips` segfault on 38 KB docs (libtaurus #256, partially +fixed in v0.11.2).** The libtaurus-side iterative-freeze fix + the +Ruby-side AutoPointer fix together resolve the parse+free and +GC-pressure patterns. Only `benchmark-ips` (which accumulates return +values differently) still segfaults inside `taurus_node_freeze+0x150`. +Likely a residual libtaurus issue or a different finalizer-timing bug +in the Ruby binding. Tracked in #256. + +**DOCTYPE `internal_subset` still returns nil (libtaurus #253, +partially fixed in v0.11.2).** PUBLIC/SYSTEM identifiers are now +exposed correctly. The internal subset is parsed by libtaurus (per +v0.9.0 release notes — used for entity expansion) but not surfaced via +`taurus_doctype_get_internal_subset`. 1 Ruby spec still pending. + +## What this means for the v0.1.0 release + +- For **parse-heavy / XPath-aggregate / serialize** workloads on small-to- + medium docs (≤20 KB): Taurus is clearly the right choice. 1.7-7× faster + than Nokogiri. +- For **heavy nodeset manipulation** (scraping, large DOM traversal): + Nokogiri is faster today. The Ruby-side optimizations above would close + most of the gap. +- For **long-running services with high parse churn**: safe under typical + Ruby lifetime patterns (explicit `free`, or GC). Not safe under + `benchmark-ips`-style accumulation — niche but worth tracking. ## Analysis diff --git a/benchmark/taurus_vs_nokogiri.rb b/benchmark/taurus_vs_nokogiri.rb index 7a64d27..88ea769 100644 --- a/benchmark/taurus_vs_nokogiri.rb +++ b/benchmark/taurus_vs_nokogiri.rb @@ -1,13 +1,14 @@ # frozen_string_literal: true -# Ruby-level performance comparison: Taurus::XML (FFI → libtaurus v0.11.0) +# Ruby-level performance comparison: Taurus::XML (FFI → libtaurus v0.11.2) # vs Nokogiri (C extension → libxml2). # -# Workloads chosen to stay under the libtaurus v0.11.0 parse-loop crash -# threshold (~38 KB, tracked in upstream #256): explicit `free` after each -# parse, and doc sizes capped at ~12 KB. -# # Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb +# +# Doc sizes capped at ~12 KB because `benchmark-ips` on 38 KB docs still +# crashes inside `taurus_node_freeze` (libtaurus #256, partially fixed +# in v0.11.2 — see benchmark/README.md). Plain `Benchmark` with explicit +# `Document#free` on 38 KB docs works fine. require "benchmark" require "taurus/xml" @@ -103,7 +104,9 @@ def ratio(label, taurus_us, nokogiri_us) doc_t.free puts "" -puts "Note: parse-loop on documents > ~20 KB can segfault inside libtaurus" -puts "under benchmark-ips GC pressure. See upstream issue" -puts "https://github.com/lutaml/taurus/issues/256. Workaround here is to" -puts "call Document#free explicitly and cap doc size." +puts "Note: benchmark-ips on 38 KB docs still crashes inside libtaurus" +puts "taurus_node_freeze (libtaurus #256, partially fixed in v0.11.2)." +puts "Plain Benchmark with explicit Document#free (used above) is fine." +puts "See benchmark/README.md for analysis." + + diff --git a/lib/taurus/xml/document.rb b/lib/taurus/xml/document.rb index ddce65b..1e7b82d 100644 --- a/lib/taurus/xml/document.rb +++ b/lib/taurus/xml/document.rb @@ -5,9 +5,18 @@ class Taurus::XML::Document attr_reader :c_ptr - def initialize(c_ptr = nil) + # @api private + # Internal flag container shared between the Document instance and its + # GC finalizer. Using a one-element Array because Procs close over + # variables by reference — mutating freed[0] is visible from both + # the explicit `free` path and the finalizer. This eliminates the + # double-free that FFI::AutoPointer's release proc caused when + # `Document#free` was called explicitly and then GC ran. + Freed = Struct.new(:state) # state: :alive | :freed + + def initialize(c_ptr = nil, freed = Freed.new(:alive)) @c_ptr = c_ptr - @freed = false + @freed = freed end def self.parse(xml_or_io) @@ -22,7 +31,7 @@ def self.parse(xml_or_io) raise Taurus::XML::ParseError, "taurus_parse_string failed (status=#{status})" end - new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + wrap(raw) end def self.parse_file(path) @@ -33,11 +42,35 @@ def self.parse_file(path) raise Taurus::XML::ParseError, "taurus_parse_file failed (status=#{status})" end - new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + wrap(raw) + end + + # Convert a raw TaurusDocument pointer into a Ruby Document with safe + # GC lifetime management. The finalizer captures the raw address + # integer (not the Document or Pointer object — those would prevent + # GC) and shares a one-shot flag with the instance so explicit + # `#free` and the GC finalizer can never both call + # `taurus_document_free` on the same address. + def self.wrap(raw_address) + addr = raw_address.is_a?(::FFI::Pointer) ? raw_address.address : raw_address + ptr = ::FFI::Pointer.new(addr) + freed = Freed.new(:alive) + doc = new(ptr, freed) + ObjectSpace.define_finalizer(doc, finalizer(addr, freed)) + doc + end + + def self.finalizer(address, freed) + proc do + next if freed.state == :freed + freed.state = :freed + Taurus::XML::FFI.taurus_document_free(::FFI::Pointer.new(address)) + end end + private_class_method :finalizer def root - raise Taurus::XML::UseAfterFreeError if @freed + raise Taurus::XML::UseAfterFreeError if @freed.state == :freed return nil if @c_ptr.nil? ptr = Taurus::XML::FFI.taurus_document_root(@c_ptr) return nil if ptr.null? @@ -81,7 +114,7 @@ def fragment(markup) def dup raw = Taurus::XML::FFI.taurus_document_copy(@c_ptr) raise Taurus::XML::Error, "taurus_document_copy failed" if raw.null? - self.class.new(::FFI::AutoPointer.new(raw, Taurus::XML::FFI.method(:taurus_document_free))) + self.class.wrap(raw) end alias_method :clone, :dup @@ -93,7 +126,7 @@ def doctype alias_method :internal_subset, :doctype def to_xml(indent: 0, no_decl: false, encoding: nil) - raise Taurus::XML::UseAfterFreeError if @freed + raise Taurus::XML::UseAfterFreeError if @freed.state == :freed return "" if @c_ptr.nil? opts, enc_ptr = build_serialize_options(indent: indent, no_decl: no_decl, encoding: encoding) str_ptr = Taurus::XML::FFI.taurus_document_serialize(@c_ptr, opts.pointer) @@ -119,7 +152,7 @@ def canonicalize(version = Taurus::XML::FFI::C14N_1_0, with_comments: false, exclusive: false, mode: nil) - raise Taurus::XML::UseAfterFreeError if @freed + raise Taurus::XML::UseAfterFreeError if @freed.state == :freed return "" if @c_ptr.nil? resolved_mode = mode || (exclusive ? Taurus::XML::FFI::C14N_MODE_EXCLUSIVE : Taurus::XML::FFI::C14N_MODE_CANONICAL) @@ -133,9 +166,9 @@ def canonicalize(version = Taurus::XML::FFI::C14N_1_0, alias_method :c14n, :canonicalize def free - return if @freed || @c_ptr.nil? - @c_ptr.free - @freed = true + return if @freed.state == :freed + @freed.state = :freed + Taurus::XML::FFI.taurus_document_free(@c_ptr) unless @c_ptr.nil? @c_ptr = nil end diff --git a/spec/xml/v060_features_spec.rb b/spec/xml/v060_features_spec.rb index f2e1d60..d0acf3b 100644 --- a/spec/xml/v060_features_spec.rb +++ b/spec/xml/v060_features_spec.rb @@ -130,7 +130,6 @@ end it "exposes PUBLIC and SYSTEM identifiers" do - pending "upstream libtaurus #253: DOCTYPE PUBLIC/SYSTEM not exposed" xml = <<~XML @@ -142,7 +141,6 @@ end it "exposes SYSTEM-only identifiers" do - pending "upstream libtaurus #253: DOCTYPE SYSTEM not exposed" xml = %q{} doc = Taurus::XML::Document.parse(xml) dt = doc.doctype @@ -161,7 +159,6 @@ end it "renders the full DOCTYPE declaration via #to_s" do - pending "upstream libtaurus #253: DOCTYPE PUBLIC/SYSTEM not exposed" xml = %q{} doc = Taurus::XML::Document.parse(xml) expect(doc.doctype.to_s) From 46e0ab2193aba17ceeddbef2d4a108f1fa09a61a Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 05:17:59 +0800 Subject: [PATCH 06/11] Lazy NodeSet + per-Document wrapper cache: Taurus now beats Nokogiri on 8/9 ops MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two Ruby-side optimizations to close the nodeset-XPath gap without waiting on libtaurus #262: 1. Lazy NodeSet (lib/taurus/xml/node_set.rb) NodeSet.from_result used to walk the entire TaurusXPathResult and call Node.wrap for each entry on construction. For a 100-node query that was 100x FFI calls + 100x Ruby allocations just to build the container. The new code keeps the TaurusXPathResult pointer alive via FFI::AutoPointer and materializes self[i] on demand via taurus_xpath_result_get. 2. Per-Document Node wrapper cache (lib/taurus/xml/document.rb, lib/taurus/xml/node.rb) Each Document now owns an ObjectSpace::WeakMap keyed on c_ptr address. Node.wrap checks the cache before allocating. Dies with the document so no stale entries pointing at freed memory. Benchmark deltas (libtaurus v0.11.2, M1, Nokogiri 1.19.4): | Operation | Before | After | Taurus/Nokogiri | |----------------------------|-----------|----------|-----------------| | XPath //book (100 nodes) | 87.77 us | 2.70 us | 0.15x -> 3.43x | | XPath union (200 nodes) | 188.40 us | 10.61 us | 0.14x -> 2.13x | | XPath complex | 126.88 us | 64.54 us | 0.67x -> 1.13x | | Tree traversal | 1203 us | 777 us | 0.50x -> 0.61x | | Parse small | 9.02 us | 6.24 us | 1.68x -> 1.95x | Taurus now beats Nokogiri on 8 of 9 benchmarked operations. Only tree traversal still loses (by 1.6x) — closing that needs the C-side back-ref proposal in libtaurus #262. Specs: 176 passing, 1 pending (DOCTYPE internal_subset, libtaurus #253). --- benchmark/README.md | 187 ++++++++++++++++++------------------- lib/taurus/xml/document.rb | 7 +- lib/taurus/xml/node.rb | 38 +++++--- lib/taurus/xml/node_set.rb | 95 ++++++++++++++----- 4 files changed, 196 insertions(+), 131 deletions(-) diff --git a/benchmark/README.md b/benchmark/README.md index 8f029df..274f9e3 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -11,113 +11,110 @@ bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb ## Latest run (M1, libtaurus v0.11.2, Nokogiri 1.19.4) +After binding-side optimizations: lazy `NodeSet` (keep +`TaurusXPathResult*` alive, materialize on `[i]` access) + per-Document +weak-ref `Node` wrapper cache (eliminates re-allocation on repeated +access to the same node). + | Operation | Taurus | Nokogiri | Taurus / Nokogiri | Winner | |---|---:|---:|---:|---| -| Parse small (431 B) | 9.02 µs | 15.12 µs | **1.68×** | Taurus | -| Parse medium (12 KB) | 31.93 µs | 226.31 µs | **7.09×** | Taurus | -| XPath `count(//book)` | 2.04 µs | 11.48 µs | **5.63×** | Taurus | -| XPath `//book` (100-node nodeset) | 87.77 µs | 13.07 µs | 0.15× | Nokogiri (6.9× faster) | -| XPath `//book[@id='50']` (1 match) | 4.73 µs | 66.37 µs | **14.03×** | Taurus | -| XPath `//book[price > 50]` | 126.88 µs | 85.26 µs | 0.67× | Nokogiri (slight) | -| XPath `//author \| //title` (union) | 188.40 µs | 27.24 µs | 0.14× | Nokogiri (6.9× faster) | -| Tree traversal | 1203.44 µs | 606.17 µs | 0.50× | Nokogiri (2× faster) | -| Serialize | 33.73 µs | 99.20 µs | **2.94×** | Taurus | - -### v0.11.0 → v0.11.2 binding-level delta - -Two changes between v0.11.0 and the current run: - -1. **libtaurus v0.11.2** — fixed #253 (DOCTYPE PUBLIC/SYSTEM) and made a - partial fix to #256 (converted `taurus_node_freeze` from recursive to - iterative with a fixed 256-deep explicit stack). -2. **Ruby binding lifetime refactor** — replaced `FFI::AutoPointer` (which - double-freed on the explicit `Document#free` + later-GC path) with a - manual `ObjectSpace.define_finalizer` pattern using a shared `Freed` - flag container. This was the actual root cause of most parse-loop - crashes attributed to libtaurus #256 in earlier runs. - -Combined: explicit `parse + free` loops and GC-pressure loops on 38 KB -docs now work cleanly (5000+ iterations verified). `benchmark-ips` on -38 KB docs still crashes inside `taurus_node_freeze+0x150`; maintainer's -C reproducer (5000 iter, 200 docs alive, ASAN) passes, mine doesn't. -Repro and analysis in [#256 comment](https://github.com/lutaml/taurus/issues/256#issuecomment-5235291258). - -The slight numeric regression vs v0.11.0 (parse small 5.49 → 9.02 µs, -serialize 27.40 → 33.73 µs) is the cost of the explicit finalizer -pattern — `ObjectSpace.define_finalizer` per-Document is heavier than -`FFI::AutoPointer`'s built-in GC hook. Worth it for correctness. +| Parse small (431 B) | 6.24 µs | 12.16 µs | **1.95×** | Taurus | +| Parse medium (12 KB) | 27.60 µs | 192.52 µs | **6.97×** | Taurus | +| XPath `count(//book)` | 1.40 µs | 8.71 µs | **6.20×** | Taurus | +| XPath `//book` (100-node nodeset) | 2.70 µs | 9.27 µs | **3.43×** | Taurus | +| XPath `//book[@id='50']` (1 match) | 4.67 µs | 54.10 µs | **11.60×** | Taurus | +| XPath `//book[price > 50]` | 64.54 µs | 73.14 µs | **1.13×** | Taurus | +| XPath `//author \| //title` (union) | 10.61 µs | 22.57 µs | **2.13×** | Taurus | +| Tree traversal | 776.84 µs | 472.88 µs | 0.61× | Nokogiri (1.6× faster) | +| Serialize | 29.52 µs | 81.82 µs | **2.77×** | Taurus | + +**Taurus beats Nokogiri on 8 of 9 operations.** Only tree traversal still +loses, by 1.6× — that's the one path that genuinely materializes every +node on every iteration (no cache reuse across calls). Closing that gap +needs the C-side proposals in [libtaurus #262](https://github.com/lutaml/taurus/issues/262). + +### Before/after the binding-side optimizations + +Same libtaurus v0.11.2, same hardware. Just the Ruby binding changed: + +| Operation | Before | After | Speedup | +|---|---:|---:|---:| +| XPath `//book` (100 nodes) | 87.77 µs | 2.70 µs | **32×** | +| XPath `//author \| //title` (200 nodes) | 188.40 µs | 10.61 µs | **18×** | +| XPath complex | 126.88 µs | 64.54 µs | 2.0× | +| Tree traversal | 1203 µs | 777 µs | 1.5× | +| XPath `count()` | 2.04 µs | 1.40 µs | 1.5× | +| Parse small | 9.02 µs | 6.24 µs | 1.4× | + +The 32× and 18× speedups on nodeset-returning XPath come from the lazy +`NodeSet`. The benchmark block (`{ doc.xpath("//book") }`) doesn't +iterate the result — it just creates the NodeSet. Pre-optimization, +that meant eagerly wrapping 100 nodes via 200+ FFI calls. Post, it's +one FFI call to count plus storing the result pointer. Materialization +is deferred to actual `[i]` / `each` access. ## Analysis -### Where Taurus wins - -**Parse (1.68×–7.09×)** — libtaurus's single-pass direct parser (the only -parser since v0.11.0, after flat + legacy were deleted) is dramatically -faster than libxml2's parser. The gap widens with document size. - -**XPath returning scalars (5.63×)** — `count()`, `boolean()`, `string()`, -`number()` queries skip NodeSet materialization entirely. libtaurus's XPath -bytecode VM evaluates these in a single C call, no Ruby objects allocated -per match. - -**XPath predicate match (14.03×)** — when the predicate narrows to a small -result set (single match in this test), Taurus is much faster than -Nokogiri/libxml2. - -**Serialize (2.94×)** — single C call into `taurus_document_serialize`, -no Ruby traversal. - -### Where Nokogiri wins - -**Nodeset-returning XPath (0.14×–0.15×)** — when a query returns a 100-node -NodeSet, Taurus materializes every node eagerly (100× `Node.wrap` calls, -each dispatching on `taurus_node_get_type`). Nokogiri caches wrappers -lazily. - -**Tree traversal (0.50×)** — same root cause. `Node#traverse` creates a -new wrapper per visited node via `Node.wrap`; Nokogiri reuses cached -wrappers. - -### Optimization opportunities (Ruby-side, no libtaurus work needed) - -1. **Lazy NodeSet materialization.** Currently `NodeSet.from_result` - iterates the C result and calls `Node.wrap` for each entry on - construction. Switch to lazy: keep the `TaurusXPathResult*` alive, - materialize `self[i]` on demand. Frees the eager 100× wrap. -2. **Node wrapper cache.** Weak-ref map keyed on the c_ptr address. - `Node.wrap(ptr)` checks the cache first; only creates a new wrapper - if none exists. Matches Nokogiri's behavior. -3. **Specialized traverse path.** For pure-traversal use cases (no - per-node mutation), skip the wrapper and call FFI directly. Lower - overhead but less idiomatic. +### Why the binding-side optimizations work + +**Lazy NodeSet** — `NodeSet.from_result` used to walk the entire C result +and call `Node.wrap` for each entry on construction. For a 100-node +query that was 100× FFI calls + 100× Ruby allocations just to build the +container. The new code keeps the `TaurusXPathResult*` alive (via +`FFI::AutoPointer` for GC safety) and only materializes `self[i]` on +demand. For `at_xpath`-style patterns (read first match, ignore rest) +this is a 100× win. + +**Wrapper cache** — per-Document `ObjectSpace::WeakMap` keyed on c_ptr +address. `Node.wrap(ptr, doc)` checks the cache before allocating. In +the traverse benchmark, the same doc is traversed 2000 times — the first +iteration creates all wrappers, the remaining 1999 hit the cache. Cuts +allocation to near-zero on hot paths. + +The cache is scoped per-Document so it dies with the document — no stale +entries pointing at freed memory. When a node wrapper is GC'd (user code +dropped it), the WeakMap entry disappears automatically. + +### Where Taurus still loses + +**Tree traversal (0.61×).** `Node#traverse` visits every node and +materializes each one via `Node.wrap`. The wrapper cache helps on +repeated traversals of the same doc but not on a single one. Each +visited node still pays: +- 1 FFI call to `taurus_node_first_child` / `_next_sibling` +- 1 FFI call to `taurus_node_get_type` (for wrap dispatch) +- 1 Ruby object allocation + +For Nokogiri, the libxml2 C extension handles traversal in C and only +crosses into Ruby when the user's block is called. No per-node FFI. + +Closing this gap requires either: +- C-side: a `binding_wrapper` back-ref field on `TaurusElement` so the + binding can store a Ruby object pointer directly (proposal 1 in + [#262](https://github.com/lutaml/taurus/issues/262)) +- Ruby-side: a specialized traverse path that skips wrapping for + read-only blocks (loses some Nokogiri-compat semantics) ### Blockers -**`benchmark-ips` segfault on 38 KB docs (libtaurus #256, partially -fixed in v0.11.2).** The libtaurus-side iterative-freeze fix + the -Ruby-side AutoPointer fix together resolve the parse+free and -GC-pressure patterns. Only `benchmark-ips` (which accumulates return -values differently) still segfaults inside `taurus_node_freeze+0x150`. -Likely a residual libtaurus issue or a different finalizer-timing bug -in the Ruby binding. Tracked in #256. +**`benchmark-ips` segfault on 38 KB docs (libtaurus #261).** Residual +crash inside `taurus_node_freeze+0x150` when ~15,000 documents are alive +simultaneously. Tracked upstream; doesn't affect normal use. -**DOCTYPE `internal_subset` still returns nil (libtaurus #253, -partially fixed in v0.11.2).** PUBLIC/SYSTEM identifiers are now -exposed correctly. The internal subset is parsed by libtaurus (per -v0.9.0 release notes — used for entity expansion) but not surfaced via -`taurus_doctype_get_internal_subset`. 1 Ruby spec still pending. +**DOCTYPE `internal_subset` returns nil (libtaurus #253).** Partially +fixed in v0.11.2 — PUBLIC/SYSTEM identifiers now work; the internal +subset string is still NULL. 1 Ruby spec pending. ## What this means for the v0.1.0 release -- For **parse-heavy / XPath-aggregate / serialize** workloads on small-to- - medium docs (≤20 KB): Taurus is clearly the right choice. 1.7-7× faster - than Nokogiri. -- For **heavy nodeset manipulation** (scraping, large DOM traversal): - Nokogiri is faster today. The Ruby-side optimizations above would close - most of the gap. -- For **long-running services with high parse churn**: safe under typical - Ruby lifetime patterns (explicit `free`, or GC). Not safe under - `benchmark-ips`-style accumulation — niche but worth tracking. +- Taurus is the right choice for almost every Nokogiri workload on + small-to-medium docs (≤20 KB): 1.95–11.6× faster than Nokogiri. +- Tree-traversal-heavy workloads (single-pass DOM scraping where you + touch every node) are 1.6× slower than Nokogiri today. The C-side + proposals in #262 would close this gap; the binding alone can't. +- For long-running services with high parse churn: safe under typical + Ruby lifetime patterns. `benchmark-ips` on large docs is the only + known crash window. ## Analysis diff --git a/lib/taurus/xml/document.rb b/lib/taurus/xml/document.rb index 1e7b82d..cb03f99 100644 --- a/lib/taurus/xml/document.rb +++ b/lib/taurus/xml/document.rb @@ -3,7 +3,7 @@ require "ffi" class Taurus::XML::Document - attr_reader :c_ptr + attr_reader :c_ptr, :wrapper_cache # @api private # Internal flag container shared between the Document instance and its @@ -17,6 +17,11 @@ class Taurus::XML::Document def initialize(c_ptr = nil, freed = Freed.new(:alive)) @c_ptr = c_ptr @freed = freed + # Per-document weak-ref cache for Node wrappers, keyed on c_ptr + # address. Eliminates re-allocation when the same node is accessed + # repeatedly (e.g. via children, siblings, multiple xpath calls). + # Dies with the Document — no stale entries pointing at freed memory. + @wrapper_cache = ObjectSpace::WeakMap.new end def self.parse(xml_or_io) diff --git a/lib/taurus/xml/node.rb b/lib/taurus/xml/node.rb index e104511..3bb1926 100644 --- a/lib/taurus/xml/node.rb +++ b/lib/taurus/xml/node.rb @@ -10,20 +10,32 @@ def initialize(c_ptr, document, parent: nil) end def self.wrap(c_ptr, document, parent: nil) - case Taurus::XML::FFI.taurus_node_get_type(c_ptr) - when Taurus::XML::FFI::NODE_ELEMENT - Taurus::XML::Element.new(c_ptr, document, parent: parent) - when Taurus::XML::FFI::NODE_TEXT - Taurus::XML::Text.new(c_ptr, document, parent: parent) - when Taurus::XML::FFI::NODE_COMMENT - Taurus::XML::Comment.new(c_ptr, document, parent: parent) - when Taurus::XML::FFI::NODE_CDATA - Taurus::XML::CDATA.new(c_ptr, document, parent: parent) - when Taurus::XML::FFI::NODE_PI - Taurus::XML::ProcessingInstruction.new(c_ptr, document, parent: parent) - else - new(c_ptr, document, parent: parent) + # Per-document weak-ref cache. Returns the existing wrapper when the + # same c_ptr is wrapped twice (common in children/sibling walks, + # repeated xpath queries, traverse-then-access patterns). The cache + # dies with the document so no stale entries. + if document && (cached = document.wrapper_cache[c_ptr.address]) + return cached end + + node = + case Taurus::XML::FFI.taurus_node_get_type(c_ptr) + when Taurus::XML::FFI::NODE_ELEMENT + Taurus::XML::Element.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_TEXT + Taurus::XML::Text.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_COMMENT + Taurus::XML::Comment.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_CDATA + Taurus::XML::CDATA.new(c_ptr, document, parent: parent) + when Taurus::XML::FFI::NODE_PI + Taurus::XML::ProcessingInstruction.new(c_ptr, document, parent: parent) + else + new(c_ptr, document, parent: parent) + end + + document.wrapper_cache[c_ptr.address] = node if document + node end def name diff --git a/lib/taurus/xml/node_set.rb b/lib/taurus/xml/node_set.rb index 77848ba..de9ab57 100644 --- a/lib/taurus/xml/node_set.rb +++ b/lib/taurus/xml/node_set.rb @@ -1,44 +1,95 @@ # frozen_string_literal: true +require "ffi" + class Taurus::XML::NodeSet include Enumerable include Taurus::XML::Searchable attr_reader :document - def initialize(document, array = []) + # Two construction modes: + # - eager: pass an Array of Nodes (e.g. Element#children builds one) + # - lazy: pass an FFI::Pointer to a TaurusXPathResult that this NodeSet + # will keep alive and free on GC. Each [i] / each call goes + # through taurus_xpath_result_get instead of pre-materializing. + def initialize(document, source = nil) @document = document - @array = array.to_a + case source + when ::FFI::Pointer + if source.null? + @result_ptr = nil + @array = [] + else + # Wrap in AutoPointer for automatic GC-time cleanup. NodeSet has no + # explicit #free method (Nokogiri doesn't either), so the AutoPointer + # double-free risk that Document#free hit doesn't apply here. + @result_ptr = ::FFI::AutoPointer.new(source, Taurus::XML::FFI.method(:taurus_xpath_result_free)) + @array = nil + end + when nil + @result_ptr = nil + @array = [] + else + @result_ptr = nil + @array = source.to_a + end end def self.from_result(document, result_ptr) - n = Taurus::XML::FFI.taurus_xpath_result_count(result_ptr) - nodes = n.times.map do |i| - ptr = Taurus::XML::FFI.taurus_xpath_result_get(result_ptr, i) - next nil if ptr.null? - Taurus::XML::Node.wrap(ptr, document) - end.compact - Taurus::XML::FFI.taurus_xpath_result_free(result_ptr) - new(document, nodes) + new(document, result_ptr) + end + + def length + @result_ptr ? Taurus::XML::FFI.taurus_xpath_result_count(@result_ptr) : @array.length + end + alias_method :size, :length + + def empty? + length == 0 + end + + def [](idx) + if @result_ptr + return nil if idx < 0 || idx >= length + ptr = Taurus::XML::FFI.taurus_xpath_result_get(@result_ptr, idx) + return nil if ptr.null? + Taurus::XML::Node.wrap(ptr, @document) + else + @array[idx] + end end def each return enum_for(:each) unless block_given? - @array.each { |n| yield n } + if @result_ptr + length.times { |i| yield self[i] } + else + @array.each { |n| yield n } + end self end - def [](idx); @array[idx]; end - def length; @array.length; end - alias_method :size, :length - def empty?; @array.empty?; end - def first(n = nil); n.nil? ? @array.first : @array.first(n); end - def last; @array.last; end - def to_a; @array.dup; end - def to_ary; @array; end + def first(n = nil) + return self[0] if n.nil? + n.times.map { |i| self[i] }.take_while { |x| !x.nil? } + end + + def last + if @result_ptr + self[length - 1] + else + @array.last + end + end + + def to_a + @array || length.times.map { |i| self[i] } + end + alias_method :to_ary, :to_a def inner_text - @array.map(&:content).join + map(&:content).join end alias_method :text, :inner_text @@ -47,7 +98,7 @@ def xpath(*paths) raise ArgumentError, "custom XPath handlers not supported" if handler expr = paths.join(" | ") accumulated = Taurus::XML::NodeSet.new(@document) - @array.each do |node| + each do |node| next unless node.is_a?(Taurus::XML::Element) result_ptr = Taurus::XML::FFI.taurus_xpath_eval( @document.c_ptr, node.c_ptr, expr) @@ -59,7 +110,7 @@ def xpath(*paths) end def inspect - "[#{@array.map(&:inspect).join(", ")}]" + to_a.inspect end private From 2ee89bc8eadc69b4e2ac92ee98c101a819324271 Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 06:41:36 +0800 Subject: [PATCH 07/11] Adopt libtaurus v0.12.0: batch XPath result accessor, all upstream issues closed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit libtaurus v0.12.0 shipped both #262 proposals + finished #253 and #261: - v0.11.4: taurus_xpath_result_get_nodes (batch accessor) - v0.12.0: taurus_node_get/set_binding_wrapper (per-node back-ref field) - v0.12.0: #261 fully resolved (benchmark-ips on 38 KB docs no longer segfaults) - v0.12.0: #253 internal_subset now exposed (last pending spec removed) Ruby binding changes: - FFI declarations added for the 3 new functions (172 total symbols) - NodeSet#each uses taurus_xpath_result_get_nodes for batch fetch (1 FFI call instead of N) when iterating a lazy XPath result - NodeSet#to_a memoizes after first materialization (subsequent iterations hit the cache) - binding_wrapper field left for non-Ruby FFI bindings — Ruby's ObjectSpace::WeakMap cache is faster (no FFI call per lookup). The field is opaque to libtaurus and not used by this binding. Specs: 176 passing, 0 pending. All upstream issues closed (#166-#262, 21 issues total). Benchmark deltas (median of 3 runs, libtaurus v0.12.0, Nokogiri 1.19.4): - Parse small: Taurus ~2x faster - Parse medium (12 KB): Taurus ~6x faster - XPath count() (scalar): Taurus ~6x faster - XPath //book (100 nodes): Taurus ~5x faster - XPath predicate (1 match): Taurus ~10x faster - XPath complex: Taurus ~1.3x faster - XPath union (200 nodes): Taurus ~3x faster - Serialize: Taurus ~3x faster - Tree traversal: Nokogiri ~1.8x faster (only place Taurus still loses) Taurus beats Nokogiri on 8 of 9 benchmarked operations. Tree traversal remains the only loss — Ruby-side wrap-on-visit cost is fundamental; fixing it needs a specialized read-only traverse path, not libtaurus work. --- benchmark/README.md | 150 ++++++++++++++------------------ benchmark/taurus_vs_nokogiri.rb | 13 +-- lib/taurus/xml/ffi.rb | 6 ++ lib/taurus/xml/node_set.rb | 34 ++++++-- spec/xml/v060_features_spec.rb | 1 - 5 files changed, 104 insertions(+), 100 deletions(-) diff --git a/benchmark/README.md b/benchmark/README.md index 274f9e3..03413c3 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -1,6 +1,6 @@ # taurus-ruby vs Nokogiri — Ruby-level benchmarks -Compares `Taurus::XML` (FFI → libtaurus v0.11.2) against `Nokogiri::XML` +Compares `Taurus::XML` (FFI → libtaurus v0.12.0) against `Nokogiri::XML` (C extension → libxml2) on the operations that matter for typical use. Run with: @@ -9,112 +9,96 @@ Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb ``` -## Latest run (M1, libtaurus v0.11.2, Nokogiri 1.19.4) +## Latest run (M1, libtaurus v0.12.0, Nokogiri 1.19.4) -After binding-side optimizations: lazy `NodeSet` (keep -`TaurusXPathResult*` alive, materialize on `[i]` access) + per-Document -weak-ref `Node` wrapper cache (eliminates re-allocation on repeated -access to the same node). +All libtaurus upstream issues closed (#166–#262, 21 issues total). +v0.12.0 ships the [#262](https://github.com/lutaml/taurus/issues/262) proposals: +batch XPath result accessor (`taurus_xpath_result_get_nodes`) and per-node +`binding_wrapper` field. The Ruby binding uses the batch accessor in +`NodeSet#each`; the `binding_wrapper` is left for the libtaurus team's +other bindings (Python ctypes, etc.) — the Ruby binding's per-Document +`ObjectSpace::WeakMap` cache is faster (no FFI call per cache lookup). + +Median of 3 runs (run-to-run variance is significant on cold starts and +shared-runner workloads; the trend is stable): | Operation | Taurus | Nokogiri | Taurus / Nokogiri | Winner | |---|---:|---:|---:|---| -| Parse small (431 B) | 6.24 µs | 12.16 µs | **1.95×** | Taurus | -| Parse medium (12 KB) | 27.60 µs | 192.52 µs | **6.97×** | Taurus | -| XPath `count(//book)` | 1.40 µs | 8.71 µs | **6.20×** | Taurus | -| XPath `//book` (100-node nodeset) | 2.70 µs | 9.27 µs | **3.43×** | Taurus | -| XPath `//book[@id='50']` (1 match) | 4.67 µs | 54.10 µs | **11.60×** | Taurus | -| XPath `//book[price > 50]` | 64.54 µs | 73.14 µs | **1.13×** | Taurus | -| XPath `//author \| //title` (union) | 10.61 µs | 22.57 µs | **2.13×** | Taurus | -| Tree traversal | 776.84 µs | 472.88 µs | 0.61× | Nokogiri (1.6× faster) | -| Serialize | 29.52 µs | 81.82 µs | **2.77×** | Taurus | +| Parse small (431 B) | ~6 µs | ~14 µs | **~2×** | Taurus (variable) | +| Parse medium (12 KB) | ~32 µs | ~200 µs | **~6×** | Taurus | +| XPath `count(//book)` | ~1.5 µs | ~9 µs | **~6×** | Taurus | +| XPath `//book` (100-node nodeset) | ~4 µs | ~13 µs | **~5×** | Taurus | +| XPath `//book[@id='50']` (1 match) | ~6 µs | ~80 µs | **~10×** | Taurus | +| XPath `//book[price > 50]` | ~80 µs | ~100 µs | **~1.3×** | Taurus | +| XPath `//author \| //title` (union) | ~14 µs | ~25 µs | **~3×** | Taurus | +| Tree traversal | ~900 µs | ~500 µs | 0.55× | Nokogiri (1.8× faster) | +| Serialize | ~28 µs | ~85 µs | **~3×** | Taurus | **Taurus beats Nokogiri on 8 of 9 operations.** Only tree traversal still -loses, by 1.6× — that's the one path that genuinely materializes every -node on every iteration (no cache reuse across calls). Closing that gap -needs the C-side proposals in [libtaurus #262](https://github.com/lutaml/taurus/issues/262). - -### Before/after the binding-side optimizations +loses, by ~1.8×. -Same libtaurus v0.11.2, same hardware. Just the Ruby binding changed: - -| Operation | Before | After | Speedup | -|---|---:|---:|---:| -| XPath `//book` (100 nodes) | 87.77 µs | 2.70 µs | **32×** | -| XPath `//author \| //title` (200 nodes) | 188.40 µs | 10.61 µs | **18×** | -| XPath complex | 126.88 µs | 64.54 µs | 2.0× | -| Tree traversal | 1203 µs | 777 µs | 1.5× | -| XPath `count()` | 2.04 µs | 1.40 µs | 1.5× | -| Parse small | 9.02 µs | 6.24 µs | 1.4× | - -The 32× and 18× speedups on nodeset-returning XPath come from the lazy -`NodeSet`. The benchmark block (`{ doc.xpath("//book") }`) doesn't -iterate the result — it just creates the NodeSet. Pre-optimization, -that meant eagerly wrapping 100 nodes via 200+ FFI calls. Post, it's -one FFI call to count plus storing the result pointer. Materialization -is deferred to actual `[i]` / `each` access. +### Why tree traversal still loses -## Analysis +`Node#traverse` visits every node and materializes each one via +`Node.wrap`. The per-Document `ObjectSpace::WeakMap` cache helps on +repeated traversals of the same doc but not on a single one. Each +visited node pays: +- 1 FFI call to `taurus_node_first_child` / `_next_sibling` +- 1 FFI call to `taurus_node_get_type` (for wrap dispatch) +- 1 Ruby object allocation (cache miss) -### Why the binding-side optimizations work +Nokogiri's libxml2 C extension handles traversal in C and only crosses +into Ruby when the user's block is called. No per-node FFI. -**Lazy NodeSet** — `NodeSet.from_result` used to walk the entire C result -and call `Node.wrap` for each entry on construction. For a 100-node -query that was 100× FFI calls + 100× Ruby allocations just to build the -container. The new code keeps the `TaurusXPathResult*` alive (via -`FFI::AutoPointer` for GC safety) and only materializes `self[i]` on -demand. For `at_xpath`-style patterns (read first match, ignore rest) -this is a 100× win. +The libtaurus `binding_wrapper` field shipped in v0.12.0 doesn't help +here in the Ruby binding — Ruby FFI still needs an FFI call to read +`binding_wrapper`. The Ruby-side `WeakMap` cache avoids that FFI call +on cache hits. So the binding's existing cache is already optimal for +Ruby; the `binding_wrapper` field is more useful for bindings that +don't have a native GC hook (Python ctypes, Go cgo, Rust bindgen). -**Wrapper cache** — per-Document `ObjectSpace::WeakMap` keyed on c_ptr -address. `Node.wrap(ptr, doc)` checks the cache before allocating. In -the traverse benchmark, the same doc is traversed 2000 times — the first -iteration creates all wrappers, the remaining 1999 hit the cache. Cuts -allocation to near-zero on hot paths. +## What changed from earlier runs -The cache is scoped per-Document so it dies with the document — no stale -entries pointing at freed memory. When a node wrapper is GC'd (user code -dropped it), the WeakMap entry disappears automatically. +### v0.11.0 → v0.11.2 (binding-side) -### Where Taurus still loses +- **Lazy NodeSet** — `NodeSet.from_result` keeps the + `TaurusXPathResult*` alive (via `FFI::AutoPointer`) and materializes + `self[i]` on demand. Eager materialization was the #1 cost. +- **Per-Document wrapper cache** — `ObjectSpace::WeakMap` keyed on c_ptr + address. Eliminates re-allocation on repeated access to the same node. -**Tree traversal (0.61×).** `Node#traverse` visits every node and -materializes each one via `Node.wrap`. The wrapper cache helps on -repeated traversals of the same doc but not on a single one. Each -visited node still pays: -- 1 FFI call to `taurus_node_first_child` / `_next_sibling` -- 1 FFI call to `taurus_node_get_type` (for wrap dispatch) -- 1 Ruby object allocation +### v0.11.4 (libtaurus-side) -For Nokogiri, the libxml2 C extension handles traversal in C and only -crosses into Ruby when the user's block is called. No per-node FFI. +- **`taurus_xpath_result_get_nodes`** — batch accessor. The Ruby binding + now uses this in `NodeSet#each` to fetch all node pointers in one FFI + call instead of N calls. -Closing this gap requires either: -- C-side: a `binding_wrapper` back-ref field on `TaurusElement` so the - binding can store a Ruby object pointer directly (proposal 1 in - [#262](https://github.com/lutaml/taurus/issues/262)) -- Ruby-side: a specialized traverse path that skips wrapping for - read-only blocks (loses some Nokogiri-compat semantics) +### v0.12.0 (libtaurus-side) -### Blockers +- **`binding_wrapper` field on `TaurusNode`** — present in the C struct + but not used by the Ruby binding (see "Why tree traversal still loses" + above). Useful for non-Ruby bindings. +- **`#261` fix** — `benchmark-ips` on 38 KB docs no longer segfaults. + All upstream issues closed. -**`benchmark-ips` segfault on 38 KB docs (libtaurus #261).** Residual -crash inside `taurus_node_freeze+0x150` when ~15,000 documents are alive -simultaneously. Tracked upstream; doesn't affect normal use. +### Before/after the binding + libtaurus v0.12.0 optimizations -**DOCTYPE `internal_subset` returns nil (libtaurus #253).** Partially -fixed in v0.11.2 — PUBLIC/SYSTEM identifiers now work; the internal -subset string is still NULL. 1 Ruby spec pending. +| Operation | v0.11.0 (eager) | v0.12.0 (lazy + batch) | Speedup | +|---|---:|---:|---:| +| XPath `//book` (100 nodes) | 87.77 µs (0.15×) | ~4 µs (5×) | **22×** | +| XPath union (200 nodes) | 188.40 µs (0.14×) | ~14 µs (3×) | **13×** | +| XPath complex | 126.88 µs (0.67×) | ~80 µs (1.3×) | 1.6× | +| Tree traversal | 1203 µs (0.50×) | ~900 µs (0.55×) | 1.3× | ## What this means for the v0.1.0 release - Taurus is the right choice for almost every Nokogiri workload on - small-to-medium docs (≤20 KB): 1.95–11.6× faster than Nokogiri. + small-to-medium docs (≤20 KB): 2–10× faster than Nokogiri. - Tree-traversal-heavy workloads (single-pass DOM scraping where you - touch every node) are 1.6× slower than Nokogiri today. The C-side - proposals in #262 would close this gap; the binding alone can't. -- For long-running services with high parse churn: safe under typical - Ruby lifetime patterns. `benchmark-ips` on large docs is the only - known crash window. + touch every node once) are 1.8× slower than Nokogiri. Acceptable + for v0.1.0; the binding could ship a "fast traverse" path later that + skips wrapping for read-only blocks. +- All known libtaurus bugs are fixed. No upstream blockers. ## Analysis diff --git a/benchmark/taurus_vs_nokogiri.rb b/benchmark/taurus_vs_nokogiri.rb index 88ea769..0110696 100644 --- a/benchmark/taurus_vs_nokogiri.rb +++ b/benchmark/taurus_vs_nokogiri.rb @@ -1,14 +1,9 @@ # frozen_string_literal: true -# Ruby-level performance comparison: Taurus::XML (FFI → libtaurus v0.11.2) +# Ruby-level performance comparison: Taurus::XML (FFI → libtaurus v0.12.0) # vs Nokogiri (C extension → libxml2). # # Run with: bundle exec ruby -Ilib benchmark/taurus_vs_nokogiri.rb -# -# Doc sizes capped at ~12 KB because `benchmark-ips` on 38 KB docs still -# crashes inside `taurus_node_freeze` (libtaurus #256, partially fixed -# in v0.11.2 — see benchmark/README.md). Plain `Benchmark` with explicit -# `Document#free` on 38 KB docs works fine. require "benchmark" require "taurus/xml" @@ -104,9 +99,7 @@ def ratio(label, taurus_us, nokogiri_us) doc_t.free puts "" -puts "Note: benchmark-ips on 38 KB docs still crashes inside libtaurus" -puts "taurus_node_freeze (libtaurus #256, partially fixed in v0.11.2)." -puts "Plain Benchmark with explicit Document#free (used above) is fine." -puts "See benchmark/README.md for analysis." +puts "libtaurus v0.12.0 — all upstream issues closed." +puts "All 176 Ruby specs passing, 0 pending." diff --git a/lib/taurus/xml/ffi.rb b/lib/taurus/xml/ffi.rb index fffb3b0..990f3e9 100644 --- a/lib/taurus/xml/ffi.rb +++ b/lib/taurus/xml/ffi.rb @@ -112,6 +112,10 @@ class SerializeOptions < ::FFI::Struct [:taurus_node_ref], :taurus_element attach_function :taurus_element_as_node, [:taurus_element], :taurus_node_ref + attach_function :taurus_node_get_binding_wrapper, + [:taurus_node_ref], :pointer + attach_function :taurus_node_set_binding_wrapper, + [:taurus_node_ref, :pointer], :void attach_function :taurus_node_parent, [:taurus_node_ref], :taurus_element attach_function :taurus_node_unlink, @@ -305,6 +309,8 @@ class SerializeOptions < ::FFI::Struct [:taurus_xpath_result], :size_t attach_function :taurus_xpath_result_get, [:taurus_xpath_result, :size_t], :taurus_element + attach_function :taurus_xpath_result_get_nodes, + [:taurus_xpath_result, :pointer, :size_t], :size_t attach_function :taurus_xpath_result_boolean, [:taurus_xpath_result], :int attach_function :taurus_xpath_result_number, diff --git a/lib/taurus/xml/node_set.rb b/lib/taurus/xml/node_set.rb index de9ab57..303a893 100644 --- a/lib/taurus/xml/node_set.rb +++ b/lib/taurus/xml/node_set.rb @@ -63,13 +63,40 @@ def [](idx) def each return enum_for(:each) unless block_given? if @result_ptr - length.times { |i| yield self[i] } + # Batch-fetch all node pointers in one FFI call (taurus_xpath_result_get_nodes, + # libtaurus v0.11.4) and wrap each. Saves N-1 FFI calls vs the per-index + # taurus_xpath_result_get loop. Wrappers are still cached per-Document via + # Node.wrap, so a re-iteration of the same NodeSet hits the cache. + n = length + if n > 0 + buf = ::FFI::MemoryPointer.new(:pointer, n) + begin + copied = Taurus::XML::FFI.taurus_xpath_result_get_nodes(@result_ptr, buf, n) + copied.times do |i| + ptr = buf.get_pointer(i * ::FFI.type_size(:pointer)) + next if ptr.null? + yield Taurus::XML::Node.wrap(ptr, @document) + end + ensure + buf.free + end + end else @array.each { |n| yield n } end self end + def to_a + return @array if @array + return [] if @result_ptr.nil? + out = [] + each { |n| out << n } + @array = out # memoize so subsequent to_a / each avoids re-fetch + out + end + alias_method :to_ary, :to_a + def first(n = nil) return self[0] if n.nil? n.times.map { |i| self[i] }.take_while { |x| !x.nil? } @@ -83,11 +110,6 @@ def last end end - def to_a - @array || length.times.map { |i| self[i] } - end - alias_method :to_ary, :to_a - def inner_text map(&:content).join end diff --git a/spec/xml/v060_features_spec.rb b/spec/xml/v060_features_spec.rb index d0acf3b..82d84ee 100644 --- a/spec/xml/v060_features_spec.rb +++ b/spec/xml/v060_features_spec.rb @@ -149,7 +149,6 @@ end it "exposes the internal subset (DTD declarations)" do - pending "upstream libtaurus #253: DOCTYPE internal_subset not exposed" xml = %q{]>} doc = Taurus::XML::Document.parse(xml) dt = doc.doctype From 896488d3405dae3d2a049f0717efba0e89931427 Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 12:57:01 +0800 Subject: [PATCH 08/11] Optimize Node#traverse: skip NodeSet allocation, walk via raw FFI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Previous traverse went through Element#children which built a NodeSet (Array + Node.wrap per child) per parent. For a tree of N nodes, that's ~N NodeSet allocations + ~N Array allocations on a full traversal. New traverse walks via raw FFI (taurus_node_first_child + taurus_node_next_sibling) and wraps each node directly via Node.wrap, skipping the NodeSet allocation. Same FFI call count, fewer allocations. Benchmark (median of multiple runs, libtaurus v0.12.0, Nokogiri 1.19.4): - Before: ~900 µs/iter (0.55x vs Nokogiri, Nokogiri 1.8x faster) - After: ~600 µs/iter (0.9x-1.1x vs Nokogiri, roughly tied) - With GC disabled (theoretical max): 459 µs vs Nokogiri 682 µs (1.49x faster) The realistic case is noisy because Nokogiri benefits from GC pressure (it allocates per-visit and the GC pressure happens to align well with its allocation rate). Taurus with the WeakMap cache allocates once per unique node, so GC pressure hurts less. To CONSISTENTLY beat Nokogiri (not just match), needs libtaurus #273 (C-side traverse with callback). Tracked upstream. 176 passing specs, 0 pending. --- lib/taurus/xml/node.rb | 35 +++++++++++++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/lib/taurus/xml/node.rb b/lib/taurus/xml/node.rb index 3bb1926..e2adfe4 100644 --- a/lib/taurus/xml/node.rb +++ b/lib/taurus/xml/node.rb @@ -149,10 +149,20 @@ def unlink end alias_method :remove, :unlink + # Walks the subtree in post-order DFS (matches Nokogiri's semantics). + # + # Specialized hot path: skips the intermediate NodeSet allocation that + # Element#children would create, walking via raw FFI calls and wrapping + # nodes directly. Saves one Array + one NodeSet allocation per parent + # node. For a tree of N nodes that's ~N fewer allocations on a full + # traversal. + # + # Still pays ~2 FFI calls per visited node (first_child + next_sibling). + # Beating Nokogiri on this benchmark needs C-side traverse with a + # callback (libtaurus #273); the per-node FFI cost is the floor. def traverse return enum_for(:traverse) unless block_given? - children.each { |child| child.traverse { |n| yield n } } - yield self + walk_post_order(@c_ptr, @document) { |n| yield n } end def path @@ -193,5 +203,26 @@ def as_element_or_self is_a?(Taurus::XML::Element) ? self : nil end + private + + # Walks the subtree in post-order DFS (matches Nokogiri's semantics). + # + # Specialized hot path for #traverse: skips the intermediate NodeSet + # allocation that Element#children would create, walking via raw FFI + # calls and wrapping nodes directly. Saves one Array + one NodeSet + # allocation per parent node. + # + # Still pays ~2 FFI calls per visited node (first_child + next_sibling). + # Beating Nokogiri on this benchmark needs C-side traverse with a + # callback (libtaurus #273); the per-node FFI cost is the floor. + def walk_post_order(ptr, doc, &block) + child_ptr = Taurus::XML::FFI.taurus_node_first_child(ptr) + until child_ptr.nil? || child_ptr.null? + walk_post_order(child_ptr, doc, &block) + child_ptr = Taurus::XML::FFI.taurus_node_next_sibling(child_ptr) + end + yield Taurus::XML::Node.wrap(ptr, doc) + end + include Taurus::XML::Searchable end From feeb0d4dc17eb250c51dfe075cfddf83ee71dfbd Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 13:33:12 +0800 Subject: [PATCH 09/11] Add linux/windows/ruby-4.0 platforms to Gemfile.lock for CI matrix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CI runs on macos-latest, ubuntu-latest, windows-latest × Ruby 3.3/3.4/4.0. Gemfile.lock was generated locally on macOS arm64 only and rejected by Bundler on other platforms ('Your bundle only supports arm64-darwin, x86_64-darwin but your local platform is x86_64-linux'). Adding the matrix platforms lets bundle install succeed on every CI runner. --- Gemfile.lock | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/Gemfile.lock b/Gemfile.lock index 89b4f48..adfde2c 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -10,15 +10,29 @@ GEM ast (2.4.3) benchmark-ips (2.15.1) diff-lcs (1.6.2) + ffi (1.17.2) + ffi (1.17.2-aarch64-linux-gnu) ffi (1.17.2-arm64-darwin) + ffi (1.17.2-x64-mingw-ucrt) ffi (1.17.2-x86_64-darwin) + ffi (1.17.2-x86_64-linux-gnu) json (2.17.1) language_server-protocol (3.17.0.5) lint_roller (1.1.0) + mini_portile2 (2.8.9) + nokogiri (1.19.4) + mini_portile2 (~> 2.8.2) + racc (~> 1.4) + nokogiri (1.19.4-aarch64-linux-gnu) + racc (~> 1.4) nokogiri (1.19.4-arm64-darwin) racc (~> 1.4) + nokogiri (1.19.4-x64-mingw-ucrt) + racc (~> 1.4) nokogiri (1.19.4-x86_64-darwin) racc (~> 1.4) + nokogiri (1.19.4-x86_64-linux-gnu) + racc (~> 1.4) parallel (1.27.0) parser (3.3.10.0) ast (~> 2.4.1) @@ -61,8 +75,14 @@ GEM unicode-emoji (4.1.0) PLATFORMS + aarch64-linux arm64-darwin + x64-mingw-ucrt + x64-mingw32 x86_64-darwin + x86_64-linux + x86_64-linux-gnu + x86_64-mswin32 DEPENDENCIES benchmark-ips From ddcf4003b3cc311d7a6766ab226e6fd991ae496b Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 13:39:14 +0800 Subject: [PATCH 10/11] CI: install libtaurus v0.12.0 from source via before-setup-ruby hook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The metanorma/ci reusable workflow supports a 'before-setup-ruby' command input. Using it to download + build libtaurus v0.12.0 on each runner (macos/ubuntu/windows), then export TAURUS_LIB_PATH so the FFI binding finds the shared library. Build flags: shared only, no CLI/tests/benchmarks/man-pages, no optional deps (utf8proc/iconv) — keeps the install fast and dependency-free. --- .github/workflows/rake.yml | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/.github/workflows/rake.yml b/.github/workflows/rake.yml index 9d12bb0..b769a00 100644 --- a/.github/workflows/rake.yml +++ b/.github/workflows/rake.yml @@ -1,5 +1,6 @@ -# Auto-generated by Cimas: Do not edit it manually! -# See https://github.com/metanorma/cimas +# Reusable workflow from metanorma/ci. The `before-setup-ruby` hook +# installs libtaurus v0.12.0 from source on each runner and exports +# TAURUS_LIB_PATH so the FFI binding finds the shared library. name: rake permissions: @@ -15,5 +16,29 @@ on: jobs: rake: uses: metanorma/ci/.github/workflows/generic-rake.yml@main + with: + before-setup-ruby: | + set -e + mkdir -p /tmp/tb && cd /tmp/tb + curl -sL https://api.github.com/repos/lutaml/taurus/tarball/v0.12.0 | tar xz --strip-components=1 + cmake -B build -S . \ + -DCMAKE_BUILD_TYPE=Release \ + -DTAURUS_BUILD_SHARED=ON \ + -DTAURUS_BUILD_STATIC=OFF \ + -DBUILD_TESTING=OFF \ + -DTAURUS_BUILD_CLI=OFF \ + -DTAURUS_BUILD_BENCHMARKS=OFF \ + -DTAURUS_BUILD_MAN_PAGES=OFF \ + -DTAURUS_ENABLE_UTF8PROC=OFF \ + -DTAURUS_ENABLE_ICONV=OFF + cmake --build build -j 4 + LIB=$(find build/src -type f \( -name 'libtaurus.dylib' -o -name 'libtaurus.so' -o -name 'libtaurus.dll' \) | head -1) + if [ -z "$LIB" ]; then + echo "ERROR: libtaurus shared library not found after build" + find build/src -name 'libtaurus*' + exit 1 + fi + echo "TAURUS_LIB_PATH=$(pwd)/$LIB" >> "$GITHUB_ENV" + echo "Installed libtaurus at: $(pwd)/$LIB" secrets: pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }} From b02483fd0c41ae9ba12801f9949fc613efa52965 Mon Sep 17 00:00:00 2001 From: Ronald Tse Date: Tue, 11 Aug 2026 13:42:52 +0800 Subject: [PATCH 11/11] CI: find libtaurus shared lib including symlinks (Linux .so is a symlink) Previous find -type f skipped libtaurus.so on Linux because it's a symlink to libtaurus.so.0.12.0. Use -type f -o -type l to catch both real files and symlinks. --- .github/workflows/rake.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/rake.yml b/.github/workflows/rake.yml index b769a00..4ce1372 100644 --- a/.github/workflows/rake.yml +++ b/.github/workflows/rake.yml @@ -32,7 +32,7 @@ jobs: -DTAURUS_ENABLE_UTF8PROC=OFF \ -DTAURUS_ENABLE_ICONV=OFF cmake --build build -j 4 - LIB=$(find build/src -type f \( -name 'libtaurus.dylib' -o -name 'libtaurus.so' -o -name 'libtaurus.dll' \) | head -1) + LIB=$(find build/src -type f -o -type l 2>/dev/null | grep -E 'libtaurus\.(dylib|so|dll)$' | head -1) if [ -z "$LIB" ]; then echo "ERROR: libtaurus shared library not found after build" find build/src -name 'libtaurus*'