RhodeCode

    when /^t/: 'tag'

    when /^u/: 'url'

    when /^r/: 'revision'

    when /^a/: 'author'

    when /^d/: 'date'

require 'ftools'

											[ '--destdir', '-d', GetoptLong::REQUIRED_ARGUMENT ],

											[ '--target', '-t', GetoptLong::REQUIRED_ARGUMENT ],

											[ '--concurrent', '-c', GetoptLong::NO_ARGUMENT],

											[ '--help', '-h', GetoptLong::NO_ARGUMENT],

											[ '--noop', '-n', GetoptLong::NO_ARGUMENT])

require "ftools"

	# declaration for you.  See |DECLARATION| and |write|.

	class Document < Element

		# A convenient default XML declaration.  If you want an XML declaration,

		# the easiest way to add one is mydoc << Document::DECLARATION

    # +DEPRECATED+

    # Use: mydoc << XMLDecl.default

		DECLARATION = XMLDecl.default

		# Constructor

		# @param source if supplied, must be a Document, String, or IO. 

		# Documents have their context and Element attributes cloned.

	  # Strings are expected to be valid XML documents.  IOs are expected

	  # to be sources of valid XML documents.

	  # @param context if supplied, contains the context of the document;

	  # this should be a Hash.

		def initialize( source = nil, context = {} )

			super()

			@context = context

			return if source.nil?

			if source.kind_of? Document

				@context = source.context

				super source

			else

				build(  source )

			end

		end

		# Should be obvious

		def clone

			Document.new self

		end

		# According to the XML spec, a root node has no expanded name

		def expanded_name

			''

			#d = doc_type

			#d ? d.name : "UNDEFINED"

		end

		alias :name :expanded_name

		# We override this, because XMLDecls and DocTypes must go at the start

		# of the document

		def add( child )

			if child.kind_of? XMLDecl

				@children.unshift child

			elsif child.kind_of? DocType

				child.parent = self

			else

				rv = super

				raise "attempted adding second root element to document" if @elements.size > 1

				rv

			end

		end

		alias :<< :add

		def add_element(arg=nil, arg2=nil)

			rv = super

			raise "attempted adding second root element to document" if @elements.size > 1

			rv

		end

		# @return the root Element of the document, or nil if this document

		# has no children.

		def root

		end

		# @return the DocType child of the document, if one exists,

		# and nil otherwise.

		def doctype

			@children.find { |item| item.kind_of? DocType }

		end

		# @return the XMLDecl of this document; if no XMLDecl has been

		# set, the default declaration is returned.

		def xml_decl

			rv = @children[0]

		end

		# @return the XMLDecl version of this document as a String.

		# If no XMLDecl has been set, returns the default version.

		def version

			xml_decl().version

		end

		# @return the XMLDecl encoding of this document as a String.

		# If no XMLDecl has been set, returns the default encoding.

		def encoding

			xml_decl().encoding

		end

		# @return the XMLDecl standalone value of this document as a String.

		# If no XMLDecl has been set, returns the default setting.

		def stand_alone?

			xml_decl().stand_alone?

		end

		end

		def Document::parse_stream( source, listener )

			Parsers::StreamParser.new( source, listener ).parse

		end

		private

		def build( source )

		end

		assert_raises( ParseException, 

      assert_raises( ParseException, %Q{Parse #{src.inspect} should have failed!} ) do

    assert_raises(ParseException) {

    assert_raises(ParseException) {

    assert_raises(ParseException) {

    assert_raises( REXML::UndefinedNamespaceException, 

    assert_raises( RuntimeError ) {

    assert_raises( ParseException, %Q{"#{src}" is invalid XML} )  {

    assert_raises( ParseException, "invalid XML should be caught" ) {

    assert_raises( REXML::UndefinedNamespaceException, 

    assert_raises(ParseException, "Parsing should have failed") { 

    assert_raises( REXML::Validation::ValidationException, 

    assert_raises( UndefinedNamespaceException, "x should be undefined" ) {