moxml 0.1.0 → 0.1.1

data/lib/moxml/xml_utils.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "xml_utils/encoder"
+
+# Ruby 3.3+ requires the URI module to be explicitly required
+require "uri" unless defined?(::URI)
+
+module Moxml
+  module XmlUtils
+    def encode_entities(text, mode = nil)
+      Encoder.new(text, mode).call
+    end
+
+    def validate_declaration_version(version)
+      return if ::Moxml::Declaration::ALLOWED_VERSIONS.include?(version)
+
+      raise ValidationError, "Invalid XML version: #{version}"
+    end
+
+    def validate_declaration_encoding(encoding)
+      return if encoding.nil?
+
+      begin
+        Encoding.find(encoding)
+      rescue ArgumentError
+        raise ValidationError, "Invalid encoding: #{encoding}"
+      end
+    end
+
+    def validate_declaration_standalone(standalone)
+      return if standalone.nil?
+      return if ::Moxml::Declaration::ALLOWED_STANDALONE.include?(standalone)
+
+      raise ValidationError, "Invalid standalone value: #{standalone}"
+    end
+
+    def validate_comment_content(text)
+      if text.start_with?("-") || text.end_with?("-")
+        raise ValidationError, "XML comment cannot start or end with a hyphen"
+      end
+
+      return unless text.include?("--")
+
+      raise ValidationError, "XML comment cannot contain double hyphens (--)"
+    end
+
+    def validate_element_name(name)
+      return if name.is_a?(String) && name.match?(/^[a-zA-Z_][\w\-.:]*$/)
+
+      raise ValidationError, "Invalid XML name: #{name}"
+    end
+
+    def validate_pi_target(target)
+      return if target.is_a?(String) && target.match?(/^[a-zA-Z_][\w\-.]*$/)
+
+      raise ValidationError, "Invalid XML target: #{target}"
+    end
+
+    def validate_uri(uri)
+      return if uri.empty? || uri.match?(/\A#{::URI::DEFAULT_PARSER.make_regexp}\z/)
+
+      raise ValidationError, "Invalid URI: #{uri}"
+    end
+
+    def validate_prefix(prefix)
+      return if prefix.match?(/\A[a-zA-Z_][\w-]*\z/)
+
+      raise ValidationError, "Invalid namespace prefix: #{prefix}"
+    end
+
+    def normalize_xml_value(value)
+      case value
+      when nil then ""
+      when true then "true"
+      when false then "false"
+      else value.to_s
+      end
+    end
+  end
+end

data/lib/moxml.rb

@@ -1,44 +1,44 @@
-# lib/moxml.rb
-require_relative "moxml/version"
-require_relative "moxml/config"
-require_relative "moxml/document"
-require_relative "moxml/node"
-require_relative "moxml/element"
-require_relative "moxml/text"
-require_relative "moxml/cdata_section"
-require_relative "moxml/comment"
-require_relative "moxml/processing_instruction"
-require_relative "moxml/visitor"
-require_relative "moxml/errors"
-require_relative "moxml/backends/base"
+# frozen_string_literal: true
 
 module Moxml
   class << self
-    def config
-      @config ||= Config.new
+    def new(adapter = nil, &block)
+      context = Context.new(adapter)
+      context.config.instance_eval(&block) if block_given?
+      context
     end
 
     def configure
-      yield(config)
+      yield Config.default if block_given?
     end
 
-    def backend
-      @backend ||= begin
-          backend_class = case config.backend
-            when :nokogiri
-              require_relative "moxml/backends/nokogiri"
-              Backends::Nokogiri
-            when :ox
-              require_relative "moxml/backends/ox"
-              Backends::Ox
-            when :oga
-              require_relative "moxml/backends/oga"
-              Backends::Oga
-            else
-              raise ArgumentError, "Unknown backend: #{config.backend}"
-            end
-          backend_class.new
-        end
+    def with_config(adapter_name = nil, strict_parsing = nil, default_encoding = nil)
+      original_config = Config.default.dup
+
+      configure do |config|
+        config.adapter = adapter_name unless adapter_name.nil?
+        config.strict_parsing = strict_parsing unless strict_parsing.nil?
+        config.default_encoding = default_encoding unless default_encoding.nil?
+      end
+
+      yield if block_given?
+
+      # restore the original config
+      configure do |config|
+        config.adapter = original_config.adapter_name
+        config.strict_parsing = original_config.strict_parsing
+        config.default_encoding = original_config.default_encoding
+      end
+      original_config = nil
     end
   end
 end
+
+require_relative "moxml/version"
+require_relative "moxml/document"
+require_relative "moxml/document_builder"
+require_relative "moxml/error"
+require_relative "moxml/builder"
+require_relative "moxml/config"
+require_relative "moxml/context"
+require_relative "moxml/adapter"

data/moxml.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   # RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
+      f.match(%r{^(test|features)/})
     end
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/spec/moxml/adapter/nokogiri_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "moxml/adapter/nokogiri"
+
+RSpec.describe Moxml::Adapter::Nokogiri do
+  around do |example|
+    Moxml.with_config(:nokogiri, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+end

data/spec/moxml/adapter/oga_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "oga"
+require "moxml/adapter/oga"
+
+RSpec.describe Moxml::Adapter::Oga do
+  around do |example|
+    Moxml.with_config(:oga, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+end

data/spec/moxml/adapter/ox_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "ox"
+require "moxml/adapter/ox"
+
+RSpec.describe Moxml::Adapter::Ox, skip: "Ox will be added later" do
+  before(:all) do
+    Moxml.configure do |config|
+      config.adapter = :ox
+      config.strict_parsing = true
+      config.default_encoding = "UTF-8"
+    end
+  end
+
+  it_behaves_like "xml adapter"
+
+  describe "text handling" do
+    let(:doc) { described_class.create_document }
+    let(:element) { described_class.create_native_element("test") }
+
+    it "creates text nodes as strings" do
+      text = described_class.create_native_text("content")
+      expect(text).to be_a(String)
+      expect(text).to eq("content")
+    end
+
+    it "adds text nodes to elements" do
+      text = described_class.create_native_text("content")
+      described_class.add_child(element, text)
+      expect(element.nodes.first).to eq("content")
+    end
+  end
+
+  describe "xpath support" do
+    let(:doc) { described_class.parse("<root><child id='1'>text</child></root>") }
+
+    it "supports basic element matching" do
+      nodes = described_class.xpath(doc, "//child")
+      expect(nodes.size).to eq(1)
+      expect(nodes.first.name).to eq("child")
+    end
+
+    it "supports attribute matching" do
+      nodes = described_class.xpath(doc, "//child[@id='1']")
+      expect(nodes.size).to eq(1)
+      expect(nodes.first.attributes["id"]).to eq("1")
+    end
+  end
+end

data/spec/moxml/all_with_adapters_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe "Test all shared examples" do
+  all_shared_examples = [
+    "Moxml::Node",
+    "Moxml::Namespace",
+    "Moxml::Attribute",
+    "Moxml::NodeSet",
+    "Moxml::Element",
+    "Moxml::Cdata",
+    "Moxml::Comment",
+    "Moxml::Text",
+    "Moxml::ProcessingInstruction",
+    "Moxml::Declaration",
+    "Moxml::Doctype",
+    "Moxml::Document",
+    "Moxml::Context",
+    "Moxml::Builder",
+    "Moxml::DocumentBuilder",
+    "Moxml Integration",
+    "Moxml Edge Cases",
+    "Attribute Examples",
+    "Basic Usage Examples",
+    "Namespace Examples",
+    "README Examples",
+    "XPath Examples",
+    "Memory Usage Examples",
+    "Thread Safety Examples"
+  ]
+
+  Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+    # [:nokogiri].each do |adapter_name|
+    # [:oga].each do |adapter_name|
+    context "with #{adapter_name}" do
+      around do |example|
+        Moxml.with_config(adapter_name) do
+          example.run
+        end
+      end
+
+      all_shared_examples.each do |shared_example_name|
+        it_behaves_like shared_example_name
+      end
+    end
+  end
+end

data/spec/moxml/config_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# spec/moxml/config_spec.rb
+RSpec.describe Moxml::Config do
+  subject(:config) { described_class.new }
+
+  describe "#initialize" do
+    it "sets default values" do
+      expect(config.adapter_name).to eq(:nokogiri)
+      expect(config.strict_parsing).to be true
+      expect(config.default_encoding).to eq("UTF-8")
+      expect(config.default_indent).to eq(2)
+      expect(config.entity_encoding).to eq(:basic)
+    end
+  end
+
+  describe "#adapter=" do
+    it "sets valid adapter" do
+      config.adapter = :ox
+      expect(config.adapter_name).to eq(:ox)
+    end
+
+    it "raises error for invalid adapter" do
+      expect { config.adapter = :invalid }.to raise_error(ArgumentError)
+    end
+
+    it "requires adapter gem" do
+      expect { config.adapter = :oga }.not_to raise_error
+
+      expect(defined?(::Oga)).to be_truthy
+    end
+
+    it "handles missing gems" do
+      allow(Moxml::Adapter).to receive(:require).and_raise(LoadError)
+      expect { config.adapter = :nokogiri }.to raise_error(LoadError)
+    end
+  end
+
+  describe "#adapter" do
+    it "returns nokogiri adapter by default" do
+      expect(config.adapter).to eq(Moxml::Adapter::Nokogiri)
+    end
+
+    it "caches adapter instance" do
+      adapter = config.adapter
+      expect(config.adapter.object_id).to eq(adapter.object_id)
+    end
+
+    it "resets cached adapter when changing adapter type" do
+      original = config.adapter
+      config.adapter = :ox
+      expect(config.adapter).not_to eq(original)
+    end
+  end
+end

data/spec/moxml/error_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# spec/moxml/errors_spec.rb
+RSpec.describe "Moxml errors" do
+  describe Moxml::Error do
+    it "is a StandardError" do
+      expect(Moxml::Error.new).to be_a(StandardError)
+    end
+  end
+
+  describe Moxml::ParseError do
+    it "includes line and column information" do
+      error = Moxml::ParseError.new("Invalid XML", line: 5, column: 10)
+      expect(error.line).to eq(5)
+      expect(error.column).to eq(10)
+      expect(error.message).to eq("Invalid XML")
+    end
+
+    it "works without line and column" do
+      error = Moxml::ParseError.new("Invalid XML")
+      expect(error.line).to be_nil
+      expect(error.column).to be_nil
+    end
+  end
+
+  describe Moxml::ValidationError do
+    it "handles validation errors" do
+      error = Moxml::ValidationError.new("Invalid document structure")
+      expect(error.message).to eq("Invalid document structure")
+    end
+  end
+
+  describe Moxml::XPathError do
+    it "handles XPath errors" do
+      error = Moxml::XPathError.new("Invalid XPath expression")
+      expect(error.message).to eq("Invalid XPath expression")
+    end
+  end
+
+  describe Moxml::NamespaceError do
+    it "handles namespace errors" do
+      error = Moxml::NamespaceError.new("Invalid namespace URI")
+      expect(error.message).to eq("Invalid namespace URI")
+    end
+  end
+
+  describe "error handling in context" do
+    let(:context) { Moxml.new }
+
+    it "raises ParseError for invalid XML" do
+      expect do
+        context.parse("<invalid>")
+      end.to raise_error(Moxml::ParseError)
+    end
+
+    it "raises XPathError for invalid XPath" do
+      doc = context.parse("<root/>")
+      expect do
+        doc.xpath("///")
+      end.to raise_error(Moxml::XPathError)
+    end
+
+    it "raises NamespaceError for invalid namespace" do
+      doc = context.parse("<root/>")
+
+      expect do
+        doc.root.add_namespace("xml", "http//invalid.com")
+      end.to raise_error(Moxml::NamespaceError, "Invalid URI: http//invalid.com")
+    end
+  end
+end

data/spec/moxml/examples/adapter_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe "Adapter Examples" do
+  let(:xml) { "<root><child>text</child></root>" }
+
+  describe "Serialization consistency" do
+    it "produces equivalent XML across adapters",
+       skip: "No easy way to exclude the declaration from Nokogiri documents" do
+      docs = Moxml::Adapter::AVALIABLE_ADAPTERS.map do |adapter|
+        Moxml.new(adapter).parse(xml, fragment: true)
+      end
+
+      xmls = docs.map { |doc| normalize_xml(doc.to_xml) }
+      expect(xmls.uniq.size).to eq(1)
+    end
+
+    private
+
+    def normalize_xml(xml)
+      xml.gsub(/>\s+</, "><")
+         .gsub(/\s+/, " ")
+         .gsub(/ >/, ">")
+         .gsub(/\?></, "?>\n<")
+         .strip
+    end
+  end
+end

data/spec/moxml_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# spec/moxml_spec.rb
+RSpec.describe Moxml do
+  it "has a version number" do
+    expect(Moxml::VERSION).not_to be_nil
+  end
+
+  describe ".new" do
+    it "creates a new context" do
+      expect(Moxml.new).to be_a(Moxml::Context)
+    end
+
+    it "accepts adapter specification" do
+      context = Moxml.new(:nokogiri)
+      expect(context.config.adapter_name).to eq(:nokogiri)
+    end
+
+    it "raises error for invalid adapter" do
+      expect { Moxml.new(:invalid) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ".configure" do
+    around do |example|
+      # preserve the original config because it may be changed in examples
+      Moxml.with_config { example.run }
+    end
+
+    it "sets default values without a block" do
+      Moxml.configure
+
+      context = Moxml.new
+      expect(context.config.adapter_name).to eq(:nokogiri)
+    end
+
+    it "uses configured options from the block" do
+      Moxml.configure do |config|
+        config.adapter = :oga
+        config.strict_parsing = false
+        config.default_encoding = "US-ASCII"
+      end
+
+      context = Moxml.new
+      expect(context.config.adapter_name).to eq(:oga)
+      expect(context.config.strict_parsing).to eq(false)
+      expect(context.config.default_encoding).to eq("US-ASCII")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "moxml"
+require "nokogiri"
+require "byebug"
+
+Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.order = :random
+  Kernel.srand config.seed
+end
+
+Moxml.configure do |config|
+  config.adapter = :nokogiri
+  config.strict_parsing = true
+  config.default_encoding = "UTF-8"
+end