lutaml-model 0.8.17 → 0.8.18

data/lib/lutaml/toml.rb

@@ -30,7 +30,7 @@ Lutaml::Model::FormatRegistry.register(
   adapter_class: nil,
   transformer: Lutaml::Toml::Adapter::Transform,
   key_value: true,
-  adapter_options: if Lutaml::Model::RuntimeCompatibility.opal?
+  adapter_options: if Lutaml::Model.opal?
                      nil
                    else
                      {

data/lib/lutaml/xml/adapter.rb

@@ -13,11 +13,11 @@ module Lutaml
       autoload :NamespaceUriCollector,
                "#{__dir__}/adapter/namespace_uri_collector"
       autoload :OgaAdapter, "#{__dir__}/adapter/oga_adapter"
+      autoload :RexmlAdapter, "#{__dir__}/adapter/rexml_adapter"
       Lutaml::Model::RuntimeCompatibility.autoload_native(
         self,
         NokogiriAdapter: "#{__dir__}/adapter/nokogiri_adapter",
         OxAdapter: "#{__dir__}/adapter/ox_adapter",
-        RexmlAdapter: "#{__dir__}/adapter/rexml_adapter",
       )
     end
   end

data/lib/lutaml/xml/adapter_loader.rb

@@ -13,7 +13,7 @@ module Lutaml
       # @param _adapter [String] The adapter format name ("xml")
       # @param type [String] The normalized type name (e.g., "nokogiri_adapter")
       def self.load_adapter_file(_adapter, type)
-        adapter_path = if Lutaml::Model::RuntimeCompatibility.opal?
+        adapter_path = if Lutaml::Model.opal?
                          "lutaml/xml/adapter/#{type}"
                        else
                          File.join(File.dirname(__FILE__), "adapter", type)

data/lib/lutaml/xml/builder/base.rb

@@ -14,7 +14,7 @@ module Lutaml
       class Base
         def self.build(options = {})
           context = Moxml.new(moxml_backend)
-          if Lutaml::Model::RuntimeCompatibility.opal?
+          if Lutaml::Model.opal?
             context.config.namespace_validation_mode = :lenient
           end
 

data/lib/lutaml/xml/builder.rb

@@ -6,11 +6,11 @@ module Lutaml
     module Builder
       autoload :Base, "#{__dir__}/builder/base"
       autoload :Oga, "#{__dir__}/builder/oga"
+      autoload :Rexml, "#{__dir__}/builder/rexml"
       Lutaml::Model::RuntimeCompatibility.autoload_native(
         self,
         Nokogiri: "#{__dir__}/builder/nokogiri",
         Ox: "#{__dir__}/builder/ox",
-        Rexml: "#{__dir__}/builder/rexml",
       )
     end
   end

data/lib/lutaml/xml/error/schema_validation_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Error
+      # Collected when a model's generated XML does not conform to the
+      # XSD schema configured via the `validate_xml_with` macro.
+      #
+      # One instance represents one schema violation reported by the
+      # validating parser, so Lutaml::Model::ValidationError#error_messages
+      # lists each violation individually.
+      #
+      # Not to be confused with Schema::Xsd::SchemaValidationError, which
+      # reports problems in an XSD document itself.
+      class SchemaValidationError < XmlError
+        attr_reader :schema_path
+
+        def initialize(message, schema_path)
+          @schema_path = schema_path
+          super("XML does not conform to schema #{schema_path}: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/model_transform.rb

@@ -708,7 +708,9 @@ _effective_register)
         base_cast_options[:resolved_type] = attr_type
 
         children.each do |child|
-          if !rule_has_custom_method && attr_type_is_serializable
+          if !rule_has_custom_method &&
+              (attr_type_is_serializable ||
+                (attr&.union? && ::Lutaml::Model::Type::Union.xml_structured?(child)))
             # Performance: Build cast_options efficiently (dup + []= cheaper than merge)
             cast_options = if (child_namespace_uri = child.namespace_uri)
                              ns_type = attr.type_with_namespace(effective_register,
@@ -984,6 +986,8 @@ effective_register = lutaml_register)
       # @return [Boolean] true if a matching child likely exists
       def child_matches_rule?(rule, child_names_set, default_namespace)
         rule_names = rule.namespaced_names(default_namespace)
+        # Array#intersect? requires an Array argument; child_names_set may
+        # be a Set, so use the block form which works for any includable.
         rule_names.any? { |rn| child_names_set.include?(rn) } ||
           child_names_set.include?(rule.name.to_s)
       end

data/lib/lutaml/xml/schema/relaxng_schema.rb

@@ -31,6 +31,11 @@ module Lutaml
 
         def self.generate_attributes(xml, klass, register)
           klass.attributes.each do |name, attr|
+            if attr.union?
+              raise Lutaml::Model::UnionSchemaUnsupportedError.new(name,
+                                                                   "RelaxNG")
+            end
+
             attr_type = attr.type(register)
             if attr_type <= Lutaml::Model::Serialize
               xml.ref(name: attr_type.name)

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -409,6 +409,10 @@ attr_name)
 
         def self.get_attribute_xsd_type(attr, attr_type, register,
 _mapping_rule = nil)
+          if attr.union?
+            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name, "XSD")
+          end
+
           # 1. Check for deprecated attribute-level xsd_type override
           return attr.options[:xsd_type] if attr.options[:xsd_type]
 

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -44,6 +44,50 @@ module Lutaml
           @namespace_class&.prefix_default
         end
 
+        # Configure one or more XSD schemas that the model's generated
+        # XML must conform to. Checked during validate/validate!
+        # (issue #264). Repeated calls (including in subclasses) append.
+        #
+        # Relative paths resolve against the file that declares the macro,
+        # so a model works regardless of the process working directory.
+        #
+        # @param paths [Array<String, Pathname>] paths to XSD schema files
+        def validate_xml_with(*paths)
+          base = File.dirname(caller_locations(1, 1).first.path)
+          @own_xml_schema_paths = own_xml_schema_paths +
+            paths.flatten.map { |path| File.expand_path(path.to_s, base) }
+        end
+
+        # All configured XSD schema paths, parent-first: inherited paths
+        # come before paths declared on this class.
+        #
+        # @return [Array<String>]
+        def xml_schema_paths
+          inherited = if superclass.respond_to?(:xml_schema_paths)
+                        superclass.xml_schema_paths
+                      else
+                        []
+                      end
+          inherited + own_xml_schema_paths
+        end
+
+        # Validate a raw XML string against the configured schemas without
+        # instantiating a model — the explicit input-side counterpart to
+        # the validate/validate! output-side check.
+        #
+        # @param xml [String] an XML document
+        # @return [Array<Lutaml::Xml::Error::SchemaValidationError>]
+        def validate_xml(xml)
+          XsdValidator.validate(xml, xml_schema_paths)
+        end
+
+        # @raise [Lutaml::Model::ValidationError] when the XML does not
+        #   conform to every configured schema
+        def validate_xml!(xml)
+          errors = validate_xml(xml)
+          raise Lutaml::Model::ValidationError.new(errors) if errors.any?
+        end
+
         # Override choice to set format: :xml so Choice knows which format it belongs to.
         def choice(min: 1, max: 1, format: :xml, &)
           super
@@ -204,6 +248,10 @@ module Lutaml
 
         private
 
+        def own_xml_schema_paths
+          @own_xml_schema_paths ||= []
+        end
+
         # Handle XML mapping class inheritance pattern (e.g., `xml SomeMapping`)
         #
         # When a mapping class is passed, inherit mappings from it directly.

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -263,6 +263,19 @@ module Lutaml
           self.class.mappings_for(:xml, register)&.element_sequence
         end
 
+        # Append XSD schema errors (validate_xml_with macro) to the
+        # standard validation errors. No-op unless schemas are configured.
+        #
+        # @see Lutaml::Model::Validation#validate
+        def validate(register: Lutaml::Model::Config.default_register)
+          errors = super
+          return errors if self.class.xml_schema_paths.empty?
+
+          errors.concat(
+            self.class.validate_xml(to_xml(register: register)),
+          )
+        end
+
         private
 
         # Build declaration plan from stored element reference (lazy mode).

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -28,13 +28,22 @@ register_id, register)
           # class AND the value is not a nil/empty marker from collection handlers.
           # Nil and empty string markers should create simple elements, not attempt
           # nested model transformation.
-          is_nested_model = rule.attribute_type.is_a?(Class) &&
-            rule.attribute_type < Lutaml::Model::Serialize &&
-            !value.nil? &&
-            !(value.is_a?(String) && value.empty?)
+          # Union: dispatch on the value's own class (stateless). A model member
+          # becomes a nested element; a scalar member a simple value element.
+          union = Lutaml::Model::Type::Union.rule?(rule)
+
+          is_nested_model = !value.nil? &&
+            !(value.is_a?(String) && value.empty?) &&
+            if union
+              value.is_a?(Lutaml::Model::Serialize)
+            else
+              rule.attribute_type.is_a?(Class) &&
+                rule.attribute_type < Lutaml::Model::Serialize
+            end
 
           if is_nested_model
-            create_nested_model_element(rule, value, options, register)
+            create_nested_model_element(rule, value, options, register,
+                                        union: union)
           else
             create_simple_value_element(rule, value, options, model_class,
                                         register_id)
@@ -119,7 +128,8 @@ parent_element_form_default)
         # @param options [Hash] Options
         # @param register [Register, nil] The register
         # @return [::Lutaml::Xml::DataModel::XmlElement] The created element
-        def create_nested_model_element(rule, value, options, register)
+        def create_nested_model_element(rule, value, options, register,
+                                        union: false)
           # Resolve polymorphic configuration
           polymorphic_config = rule.options[:polymorphic]
           is_polymorphic = polymorphic_config.is_a?(::Hash) ? !polymorphic_config.empty? : !!polymorphic_config
@@ -130,8 +140,11 @@ parent_element_form_default)
           actual_class = resolve_polymorphic_class(rule, value, is_polymorphic,
                                                    is_polymorphic_subtype)
 
-          # Get transformation for the actual class
-          child_transformation = if is_polymorphic || is_polymorphic_subtype
+          # Get transformation for the actual class. Unions resolve the member
+          # from the value's own class, like polymorphism.
+          child_transformation = if union
+                                   value.class.transformation_for(:xml, register)
+                                 elsif is_polymorphic || is_polymorphic_subtype
                                    actual_class.transformation_for(:xml,
                                                                    register)
                                  else

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -81,6 +81,12 @@ model_class, register_id)
         # @param options [Hash] Options
         # @yield Block to create element for value
         def apply_element_rule_single(parent:, rule:, value:, options:)
+          # raw: :element — value is a complete XML element string, inject directly
+          if rule.raw == :element
+            add_raw_element_fragments(parent, value)
+            return
+          end
+
           # Extract parent's namespace info for element_form_default inheritance
           parent_ns_class = parent.namespace_class
           # Only pass element_form_default VALUE if it was explicitly set

data/lib/lutaml/xml/xsd_validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "concurrent" unless RUBY_ENGINE == "opal"
+
+module Lutaml
+  module Xml
+    # Validates a serialized XML string against an XSD schema file.
+    #
+    # Backs the `validate_xml_with` class macro (issue #264). Nokogiri is
+    # required lazily so models that do not use XSD validation keep working
+    # on platforms/adapters without it (Opal, ox-only installs).
+    #
+    # Compiled schemas are memoized by absolute path: the XSD files are
+    # constant for the life of the process, so each is read and compiled once
+    # and reused across every validate / validate_xml call.
+    #
+    # Not to be confused with Schema::Xsd::SchemaValidator, which checks
+    # that an XSD document itself is well-formed XSD.
+    module XsdValidator
+      # Concurrent (and a working Nokogiri) are unavailable under Opal, so
+      # the memoization store is only built off-Opal. validate raises a clear
+      # NotImplementedError under Opal before this store is ever consulted.
+      @schemas = ::Concurrent::Map.new unless RUBY_ENGINE == "opal"
+
+      # @param xml [String] an XML document
+      # @param schema_paths [Array<String>] paths to XSD schema files
+      # @return [Array<Error::SchemaValidationError>] one error per violation
+      def self.validate(xml, schema_paths)
+        paths = Array(schema_paths)
+        return [] if paths.empty?
+
+        if RUBY_ENGINE == "opal"
+          raise NotImplementedError,
+                "XSD schema validation (validate_xml_with) requires the " \
+                "nokogiri gem, which is not available under Opal."
+        end
+
+        ensure_nokogiri!
+        # Strict parsing: libxml2 recovery would otherwise repair malformed
+        # input and report it as schema-valid. NONET remains on by default.
+        document = ::Nokogiri::XML(xml, &:strict)
+        paths.flat_map do |path|
+          schema_for(path)
+            .validate(document)
+            .map { |error| Error::SchemaValidationError.new(error.message, path) }
+        end
+      end
+
+      def self.schema_for(path)
+        @schemas.compute_if_absent(path) do
+          ::Nokogiri::XML::Schema(File.read(path))
+        end
+      end
+
+      def self.ensure_nokogiri!
+        require "nokogiri"
+      rescue LoadError
+        raise Error::XmlConfigurationError,
+              "XSD schema validation (validate_xml_with) requires the " \
+              "nokogiri gem; add `gem \"nokogiri\"` to your Gemfile"
+      end
+
+      private_class_method :ensure_nokogiri!, :schema_for
+    end
+  end
+end

data/lib/lutaml/xml.rb

@@ -11,6 +11,15 @@ require_relative "model"
 # XML requires moxml for parsing
 require "moxml"
 
+# Under Opal, moxml's autoloads don't fire (Opal ignores autoload).
+# Pull in the eager-load boot that ships at lib/compat/opal/moxml_boot.rb
+# so Moxml::Adapter::{Oga,Rexml} etc. are actually defined. Without
+# this, `Config.adapter = :oga` later fails with
+# `NameError: uninitialized constant Moxml::Adapter::Oga`.
+if Lutaml::Model.opal?
+  require "moxml_boot"
+end
+
 module Lutaml
   module Xml
     # Error module for XML-specific errors
@@ -24,6 +33,8 @@ module Lutaml
                "#{__dir__}/xml/error/xml_configuration_error"
       autoload :NamespaceMismatchError,
                "#{__dir__}/xml/error/namespace_mismatch_error"
+      autoload :SchemaValidationError,
+               "#{__dir__}/xml/error/schema_validation_error"
     end
 
     # XML Configuration modules
@@ -86,6 +97,7 @@ module Lutaml
     autoload :CustomMethodWrapper,
              "#{__dir__}/xml/transformation/custom_method_wrapper"
     autoload :Transform, "#{__dir__}/xml/transform"
+    autoload :XsdValidator, "#{__dir__}/xml/xsd_validator"
     autoload :Adapter, "#{__dir__}/xml/adapter"
     autoload :XmlElement, "#{__dir__}/xml/xml_element"
     autoload :AdapterElement, "#{__dir__}/xml/adapter_element"
@@ -143,12 +155,12 @@ module Lutaml
     autoload :SharedDsl, "#{__dir__}/xml/shared_dsl"
 
     autoload :Oga, "#{__dir__}/xml/oga"
+    autoload :Rexml, "#{__dir__}/xml/rexml"
     Lutaml::Model::RuntimeCompatibility.autoload_native(
       self,
       NokogiriElement: "#{__dir__}/xml/nokogiri/element",
       Nokogiri: "#{__dir__}/xml/nokogiri",
       Ox: "#{__dir__}/xml/ox",
-      Rexml: "#{__dir__}/xml/rexml",
     )
   end
 end
@@ -168,10 +180,15 @@ Lutaml::Model::FormatRegistry.register(
     Ox::ParseError
     REXML::ParseException
   ],
-  adapter_options: if Lutaml::Model::RuntimeCompatibility.opal?
+  adapter_options: if Lutaml::Model.opal?
+                     # Both Oga (vendored opal-oga fork, pure-Ruby lexer)
+                     # and REXML (bundled stdlib gem, pure Ruby) work
+                     # under Opal. Oga is the default because moxml's CI
+                     # verifies it most thoroughly; REXML is selectable
+                     # for callers that prefer a stdlib-only stack.
                      {
-                       available: %i[rexml],
-                       default: :rexml,
+                       available: %i[oga rexml],
+                       default: :oga,
                      }
                    else
                      {
@@ -210,18 +227,24 @@ Lutaml::Model::Serialize.prepend(
 # to classes that included it before the prepend. Serializable includes
 # Serialize during model boot, so make the XML instance API available on the
 # concrete base class as well.
-if Lutaml::Model::RuntimeCompatibility.opal?
+#
+# Anonymous model classes (Class.new { include Serialize }) extend
+# Serialize::ClassMethods rather than inheriting from Serializable, so the
+# ModelImportExt override (root?) must land on ClassMethods too. The other
+# two (FormatConversion, InstanceMethods) are already prepended unconditionally
+# above, so Opal's no-double-prepend rule means we don't repeat them here.
+if Lutaml::Model.opal?
   Lutaml::Model::Serializable.singleton_class.prepend(
     Lutaml::Xml::Serialization::ModelImportExt,
   )
 
-  Lutaml::Model::Serializable.singleton_class.prepend(
-    Lutaml::Xml::Serialization::FormatConversion,
-  )
-
   Lutaml::Model::Serializable.prepend(
     Lutaml::Xml::Serialization::InstanceMethods,
   )
+
+  Lutaml::Model::Serialize::ClassMethods.prepend(
+    Lutaml::Xml::Serialization::ModelImportExt,
+  )
 end
 
 # Register XML-specific attribute override warning names
@@ -240,7 +263,7 @@ Lutaml::Xml::Type::Serializers.register_all!
 
 # Register XML schema methods
 Lutaml::Model::Schema.register_method(:to_xsd) do |klass, options = {}|
-  if Lutaml::Model::RuntimeCompatibility.opal?
+  if Lutaml::Model.opal?
     raise NotImplementedError,
           "XSD schema generation is not available under Opal."
   end
@@ -249,7 +272,7 @@ Lutaml::Model::Schema.register_method(:to_xsd) do |klass, options = {}|
 end
 
 Lutaml::Model::Schema.register_method(:to_relaxng) do |klass, options = {}|
-  if Lutaml::Model::RuntimeCompatibility.opal?
+  if Lutaml::Model.opal?
     raise NotImplementedError,
           "RELAX NG schema generation requires Nokogiri, " \
           "which is not available under Opal."
@@ -259,7 +282,7 @@ Lutaml::Model::Schema.register_method(:to_relaxng) do |klass, options = {}|
 end
 
 Lutaml::Model::Schema.register_method(:from_xml) do |xml, options = {}|
-  if Lutaml::Model::RuntimeCompatibility.opal?
+  if Lutaml::Model.opal?
     raise NotImplementedError,
           "XML schema compilation is not available under Opal."
   end
@@ -267,6 +290,24 @@ Lutaml::Model::Schema.register_method(:from_xml) do |xml, options = {}|
   Lutaml::Model::Schema::XmlCompiler.to_models(xml, options)
 end
 
+Lutaml::Model::Schema.register_method(:from_relaxng) do |rng, options = {}|
+  if Lutaml::Model::RuntimeCompatibility.opal?
+    raise NotImplementedError,
+          "RELAX NG schema compilation is not available under Opal."
+  end
+
+  Lutaml::Model::Schema::RngCompiler.to_models(rng, options)
+end
+
+Lutaml::Model::Schema.register_method(:from_rnc) do |rnc, options = {}|
+  if Lutaml::Model::RuntimeCompatibility.opal?
+    raise NotImplementedError,
+          "RNC schema compilation is not available under Opal."
+  end
+
+  Lutaml::Model::Schema::RncCompiler.to_models(rnc, options)
+end
+
 # Register XML namespace registry with GlobalContext
 Lutaml::Model::GlobalContext.register_format_registry(
   :xml, Lutaml::Xml::NamespaceClassRegistry.new

data/lutaml-model.gemspec

@@ -23,9 +23,11 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the
   # RubyGem that have been added into git.
+  # vendor/ is excluded so the opal-oga / opal-ruby-ll submodule checkouts
+  # are not shipped in the published gem.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|features)/})
+      f.match(%r{^(test|features|vendor/)/})
     end
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -36,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", "~> 0.1.23"
+  spec.add_dependency "moxml", "~> 0.1.25"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"

data/spec/fixtures/xml/schema/rnc/address_book.rnc

@@ -0,0 +1,15 @@
+addressBook =
+  element addressBook {
+    card*
+  }
+
+card =
+  element card {
+    name,
+    email
+  }
+
+name = element name { text }
+email = element email { text }
+
+start |= addressBook

data/spec/fixtures/xml/schema/rnc/book_features.rnc

@@ -0,0 +1,18 @@
+namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
+
+book =
+  element book {
+    attribute xml:lang { text }?,
+    [ a:defaultValue = "paperback" ]
+    attribute format { "hardcover" | "paperback" }?,
+    attribute anchor { xsd:ID }?,
+    attribute indent { text | "adaptive" }?,
+    title,
+    \list
+  }
+
+title = element title { text }
+\list = element list { item+ }
+item = element item { text }
+
+start |= book

data/spec/fixtures/xml/schema/rnc/includes/book.rnc

@@ -0,0 +1,6 @@
+book =
+  element book {
+    title
+  }
+
+title = element title { text }

data/spec/fixtures/xml/schema/rnc/includes/circular_a.rnc

@@ -0,0 +1,8 @@
+include "circular_b.rnc"
+
+circular_a =
+  element circularA {
+    empty
+  }
+
+start |= circular_a

data/spec/fixtures/xml/schema/rnc/includes/circular_b.rnc

@@ -0,0 +1,8 @@
+include "circular_a.rnc"
+
+circular_b =
+  element circularB {
+    empty
+  }
+
+start |= circular_b

data/spec/fixtures/xml/schema/rnc/includes/library.rnc

@@ -0,0 +1,8 @@
+include "book.rnc"
+
+library =
+  element library {
+    book+
+  }
+
+start |= library

data/spec/fixtures/xml/schema/rng/address_book.rng

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0">
+  <start>
+    <element name="addressBook">
+      <zeroOrMore>
+        <element name="card">
+          <ref name="cardContent"/>
+        </element>
+      </zeroOrMore>
+    </element>
+  </start>
+  <define name="cardContent">
+    <element name="name"><text/></element>
+    <element name="email"><text/></element>
+  </define>
+</grammar>

data/spec/fixtures/xml/schema/rng/book.rng

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Exercises: <attribute>, <optional>, <oneOrMore>, <group>, <choice>,
+  <empty>, <data type="..."/>
+-->
+<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+  <start>
+    <element name="book">
+      <attribute name="isbn"><data type="string"/></attribute>
+      <element name="title"><text/></element>
+      <optional>
+        <element name="subtitle"><text/></element>
+      </optional>
+      <oneOrMore>
+        <element name="author"><text/></element>
+      </oneOrMore>
+      <group>
+        <element name="publisher"><text/></element>
+        <element name="year"><data type="integer"/></element>
+      </group>
+      <choice>
+        <element name="hardcover"><empty/></element>
+        <element name="paperback"><empty/></element>
+      </choice>
+    </element>
+  </start>
+</grammar>

data/spec/fixtures/xml/schema/rng/fixed_value.rng

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0">
+  <start>
+    <element name="thing">
+      <attribute name="version">
+        <value>1.0</value>
+      </attribute>
+      <element name="name"><text/></element>
+    </element>
+  </start>
+</grammar>