moxml 0.1.0 → 0.1.1

data/lib/moxml/node.rb

@@ -1,113 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "xml_utils"
+require_relative "node_set"
+
 module Moxml
   class Node
-    attr_reader :native
-
-    def initialize(native_node = nil)
-      @native = native_node || create_native_node
-    end
+    include XmlUtils
 
-    def self.wrap(native_node)
-      return nil if native_node.nil?
+    attr_reader :native, :context
 
-      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
+    def initialize(native, context)
+      @native = native
+      @context = context
+    end
 
-      klass.new(native_node)
+    def document
+      Document.wrap(adapter.document(@native), context)
     end
 
     def parent
-      wrap_node(adapter.parent(native))
+      Node.wrap(adapter.parent(@native), context)
     end
 
     def children
-      NodeSet.new(adapter.children(native))
+      NodeSet.new(adapter.children(@native), context)
     end
 
     def next_sibling
-      wrap_node(adapter.next_sibling(native))
+      Node.wrap(adapter.next_sibling(@native), context)
     end
 
     def previous_sibling
-      wrap_node(adapter.previous_sibling(native))
+      Node.wrap(adapter.previous_sibling(@native), context)
     end
 
-    def remove
-      adapter.remove(native)
-      self
-    end
-
-    def replace(node)
-      adapter.replace(native, node.native)
+    def add_child(node)
+      node = prepare_node(node)
+      adapter.add_child(@native, node.native)
       self
     end
 
     def add_previous_sibling(node)
-      adapter.add_previous_sibling(native, node.native)
+      node = prepare_node(node)
+      adapter.add_previous_sibling(@native, node.native)
       self
     end
 
     def add_next_sibling(node)
-      adapter.add_next_sibling(native, node.native)
+      node = prepare_node(node)
+      adapter.add_next_sibling(@native, node.native)
       self
     end
 
-    def text
-      adapter.text_content(native)
+    def remove
+      adapter.remove(@native)
+      self
     end
 
-    def text=(content)
-      adapter.set_text_content(native, content)
+    def replace(node)
+      node = prepare_node(node)
+      adapter.replace(@native, node.native)
       self
     end
 
-    def inner_html
-      adapter.inner_html(native)
+    def to_xml(options = {})
+      adapter.serialize(@native, default_options.merge(options))
     end
 
-    def inner_html=(html)
-      adapter.set_inner_html(native, html)
+    def xpath(expression, namespaces = {})
+      NodeSet.new(adapter.xpath(@native, expression, namespaces), context)
     end
 
-    def outer_html
-      adapter.outer_html(native)
+    def at_xpath(expression, namespaces = {})
+      Node.wrap(adapter.at_xpath(@native, expression, namespaces), context)
     end
 
-    def path
-      adapter.path(native)
+    def ==(other)
+      self.class == other.class && @native == other.native
     end
 
-    def line
-      adapter.line(native)
-    end
+    def self.wrap(node, context)
+      return nil if node.nil?
 
-    def column
-      adapter.column(native)
+      klass = case adapter(context).node_type(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 :declaration then Declaration
+              when :doctype then Doctype
+              else self
+              end
+
+      klass.new(node, context)
     end
 
     protected
 
-    def wrap_node(native_node)
-      self.class.wrap(native_node)
+    def adapter
+      context.config.adapter
+    end
+
+    def self.adapter(context)
+      context.config.adapter
     end
 
     private
 
-    def adapter
-      Moxml.adapter
-    end
-
-    def create_native_node
-      raise NotImplementedError, "Subclasses must implement create_native_node"
+    def prepare_node(node)
+      case node
+      when String then Text.new(adapter.create_text(node), context)
+      when Node then node
+      else
+        raise ArgumentError, "Invalid node type: #{node.class}"
+      end
+    end
+
+    def default_options
+      {
+        encoding: context.config.default_encoding,
+        indent: context.config.default_indent,
+        # The short format of empty tags in Oga and Nokogiri isn't configurable
+        # Oga: <empty /> (with a space)
+        # Nokogiri: <empty/> (without a space)
+        # The expanded format is enforced to avoid this conflict
+        expand_empty: true
+      }
     end
   end
 end

data/lib/moxml/node_set.rb

@@ -1,43 +1,46 @@
-# lib/moxml/node_set.rb
+# frozen_string_literal: true
+
 module Moxml
   class NodeSet
     include Enumerable
 
-    attr_reader :native_nodes
+    attr_reader :nodes, :context
 
-    def initialize(native_nodes = [])
-      @native_nodes = Array(native_nodes)
+    def initialize(nodes, context)
+      @nodes = Array(nodes)
+      @context = context
     end
 
     def each
-      return enum_for(:each) unless block_given?
-      native_nodes.each { |node| yield Node.wrap(node) }
+      return to_enum(:each) unless block_given?
+
+      nodes.each { |node| yield Node.wrap(node, context) }
       self
     end
 
     def [](index)
       case index
       when Integer
-        Node.wrap(native_nodes[index])
+        Node.wrap(nodes[index], context)
       when Range
-        NodeSet.new(native_nodes[index])
+        NodeSet.new(nodes[index], context)
       end
     end
 
     def first
-      Node.wrap(native_nodes.first)
+      Node.wrap(nodes.first, context)
     end
 
     def last
-      Node.wrap(native_nodes.last)
+      Node.wrap(nodes.last, context)
     end
 
     def empty?
-      native_nodes.empty?
+      nodes.empty?
     end
 
     def size
-      native_nodes.size
+      nodes.size
     end
 
     alias length size
@@ -46,223 +49,17 @@ module Moxml
       map { |node| node }
     end
 
-    def filter(selector)
-      NodeSet.new(
-        native_nodes.select { |node| Moxml.adapter.matches?(node, selector) }
-      )
-    end
-
-    def remove
-      each(&:remove)
-      self
+    def +(other)
+      self.class.new(nodes + other.nodes, context)
     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
+    def remove
+      each(&:remove)
       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

@@ -1,44 +1,25 @@
+# frozen_string_literal: true
+
 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)
+      adapter.processing_instruction_target(@native)
     end
 
     def target=(new_target)
-      adapter.set_processing_instruction_target(native, new_target)
-      self
+      adapter.set_node_name(@native, new_target.to_s)
     end
 
     def content
-      adapter.processing_instruction_content(native)
+      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?
+      adapter.set_processing_instruction_content(@native, new_content.to_s)
     end
 
     def processing_instruction?
       true
     end
-
-    private
-
-    def create_native_node
-      adapter.create_processing_instruction(nil, "", "")
-    end
   end
 end

data/lib/moxml/text.rb

@@ -1,39 +1,17 @@
+# frozen_string_literal: true
+
 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)
+      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
+      adapter.set_text_content(@native, normalize_xml_value(text))
     end
 
     def text?
       true
     end
-
-    private
-
-    def create_native_node
-      adapter.create_text(nil, "")
-    end
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils/encoder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XmlUtils
+    class Encoder
+      attr_reader :mode
+
+      MAPPINGS = {
+        none: {},
+        basic: {
+          "<" => "&lt;",
+          ">" => "&gt;",
+          "&" => "&amp;"
+        },
+        quotes: {
+          "'" => "&apos;",
+          '"' => "&quot;"
+        },
+        full: {
+          "<" => "&lt;",
+          ">" => "&gt;",
+          "'" => "&apos;",
+          '"' => "&quot;",
+          "&" => "&amp;"
+        }
+      }.freeze
+      MODES = MAPPINGS.keys.freeze
+
+      def initialize(text, mode = nil)
+        @text = text
+        @mode = valid_mode(mode)
+      end
+
+      def call
+        return @text if mode == :none
+
+        @text.to_s.gsub(/[#{mapping.keys.join}]/) do |match|
+          mapping[match]
+        end
+      end
+
+      protected
+
+      def valid_mode(raw_mode)
+        mode_sym = raw_mode.to_s.to_sym
+
+        MODES.include?(mode_sym) ? mode_sym : MODES.first
+      end
+
+      def mapping
+        MAPPINGS[mode] || {}
+      end
+    end
+  end
+end