moxml 0.1.0 → 0.1.2

data/lib/moxml/adapter/oga.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "customized_oga/xml_generator"
+require_relative "customized_oga/xml_declaration"
+require "oga"
+
+module Moxml
+  module Adapter
+    class Oga < Base
+      class << self
+        def set_root(doc, element)
+          doc.children.clear # Clear any existing children
+          doc.children << element
+        end
+
+        def parse(xml, options = {})
+          native_doc = begin
+            ::Oga.parse_xml(xml, strict: options[:strict])
+          rescue LL::ParserError => e
+            raise Moxml::ParseError, e.message
+          end
+
+          DocumentBuilder.new(Context.new(:oga)).build(native_doc)
+        end
+
+        def create_document
+          ::Oga::XML::Document.new
+        end
+
+        def create_native_element(name)
+          ::Oga::XML::Element.new(name: name)
+        end
+
+        def create_native_text(content)
+          ::Oga::XML::Text.new(text: content)
+        end
+
+        def create_native_cdata(content)
+          ::Oga::XML::Cdata.new(text: content)
+        end
+
+        def create_native_comment(content)
+          ::Oga::XML::Comment.new(text: content)
+        end
+
+        def create_native_doctype(name, external_id, system_id)
+          ::Oga::XML::Doctype.new(
+            name: name, public_id: external_id, system_id: system_id, type: "PUBLIC"
+          )
+        end
+
+        def create_native_processing_instruction(target, content)
+          ::Oga::XML::ProcessingInstruction.new(name: target, text: content)
+        end
+
+        def create_native_declaration(version, encoding, standalone)
+          attrs = {
+            version: version,
+            encoding: encoding,
+            standalone: standalone
+          }.compact
+          ::Moxml::Adapter::CustomizedOga::XmlDeclaration.new(attrs)
+        end
+
+        def declaration_attribute(declaration, attr_name)
+          return unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+
+          declaration.public_send(attr_name)
+        end
+
+        def set_declaration_attribute(declaration, attr_name, value)
+          return unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+
+          declaration.public_send("#{attr_name}=", value)
+        end
+
+        def create_native_namespace(element, prefix, uri)
+          ns = element.available_namespaces[prefix]
+          return ns unless ns.nil?
+
+          # Oga creates an attribute and registers a namespace
+          set_attribute(element, [::Oga::XML::Element::XMLNS_PREFIX, prefix].compact.join(":"), uri)
+          element.register_namespace(prefix, uri)
+          ::Oga::XML::Namespace.new(name: prefix, uri: uri)
+        end
+
+        def set_namespace(element, ns_or_string)
+          element.namespace_name = ns_or_string.to_s
+        end
+
+        def namespace(element)
+          if element.respond_to?(:namespace)
+            element.namespace
+          elsif element.respond_to?(:namespaces)
+            element.namespaces.values.last
+          end
+        rescue NoMethodError
+          # Oga attributes fail with NoMethodError:
+          # undefined method `available_namespaces' for nil:NilClass
+          nil
+        end
+
+        def processing_instruction_target(node)
+          node.name
+        end
+
+        def node_type(node)
+          case node
+          when ::Oga::XML::Element then :element
+          when ::Oga::XML::Text then :text
+          when ::Oga::XML::Cdata then :cdata
+          when ::Oga::XML::Comment then :comment
+          when ::Oga::XML::ProcessingInstruction then :processing_instruction
+          when ::Oga::XML::Document then :document
+          when ::Oga::XML::Doctype then :doctype
+          else :unknown
+          end
+        end
+
+        def node_name(node)
+          node.name
+        end
+
+        def set_node_name(node, name)
+          node.name = name
+        end
+
+        def children(node)
+          all_children = []
+
+          all_children += [node.xml_declaration, node.doctype].compact if node.is_a?(::Oga::XML::Document)
+
+          return all_children unless node.respond_to?(:children)
+
+          all_children + node.children.reject do |child|
+            child.is_a?(::Oga::XML::Text) &&
+              child.text.strip.empty? &&
+              !(child.previous.nil? && child.next.nil?)
+          end
+        end
+
+        def parent(node)
+          node.parent if node.respond_to?(:parent)
+        end
+
+        def next_sibling(node)
+          node.next
+        end
+
+        def previous_sibling(node)
+          node.previous
+        end
+
+        def document(node)
+          current = node
+          current = current.parent while parent(current)
+
+          current
+        end
+
+        def root(document)
+          document.children.find { |node| node.is_a?(::Oga::XML::Element) }
+        end
+
+        def attribute_element(attr)
+          attr.element
+        end
+
+        def attributes(element)
+          return [] unless element.respond_to?(:attributes)
+
+          # remove attributes-namespaces
+          element.attributes.reject do |attr|
+            attr.name == ::Oga::XML::Element::XMLNS_PREFIX || attr.namespace_name == ::Oga::XML::Element::XMLNS_PREFIX
+          end
+        end
+
+        def set_attribute(element, name, value)
+          namespace_name = nil
+          namespace_name, name = name.to_s.split(":", 2) if name.to_s.include?(":")
+
+          attr = ::Oga::XML::Attribute.new(
+            name: name.to_s,
+            namespace_name: namespace_name,
+            value: value.to_s
+          )
+          element.add_attribute(attr)
+        end
+
+        def get_attribute(element, name)
+          element.attribute(name.to_s)
+        end
+
+        def get_attribute_value(element, name)
+          element[name.to_s]
+        end
+
+        def remove_attribute(element, name)
+          attr = element.attribute(name.to_s)
+          element.attributes.delete(attr) if attr
+        end
+
+        def add_child(element, child_or_text)
+          child =
+            if child_or_text.is_a?(String)
+              create_native_text(child_or_text)
+            else
+              child_or_text
+            end
+
+          element.children << child
+        end
+
+        def add_previous_sibling(node, sibling)
+          node.before(sibling)
+        end
+
+        def add_next_sibling(node, sibling)
+          node.after(sibling)
+        end
+
+        def remove(node)
+          node.remove
+        end
+
+        def replace(node, new_node)
+          node.replace(new_node)
+        end
+
+        def replace_children(node, new_children)
+          node.inner_text = ""
+          new_children.each { |child| add_child(node, child) }
+        end
+
+        def text_content(node)
+          node.text
+        end
+
+        def inner_text(node)
+          if node.respond_to?(:inner_text)
+            node.inner_text
+          else
+            # Oga::XML::Text node for example
+            node.text
+          end
+        end
+
+        def set_text_content(node, content)
+          if node.respond_to?(:inner_text)
+            node.inner_text = content
+          else
+            # Oga::XML::Text node for example
+            node.text = content
+          end
+        end
+
+        def cdata_content(node)
+          node.text
+        end
+
+        def set_cdata_content(node, content)
+          node.text = content
+        end
+
+        def comment_content(node)
+          node.text
+        end
+
+        def set_comment_content(node, content)
+          node.text = content
+        end
+
+        def processing_instruction_content(node)
+          node.text
+        end
+
+        def set_processing_instruction_content(node, content)
+          node.text = content
+        end
+
+        def namespace_prefix(namespace)
+          # nil for the default namespace
+          return if namespace.name == ::Oga::XML::Element::XMLNS_PREFIX
+
+          namespace.name
+        end
+
+        def namespace_uri(namespace)
+          namespace.uri
+        end
+
+        def namespace_definitions(node)
+          return [] unless node.respond_to?(:namespaces)
+
+          node.namespaces.values
+        end
+
+        def xpath(node, expression, _namespaces = {})
+          node.xpath(expression).to_a
+        rescue ::LL::ParserError => e
+          raise Moxml::XPathError, e.message
+        end
+
+        def at_xpath(node, expression, _namespaces = {})
+          node.at_xpath(expression)
+        rescue ::Oga::XPath::Error => e
+          raise Moxml::XPathError, e.message
+        end
+
+        def serialize(node, _options = {})
+          # Expand empty tags, encode attributes, etc
+          ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/ox.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "ox"
+
+module Moxml
+  module Adapter
+    class Ox < Base
+      class << self
+        def set_root(doc, element)
+          replace_children(doc, [element])
+        end
+
+        def parse(xml, _options = {})
+          native_doc = begin
+            result = ::Ox.parse(xml)
+
+            # result can be either Document or Element
+            if result.is_a?(::Ox::Document)
+              result
+            else
+              doc = ::Ox::Document.new
+              doc << result
+              doc
+            end
+          rescue ::Ox::ParseError => e
+            raise Moxml::ParseError, e.message
+          end
+
+          DocumentBuilder.new(Context.new(:ox)).build(native_doc)
+        end
+
+        def create_document
+          ::Ox::Document.new
+        end
+
+        def create_native_element(name)
+          element = ::Ox::Element.new(name)
+          element.instance_variable_set(:@attributes, {})
+          element
+        end
+
+        def create_native_text(content)
+          content
+        end
+
+        def create_native_cdata(content)
+          ::Ox::CData.new(content)
+        end
+
+        def create_native_comment(content)
+          ::Ox::Comment.new(content)
+        end
+
+        def create_native_processing_instruction(target, content)
+          inst = ::Ox::Instruction.new(target)
+          inst.value = content
+          inst
+        end
+
+        # TODO: compare  to create_native_declaration
+        def create_native_declaration2(version, encoding, standalone)
+          inst = ::Ox::Instruct.new("xml")
+          inst.value = build_declaration_attrs(version, encoding, standalone)
+          inst
+        end
+
+        def create_native_declaration(version, encoding, standalone)
+          doc = ::Ox::Document.new
+          doc.version = version
+          doc.encoding = encoding
+          doc.standalone = standalone
+          doc
+        end
+
+        def create_native_namespace(element, prefix, uri)
+          element.attributes ||= {}
+          attr_name = prefix ? "xmlns:#{prefix}" : "xmlns"
+          element.attributes[attr_name] = uri
+          [prefix, uri]
+        end
+
+        def set_namespace(element, ns)
+          prefix, uri = ns
+          element.attributes ||= {}
+          attr_name = prefix ? "xmlns:#{prefix}" : "xmlns"
+          element.attributes[attr_name] = uri
+        end
+
+        def namespace(element)
+          return nil unless element.attributes
+
+          xmlns_attr = element.attributes.find { |k, _| k.start_with?("xmlns:") || k == "xmlns" }
+          return nil unless xmlns_attr
+
+          prefix = xmlns_attr[0] == "xmlns" ? nil : xmlns_attr[0].sub("xmlns:", "")
+          [prefix, xmlns_attr[1]]
+        end
+
+        def processing_instruction_target(node)
+          node.name
+        end
+
+        def node_type(node)
+          case node
+          when ::Ox::Document then :document
+          when String then :text
+          when ::Ox::CData then :cdata
+          when ::Ox::Comment then :comment
+          when ::Ox::Instruct then :processing_instruction
+          when ::Ox::Element then :element
+          else :unknown
+          end
+        end
+
+        def node_name(node)
+          node.value
+        rescue StandardError
+          node.name
+        end
+
+        def set_node_name(node, name)
+          node.value = name if node.respond_to?(:value=)
+          node.name = name if node.respond_to?(:name=)
+        end
+
+        def children(node)
+          return [] unless node.respond_to?(:nodes)
+
+          node.nodes || []
+        end
+
+        def parent(node)
+          node.parent if node.respond_to?(:parent)
+        end
+
+        def next_sibling(node)
+          return unless (parent = parent(node))
+
+          siblings = parent.nodes
+          idx = siblings.index(node)
+          idx ? siblings[idx + 1] : nil
+        end
+
+        def previous_sibling(node)
+          return unless (parent = parent(node))
+
+          siblings = parent.nodes
+          idx = siblings.index(node)
+          idx&.positive? ? siblings[idx - 1] : nil
+        end
+
+        def document(node)
+          current = node
+          current = parent(current) while parent(current)
+          current
+        end
+
+        def root(document)
+          document.nodes&.find { |node| node.is_a?(::Ox::Element) }
+        end
+
+        def attributes(element)
+          return {} unless element.respond_to?(:attributes) && element.attributes
+
+          element.attributes.reject { |k, _| k.start_with?("xmlns") }
+        end
+
+        def set_attribute(element, name, value)
+          element.attributes ||= {}
+          element.attributes[name.to_s] = value.to_s
+        end
+
+        def get_attribute(element, name)
+          return nil unless element.respond_to?(:attributes) && element.attributes
+
+          element.attributes[name.to_s]
+        end
+
+        def remove_attribute(element, name)
+          return unless element.respond_to?(:attributes) && element.attributes
+
+          element.attributes.delete(name.to_s)
+        end
+
+        def add_child(element, child)
+          element.nodes ||= []
+          puts "Add child #{child} for #{element.name}: #{element.nodes.count}"
+          element.nodes << child
+        end
+
+        def add_previous_sibling(node, sibling)
+          return unless parent(node)
+
+          idx = node.parent.nodes.index(node)
+          node.parent.nodes.insert(idx, sibling) if idx
+        end
+
+        def add_next_sibling(node, sibling)
+          return unless parent(node)
+
+          idx = node.parent.nodes.index(node)
+          node.parent.nodes.insert(idx + 1, sibling) if idx
+        end
+
+        def remove(node)
+          return unless parent(node)
+
+          node.parent.nodes.delete(node)
+        end
+
+        def replace(node, new_node)
+          return unless parent(node)
+
+          idx = node.parent.nodes.index(node)
+          node.parent.nodes[idx] = new_node if idx
+        end
+
+        def replace_children(node, new_children)
+          node.remove_children_by_path("*")
+          new_children.each { |child| node << child }
+          node
+        end
+
+        def text_content(node)
+          node.is_a?(String) ? node : node.value.to_s
+        end
+
+        def set_text_content(node, content)
+          if node.is_a?(String)
+            node.replace(content.to_s)
+          else
+            node.value = content.to_s
+          end
+        end
+
+        def cdata_content(node)
+          node.value.to_s
+        end
+
+        def set_cdata_content(node, content)
+          node.value = content.to_s
+        end
+
+        def comment_content(node)
+          node.value.to_s
+        end
+
+        def set_comment_content(node, content)
+          node.value = content.to_s
+        end
+
+        def processing_instruction_content(node)
+          node.value.to_s
+        end
+
+        def set_processing_instruction_content(node, content)
+          node.value = content.to_s
+        end
+
+        def namespace_definitions(node)
+          return [] unless node.respond_to?(:attributes) && node.attributes
+
+          node.attributes.each_with_object([]) do |(name, value), namespaces|
+            next unless name.start_with?("xmlns")
+
+            prefix = name == "xmlns" ? nil : name.sub("xmlns:", "")
+            namespaces << [prefix, value]
+          end
+        end
+
+        def xpath(node, expression, namespaces = {})
+          # Ox doesn't support XPath, implement basic path matching
+          results = []
+          traverse(node) do |n|
+            results << n if matches_xpath?(n, expression, namespaces)
+          end
+          results
+        end
+
+        def at_xpath(node, expression, namespaces = {})
+          traverse(node) do |n|
+            return n if matches_xpath?(n, expression, namespaces)
+          end
+          nil
+        end
+
+        def serialize(node, options = {})
+          ox_options = {
+            indent: options[:indent] || -1,
+            with_xml: true,
+            with_instructions: true,
+            encoding: options[:encoding]
+          }
+          ::Ox.dump(node, ox_options)
+        end
+
+        private
+
+        def traverse(node, &block)
+          return unless node
+
+          yield node
+          return unless node.respond_to?(:nodes)
+
+          node.nodes&.each { |child| traverse(child, &block) }
+        end
+
+        def matches_xpath?(node, expression, _namespaces = {})
+          case expression
+          when %r{//(\w+)}
+            node.is_a?(::Ox::Element) && node.value == ::Regexp.last_match(1)
+          when %r{//(\w+)\[@(\w+)='([^']+)'\]}
+            node.is_a?(::Ox::Element) &&
+              node.value == ::Regexp.last_match(1) &&
+              node.attributes &&
+              node.attributes[::Regexp.last_match(2)] == ::Regexp.last_match(3)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end