moxml 0.1.0 → 0.1.1

data/spec/support/shared_examples/xml_adapter.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "xml adapter" do
+  let(:xml) do
+    <<~XML
+      <?xml version="1.0"?>
+      <root xmlns="http://example.org" xmlns:x="http://example.org/x">
+        <child id="1">Text</child>
+        <child id="2"/>
+        <x:special>
+          <![CDATA[Some <special> text]]>
+          <!-- A comment -->
+          <?pi target?>
+        </x:special>
+      </root>
+    XML
+  end
+
+  describe ".parse" do
+    it "parses XML string" do
+      doc = described_class.parse(xml).native
+      expect(described_class.node_type(doc)).to eq(:document)
+      expect(described_class.node_name(described_class.root(doc))).to eq("root")
+    end
+
+    it "handles malformed XML according to strict setting" do
+      malformed = "<root><unclosed>"
+
+      expect do
+        described_class.parse(malformed, strict: true)
+      end.to raise_error(Moxml::ParseError)
+
+      expect do
+        described_class.parse(malformed, strict: false)
+      end.not_to raise_error
+    end
+  end
+
+  describe "node creation" do
+    let(:doc) { described_class.create_document }
+
+    it "creates element" do
+      element = described_class.create_element("test")
+      expect(described_class.node_type(element)).to eq(:element)
+      expect(described_class.node_name(element)).to eq("test")
+    end
+
+    it "creates text" do
+      text = described_class.create_text("content")
+      expect(described_class.node_type(text)).to eq(:text)
+    end
+
+    it "creates CDATA" do
+      cdata = described_class.create_cdata("<content>")
+      expect(described_class.node_type(cdata)).to eq(:cdata)
+    end
+
+    it "creates comment" do
+      comment = described_class.create_comment("comment")
+      expect(described_class.node_type(comment)).to eq(:comment)
+    end
+
+    it "creates processing instruction" do
+      pi = described_class.create_processing_instruction("target", "content")
+      expect(described_class.node_type(pi)).to eq(:processing_instruction)
+    end
+  end
+
+  describe "node manipulation" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:root) { described_class.root(doc) }
+
+    it "gets parent" do
+      child = described_class.children(root).first
+      expect(described_class.parent(child)).to eq(root)
+    end
+
+    it "gets children" do
+      children = described_class.children(root)
+      expect(children.length).to eq(3)
+    end
+
+    it "gets siblings", skip: "Oga includes text nodes into siblings" do
+      children = described_class.children(root)
+      first = children[0]
+      second = children[1]
+
+      expect(described_class.next_sibling(first)).to eq(second)
+      expect(described_class.previous_sibling(second)).to eq(first)
+    end
+
+    it "adds child" do
+      element = described_class.create_element("new")
+      described_class.add_child(root, element)
+      expect(described_class.children(root).last).to eq(element)
+    end
+
+    it "adds text child" do
+      described_class.add_child(root, "text")
+      expect(described_class.children(root).last.text).to eq("text")
+    end
+  end
+
+  describe "attributes" do
+    let(:doc) { described_class.parse(xml) }
+    let(:element) { described_class.children(described_class.root(doc.native)).first }
+
+    it "gets attributes" do
+      attrs = described_class.attributes(element)
+      expect(attrs.count).to eq(1)
+      expect(attrs.first.value).to eq("1")
+    end
+
+    it "sets attribute" do
+      described_class.set_attribute(element, "new", "value")
+      expect(described_class.get_attribute(element, "new").value).to eq("value")
+    end
+
+    it "removes attribute" do
+      described_class.remove_attribute(element, "id")
+      expect(described_class.get_attribute(element, "id")&.value).to be_nil
+    end
+
+    it "handles special characters in attributes" do
+      described_class.set_attribute(element, "special", '< > & " \'')
+      value = described_class.get_attribute(element, "special")&.to_xml
+      expect(value).to match(/&lt; &gt; &amp; (&quot;|") ('|&apos;)/)
+    end
+  end
+
+  describe "namespaces" do
+    let(:doc) { described_class.parse(xml).native }
+    let(:root) { described_class.root(doc) }
+    let(:special) { described_class.children(root).last }
+
+    it "creates namespace" do
+      ns = described_class.create_namespace(root, "test", "http://test.org")
+      expect(ns).not_to be_nil
+    end
+
+    it "handles namespaced elements" do
+      expect(described_class.node_name(special)).to eq("special")
+    end
+  end
+
+  describe "serialization" do
+    let(:doc) { described_class.parse(xml).native }
+
+    it "serializes to XML" do
+      result = described_class.serialize(doc)
+
+      expect(result).to include("<?xml")
+      expect(result).to include("<root")
+      expect(result).to include('xmlns="http://example.org"').once
+      expect(result).to include('xmlns:x="http://example.org/x"').once
+      expect(result).to include("</root>")
+    end
+
+    it "respects indentation settings", skip: "Indent cannot be negative, and zero indent doesn't remove newlines" do
+      unindented = described_class.serialize(doc, indent: 0)
+      indented = described_class.serialize(doc, indent: 2)
+
+      expect(unindented).not_to include("\n  ")
+      expect(indented).to include("\n  ")
+    end
+
+    it "preserves XML declaration" do
+      result = described_class.serialize(doc)
+      expect(result).to match(/^<\?xml/)
+    end
+
+    it "handles encoding specification" do
+      result = described_class.serialize(doc, encoding: "UTF-8")
+      expect(result).to include('encoding="UTF-8"')
+    end
+  end
+
+  describe "xpath" do
+    let(:doc) { described_class.parse(xml) }
+
+    it "finds nodes by xpath" do
+      nodes = described_class.xpath(doc, "//xmlns:child")
+      expect(nodes.length).to eq(2)
+    end
+
+    it "finds first node by xpath" do
+      node = described_class.at_xpath(doc, "//xmlns:child")
+      expect(described_class.get_attribute_value(node, "id")).to eq("1")
+    end
+  end
+end

data/spec/support/xml_matchers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# spec/support/xml_matchers.rb
+# RSpec::Matchers.define :be_equivalent_to do |expected|
+#   match do |actual|
+#     normalize_xml(actual) == normalize_xml(expected)
+#   end
+
+#   failure_message do |actual|
+#     "expected XML to be equivalent to:\n#{normalize_xml(expected)}\n\nbut was:\n#{normalize_xml(actual)}"
+#   end
+
+#   def normalize_xml(xml)
+#     xml.to_s.gsub(/>\s+</, '><').strip
+#   end
+# end
+
+RSpec::Matchers.define :have_xpath do |xpath, text|
+  match do |xml_node|
+    nodes = xml_node.xpath(xpath)
+    text.nil? ? !nodes.empty? : nodes.any? { |node| node.text == text }
+  end
+
+  failure_message do |_xml_node|
+    "expected to find xpath #{xpath} #{text ? "with text '#{text}'" : ""}"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies: []
 description: 'Moxml is a unified XML manipulation library that provides a common API.
 
@@ -19,10 +19,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/main.yml"
+- ".github/workflows/rake.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
 - Gemfile
 - README.adoc
 - Rakefile
@@ -30,23 +33,69 @@ files:
 - bin/setup
 - lib/moxml.rb
 - lib/moxml/adapter.rb
+- lib/moxml/adapter/base.rb
+- lib/moxml/adapter/customized_oga/xml_declaration.rb
+- lib/moxml/adapter/customized_oga/xml_generator.rb
+- lib/moxml/adapter/nokogiri.rb
+- lib/moxml/adapter/oga.rb
+- lib/moxml/adapter/ox.rb
 - lib/moxml/attribute.rb
+- lib/moxml/builder.rb
 - lib/moxml/cdata.rb
 - lib/moxml/comment.rb
 - lib/moxml/config.rb
+- lib/moxml/context.rb
 - lib/moxml/declaration.rb
+- lib/moxml/doctype.rb
 - lib/moxml/document.rb
+- lib/moxml/document_builder.rb
 - lib/moxml/element.rb
-- lib/moxml/error_handler.rb
-- lib/moxml/errors.rb
+- lib/moxml/error.rb
 - lib/moxml/namespace.rb
 - lib/moxml/node.rb
 - lib/moxml/node_set.rb
 - lib/moxml/processing_instruction.rb
 - lib/moxml/text.rb
 - lib/moxml/version.rb
+- lib/moxml/xml_utils.rb
+- lib/moxml/xml_utils/encoder.rb
 - moxml.gemspec
 - sig/moxml.rbs
+- spec/moxml/adapter/nokogiri_spec.rb
+- spec/moxml/adapter/oga_spec.rb
+- spec/moxml/adapter/ox_spec.rb
+- spec/moxml/all_with_adapters_spec.rb
+- spec/moxml/config_spec.rb
+- spec/moxml/error_spec.rb
+- spec/moxml/examples/adapter_spec.rb
+- spec/moxml_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/attribute.rb
+- spec/support/shared_examples/builder.rb
+- spec/support/shared_examples/cdata.rb
+- spec/support/shared_examples/comment.rb
+- spec/support/shared_examples/context.rb
+- spec/support/shared_examples/declaration.rb
+- spec/support/shared_examples/doctype.rb
+- spec/support/shared_examples/document.rb
+- spec/support/shared_examples/document_builder.rb
+- spec/support/shared_examples/edge_cases.rb
+- spec/support/shared_examples/element.rb
+- spec/support/shared_examples/examples/attribute.rb
+- spec/support/shared_examples/examples/basic_usage.rb
+- spec/support/shared_examples/examples/memory.rb
+- spec/support/shared_examples/examples/namespace.rb
+- spec/support/shared_examples/examples/readme_examples.rb
+- spec/support/shared_examples/examples/thread_safety.rb
+- spec/support/shared_examples/examples/xpath.rb
+- spec/support/shared_examples/integration.rb
+- spec/support/shared_examples/namespace.rb
+- spec/support/shared_examples/node.rb
+- spec/support/shared_examples/node_set.rb
+- spec/support/shared_examples/processing_instruction.rb
+- spec/support/shared_examples/text.rb
+- spec/support/shared_examples/xml_adapter.rb
+- spec/support/xml_matchers.rb
 homepage: https://github.com/lutaml/moxml
 licenses:
 - BSD-2-Clause
@@ -67,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: Unified XML manipulation library

data/.github/workflows/main.yml

@@ -1,27 +0,0 @@
-name: Ruby
-
-on:
-  push:
-    branches:
-      - main
-
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: Ruby ${{ matrix.ruby }}
-    strategy:
-      matrix:
-        ruby:
-          - '3.3.2'
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true
-    - name: Run the default task
-      run: bundle exec rake

data/lib/moxml/error_handler.rb

@@ -1,77 +0,0 @@
-# lib/moxml/error_handler.rb
-module Moxml
-  class ErrorHandler
-    class << self
-      def handle_parse_error(error, backend)
-        case backend
-        when :nokogiri
-          handle_nokogiri_error(error)
-        when :ox
-          handle_ox_error(error)
-        when :oga
-          handle_oga_error(error)
-        else
-          handle_generic_error(error)
-        end
-      end
-
-      private
-
-      def handle_nokogiri_error(error)
-        case error
-        when ::Nokogiri::XML::SyntaxError
-          raise ParseError.new(
-            error.message,
-            line: error.line,
-            column: error.column,
-            source: error.source,
-          )
-        when ::Nokogiri::XML::XPath::SyntaxError
-          raise XPathError.new(error.message)
-        else
-          handle_generic_error(error)
-        end
-      end
-
-      def handle_ox_error(error)
-        case error
-        when ::Ox::ParseError
-          raise ParseError.new(
-            error.message,
-            line: error.line,
-            column: error.column,
-          )
-        else
-          handle_generic_error(error)
-        end
-      end
-
-      def handle_oga_error(error)
-        case error
-        when ::Oga::XML::ParseError
-          raise ParseError.new(
-            error.message,
-            line: error.line,
-            column: error.column,
-          )
-        when ::Oga::XML::XPath::Error
-          raise XPathError.new(error.message)
-        else
-          handle_generic_error(error)
-        end
-      end
-
-      def handle_generic_error(error)
-        case error
-        when NameError, NoMethodError
-          raise BackendError.new(
-            "Backend operation failed: #{error.message}",
-            Moxml.config.backend
-          )
-        else
-          raise Error, "XML operation failed: #{error.message}"
-        end
-      end
-    end
-  end
-end

data/lib/moxml/errors.rb

@@ -1,169 +0,0 @@
-# lib/moxml/errors.rb
-module Moxml
-  # Base error class for all Moxml errors
-  class Error < StandardError; end
-
-  # Parsing related errors
-  class ParseError < Error
-    attr_reader :line, :column, :source
-
-    def initialize(message, line: nil, column: nil, source: nil)
-      @line = line
-      @column = column
-      @source = source
-      super(build_message(message))
-    end
-
-    private
-
-    def build_message(message)
-      parts = [message]
-      parts << "Line: #{line}" if line
-      parts << "Column: #{column}" if column
-      parts << "\nSource: #{source}" if source
-      parts.join(" | ")
-    end
-  end
-
-  # Validation errors
-  class ValidationError < Error; end
-  class DTDValidationError < ValidationError; end
-  class SchemaValidationError < ValidationError; end
-  class NamespaceError < ValidationError; end
-
-  # Structure errors
-  class MalformedXMLError < ParseError; end
-  class UnbalancedTagError < ParseError; end
-  class UndefinedEntityError < ParseError; end
-  class DuplicateAttributeError < ParseError; end
-
-  # Encoding errors
-  class EncodingError < Error
-    attr_reader :encoding
-
-    def initialize(message, encoding)
-      @encoding = encoding
-      super("#{message} (Encoding: #{encoding})")
-    end
-  end
-
-  # Security related errors
-  class SecurityError < Error; end
-  class MaxDepthExceededError < SecurityError; end
-  class MaxAttributesExceededError < SecurityError; end
-  class MaxNameLengthExceededError < SecurityError; end
-  class EntityExpansionError < SecurityError; end
-
-  # Backend errors
-  class BackendError < Error
-    attr_reader :backend
-
-    def initialize(message, backend)
-      @backend = backend
-      super("#{message} (Backend: #{backend})")
-    end
-  end
-
-  class BackendNotFoundError < BackendError; end
-  class BackendConfigurationError < BackendError; end
-
-  # Node manipulation errors
-  class NodeError < Error
-    attr_reader :node
-
-    def initialize(message, node)
-      @node = node
-      super("#{message} (Node: #{node.class})")
-    end
-  end
-
-  class InvalidNodeTypeError < NodeError; end
-  class InvalidOperationError < NodeError; end
-  class NodeNotFoundError < NodeError; end
-
-  # Visitor pattern errors
-  class VisitorError < Error; end
-
-  class InvalidSelectorError < VisitorError
-    attr_reader :selector
-
-    def initialize(message, selector)
-      @selector = selector
-      super("#{message} (Selector: #{selector})")
-    end
-  end
-
-  class VisitorMethodError < VisitorError
-    attr_reader :method_name
-
-    def initialize(message, method_name)
-      @method_name = method_name
-      super("#{message} (Method: #{method_name})")
-    end
-  end
-
-  # Serialization errors
-  class SerializationError < Error; end
-
-  class InvalidOptionsError < SerializationError
-    attr_reader :options
-
-    def initialize(message, options)
-      @options = options
-      super("#{message} (Options: #{options})")
-    end
-  end
-
-  # IO errors
-  class IOError < Error
-    attr_reader :path
-
-    def initialize(message, path)
-      @path = path
-      super("#{message} (Path: #{path})")
-    end
-  end
-
-  class FileNotFoundError < IOError; end
-  class WriteError < IOError; end
-
-  # Memory errors
-  class MemoryError < Error
-    attr_reader :size
-
-    def initialize(message, size)
-      @size = size
-      super("#{message} (Size: #{size} bytes)")
-    end
-  end
-
-  class DocumentTooLargeError < MemoryError; end
-
-  # CDATA related errors
-  class CDATAError < Error; end
-  class NestedCDATAError < CDATAError; end
-  class InvalidCDATAContentError < CDATAError; end
-
-  # Namespace related errors
-  class NamespaceDeclarationError < Error
-    attr_reader :prefix, :uri
-
-    def initialize(message, prefix, uri)
-      @prefix = prefix
-      @uri = uri
-      super("#{message} (Prefix: #{prefix}, URI: #{uri})")
-    end
-  end
-
-  # XPath related errors
-  class XPathError < Error
-    attr_reader :expression
-
-    def initialize(message, expression)
-      @expression = expression
-      super("#{message} (Expression: #{expression})")
-    end
-  end
-
-  class InvalidXPathError < XPathError; end
-end