moxml 0.1.22 → 0.1.23

data/lib/moxml/adapter/customized_oga/xml_declaration.rb

@@ -8,10 +8,17 @@ module Moxml
       class XmlDeclaration < ::Oga::XML::XmlDeclaration
         def initialize(options = {})
           @version    = options[:version] || "1.0"
-          # encoding is optional, but Oga sets it to UTF-8 by default
           @encoding   = options[:encoding]
           @standalone = options[:standalone]
         end
+
+        def to_xml
+          parts = ["<?xml"]
+          parts << %( version="#{version}") if version
+          parts << %( encoding="#{encoding}") if encoding
+          parts << %( standalone="#{standalone}") if standalone
+          "#{parts.join}?>"
+        end
       end
     end
   end

data/lib/moxml/adapter/customized_rexml/formatter.rb

@@ -70,12 +70,12 @@ module Moxml
                       child.to_s.strip.empty? &&
                       !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
-                    output << "\n" << (' ' * @level) if indent_children
+                    output << "\n" << (" " * @level) if indent_children
                     write(child, output)
                   end
                 when :eref
                   if eref_idx < entity_refs.size
-                    output << "\n" << (' ' * @level) if indent_children
+                    output << "\n" << (" " * @level) if indent_children
                     write(entity_refs[eref_idx], output)
                     eref_idx += 1
                   end
@@ -87,14 +87,14 @@ module Moxml
                   child.to_s.strip.empty? &&
                   !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
-                output << "\n" << (' ' * @level) if indent_children
+                output << "\n" << (" " * @level) if indent_children
                 write(child, output)
               end
             end
 
             if indent_children
               @level -= @indentation.length
-              output << "\n" << (' ' * @level)
+              output << "\n" << (" " * @level)
             end
           end
 

data/lib/moxml/adapter/libxml/entity_ref_registry.rb

@@ -9,7 +9,8 @@ module Moxml
         ENTITY_REFS_KEY = :_entity_ref_pairs
         CHILD_SEQUENCE_KEY = :_child_seq_pairs
         NON_WHITESPACE_RE = /\S/
-        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY, :NON_WHITESPACE_RE
+        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY,
+                         :NON_WHITESPACE_RE
 
         def initialize(attachments, doc)
           @attachments = attachments
@@ -34,7 +35,8 @@ module Moxml
           if existing
             existing << :eref
           else
-            seq_by_path[path] = Array.new(count_native_children(element), :native)
+            seq_by_path[path] =
+              Array.new(count_native_children(element), :native)
             seq_by_path[path] << :eref
             @attachments.set(@doc, CHILD_SEQUENCE_KEY, seq_by_path)
           end

data/lib/moxml/adapter/libxml/entity_restorer.rb

@@ -76,7 +76,9 @@ module Moxml
         def append_chunk(parent, type, payload)
           case type
           when :text
-            parent.add_child(::Moxml::Text.new(@adapter.create_native_text(payload), @ctx))
+            parent.add_child(::Moxml::Text.new(
+                               @adapter.create_native_text(payload), @ctx
+                             ))
           when :eref
             parent.add_child(
               ::Moxml::EntityReference.new(

data/lib/moxml/adapter/libxml.rb

@@ -1182,7 +1182,8 @@ module Moxml
         end
 
         ESCAPE_XML_RE = /[&<>"]/
-        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;" }.freeze
+        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                           '"' => "&quot;" }.freeze
         private_constant :ESCAPE_XML_RE, :ESCAPE_XML_MAP
 
         def escape_xml(text)
@@ -1278,7 +1279,13 @@ module Moxml
           # attachment query that otherwise fires for every element under
           # Monitor#synchronize.
           eref_active = doc_eref_active?(elem.doc) if eref_active.nil?
-          entity_refs, child_sequence = eref_active ? lookup_entity_ref_serialization(elem) : [nil, nil]
+          entity_refs, child_sequence = if eref_active
+                                          lookup_entity_ref_serialization(elem)
+                                        else
+                                          [
+                                            nil, nil
+                                          ]
+                                        end
 
           # Always use verbose format <tag></tag> for consistency with other adapters
           output << ">"
@@ -1622,8 +1629,14 @@ module Moxml
         # duplicated — callers that need the subtree use deep_duplicate_node.
         def shallow_duplicate_element(native_node)
           new_node = ::LibXML::XML::Node.new(native_node.name)
-          copy_element_namespaces(native_node, new_node) if native_node.is_a?(::LibXML::XML::Node)
-          copy_element_attributes(native_node, new_node) if native_node.attributes?
+          if native_node.is_a?(::LibXML::XML::Node)
+            copy_element_namespaces(native_node,
+                                    new_node)
+          end
+          if native_node.attributes?
+            copy_element_attributes(native_node,
+                                    new_node)
+          end
           new_node
         end
 

data/lib/moxml/adapter/nokogiri.rb

@@ -245,25 +245,22 @@ module Moxml
         end
 
         def add_child(element, child)
-          # Special handling for declarations on Nokogiri documents
           if element.is_a?(::Nokogiri::XML::Document) &&
               child.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
               child.name == "xml"
-            # Set document's xml_decl property
             version = declaration_attribute(child, "version") || "1.0"
             encoding = declaration_attribute(child, "encoding")
             standalone = declaration_attribute(child, "standalone")
 
-            # Store declaration state in attachment map
             attachments.set(element, :xml_decl, {
               version: version,
               encoding: encoding,
               standalone: standalone,
             }.compact)
+            return
           end
 
           if node_type(child) == :doctype
-            # avoid exceptions: cannot reparent Nokogiri::XML::DTD there
             element.create_internal_subset(
               child.name, child.external_id, child.system_id
             )
@@ -397,23 +394,28 @@ module Moxml
             save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT
           end
 
-          # Handle declaration option
-          # Priority:
-          # 1. Explicit no_declaration option
-          # 2. Check attachment-stored xml_decl (when remove is called, this becomes nil)
-          if options.key?(:no_declaration)
-            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if options[:no_declaration]
-          elsif attachments.key?(node, :xml_decl)
-            # State stored in attachment - if nil, declaration was removed
-            xml_decl = attachments.get(node, :xml_decl)
-            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if xml_decl.nil?
+          custom_decl = nil
+          if options[:no_declaration]
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+          elsif attachments.key?(node, :xml_decl) && (xml_decl = attachments.get(node, :xml_decl))
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+            attrs = ["version=\"#{xml_decl[:version]}\""]
+            attrs << "encoding=\"#{xml_decl[:encoding]}\"" if xml_decl[:encoding]
+            attrs << "standalone=\"#{xml_decl[:standalone]}\"" if xml_decl[:standalone]
+            custom_decl = "<?xml #{attrs.join(' ')}?>"
           end
 
-          node.to_xml(
+          result = node.to_xml(
             indent: options[:indent],
             encoding: options[:encoding],
             save_with: save_options,
           )
+
+          if custom_decl
+            result = "#{custom_decl}\n#{result}"
+          end
+
+          result
         end
 
         def has_declaration?(native_doc, wrapper)

data/lib/moxml/adapter/oga.rb

@@ -289,11 +289,25 @@ module Moxml
               child_or_text
             end
 
-          # Special handling for declarations on Oga documents
           if element.is_a?(::Oga::XML::Document) &&
               child.is_a?(::Oga::XML::XmlDeclaration)
-            # Track declaration state in attachment map
             attachments.set(element, :xml_declaration, child)
+            return
+          end
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Oga::XML::Document) && child.is_a?(::Oga::XML::Doctype)
+            root_idx = nil
+            element.children.each_with_index do |n, i|
+              if n.is_a?(::Oga::XML::Element)
+                root_idx = i
+                break
+              end
+            end
+            if root_idx
+              element.children.insert(root_idx, child)
+              return
+            end
           end
 
           element.children << child
@@ -465,86 +479,53 @@ module Moxml
 
         private
 
+        def declaration_to_xml(decl)
+          parts = ["<?xml"]
+          parts << %( version="#{decl.version}") if decl.version
+          parts << %( encoding="#{decl.encoding}") if decl.encoding
+          parts << %( standalone="#{decl.standalone}") if decl.standalone
+          "#{parts.join}?>"
+        end
+
         def serialize_without_entity_processing(node, options = {})
-          # Oga's XmlGenerator doesn't support options directly
-          # We need to handle declaration options ourselves for Document nodes
           if node.is_a?(::Oga::XML::Document)
-            # Check if we should include declaration
-            # Priority: explicit option > existence of xml_declaration (native or attachment)
-            effective_xml_declaration = node.xml_declaration || attachments.get(
-              node, :xml_declaration
-            )
+            effective_xml_declaration = attachments.get(node, :xml_declaration)
+
             should_include_decl = if options.key?(:no_declaration)
                                     !options[:no_declaration]
                                   elsif options.key?(:declaration)
                                     options[:declaration]
                                   else
-                                    # Default: include if document has xml_declaration
-                                    effective_xml_declaration ? true : false
+                                    effective_xml_declaration || node.xml_declaration ? true : false
                                   end
 
-            # Fix: Check if declaration already exists in children
-            # This prevents duplicate declarations when document already has one
-            has_existing_declaration = node.children.any?(::Oga::XML::XmlDeclaration)
-
-            if should_include_decl && !effective_xml_declaration && !has_existing_declaration
-              # Need to add declaration - create default one
-              output = []
-              output << '<?xml version="1.0" encoding="UTF-8"?>'
-              output << "\n"
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize children
-              node.children.each do |child|
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
-              end
-
-              return output.join
-            elsif !should_include_decl
-              # Skip xml_declaration
-              output = []
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize root and other children
-              node.children.each do |child|
-                next if child.is_a?(::Oga::XML::XmlDeclaration)
+            output = []
 
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
+            if should_include_decl
+              decl = effective_xml_declaration || node.xml_declaration
+              if decl
+                output << declaration_to_xml(decl)
+              else
+                output << '<?xml version="1.0" encoding="UTF-8"?>'
               end
-
-              return output.join
+              output << "\n"
             end
-          end
 
-          # Default: use XmlGenerator
-          # But first check if we need to handle declaration specially
-          effective_xml_declaration = node.is_a?(::Oga::XML::Document) && (node.xml_declaration || attachments.get(
-            node, :xml_declaration
-          ))
-          if node.is_a?(::Oga::XML::Document) && effective_xml_declaration
-            # Document has declaration - use custom handling to avoid duplicates
-            output = []
-            xml_declaration_serialized = false
+            if node.doctype
+              output << node.doctype.to_xml
+              output << "\n"
+            end
 
-            # Serialize children, but skip XmlDeclaration if it would cause duplication
             node.children.each do |child|
-              xml_declaration = child.is_a?(::Oga::XML::XmlDeclaration)
-              next if xml_declaration && xml_declaration_serialized
-
-              xml_declaration_serialized = true if xml_declaration
+              next if child.is_a?(::Oga::XML::XmlDeclaration)
 
               output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
             end
 
-            output.join
-          else
-            # Normal case - use XmlGenerator directly
-            ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
+            return output.join
           end
+
+          ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
         end
       end
     end

data/lib/moxml/adapter/ox.rb

@@ -19,7 +19,17 @@ module Moxml
         end
 
         def set_root(doc, element)
-          replace_children(doc, [element])
+          existing_root = root(doc)
+          if existing_root
+            # Replace the existing root element, preserving other children
+            element.parent = doc if element.is_a?(::Ox::Node)
+            idx = doc.nodes.index(existing_root)
+            doc.nodes[idx] = element
+          else
+            # No root yet, just append the element
+            element.parent = doc if element.is_a?(::Ox::Node)
+            doc << element
+          end
         end
 
         def parse(xml, options = {}, _context = nil)
@@ -101,9 +111,14 @@ module Moxml
         end
 
         def create_native_doctype(name, external_id, system_id)
-          ::Ox::DocType.new(
-            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\"",
-          )
+          value = if external_id
+                    "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\""
+                  elsif system_id
+                    "#{name} SYSTEM \"#{system_id}\""
+                  else
+                    "#{name}"
+                  end
+          ::Ox::DocType.new(value)
         end
 
         def create_native_processing_instruction(target, content)
@@ -370,25 +385,27 @@ module Moxml
         def add_child(element, child)
           # Special handling for declarations on Ox documents
           if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
-            # Transfer declaration attributes to document
             element.attributes ||= {}
-            if child.attributes["version"]
-              element.attributes[:version] =
-                child.attributes["version"]
-            end
-            if child.attributes["encoding"]
-              element.attributes[:encoding] =
-                child.attributes["encoding"]
-            end
-            if child.attributes["standalone"]
-              element.attributes[:standalone] =
-                child.attributes["standalone"]
-            end
+            element.attributes[:version] = child.attributes["version"] if child.attributes["version"]
+            element.attributes[:encoding] = child.attributes["encoding"] if child.attributes["encoding"]
+            element.attributes[:standalone] = child.attributes["standalone"] if child.attributes["standalone"]
+            return
           end
 
           child.parent = element if child.is_a?(::Ox::Node)
           element.nodes ||= []
-          element.nodes << child
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Ox::Document) && child.is_a?(::Ox::DocType)
+            root_idx = element.nodes.index { |n| n.is_a?(::Ox::Element) }
+            if root_idx
+              element.nodes.insert(root_idx, child)
+            else
+              element.nodes << child
+            end
+          else
+            element.nodes << child
+          end
 
           # Mark document if EntityReference is added (avoids tree scan in serialize)
           if child.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)

data/lib/moxml/adapter.rb

@@ -46,7 +46,7 @@ module Moxml
       def validate_platform!(name)
         return if platform_adapters.include?(name.to_sym)
 
-        available = platform_adapters.map(&:to_s).join(", ")
+        available = platform_adapters.join(", ")
         raise Moxml::AdapterError.new(
           "The '#{name}' adapter is not available on this platform. Available: #{available}",
           adapter: name,

data/lib/moxml/config.rb

@@ -2,6 +2,9 @@
 
 module Moxml
   class Config
+    LINE_ENDING_LF = "\n"
+    LINE_ENDING_CRLF = "\r\n"
+    VALID_LINE_ENDINGS = [LINE_ENDING_LF, LINE_ENDING_CRLF].freeze
     VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
     DEFAULT_ADAPTER = :nokogiri
     OPAL_DEFAULT_ADAPTER = :rexml
@@ -46,7 +49,7 @@ module Moxml
     # - :strict — only restore DTD-declared entities (falls back to lenient until DTD parsing is implemented)
     ENTITY_RESTORATION_MODES = %i[strict lenient].freeze
 
-    attr_reader :adapter_name
+    attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
                   :default_encoding,
                   :entity_encoding,
@@ -58,13 +61,23 @@ module Moxml
                   :namespace_validation_mode,
                   :entity_restoration_mode
 
+    def default_line_ending=(value)
+      unless VALID_LINE_ENDINGS.include?(value)
+        raise ArgumentError,
+              "Invalid line_ending: #{value.inspect}. " \
+              "Must be Config::LINE_ENDING_LF or Config::LINE_ENDING_CRLF"
+      end
+
+      @default_line_ending = value
+    end
+
     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
+      @default_line_ending = LINE_ENDING_LF
       @entity_encoding = :basic
       @restore_entities = false
       @preload_entity_sets = []

data/lib/moxml/document.rb

@@ -81,14 +81,8 @@ module Moxml
       if node.is_a?(Declaration)
         # Mark that document now has a declaration
         @has_xml_declaration = true
-
-        if children.empty?
-          adapter.add_child(@native, node.native)
-        else
-          adapter.add_previous_sibling(adapter.children(@native).first,
-                                       node.native)
-        end
-      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment)
+        adapter.add_child(@native, node.native)
+      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment) && !node.is_a?(Doctype)
         raise Error, "Document already has a root element"
       else
         adapter.add_child(@native, node.native)

data/lib/moxml/entity_registry.rb

@@ -226,7 +226,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_html5
-      warn "EntityRegistry#load_html5 is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_html5 is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -235,7 +236,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_mathml
-      warn "EntityRegistry#load_mathml is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_mathml is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -245,7 +247,8 @@ module Moxml
     # @param _set_name [Symbol] (ignored, all loaded together)
     # @return [self]
     def load_iso(_set_name = :iso8879)
-      warn "EntityRegistry#load_iso is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_iso is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -254,7 +257,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_all
-      warn "EntityRegistry#load_all is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_all is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 

data/lib/moxml/entity_registry_opal_data.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 #
 # Auto-generated entity data for Opal runtime.
-# Generated from data/w3c_entities.json
-# Do not edit manually. Regenerate with: rake opal:generate_entity_data
+# Source: data/w3c_entities.json (2125 entities)
+# Regenerate with: rake opal:generate_entity_data
 
 module Moxml
   class EntityRegistry

data/lib/moxml/node.rb

@@ -98,6 +98,7 @@ module Moxml
       serialize_options[:no_declaration] = !should_include_declaration?(options)
 
       result = adapter.serialize(@native, serialize_options)
+      result = apply_line_ending(result, serialize_options[:line_ending])
 
       # Restore entity markers to named entity references
       adapter.restore_entities(result)
@@ -279,6 +280,7 @@ module Moxml
       {
         encoding: context.config.default_encoding,
         indent: context.config.default_indent,
+        line_ending: context.config.default_line_ending,
         # The short format of empty tags in Oga and Nokogiri isn't configurable
         # Oga: <empty /> (with a space)
         # Nokogiri: <empty/> (without a space)
@@ -294,5 +296,11 @@ module Moxml
       # For Document nodes, delegate to adapter for native state check
       adapter.has_declaration?(@native, self)
     end
+
+    def apply_line_ending(xml, line_ending)
+      return xml if line_ending == Config::LINE_ENDING_LF || !xml.include?("\n")
+
+      xml.gsub(/\r?\n/, line_ending)
+    end
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils.rb

@@ -82,6 +82,7 @@ module Moxml
       else
         # Accept relative references and bare paths
         return unless uri.match?(/[\x00-\x08\x0B\x0C\x0E-\x1F]/)
+
         raise ValidationError, "Invalid URI: #{uri}"
       end
     rescue URI::InvalidURIError

data/lib/moxml.rb

@@ -32,6 +32,13 @@ module Moxml
       end
       original_config = nil
     end
+    def preprocess_entities(xml)
+      Adapter::Base.preprocess_entities(xml)
+    end
+
+    def restore_entities(text)
+      Adapter::Base.restore_entities(text)
+    end
   end
 end
 

data/spec/integration/all_adapters_spec.rb

@@ -29,6 +29,7 @@ RSpec.describe "Cross-adapter integration" do
     "Memory Usage Examples",
     "Thread Safety Examples",
     "Entity Reference Whitespace Preservation",
+    "Moxml Line Ending",
     "Performance Examples",
   ]
 

data/spec/integration/shared_examples/line_ending_behavior.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml Line Ending" do
+  describe "Line ending configuration" do
+    let(:context) { Moxml.new }
+    let(:xml) { "<root><child>text</child></root>" }
+
+    it "produces no CRLF with LF default" do
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to include("\r\n")
+    end
+
+    it "produces no bare LF with CRLF configured" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to match(/(?<!\r)\n/)
+    end
+
+    it "allows per-call CRLF override producing no bare LF" do
+      doc = context.parse(xml)
+      output = doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_CRLF)
+      expect(output).not_to match(/(?<!\r)\n/)
+    end
+
+    it "per-call LF override wins over config CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_LF))
+        .not_to include("\r\n")
+    end
+
+    it "produces identical bytes on re-serialization with CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      first = doc.to_xml
+
+      ctx2 = Moxml.new
+      ctx2.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      result = ctx2.parse(first)
+      expect(result.to_xml).to eq(first)
+    end
+
+    it "preserves element structure through CRLF round-trip" do
+      doc = context.parse("<root><a>text</a><b>more</b></root>")
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      crlf_output = doc.to_xml
+
+      ctx2 = Moxml.new
+      result = ctx2.parse(crlf_output)
+      elements = result.root.children.select(&:element?)
+      expect(elements.map(&:name)).to eq(%w[a b])
+      expect(elements[0].children.first.content).to eq("text")
+      expect(elements[1].children.first.content).to eq("more")
+    end
+  end
+end