wax 0.9.4

data/README.rdoc

@@ -0,0 +1,7 @@
+This package provides a simple API for writing XML documents
+It is particularly well-suited to writing large XML documents
+because it doesn't require storing them in a DOM-like structure
+before outputting them.  XML libraries that use that approach can
+cause the JVM to run out of memory when outputting large XML documents.
+
+For more information, see http://ociweb.com/wax.

data/lib/cd_demo.rb

@@ -0,0 +1,16 @@
+require 'wax'
+
+url = "http://www.ociweb.com"
+WAX.write($stdout, "1.0") do
+  comment "This is one of my favorite CDs!"
+  dtd "#{url}/xml/cd.dtd"
+  xslt "cd.xslt"
+  start "cd"
+  attr "year", 2008
+  namespace nil, "#{url}/music", "#{url}/xml/cd.xsd"
+  namespace "date", "#{url}/date", "#{url}/xml/date.xsd"
+  start "artist"
+  attr "name", "Gardot, Melody"
+  child "title", "Worrisome Heart"
+  child "date", "purchaseDate", "4/3/2008"
+end

data/lib/instance_exec.rb

@@ -0,0 +1,32 @@
+# This solution was found at
+# http://www.jroller.com/abstractScope/entry/
+# passing_parameters_to_an_instance
+
+# Add a bind method to the Proc class.
+class Proc
+
+  # This creates an UnboundMethod (from a temporary instance method)
+  # and binds it to a given object.
+  # In the case of Object#instance_exec (below), the method is bound to self.
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end
+
+# Add an instance_exec method to the Object class unless it's already there.
+class Object
+  unless defined? instance_exec # a new method in Ruby 1.9
+    # This binds a block to an arbitrary scope and
+    # calls it (with or without arguments).
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
+  end
+end

data/lib/tutorial.rb

@@ -0,0 +1,190 @@
+require 'wax'
+
+# This serves as a tutorial for using WAX.
+
+def out(text)
+  puts "\n\n#{text}\n"
+end
+
+# When the no-arg WAX constructor is used, XML is written to stdout.
+# There are also WAX constructors that take an IO object.
+wax = WAX.new
+
+out "Only a root element:"
+wax.start("car").close
+# <car/>
+
+# After a WAX object is closed,
+# a new one must be created to write more XML.
+wax = WAX.new
+
+out "A root element with some text inside:"
+wax.start("car").text("Prius").close
+# <car>Prius</car>
+
+out "Text inside a child element:"
+wax = WAX.new
+wax.start("car").start("model").text("Prius").close
+# <car>
+#   <model>Prius</model>
+# </car>
+
+out "The same with the \"child\" convenience method:"
+wax = WAX.new
+wax.start("car").child("model", "Prius").close
+# <car>
+#   <model>Prius</model>
+# </car>
+
+out "Text in a CDATA section:"
+wax = WAX.new
+wax.start("car").start("model").cdata("1<2>3&4'5\"6").close
+# <car>
+#   <model>
+#     <![CDATA[1<2>3&4'5\"6]]>
+#   </model>
+# </car>
+
+out "Without indentation, on a single line:"
+wax = WAX.new
+wax.set_indent(nil)
+wax.start("car").child("model", "Prius").close
+# <car><model>Prius</model></car>
+
+out "Indent with four spaces instead of the default of two:"
+wax = WAX.new
+wax.set_indent("    ")
+wax.start("car").child("model", "Prius").close
+# <car>
+#     <model>Prius</model>
+# </car>
+
+out "Add an attribute:"
+wax = WAX.new
+wax.start("car").attr("year", 2008).child("model", "Prius").close
+# <car year="2008">
+#   <model>Prius</model>
+# </car>
+
+out "XML declaration:"
+wax = WAX.new($stdout, "1.0")
+wax.start("car").attr("year", 2008).child("model", "Prius").close
+# <?xml version="1.0" encoding="UTF-8"?>
+# <car year="2008">
+#   <model>Prius</model>
+# </car>
+
+out "Comment:"
+WAX.write do
+  comment "This is a hybrid car."
+  start "car"
+  child "model", "Prius"
+end
+# <!-- This is a hybrid car. -->
+# <car>
+#   <model>Prius</model>
+# </car>
+
+out "Processing instruction:"
+WAX.write do
+  processing_instruction "target", "data"
+  start "car"
+  attr "year", 2008
+  child "model", "Prius"
+end
+# <?target data?>
+# <car year="2008">
+#   <model>Prius</model>
+# </car>
+
+out "Associate an XSLT stylesheet:"
+WAX.write do
+  xslt "car.xslt"
+  start "car"
+  attr "year", 2008
+  child "model", "Prius"
+end
+# <?xml-stylesheet type="text/xsl" href="car.xslt"?>
+# <car year="2008">
+#   <model>Prius</model>
+# </car>
+
+out "Associate a default namespace:"
+WAX.write do
+  xslt "car.xslt"
+  start "car"
+  attr "year", 2008
+  namespace "http://www.ociweb.com/cars"
+  child "model", "Prius"
+end
+# <car year="2008"
+#   xmlns="http://www.ociweb.com/cars">
+#   <model>Prius</model>
+# </car>
+
+out "Associate a non-default namespace with the XML:"
+prefix = "c"
+WAX.write do
+  start prefix, "car"
+  attr "year", 2008
+  namespace prefix, "http://www.ociweb.com/cars"
+  child prefix, "model", "Prius"
+end
+# <c:car year="2008"
+#   xmlns:c="http://www.ociweb.com/cars">
+#   <c:model>Prius</c:model>
+# </c:car>
+
+out "Associate an XML Schema:"
+WAX.write do
+  start "car"
+  attr "year", 2008
+  namespace nil, "http://www.ociweb.com/cars", "car.xsd"
+  child "model", "Prius"
+end
+# <car year="2008"
+#   xmlns="http://www.ociweb.com/cars"
+#   xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance"
+#   xsi:schemaLocation="http://www.ociweb.com/cars car.xsd">
+#   <model>Prius</model>
+# </car>
+
+out "Associate multiple XML Schemas:"
+WAX.write do
+  start "car"
+  attr "year", 2008
+  namespace nil, "http://www.ociweb.com/cars", "car.xsd"
+  namespace "m", "http://www.ociweb.com/model", "model.xsd"
+  child "m", "model", "Prius"
+end
+# <car year="2008"
+#   xmlns="http://www.ociweb.com/cars"
+#   xmlns:m="http://www.ociweb.com/model"
+#   xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance"
+#   xsi:schemaLocation="http://www.ociweb.com/cars car.xsd
+#     http://www.ociweb.com/model model.xsd">
+#   <m:model>Prius</m:model>
+# </car>
+
+out "Associate a DTD:"
+WAX.write do
+  dtd "car.dtd"
+  start "car"
+  attr "year", 2008
+  child "model", "Prius"
+end
+# <!DOCTYPE car SYSTEM "car.dtd">
+# <car year="2008">
+#   <model>Prius</model>
+# </car>
+
+out "Entity definitions in DOCTYPE:"
+String url = "http://www.ociweb.com/xml/";
+WAX.write do
+  entity_def "oci", "Object Computing, Inc."
+  external_entity_def "moreData", url + "moreData.xml"
+  start "root"
+  text "The author works at &oci; in St. Louis, Missouri.",
+    true, false # turning escaping off for entity reference
+  text "&moreData;", true, false
+end

data/lib/wax.rb

@@ -0,0 +1,600 @@
+require 'instance_exec'
+require 'xml_util'
+
+# This class provides methods that make outputting XML
+# easy, fast and efficient in terms of memory utilization.
+#
+# A WAX object should not be used from multiple threads!
+# 
+# For more information, see http://www.ociweb.com/wax.
+# 
+# Copyright 2008 R. Mark Volkmann
+# This file is part of WAX.
+# 
+# WAX is free software.  You can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License,
+# or (at your option) any later version.
+#
+# WAX is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with WAX.  If not, see http://www.gnu.org/licenses.
+# 
+# R. Mark Volkmann, Object Computing, Inc.
+class WAX
+
+  # The current state of XML output is used to verify that methods
+  # in this class aren't called in an illogical order.
+  # If they are, a RuntimeError is raised.
+  STATES = [:in_prolog, :in_start_tag, :in_element, :after_root]
+
+  # Creates a WAX object, invokes the specified block on it
+  # and calls close on the WAX object.
+  # The writer can be a String file path, an IO object such as a File,
+  # or unspecified to write $stdout.
+  # If the version isn't specified then no XML declaration will be written.
+  def self.write(writer=$stdout, version=nil, &proc)
+    writer = File.new(writer, "w") if writer.kind_of?(String)
+    wax = WAX.new(writer, version)
+    wax.instance_exec(&proc)
+    wax.close
+  end
+
+  # Initializes new instances of this class.
+  def initialize(writer=$stdout, version=nil)
+    @attr_on_new_line = false
+    @check_me = true
+    @close_stream = writer != $stdout
+    @dtd_file_path = nil
+    @entity_defs = []
+    @has_content = @has_indented_content = false
+    @indent = '  '
+    @namespace_uri_to_schema_path_map = {}
+    @parent_stack = []
+    @pending_prefixes = []
+    @prefixes_stack = []
+    @state = :in_prolog
+    @writer = writer 
+    write_xml_declaration(version)
+  end
+
+  # Writes an attribute for the currently open element start tag.
+  # If two parameters are specified, they are name and value.
+  # If three parameters are specified, they are prefix, name and value.
+  # If four parameters are specified, they are prefix, name, value and a flag
+  # to indicate whether the attribute should be written on a new line.
+  def attr(p1, p2, p3=nil, p4=nil)
+    if (p3 == nil)
+      prefix, name, value, new_line = nil, p1, p2, false
+    elsif (p4 == nil)
+      prefix, name, value, new_line = p1, p2, p3, false
+    else
+      prefix, name, value, new_line = p1, p2, p3, p4
+    end
+
+    if @check_me
+      bad_state("attr") unless @state == :in_start_tag
+
+      unless prefix == nil
+        XMLUtil.verify_nmtoken(prefix)
+        @pending_prefixes << prefix
+      end
+
+       XMLUtil.verify_nmtoken(name)
+       value = XMLUtil.escape(value)
+    end
+
+    has_prefix = prefix != nil and prefix.length > 0
+    qname = has_prefix ? prefix + ':' + name : name
+
+    if new_line
+      write_indent
+    else
+      write ' '
+    end
+        
+    write "#{qname}=\"#{value}\""
+
+    self
+  end
+
+  # Raises a RuntimeError that indicates
+  # the method that was called and the current state that was invalid.
+  def bad_state(method_name)
+    raise "can't call #{method_name} when state is #{@state}"
+  end
+
+  # Writes a blank line to increase readability of the XML.
+  def blank_line
+    nl_text ""
+  end
+
+  # Writes a CDATA section in the content of the current element.
+  def cdata(text)
+    if @check_me
+      bad_state("cdata") if @state == :in_prolog or @state == :after_root
+    end
+
+    text("<![CDATA[" + text + "]]>", true, false)
+  end
+
+  # A convenience method that is a shortcut for
+  # start(prefix, name).text(text).end_element().
+  def child(p1, p2, p3=nil)
+    if (p3 == nil)
+      # only specified element name and text
+      prefix, name, text = nil, p1, p2
+    else
+      # specified element namespace prefix, name and text
+      prefix, name, text = p1, p2, p3
+    end
+
+    bad_state("child") if @check_me and @state == :after_root
+    start(prefix, name).text(text).end_element
+  end
+
+  # Terminates all unterminated elements,
+  # closes the Writer that is being used to output XML,
+  # and insures that nothing else can be written.
+  def close
+    raise "already closed" unless @writer
+    bad_state("close") if @check_me and @state == :in_prolog
+
+    # End all the unended elements.
+    while @parent_stack.size > 0; end_element; end
+
+    if @close_stream
+      @writer.close
+    else
+      @writer.flush
+    end
+
+    @writer = nil
+  end
+
+  # Writes a comment (&lt;!-- text --&gt;).
+  # The comment text cannot contain "--".
+  def comment(text)
+    # Comments can be output in any state.
+
+    XMLUtil.verify_comment(text) if @check_me
+        
+    @has_content = @has_indented_content = true
+    terminate_start
+    write_indent if @parent_stack.size > 0
+
+    write "<!-- #{text} -->"
+    write "\n" if will_indent and @parent_stack.size == 0
+
+    self
+  end
+
+  # Writes a DOCTYPE that associates a DTD with the XML document.
+  def dtd(file_path)
+    if @check_me
+      bad_state("dtd") unless @state == :in_prolog
+      XMLUtil.verify_uri(file_path)
+    end
+
+    @dtd_file_path = file_path
+    self
+  end
+
+  # Terminates the current element.
+  # It does so in the shorthand way (/&gt;) if the element has no content,
+  # and in the long way (&lt;/name&gt;) if it does.
+  def end_element
+    if @check_me
+      bad_state("end") if @state == :in_prolog or @state == :after_root
+      verify_prefixes
+    end
+
+    write_schema_locations
+
+    name = @parent_stack.pop
+
+    # Namespace prefixes that were in scope for this element
+    # are no longer in scope.
+    @prefixes_stack.pop
+
+    if @has_content
+      write_indent if @has_indented_content
+      write "</#{name}>"
+    else
+      write "/>"
+    end
+
+    @has_content = @has_indented_content = true # new setting for parent
+
+    @state = @parent_stack.size == 0 ? :after_root : :in_element
+
+    self
+  end
+
+  # Adds an entity definition to the internal subset of the DOCTYPE.
+  def entity_def(name, value)
+    bad_state("entity") if @check_me and @state != :in_prolog
+    @entity_defs << "#{name} \"#{value}\""
+    self
+  end
+
+  # Adds an external entity definition to the internal subset of the DOCTYPE.
+  def external_entity_def(name, file_path)
+    entity_def(name + " SYSTEM", file_path)
+  end
+
+  # Gets the indentation characters being used.
+  def get_indent
+    @indent
+  end
+
+  # Determines whether a given namespace prefix is currently in scope.
+  def is_in_scope_prefix(prefix)
+    @prefixes_stack.each do |prefixes|
+      next if prefixes == nil
+
+      # Check for the special case where we are testing for the
+      # default namespace and that's the only namespace in scope.
+      return true if prefix.length == 0 and prefixes.length == 0
+
+      prefixes.split(',').each do |token|
+        return true if token == prefix
+      end
+    end
+
+    false
+  end
+ 
+  # Gets whether "trust me" mode is enabled.
+  def is_trust_me
+    !@check_me
+  end
+
+  # Writes a namespace declaration in the start tag of the current element.
+  # If one parameter is specified, it is the default namespace uri.
+  # If two parameters are specified, they are prefix and uri.
+  # If three parameters are specified, they are prefix, uri and schema location.
+  def namespace(p1, p2=nil, p3=nil)
+    if (p2 == nil)
+      # only specified the default namespace uri
+      prefix, uri, schema_path = nil, p1, nil
+    elsif (p3 == nil)
+      # only specified a namespace prefix and uri
+      prefix, uri, schema_path = p1, p2, nil
+    else
+      # specified namespace prefix, uri and schema location
+      prefix, uri, schema_path = p1, p2, p3
+    end
+
+    prefix = "" if prefix == nil
+    has_prefix = prefix.length > 0
+
+    if @check_me
+      bad_state("namespace") unless @state == :in_start_tag
+
+      XMLUtil.verify_nmtoken(prefix) if has_prefix
+      XMLUtil.verify_uri(uri)
+      XMLUtil.verify_uri(schema_path) unless schema_path == nil
+    end
+
+    # Verify that the prefix isn't already defined in the current scope.
+    if is_in_scope_prefix(prefix)
+      raise ArgumentError,
+        "The namespace prefix \"#{prefix}\" is already in scope."
+    end
+
+    if will_indent
+      write_indent
+    else
+      write ' '
+    end
+        
+    write "xmlns"
+    write(':' + prefix) if has_prefix
+    write "=\"#{uri}\""
+        
+    if schema_path != nil
+      @namespace_uri_to_schema_path_map[uri] = schema_path
+    end
+
+    # Add this prefix to the list of those in scope for this element.
+    prefixes = @prefixes_stack.pop
+    if prefixes == nil
+      prefixes = prefix
+    else
+      prefixes << ',' + prefix
+    end
+    @prefixes_stack.push(prefixes)
+
+    @attr_on_new_line = true # for the next attribute
+
+    self
+  end
+
+  # Writes text preceded by a newline.
+  def nl_text(text)
+    text text, true, @check_me
+  end
+
+  # Writes a processing instruction.
+  def processing_instruction(target, data)
+    if @check_me
+      bad_state("pi") if @state == :after_root
+      XMLUtil.verify_nmtoken(target)
+    end
+        
+    @has_content = @has_indented_content = true
+    terminate_start
+    write_indent if @parent_stack.size > 0
+
+    write "<?#{target} #{data}?>"
+    write("\n") if will_indent and @parent_stack.size == 0
+
+    self
+  end
+
+  # Sets the indentation characters to use.
+  # The only valid values are
+  # a single tab, one or more spaces, an empty string, or null.
+  # Passing "" causes elements to be output on separate lines,
+  # but not indented.
+  # Passing null causes all output to be on a single line.
+  def set_indent(indent)
+    if indent == nil
+      @indent = indent
+
+    elsif indent.kind_of?(Fixnum)
+      count, @indent = indent, ''
+
+      if count < 0
+        raise ArgumentError, "can't indent a negative number of spaces"
+      end
+
+      if count > 4
+        raise ArgumentError, "#{count} is an unreasonable indentation"
+      end
+
+      for i in 1..count; @indent << ' '; end
+
+      return
+
+    elsif indent.kind_of?(String)
+      # Note that the parens on the next line are necessary
+      # because the assignment operator has higher precedence than "or".
+      valid = (indent == nil or indent.length == 0 or indent == "\t")
+      
+      unless valid
+        # It can only be valid now if every character is a space.
+        valid = true
+        for i in 0...indent.length
+          unless indent[i] == 32 # space
+            valid = false
+            break
+          end
+        end
+      end
+      
+      raise ArgumentError, "invalid indent value #{indent}" unless valid
+      
+      @indent = indent
+
+    else
+      raise ArgumentError, "invalid indent value #{indent}"
+    end
+  end
+
+  # Gets whether "trust me" mode is enabled.
+  # When disabled (the default),
+  # proper order of method calls is verified,
+  # method parameter values are verified,
+  # element and attribute names are verified to be NMTokens,
+  # and reserved characters in element/attribute text
+  # are replaced by built-in entity references.
+  # The main reason to enable "trust me" mode is for performance
+  # which is typically good even when disabled.
+  def set_trust_me(trust_me)
+    @check_me = !trust_me
+  end
+
+  # Writes the start tag for a given element name, but doesn't terminate it.
+  # If one parameter is specified, it is the element name.
+  # If two parameters are specified, they are prefix and name.
+  def start(p1, p2=nil)
+    if (p2 == nil)
+      # only specified element name
+      prefix, name = nil, p1
+    else
+      # specified element namespace prefix, name and text
+      prefix, name = p1, p2
+    end
+
+    @has_content = @has_indented_content = true
+    terminate_start
+    @has_content = false
+
+    if @check_me
+      bad_state("start") if @state == :after_root
+      if prefix != nil
+        XMLUtil.verify_nmtoken(prefix)
+        @pending_prefixes << prefix
+      end
+      XMLUtil.verify_nmtoken(name)
+    end
+
+    # If this is the root element ...
+    write_doctype(name) if @state == :in_prolog
+
+    # Can't add to pendingPrefixes until
+    # previous start tag has been terminated.
+    @pending_prefixes << prefix if @check_me and prefix != nil
+
+    write_indent if @parent_stack.size > 0
+
+    has_prefix = prefix != nil and prefix.length > 0
+    qname = has_prefix ? prefix + ':' + name : name
+
+    write '<' + qname
+
+    @parent_stack.push(qname)
+
+    # No namespace prefixes have been associated with this element yet.
+    @prefixes_stack.push(nil)
+
+    @state = :in_start_tag
+
+    self
+  end
+
+  # Closes the start tag, with &gt; or /&gt;, that had been kept open
+  # waiting for more namespace declarations and attributes.
+  def terminate_start
+    verify_prefixes if @check_me
+    return if @state != :in_start_tag
+    write_schema_locations
+    write '>'
+    @attr_on_new_line = false # reset
+    @state = :in_element
+  end
+
+  # Writes text inside the content of the current element.
+  def text(text, newline=false, escape=@check_me)
+    if @check_me
+      bad_state("text") if @state == :in_prolog or @state == :after_root
+    end
+
+    @has_content = true
+    @has_indented_content = newline
+    terminate_start
+
+    if text != nil and text.length > 0
+      write_indent if newline
+      text = XMLUtil.escape(text) if escape
+      write text
+    elsif newline
+      write "\n"
+    end
+
+    self
+  end
+
+  # Verifies that all the pending namespace prefix are currently in scope.
+  # ArgumentError is raises if any aren't in scope.
+  def verify_prefixes
+    @pending_prefixes.each do |prefix|
+      if !is_in_scope_prefix(prefix)
+        raise ArgumentError,
+          "The namespace prefix \"#{prefix}\" isn't in scope."
+      end 
+    end
+
+    @pending_prefixes.clear
+  end
+
+  # Determines whether XML should be indented.
+  def will_indent
+    @indent != nil
+  end
+
+  # Writes the to_s value of an Object to the writer.
+  def write(data)
+    raise "attempting to write XML after close has been called" unless @writer
+    @writer.write(data.to_s)
+  end
+
+  # Writes a DOCTYPE.
+  def write_doctype(root_element_name)
+    return if @dtd_file_path == nil and @entity_defs.empty?
+
+    write "<!DOCTYPE #{root_element_name}"
+    write " SYSTEM \"#{@dtd_file_path}\"" unless @dtd_file_path == nil 
+
+    if not @entity_defs.empty?
+      write " ["
+
+      @entity_defs.each do |entity_def|
+        write "\n" + @indent if will_indent
+        write "<!ENTITY #{entity_def}>"
+      end
+
+      write "\n" if will_indent
+      write ']'
+
+      @entity_defs.clear
+    end
+
+    write '>'
+    write "\n" if will_indent
+  end
+
+  # Writes the proper amount of indentation
+  # given the current nesting of elements.
+  def write_indent
+    return unless will_indent
+    write "\n"
+    for i in 0...@parent_stack.size
+      write @indent
+    end
+  end
+
+  # Writes the namespace declaration for the XMLSchema-instance namespace
+  # and writes the schemaLocation attribute
+  # which associates namespace URIs with schema locations.
+  def write_schema_locations
+    return if @namespace_uri_to_schema_path_map.empty?
+
+    # Write the attributes needed to associate XML Schemas with this XML.
+    schema_location = ""
+    @namespace_uri_to_schema_path_map.each_pair do |uri, path|
+      if schema_location.length > 0 # not first pair output
+        if will_indent
+          schema_location << "\n"
+          for i in 0..@parent_stack.size
+            schema_location << @indent
+          end
+        else
+          schema_location << ' '
+        end
+      end
+            
+      schema_location << uri + ' ' + path
+    end
+        
+    namespace("xsi", XMLUtil::XMLSCHEMA_INSTANCE_NS)
+    attr("xsi", "schemaLocation", schema_location,  will_indent)
+    @attr_on_new_line = true # for the next attribute
+    @namespace_uri_to_schema_path_map.clear
+  end
+
+  # Writes an XML declaration.
+  # Note that regardless of indentation,
+  # a newline is always written after this.
+  def write_xml_declaration(version)
+    return if version == nil
+    XMLUtil.verify_version(version) if @check_me
+
+    write "<?xml version=\"#{version}\" " +
+      "encoding=\"#{XMLUtil::DEFAULT_ENCODING}\"?>\n"
+  end
+
+  # Writes an "xml-stylesheet" processing instruction.
+  def xslt(file_path)
+    if @check_me
+      bad_state("xslt") unless @state == :in_prolog
+      XMLUtil.verify_uri(file_path)
+    end
+
+    @state = :in_prolog
+
+    processing_instruction("xml-stylesheet",
+      "type=\"text/xsl\" href=\"#{file_path}\"")
+  end
+
+  private :bad_state, :is_in_scope_prefix, :terminate_start,
+    :verify_prefixes, :will_indent, :write_doctype, :write_indent,
+    :write_schema_locations, :write_xml_declaration
+
+end