moxml 0.1.0 → 0.1.1

data/lib/moxml/adapter.rb

@@ -1,175 +1,31 @@
-# 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
+# frozen_string_literal: true
 
-    def attributes(element)
-      raise NotImplementedError
-    end
-
-    def get_attribute(element, name)
-      raise NotImplementedError
-    end
-
-    def set_attribute(element, name, value)
-      raise NotImplementedError
-    end
+require_relative "adapter/base"
 
-    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),
-      }
+module Moxml
+  module Adapter
+    AVALIABLE_ADAPTERS = %i[nokogiri oga].freeze # ox to be added later
+
+    class << self
+      def load(name)
+        require_adapter(name)
+        const_get(name.to_s.capitalize)
+      rescue LoadError => e
+        raise LoadError, "Could not load #{name} adapter. Please ensure the #{name} gem is available: #{e.message}"
+      end
+
+      private
+
+      def require_adapter(name)
+        require "#{__dir__}/adapter/#{name}"
+      rescue LoadError
+        begin
+          require name.to_s
+          require "#{__dir__}/adapter/#{name}"
+        rescue LoadError => e
+          raise LoadError, "Failed to load #{name} adapter: #{e.message}"
+        end
+      end
     end
   end
 end

data/lib/moxml/attribute.rb

@@ -1,30 +1,63 @@
+# frozen_string_literal: true
+
 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
+    def name
+      @native.name
     end
 
-    def name
-      adapter.attribute_name(native)
+    def name=(new_name)
+      @native.name = new_name
     end
 
     def value
-      adapter.attribute_value(native)
+      @native.value
     end
 
     def value=(new_value)
-      adapter.set_attribute_value(native, new_value)
+      @native.value = normalize_xml_value(new_value)
+    end
+
+    def namespace
+      ns = adapter.namespace(@native)
+      ns && Namespace.new(ns, context)
+    end
+
+    def namespace=(ns)
+      adapter.set_namespace(@native, ns&.native)
+    end
+
+    def element
+      adapter.attribute_element(@native)
+    end
+
+    def remove
+      adapter.remove_attribute(element, name)
+      self
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Attribute)
+
+      name == other.name && value == other.value && namespace == other.namespace
+    end
+
+    def to_s
+      if namespace&.prefix
+        "#{namespace.prefix}:#{name}=\"#{value}\""
+      else
+        "#{name}=\"#{value}\""
+      end
+    end
+
+    def attribute?
+      true
     end
 
-    private
+    protected
 
-    def create_native_node
-      adapter.create_attribute(nil, "", "")
+    def adapter
+      context.config.adapter
     end
   end
 end

data/lib/moxml/builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Moxml
+  class Builder
+    def initialize(context)
+      @context = context
+      @current = @document = context.create_document
+      @namespaces = {}
+    end
+
+    def build(&block)
+      instance_eval(&block)
+      @document
+    end
+
+    def declaration(version: "1.0", encoding: "UTF-8", standalone: nil)
+      @current.add_child(
+        @document.create_declaration(version, encoding, standalone)
+      )
+    end
+
+    def element(name, attributes = {}, &block)
+      el = @document.create_element(name)
+
+      attributes.each do |key, value|
+        el[key] = value
+      end
+
+      @current.add_child(el)
+
+      if block_given?
+        previous = @current
+        @current = el
+        instance_eval(&block)
+        @current = previous
+      end
+
+      el
+    end
+
+    def text(content)
+      @current.add_child(@document.create_text(content))
+    end
+
+    def cdata(content)
+      @current.add_child(@document.create_cdata(content))
+    end
+
+    def comment(content)
+      @current.add_child(@document.create_comment(content))
+    end
+
+    def processing_instruction(target, content)
+      @current.add_child(
+        @document.create_processing_instruction(target, content)
+      )
+    end
+
+    def namespace(prefix, uri)
+      @current.add_namespace(prefix, uri)
+      @namespaces[prefix] = uri
+    end
+  end
+end

data/lib/moxml/cdata.rb

@@ -1,39 +1,17 @@
+# frozen_string_literal: true
+
 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)
+      adapter.cdata_content(@native)
     end
 
     def content=(text)
-      adapter.set_cdata_content(native, text)
-      self
-    end
-
-    def blank?
-      content.strip.empty?
+      adapter.set_cdata_content(@native, normalize_xml_value(text))
     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

@@ -1,35 +1,19 @@
+# frozen_string_literal: true
+
 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)
+      adapter.comment_content(@native)
     end
 
     def content=(text)
-      adapter.set_comment_content(native, text)
-      self
-    end
-
-    def blank?
-      content.strip.empty?
+      text = normalize_xml_value(text)
+      adapter.validate_comment_content(text)
+      adapter.set_comment_content(@native, text)
     end
 
     def comment?
       true
     end
-
-    private
-
-    def create_native_node
-      adapter.create_comment(nil, "")
-    end
   end
 end

data/lib/moxml/config.rb

@@ -1,23 +1,47 @@
-# lib/moxml/config.rb
+# frozen_string_literal: true
+
 module Moxml
   class Config
-    attr_accessor :backend, :huge_document,
+    VALID_ADAPTERS = %i[nokogiri oga ox].freeze
+    DEFAULT_ADAPTER = VALID_ADAPTERS.first
+
+    class << self
+      def default
+        @default ||= new(DEFAULT_ADAPTER, true, "UTF-8")
+      end
+    end
+
+    attr_reader :adapter_name
+    attr_accessor :strict_parsing,
                   :default_encoding,
-                  :default_indent,
-                  :cdata_sections,
-                  :cdata_patterns,
-                  :strict_parsing,
-                  :entity_encoding
-
-    def initialize
-      @backend = :nokogiri
-      @huge_document = false
-      @default_encoding = "UTF-8"
+                  :entity_encoding,
+                  :default_indent
+
+    def initialize(adapter_name = nil, strict_parsing = nil, default_encoding = nil)
+      self.adapter = adapter_name || Config.default.adapter_name
+      @strict_parsing = strict_parsing || Config.default.strict_parsing
+      @default_encoding = default_encoding || Config.default.default_encoding
+      # reserved for future use
       @default_indent = 2
-      @cdata_sections = true
-      @cdata_patterns = ["script", "style"]
-      @strict_parsing = true
       @entity_encoding = :basic
     end
+
+    def adapter=(name)
+      name = name.to_sym
+      @adapter = nil
+
+      unless VALID_ADAPTERS.include?(name)
+        raise ArgumentError, "Invalid adapter: #{name}. Valid adapters are: #{VALID_ADAPTERS.join(", ")}"
+      end
+
+      @adapter_name = name
+      adapter
+    end
+
+    alias default_adapter= adapter=
+
+    def adapter
+      @adapter ||= Adapter.load(@adapter_name)
+    end
   end
 end

data/lib/moxml/context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moxml
+  class Context
+    attr_reader :config
+
+    def initialize(adapter = nil)
+      @config = Config.new(adapter)
+    end
+
+    def create_document
+      Document.new(config.adapter.create_document, self)
+    end
+
+    def parse(xml, options = {})
+      config.adapter.parse(xml, default_options.merge(options))
+    end
+
+    private
+
+    def default_options
+      {
+        encoding: config.default_encoding,
+        strict: config.strict_parsing,
+        indent: config.default_indent
+      }
+    end
+  end
+end

data/lib/moxml/declaration.rb

@@ -1,50 +1,40 @@
-# lib/moxml/declaration.rb
+# frozen_string_literal: true
+
 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
+    ALLOWED_VERSIONS = ["1.0", "1.1"].freeze
+    ALLOWED_STANDALONE = %w[yes no].freeze
+    ALLOWED_ATTRIBUTES = %w[version encoding standalone].freeze
 
     def version
-      adapter.declaration_version(native)
+      adapter.declaration_attribute(@native, "version")
     end
 
     def version=(new_version)
-      adapter.set_declaration_version(native, new_version)
-      self
+      adapter.validate_declaration_version(new_version)
+      adapter.set_declaration_attribute(@native, "version", new_version)
     end
 
     def encoding
-      adapter.declaration_encoding(native)
+      adapter.declaration_attribute(@native, "encoding")
     end
 
     def encoding=(new_encoding)
-      adapter.set_declaration_encoding(native, new_encoding)
-      self
+      adapter.validate_declaration_encoding(new_encoding)
+      adapter.set_declaration_attribute(@native, "encoding", new_encoding)
     end
 
     def standalone
-      adapter.declaration_standalone(native)
+      adapter.declaration_attribute(@native, "standalone")
     end
 
     def standalone=(new_standalone)
-      adapter.set_declaration_standalone(native, new_standalone)
-      self
+      adapter.validate_declaration_standalone(new_standalone)
+      adapter.set_declaration_attribute(@native, "standalone", new_standalone)
     end
 
-    def to_xml
-      adapter.serialize_declaration(native)
-    end
-
-    private
-
-    def create_native_node
-      adapter.create_declaration(nil, "1.0", "UTF-8", nil)
+    def declaration?
+      true
     end
   end
 end

data/lib/moxml/doctype.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Moxml
+  class Doctype < Node
+    def doctype?
+      true
+    end
+  end
+end