An alternative proposal for XML validation : Relax-NG

Jean-François Perrot

1. Principle
2. Examples
3. Restrictions (after XMLS)
4. Namespaces
5. Java-based validation

1. Principle

   Grammars rather than type systems, but vastly more powerful than DTDs.
   
   Two equivalent syntaxes :
   
   
   • compact (.rnc) easy to write.
     
     • Should be directly usable with specific tools (jing), but there is apparently a bug in the latest version  (20091111) of jing.
     • Translatable to RNG XML syntax and to XMLSchema (trang)
       
     
     
   • XML (.rng)
     
     • Usable with standard tools as well as with jing.
e.g. %xmllint --noout myFile.xml --relaxng myGram.rng
     • Translatable to compact syntax (trang)
       
     • May be transformed and displayed in more legible formats, e.g. with the Algone tool.
     • Usable with DOM-PHP : DOMDocument::relaxNGValidate exact parallel to DOMDocument::schemaValidate (used in Average_1V.php)
       For Java usage, see below.
       
     
     
   Java implementation : http://code.google.com/p/jing-trang/
   Download jing & trang ! And try your hand at using them on the examples below...
   Example scripts :
   
   • jing
java -jar /The/.../Path/to/jing-20091111/bin/jing.jar  $1.rng $2.xml


   • trang
java -jar /The/.../Path/to/trang-20091111/trang.jar $1.rnc $1.rng
java -jar /The/.../Path/to/trang-20091111/trang.jar $1.rnc $1.xsd

     
   
   

2. Examples

   • Names & Marks #1 (candidate file, other candidate)
     1. Compact syntax : NM1.rnc
        
     2. XML syntax : NM1.rng
        
     3. Equivalent XML schema : NM1.xsd
        
     
     
   • Menu
     1. Basic Menu : candidate file, compact grammar
     2. Extended Menu (with prices) : candidate file, extension grammar
   
   

3. Pattern expressions

   The heart od RNG's superiority over XMLS lies in the flexibility of patterns.
   A pattern in RNG is the value of a pattern expression, made up of
   
   • named constants :  text, empty, string, token
     
     
   • basic values : explicit strings (between double quotes)
     
     
   • variables = pattern names declared via definitions <name> = <expression>
     (possibly recursive).
     
     
   • constructors
     
     1. element <name> { <expression> }
     2. attribute <ame> { <expression> }
     3. list { <expression> }

        
   • operators
     
     1. binary infix : "," "&" and "|" (sequence, arbitrary order, choice)
     2. unary postfix : "*", "+" and "?" (iteration, strict iteration, option)
     
     
   • restrictions over data types (see below)
     
   
   Exaample : a pattern for a node in a binary tree
       node = element node {
        (node, node) | leaf { empty }
    }
   
   

4. Restrictions (after XMLS)

   • Compact syntax
     
     

     <xsd:restriction base="xsd:integer">         <xsd:minInclusive value="0"/>         <xsd:maxInclusive value="20"/>     </xsd:restriction>	xsd:integer { minInclusive = "0" maxInclusive = "20" }
     <xsd:restriction base="xsd:string">       <xsd:minLength value="1"/>       <xsd:maxLength value="127"/>     </xsd:restriction>	xsd:string { minLength = "1" maxLength = "127" }
     <xsd:restriction base="xsd:string">       <xsd:pattern value="[A-Z][a-z]*"/>    </xsd:restriction>	xsd:string { pattern = "[A-Z][a-z]*" }

     
     
     Ex. : noteSur20 = attribute note { xsd:integer {minInclusive = "0" maxInclusive = "20" } }
     
     
   • XML syntax
     
       <define name="noteSur20">
    <attribute name="note">
      <data type="integer">
        <param name="minInclusive">0</param>
        <param name="maxInclusive">20</param>
      </data>
    </attribute>
  </define>

  <define name="nomPers">
    <data type="string">
      <param name="pattern">[A-Z][a-z]*</param>
    </data>
  </define>
     
     

5. Namespaces

   (Compare with XMLS and NS)
   
   
   • No problem !
     In compact syntax, introduced either as : namespace prefix = "URI"
     or as default namespace = "URI"
     Of course, these notations apply to the text of the grammar, not to the object files !
     
     
   • Examples :
     
     1. Both grammars NM1.ds.rnc (with default ns) and NM1.ns.rnc (with prefix)
        apply to object files NM1.ds.xml (with default ns) as well as to NM1.ns.xml (with prefix).
        
        
     2. Our favorite RDF-based example (candidate file) is readily described as NMrdf.rnc (translated in XML format as NMrdf.rng)
        
        
     3. DocBook v.5 grammars :
        
        • rng (XML)
        • rnc (compact)
        • html (via Algone)
          

6. Java-based validation

   1. Package javax.xml.validation
      Although the javadoc seems to indicate that RNGgrammars are in the scope of javax validation,
      direct application of the doc leads to a dismal failure at runtime :
      

      ---

              SchemaFactory factory =
                SchemaFactory.newInstance(XMLConstants.RELAXNG_NS_URI);
     // as opposed to XMLSchema : XMLConstants.W3C_XML_SCHEMA_NS_URI
...........
compiles, but does not run :

Error : No SchemaFactory that implements the schema language specified by: http://relaxng.org/ns/structure/1.0 could be loaded


      ---

      
      A workaround is needed to make validation work with RNG grammars:
      

      ---

      import com.thaiopensource.relaxng.jaxp.CompactSyntaxSchemaFactory; // Jing
.............

          System.setProperty(
              SchemaFactory.class.getName() + ":" + XMLConstants.RELAXNG_NS_URI,
              "com.thaiopensource.relaxng.jaxp.CompactSyntaxSchemaFactory"
          ); // necessary precaution
          SchemaFactory factory =
                       CompactSyntaxSchemaFactory.newInstance(XMLConstants.RELAXNG_NS_URI);
          ............           
      

      ---

       to be compiled (and executed) with .....jing-20091111/bin/jing.jar (to be downloaded from jing-trang) on the classPath.
      
      See class VerifRNC, to be used with grammars in compact syntax (.rnc).
      If you wish to apply in XML format (.rng), use "com.thaiopensource.relaxng.jaxp.XMLSyntaxSchemaFactory".
      
      
   2. Remember that this class validates XML documents that are read directly from file, via a StreamSource.
      However, if you try to apply such a validator to a DOMSource, as we did in Average_1V, execution aborts
      with an IllegalArgumentException (null)
      which, according to the JavaDoc, means that the Source is an XML artifact that the implementation cannot validate.
      
      Unfortunately, the original Java implementation of RNG-based validation (jing-trang) does not seem to offer an API which could be substituted to javax.xml.validation.
      Please let me know if you find more light on this subject!