moxml 0.1.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "moxml"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/moxml/adapter.rb

@@ -0,0 +1,175 @@
+# lib/moxml/adapter.rb
+module Moxml
+  class Adapter
+    # Document operations
+    def parse(input, options = {})
+      raise NotImplementedError
+    end
+
+    def serialize(node, options = {})
+      raise NotImplementedError
+    end
+
+    # Node type detection
+    def node_type(node)
+      raise NotImplementedError
+    end
+
+    # Node operations
+    def node_name(node)
+      raise NotImplementedError
+    end
+
+    def parent(node)
+      raise NotImplementedError
+    end
+
+    def children(node)
+      raise NotImplementedError
+    end
+
+    def next_sibling(node)
+      raise NotImplementedError
+    end
+
+    def previous_sibling(node)
+      raise NotImplementedError
+    end
+
+    def document(node)
+      raise NotImplementedError
+    end
+
+    def remove(node)
+      raise NotImplementedError
+    end
+
+    def replace(node, new_node)
+      raise NotImplementedError
+    end
+
+    # Element operations
+    def create_element(document, name)
+      raise NotImplementedError
+    end
+
+    def attributes(element)
+      raise NotImplementedError
+    end
+
+    def get_attribute(element, name)
+      raise NotImplementedError
+    end
+
+    def set_attribute(element, name, value)
+      raise NotImplementedError
+    end
+
+    def remove_attribute(element, name)
+      raise NotImplementedError
+    end
+
+    def add_child(element, child)
+      raise NotImplementedError
+    end
+
+    # Namespace operations
+    def namespaces(element)
+      raise NotImplementedError
+    end
+
+    def add_namespace(element, prefix, uri)
+      raise NotImplementedError
+    end
+
+    def namespace_prefix(namespace)
+      raise NotImplementedError
+    end
+
+    def namespace_uri(namespace)
+      raise NotImplementedError
+    end
+
+    # Attribute operations
+    def attribute_value(attribute)
+      raise NotImplementedError
+    end
+
+    def set_attribute_value(attribute, value)
+      raise NotImplementedError
+    end
+
+    def attribute_namespace(attribute)
+      raise NotImplementedError
+    end
+
+    # Text operations
+    def create_text(document, content)
+      raise NotImplementedError
+    end
+
+    def text_content(text)
+      raise NotImplementedError
+    end
+
+    def set_text_content(text, content)
+      raise NotImplementedError
+    end
+
+    # CDATA operations
+    def create_cdata(document, content)
+      raise NotImplementedError
+    end
+
+    # Comment operations
+    def create_comment(document, content)
+      raise NotImplementedError
+    end
+
+    def comment_content(comment)
+      raise NotImplementedError
+    end
+
+    def set_comment_content(comment, content)
+      raise NotImplementedError
+    end
+
+    # Processing instruction operations
+    def create_processing_instruction(document, target, content)
+      raise NotImplementedError
+    end
+
+    def processing_instruction_target(pi)
+      raise NotImplementedError
+    end
+
+    def processing_instruction_content(pi)
+      raise NotImplementedError
+    end
+
+    def set_processing_instruction_target(pi, target)
+      raise NotImplementedError
+    end
+
+    def set_processing_instruction_content(pi, content)
+      raise NotImplementedError
+    end
+
+    # Document specific operations
+    def root(document)
+      raise NotImplementedError
+    end
+
+    protected
+
+    def normalize_options(options)
+      {
+        encoding: options[:encoding] || "UTF-8",
+        indent: options[:indent] || 2,
+        xml_declaration: options.fetch(:xml_declaration, true),
+        pretty: options.fetch(:pretty, true),
+        namespace_declarations: options.fetch(:namespace_declarations, true),
+      }
+    end
+  end
+end

data/lib/moxml/attribute.rb

@@ -0,0 +1,30 @@
+module Moxml
+  class Attribute < Node
+    def initialize(name_or_native = nil, value = nil)
+      case name_or_native
+      when String
+        super(adapter.create_attribute(nil, name_or_native, value))
+      else
+        super(name_or_native)
+      end
+    end
+
+    def name
+      adapter.attribute_name(native)
+    end
+
+    def value
+      adapter.attribute_value(native)
+    end
+
+    def value=(new_value)
+      adapter.set_attribute_value(native, new_value)
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_attribute(nil, "", "")
+    end
+  end
+end

data/lib/moxml/cdata.rb

@@ -0,0 +1,39 @@
+module Moxml
+  class Cdata < Node
+    def initialize(content_or_native = nil)
+      case content_or_native
+      when String
+        super(adapter.create_cdata(nil, content_or_native))
+      else
+        super(content_or_native)
+      end
+    end
+
+    def content
+      adapter.cdata_content(native)
+    end
+
+    def content=(text)
+      adapter.set_cdata_content(native, text)
+      self
+    end
+
+    def blank?
+      content.strip.empty?
+    end
+
+    def cdata?
+      true
+    end
+
+    def text?
+      false
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_cdata(nil, "")
+    end
+  end
+end

data/lib/moxml/comment.rb

@@ -0,0 +1,35 @@
+module Moxml
+  class Comment < Node
+    def initialize(content_or_native = nil)
+      case content_or_native
+      when String
+        super(adapter.create_comment(nil, content_or_native))
+      else
+        super(content_or_native)
+      end
+    end
+
+    def content
+      adapter.comment_content(native)
+    end
+
+    def content=(text)
+      adapter.set_comment_content(native, text)
+      self
+    end
+
+    def blank?
+      content.strip.empty?
+    end
+
+    def comment?
+      true
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_comment(nil, "")
+    end
+  end
+end

data/lib/moxml/config.rb

@@ -0,0 +1,23 @@
+# lib/moxml/config.rb
+module Moxml
+  class Config
+    attr_accessor :backend, :huge_document,
+                  :default_encoding,
+                  :default_indent,
+                  :cdata_sections,
+                  :cdata_patterns,
+                  :strict_parsing,
+                  :entity_encoding
+
+    def initialize
+      @backend = :nokogiri
+      @huge_document = false
+      @default_encoding = "UTF-8"
+      @default_indent = 2
+      @cdata_sections = true
+      @cdata_patterns = ["script", "style"]
+      @strict_parsing = true
+      @entity_encoding = :basic
+    end
+  end
+end

data/lib/moxml/declaration.rb

@@ -0,0 +1,50 @@
+# lib/moxml/declaration.rb
+module Moxml
+  class Declaration < Node
+    def initialize(version_or_native = "1.0", encoding = "UTF-8", standalone = nil)
+      case version_or_native
+      when String
+        super(adapter.create_declaration(nil, version_or_native, encoding, standalone))
+      else
+        super(version_or_native)
+      end
+    end
+
+    def version
+      adapter.declaration_version(native)
+    end
+
+    def version=(new_version)
+      adapter.set_declaration_version(native, new_version)
+      self
+    end
+
+    def encoding
+      adapter.declaration_encoding(native)
+    end
+
+    def encoding=(new_encoding)
+      adapter.set_declaration_encoding(native, new_encoding)
+      self
+    end
+
+    def standalone
+      adapter.declaration_standalone(native)
+    end
+
+    def standalone=(new_standalone)
+      adapter.set_declaration_standalone(native, new_standalone)
+      self
+    end
+
+    def to_xml
+      adapter.serialize_declaration(native)
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_declaration(nil, "1.0", "UTF-8", nil)
+    end
+  end
+end

data/lib/moxml/document.rb

@@ -0,0 +1,99 @@
+module Moxml
+  class Document < Node
+    def self.parse(input, options = {})
+      new(Moxml.adapter.parse(input, options))
+    end
+
+    def root
+      wrap_node(adapter.root(native))
+    end
+
+    def create_element(name)
+      Element.new(adapter.create_element(native, name))
+    end
+
+    def create_text(content)
+      Text.new(adapter.create_text(native, content))
+    end
+
+    def create_cdata(content)
+      Cdata.new(adapter.create_cdata(native, content))
+    end
+
+    def create_comment(content)
+      Comment.new(adapter.create_comment(native, content))
+    end
+
+    def create_processing_instruction(target, content)
+      ProcessingInstruction.new(
+        adapter.create_processing_instruction(native, target, content)
+      )
+    end
+
+    def to_xml(options = {})
+      adapter.serialize(native, options)
+    end
+
+    def encoding
+      declaration&.encoding
+    end
+
+    def encoding=(encoding)
+      (declaration || add_declaration).encoding = encoding
+    end
+
+    def version
+      declaration&.version
+    end
+
+    def version=(version)
+      (declaration || add_declaration).version = version
+    end
+
+    def standalone
+      declaration&.standalone
+    end
+
+    def standalone=(standalone)
+      (declaration || add_declaration).standalone = standalone
+    end
+
+    def declaration
+      children.find { |node| node.is_a?(Declaration) }
+    end
+
+    def add_declaration(version = "1.0", encoding = "UTF-8", standalone = nil)
+      decl = Declaration.new(version, encoding, standalone)
+      if declaration
+        declaration.replace(decl)
+      else
+        add_child(decl)
+      end
+      decl
+    end
+
+    def css(selector)
+      NodeSet.new(adapter.css(native, selector))
+    end
+
+    def xpath(expression, namespaces = {})
+      NodeSet.new(adapter.xpath(native, expression, namespaces))
+    end
+
+    def at_css(selector)
+      node = adapter.at_css(native, selector)
+      node.nil? ? nil : wrap_node(node)
+    end
+
+    def at_xpath(expression, namespaces = {})
+      node = adapter.at_xpath(native, expression, namespaces)
+      node.nil? ? nil : wrap_node(node)
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_document
+    end
+  end
+end

data/lib/moxml/element.rb

@@ -0,0 +1,145 @@
+module Moxml
+  class Element < Node
+    def initialize(name_or_native = nil)
+      case name_or_native
+      when String
+        super(adapter.create_element(nil, name_or_native))
+      else
+        super(name_or_native)
+      end
+    end
+
+    def name
+      adapter.node_name(native)
+    end
+
+    def attributes
+      adapter.attributes(native).transform_values { |attr| Attribute.new(attr) }
+    end
+
+    def []=(name, value)
+      adapter.set_attribute(native, name, value)
+    end
+
+    def [](name)
+      attr = adapter.get_attribute(native, name)
+      attr.nil? ? nil : Attribute.new(attr)
+    end
+
+    def add_child(node)
+      adapter.add_child(native, node.native)
+      self
+    end
+
+    def namespace
+      ns = adapter.namespace(native)
+      ns.nil? ? nil : Namespace.new(ns)
+    end
+
+    def namespace=(ns)
+      adapter.set_namespace(native, ns&.native)
+      self
+    end
+
+    def namespaces
+      adapter.namespaces(native).transform_values { |ns| Namespace.new(ns) }
+    end
+
+    def css(selector)
+      NodeSet.new(adapter.css(native, selector))
+    end
+
+    def xpath(expression, namespaces = {})
+      NodeSet.new(adapter.xpath(native, expression, namespaces))
+    end
+
+    def at_css(selector)
+      node = adapter.at_css(native, selector)
+      node.nil? ? nil : wrap_node(node)
+    end
+
+    def at_xpath(expression, namespaces = {})
+      node = adapter.at_xpath(native, expression, namespaces)
+      node.nil? ? nil : wrap_node(node)
+    end
+
+    def blank?
+      text.strip.empty? && children.empty?
+    end
+
+    def value
+      text.strip
+    end
+
+    def value=(val)
+      self.text = val.to_s
+    end
+
+    def matches?(selector)
+      adapter.matches?(native, selector)
+    end
+
+    def ancestors
+      NodeSet.new(adapter.ancestors(native))
+    end
+
+    def descendants
+      NodeSet.new(adapter.descendants(native))
+    end
+
+    def previous_elements
+      NodeSet.new(adapter.previous_elements(native))
+    end
+
+    def next_elements
+      NodeSet.new(adapter.next_elements(native))
+    end
+
+    def inner_text
+      adapter.inner_text(native)
+    end
+
+    def inner_text=(text)
+      adapter.set_inner_text(native, text)
+      self
+    end
+
+    def key?(name)
+      adapter.has_attribute?(native, name)
+    end
+
+    alias has_attribute? key?
+
+    def classes
+      (self["class"] || "").split(/\s+/)
+    end
+
+    def add_class(*names)
+      self["class"] = (classes + names).uniq.join(" ")
+      self
+    end
+
+    def remove_class(*names)
+      self["class"] = (classes - names).join(" ")
+      self
+    end
+
+    def toggle_class(name)
+      if classes.include?(name)
+        remove_class(name)
+      else
+        add_class(name)
+      end
+    end
+
+    def has_class?(name)
+      classes.include?(name)
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_element(nil, "")
+    end
+  end
+end

data/lib/moxml/error_handler.rb

@@ -0,0 +1,77 @@
+# 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