moxml 0.1.0

data/lib/moxml/errors.rb

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

data/lib/moxml/namespace.rb

@@ -0,0 +1,54 @@
+module Moxml
+  class Namespace < Node
+    def initialize(prefix_or_native = nil, uri = nil)
+      case prefix_or_native
+      when String
+        super(adapter.create_namespace(nil, prefix_or_native, uri))
+      else
+        super(prefix_or_native)
+      end
+    end
+
+    def prefix
+      adapter.namespace_prefix(native)
+    end
+
+    def prefix=(new_prefix)
+      adapter.set_namespace_prefix(native, new_prefix)
+      self
+    end
+
+    def uri
+      adapter.namespace_uri(native)
+    end
+
+    def uri=(new_uri)
+      adapter.set_namespace_uri(native, new_uri)
+      self
+    end
+
+    def blank?
+      uri.nil? || uri.empty?
+    end
+
+    def namespace?
+      true
+    end
+
+    def ==(other)
+      other.is_a?(Namespace) &&
+        other.prefix == prefix &&
+        other.uri == uri
+    end
+
+    def to_s
+      prefix ? "xmlns:#{prefix}='#{uri}'" : "xmlns='#{uri}'"
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_namespace(nil, "", "")
+    end
+  end
+end

data/lib/moxml/node.rb

@@ -0,0 +1,113 @@
+module Moxml
+  class Node
+    attr_reader :native
+
+    def initialize(native_node = nil)
+      @native = native_node || create_native_node
+    end
+
+    def self.wrap(native_node)
+      return nil if native_node.nil?
+
+      klass = case Moxml.adapter.node_type(native_node)
+        when :element then Element
+        when :text then Text
+        when :cdata then Cdata
+        when :comment then Comment
+        when :processing_instruction then ProcessingInstruction
+        when :document then Document
+        when :attribute then Attribute
+        when :namespace then Namespace
+        else
+          raise Error, "Unknown node type: #{native_node.class}"
+        end
+
+      klass.new(native_node)
+    end
+
+    def parent
+      wrap_node(adapter.parent(native))
+    end
+
+    def children
+      NodeSet.new(adapter.children(native))
+    end
+
+    def next_sibling
+      wrap_node(adapter.next_sibling(native))
+    end
+
+    def previous_sibling
+      wrap_node(adapter.previous_sibling(native))
+    end
+
+    def remove
+      adapter.remove(native)
+      self
+    end
+
+    def replace(node)
+      adapter.replace(native, node.native)
+      self
+    end
+
+    def add_previous_sibling(node)
+      adapter.add_previous_sibling(native, node.native)
+      self
+    end
+
+    def add_next_sibling(node)
+      adapter.add_next_sibling(native, node.native)
+      self
+    end
+
+    def text
+      adapter.text_content(native)
+    end
+
+    def text=(content)
+      adapter.set_text_content(native, content)
+      self
+    end
+
+    def inner_html
+      adapter.inner_html(native)
+    end
+
+    def inner_html=(html)
+      adapter.set_inner_html(native, html)
+    end
+
+    def outer_html
+      adapter.outer_html(native)
+    end
+
+    def path
+      adapter.path(native)
+    end
+
+    def line
+      adapter.line(native)
+    end
+
+    def column
+      adapter.column(native)
+    end
+
+    protected
+
+    def wrap_node(native_node)
+      self.class.wrap(native_node)
+    end
+
+    private
+
+    def adapter
+      Moxml.adapter
+    end
+
+    def create_native_node
+      raise NotImplementedError, "Subclasses must implement create_native_node"
+    end
+  end
+end

data/lib/moxml/node_set.rb

@@ -0,0 +1,268 @@
+# lib/moxml/node_set.rb
+module Moxml
+  class NodeSet
+    include Enumerable
+
+    attr_reader :native_nodes
+
+    def initialize(native_nodes = [])
+      @native_nodes = Array(native_nodes)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      native_nodes.each { |node| yield Node.wrap(node) }
+      self
+    end
+
+    def [](index)
+      case index
+      when Integer
+        Node.wrap(native_nodes[index])
+      when Range
+        NodeSet.new(native_nodes[index])
+      end
+    end
+
+    def first
+      Node.wrap(native_nodes.first)
+    end
+
+    def last
+      Node.wrap(native_nodes.last)
+    end
+
+    def empty?
+      native_nodes.empty?
+    end
+
+    def size
+      native_nodes.size
+    end
+
+    alias length size
+
+    def to_a
+      map { |node| node }
+    end
+
+    def filter(selector)
+      NodeSet.new(
+        native_nodes.select { |node| Moxml.adapter.matches?(node, selector) }
+      )
+    end
+
+    def remove
+      each(&:remove)
+      self
+    end
+
+    def text
+      map(&:text).join
+    end
+
+    def inner_html
+      map(&:inner_html).join
+    end
+
+    def wrap(html_or_element)
+      each do |node|
+        wrapper = case html_or_element
+          when String
+            Document.parse("<div>#{html_or_element}</div>").root.children.first
+          when Element
+            html_or_element.dup
+          else
+            raise ArgumentError, "Expected String or Element"
+          end
+
+        node.add_previous_sibling(wrapper)
+        wrapper.add_child(node)
+      end
+      self
+    end
+
+    def add_class(names)
+      each do |node|
+        next unless node.is_a?(Element)
+        current = (node["class"] || "").split(/\s+/)
+        new_classes = names.is_a?(Array) ? names : names.split(/\s+/)
+        node["class"] = (current + new_classes).uniq.join(" ")
+      end
+      self
+    end
+
+    def remove_class(names)
+      each do |node|
+        next unless node.is_a?(Element)
+        current = (node["class"] || "").split(/\s+/)
+        remove_classes = names.is_a?(Array) ? names : names.split(/\s+/)
+        node["class"] = (current - remove_classes).join(" ")
+      end
+      self
+    end
+
+    def attr(name, value = nil)
+      if value.nil?
+        first&.[](name)
+      else
+        each { |node| node[name] = value if node.is_a?(Element) }
+        self
+      end
+    end
+
+    # Collection operations
+    def +(other)
+      NodeSet.new(native_nodes + other.native_nodes)
+    end
+
+    def -(other)
+      NodeSet.new(native_nodes - other.native_nodes)
+    end
+
+    def &(other)
+      NodeSet.new(native_nodes & other.native_nodes)
+    end
+
+    def |(other)
+      NodeSet.new(native_nodes | other.native_nodes)
+    end
+
+    def uniq
+      NodeSet.new(native_nodes.uniq)
+    end
+
+    def reverse
+      NodeSet.new(native_nodes.reverse)
+    end
+
+    # Search and filtering
+    def find_by_id(id)
+      detect { |node| node.is_a?(Element) && node["id"] == id }
+    end
+
+    def find_by_class(class_name)
+      select { |node| node.is_a?(Element) && (node["class"] || "").split(/\s+/).include?(class_name) }
+    end
+
+    def find_by_attribute(name, value = nil)
+      select do |node|
+        next unless node.is_a?(Element)
+        if value.nil?
+          node.attributes.key?(name)
+        else
+          node[name] == value
+        end
+      end
+    end
+
+    def of_type(type)
+      select { |node| node.is_a?(type) }
+    end
+
+    # DOM Manipulation
+    def before(node_or_nodes)
+      each { |node| node.add_previous_sibling(node_or_nodes) }
+      self
+    end
+
+    def after(node_or_nodes)
+      each { |node| node.add_next_sibling(node_or_nodes) }
+      self
+    end
+
+    def replace_with(node_or_nodes)
+      each { |node| node.replace(node_or_nodes) }
+      self
+    end
+
+    def wrap_all(wrapper)
+      return self if empty?
+
+      wrapper_node = case wrapper
+        when String
+          Document.parse(wrapper).root
+        when Element
+          wrapper
+        else
+          raise ArgumentError, "Expected String or Element"
+        end
+
+      first.add_previous_sibling(wrapper_node)
+      wrapper_node.add_child(self)
+      self
+    end
+
+    # Content manipulation
+    def inner_text=(text)
+      each { |node| node.inner_text = text }
+      self
+    end
+
+    def inner_html=(html)
+      each { |node| node.inner_html = html }
+      self
+    end
+
+    # Attribute operations
+    def toggle_class(names)
+      names = names.split(/\s+/) if names.is_a?(String)
+      each do |node|
+        next unless node.is_a?(Element)
+        current = (node["class"] || "").split(/\s+/)
+        names.each do |name|
+          if current.include?(name)
+            current.delete(name)
+          else
+            current << name
+          end
+        end
+        node["class"] = current.uniq.join(" ")
+      end
+      self
+    end
+
+    def has_class?(name)
+      any? { |node| node.is_a?(Element) && (node["class"] || "").split(/\s+/).include?(name) }
+    end
+
+    def remove_attr(*attrs)
+      each do |node|
+        next unless node.is_a?(Element)
+        attrs.each { |attr| node.remove_attribute(attr) }
+      end
+      self
+    end
+
+    # Position and hierarchy
+    def parents
+      NodeSet.new(
+        map { |node| node.parent }.compact.uniq
+      )
+    end
+
+    def children
+      NodeSet.new(
+        flat_map { |node| node.children.to_a }
+      )
+    end
+
+    def siblings
+      NodeSet.new(
+        flat_map { |node| node.parent ? node.parent.children.reject { |sibling| sibling == node } : [] }
+      ).uniq
+    end
+
+    def next
+      NodeSet.new(
+        map { |node| node.next_sibling }.compact
+      )
+    end
+
+    def previous
+      NodeSet.new(
+        map { |node| node.previous_sibling }.compact
+      )
+    end
+  end
+end

data/lib/moxml/processing_instruction.rb

@@ -0,0 +1,44 @@
+module Moxml
+  class ProcessingInstruction < Node
+    def initialize(target_or_native = nil, content = nil)
+      case target_or_native
+      when String
+        super(adapter.create_processing_instruction(nil, target_or_native, content))
+      else
+        super(target_or_native)
+      end
+    end
+
+    def target
+      adapter.processing_instruction_target(native)
+    end
+
+    def target=(new_target)
+      adapter.set_processing_instruction_target(native, new_target)
+      self
+    end
+
+    def content
+      adapter.processing_instruction_content(native)
+    end
+
+    def content=(new_content)
+      adapter.set_processing_instruction_content(native, new_content)
+      self
+    end
+
+    def blank?
+      content.strip.empty?
+    end
+
+    def processing_instruction?
+      true
+    end
+
+    private
+
+    def create_native_node
+      adapter.create_processing_instruction(nil, "", "")
+    end
+  end
+end

data/lib/moxml/text.rb

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

data/lib/moxml/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Moxml
+  VERSION = "0.1.0"
+end