moxml 0.1.0 → 0.1.1

data/lib/moxml/document.rb

@@ -1,99 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "node"
+require_relative "element"
+require_relative "text"
+require_relative "cdata"
+require_relative "comment"
+require_relative "processing_instruction"
+require_relative "declaration"
+require_relative "namespace"
+require_relative "doctype"
+
 module Moxml
   class Document < Node
-    def self.parse(input, options = {})
-      new(Moxml.adapter.parse(input, options))
+    def root=(element)
+      adapter.set_root(@native, element.native)
     end
 
     def root
-      wrap_node(adapter.root(native))
+      root_element = adapter.root(@native)
+      root_element ? Element.wrap(root_element, context) : nil
     end
 
     def create_element(name)
-      Element.new(adapter.create_element(native, name))
+      Element.new(adapter.create_element(name), context)
     end
 
     def create_text(content)
-      Text.new(adapter.create_text(native, content))
+      Text.new(adapter.create_text(content), context)
     end
 
     def create_cdata(content)
-      Cdata.new(adapter.create_cdata(native, content))
+      Cdata.new(adapter.create_cdata(content), context)
     end
 
     def create_comment(content)
-      Comment.new(adapter.create_comment(native, content))
+      Comment.new(adapter.create_comment(content), context)
     end
 
-    def create_processing_instruction(target, content)
-      ProcessingInstruction.new(
-        adapter.create_processing_instruction(native, target, content)
+    def create_doctype(name, external_id, system_id)
+      Doctype.new(
+        adapter.create_doctype(name, external_id, system_id),
+        context
       )
     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
+    def create_processing_instruction(target, content)
+      ProcessingInstruction.new(
+        adapter.create_processing_instruction(target, content),
+        context
+      )
     end
 
-    def standalone=(standalone)
-      (declaration || add_declaration).standalone = standalone
+    def create_declaration(version = "1.0", encoding = "UTF-8", standalone = nil)
+      decl = adapter.create_declaration(version, encoding, standalone)
+      Declaration.new(decl, context)
     end
 
-    def declaration
-      children.find { |node| node.is_a?(Declaration) }
-    end
+    def add_child(node)
+      node = prepare_node(node)
 
-    def add_declaration(version = "1.0", encoding = "UTF-8", standalone = nil)
-      decl = Declaration.new(version, encoding, standalone)
-      if declaration
-        declaration.replace(decl)
+      if node.is_a?(Declaration)
+        if children.empty?
+          adapter.add_child(@native, node.native)
+        else
+          adapter.add_previous_sibling(children.first.native, node.native)
+        end
+      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment)
+        raise Error, "Document already has a root element"
       else
-        add_child(decl)
+        adapter.add_child(@native, node.native)
       end
-      decl
-    end
-
-    def css(selector)
-      NodeSet.new(adapter.css(native, selector))
+      self
     end
 
-    def xpath(expression, namespaces = {})
-      NodeSet.new(adapter.xpath(native, expression, namespaces))
+    def xpath(expression, namespaces = nil)
+      native_nodes = adapter.xpath(@native, expression, namespaces)
+      NodeSet.new(native_nodes, context)
     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
+    def at_xpath(expression, namespaces = nil)
+      if (native_node = adapter.at_xpath(@native, expression, namespaces))
+        Node.wrap(native_node, context)
+      end
     end
   end
 end

data/lib/moxml/document_builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Moxml
+  class DocumentBuilder
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+      @node_stack = []
+    end
+
+    def build(native_doc)
+      @current_doc = context.create_document
+      visit_node(native_doc)
+      @current_doc
+    end
+
+    private
+
+    def visit_node(node)
+      node.respond_to?(:name) ? node.name : node
+      method_name = "visit_#{node_type(node)}"
+      return unless respond_to?(method_name, true)
+
+      send(method_name, node)
+    end
+
+    def visit_document(doc)
+      @node_stack.push(@current_doc)
+      visit_children(doc)
+      @node_stack.pop
+    end
+
+    def visit_element(node)
+      element = Element.new(node, context)
+      if @node_stack.empty?
+        # For root element, we need to set it directly
+        adapter.set_root(@current_doc.native, element.native)
+      else
+        @node_stack.last.add_child(element)
+      end
+      @node_stack.push(element)
+      visit_children(node)
+      @node_stack.pop
+      element
+    end
+
+    def visit_text(node)
+      @node_stack.last.add_child(Text.new(node, context)) if @node_stack.any?
+    end
+
+    def visit_cdata(node)
+      @node_stack.last.add_child(Cdata.new(node, context)) if @node_stack.any?
+    end
+
+    def visit_comment(node)
+      @node_stack.last.add_child(Comment.new(node, context)) if @node_stack.any?
+    end
+
+    def visit_processing_instruction(node)
+      @node_stack.last.add_child(ProcessingInstruction.new(node, context)) if @node_stack.any?
+    end
+
+    def visit_doctype(node)
+      @node_stack.last.add_child(Doctype.new(node, context)) if @node_stack.any?
+    end
+
+    def visit_children(node)
+      node_children = children(node).dup
+      node_children.each do |child|
+        visit_node(child)
+      end
+    end
+
+    def node_type(node)
+      context.config.adapter.node_type(node)
+    end
+
+    def children(node)
+      context.config.adapter.children(node)
+    end
+
+    def adapter
+      context.config.adapter
+    end
+  end
+end

data/lib/moxml/element.rb

@@ -1,145 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "attribute"
+require_relative "namespace"
+
 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)
+      adapter.node_name(@native)
     end
 
-    def attributes
-      adapter.attributes(native).transform_values { |attr| Attribute.new(attr) }
+    def name=(value)
+      adapter.set_node_name(@native, value)
     end
 
     def []=(name, value)
-      adapter.set_attribute(native, name, value)
+      adapter.set_attribute(@native, name, normalize_xml_value(value))
     end
 
     def [](name)
-      attr = adapter.get_attribute(native, name)
-      attr.nil? ? nil : Attribute.new(attr)
+      adapter.get_attribute_value(@native, name)
     end
 
-    def add_child(node)
-      adapter.add_child(native, node.native)
-      self
+    def attribute(name)
+      native_attr = adapter.get_attribute(@native, name)
+      native_attr && Attribute.new(native_attr, context)
     end
 
-    def namespace
-      ns = adapter.namespace(native)
-      ns.nil? ? nil : Namespace.new(ns)
+    def attributes
+      adapter.attributes(@native).map do |attr|
+        Attribute.new(attr, context)
+      end
     end
 
-    def namespace=(ns)
-      adapter.set_namespace(native, ns&.native)
+    def remove_attribute(name)
+      adapter.remove_attribute(@native, name)
       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
+    def add_namespace(prefix, uri)
+      validate_uri(uri)
+      adapter.create_native_namespace(@native, prefix, uri)
+      self
+    rescue ValidationError => e
+      raise Moxml::NamespaceError, e.message
     end
+    alias add_namespace_definition add_namespace
 
-    def value=(val)
-      self.text = val.to_s
+    # it's NOT the same as namespaces.first
+    def namespace
+      ns = adapter.namespace(@native)
+      ns && Namespace.new(ns, context)
     end
 
-    def matches?(selector)
-      adapter.matches?(native, selector)
+    # it does NOT change the list of namespace definitions
+    def namespace=(ns_or_hash)
+      if ns_or_hash.is_a?(Hash)
+        adapter.set_namespace(
+          @native,
+          adapter.create_namespace(@native, *ns_or_hash.to_a.first)
+        )
+      else
+        adapter.set_namespace(@native, ns_or_hash&.native)
+      end
     end
 
-    def ancestors
-      NodeSet.new(adapter.ancestors(native))
+    def namespaces
+      adapter.namespace_definitions(@native).map do |ns|
+        Namespace.new(ns, context)
+      end
     end
+    alias namespace_definitions namespaces
 
-    def descendants
-      NodeSet.new(adapter.descendants(native))
+    def text
+      adapter.text_content(@native)
     end
 
-    def previous_elements
-      NodeSet.new(adapter.previous_elements(native))
+    def text=(content)
+      adapter.set_text_content(@native, normalize_xml_value(content))
     end
 
-    def next_elements
-      NodeSet.new(adapter.next_elements(native))
+    def inner_html
+      adapter.inner_html(@native)
     end
 
-    def inner_text
-      adapter.inner_text(native)
+    def inner_html=(html)
+      doc = context.parse("<root>#{html}</root>")
+      adapter.replace_children(@native, doc.root.children.map(&:native))
     end
 
-    def inner_text=(text)
-      adapter.set_inner_text(native, text)
+    # Fluent interface methods
+    def with_attribute(name, value)
+      self[name] = value
       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(" ")
+    def with_namespace(prefix, uri)
+      add_namespace(prefix, uri)
       self
     end
 
-    def remove_class(*names)
-      self["class"] = (classes - names).join(" ")
+    def with_text(content)
+      self.text = content
       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.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Moxml
+  class Error < StandardError; end
+
+  class ParseError < Error
+    attr_reader :line, :column
+
+    def initialize(message, line: nil, column: nil)
+      @line = line
+      @column = column
+      super(message)
+    end
+  end
+
+  class ValidationError < Error; end
+  class XPathError < Error; end
+  class NamespaceError < Error; end
+  class AdapterError < Error; end
+end

data/lib/moxml/namespace.rb

@@ -1,54 +1,29 @@
+# frozen_string_literal: true
+
 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
+      adapter.namespace_prefix(@native)
     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
+      adapter.namespace_uri(@native)
     end
 
     def ==(other)
-      other.is_a?(Namespace) &&
-        other.prefix == prefix &&
-        other.uri == uri
+      other.is_a?(Namespace) && prefix == other.prefix && uri == other.uri
     end
 
     def to_s
-      prefix ? "xmlns:#{prefix}='#{uri}'" : "xmlns='#{uri}'"
+      if prefix
+        %(xmlns:#{prefix}="#{uri}")
+      else
+        %(xmlns="#{uri}")
+      end
     end
 
-    private
-
-    def create_native_node
-      adapter.create_namespace(nil, "", "")
+    def namespace?
+      true
     end
   end
 end