Fixes more 1.9 - related syntax
Changes ftools to FileUtils
M bin/info.rb +5 -5
@@ 17,11 17,11 @@ if ARGV.length < 1
 end
 
 k = case ARGV[0]
-    when /^t/: 'tag'
-    when /^u/: 'url'
-    when /^r/: 'revision'
-    when /^a/: 'author'
-    when /^d/: 'date'
+    when /^t/ then 'tag'
+    when /^u/ then 'url'
+    when /^r/ then 'revision'
+    when /^a/ then 'author'
+    when /^d/ then 'date'
     else
       puts %Q{Unrecognized command "#{ARGV[0]}"}
       puts HELP

          
M bin/install.rb +6 -6
@@ 29,15 29,15 @@ Dir.chdir ".." if Dir.pwd =~ /bin.?$/
 
 require 'getoptlong'
 require 'rbconfig'
-require 'ftools'
+require 'FileUtils'
 require 'find'
 
 opts = GetoptLong.new( [ '--uninstall',	'-u',		GetoptLong::NO_ARGUMENT],
-											[ '--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])
+						[ '--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])
 
 
 destdir = File.join(Config::CONFIG['sitedir'], 

          
M bin/repackage.rb +1 -1
@@ 2,7 2,7 @@ 
 
 Dir.chdir ".." if Dir.pwd =~ /bin.?$/
 
-require "ftools"
+require "FileUtils"
 
 def copy_recursively( dir_name, dest )
 	Dir.entries( dir_name ).each { |fname|

          
M src/rexml/document.rb +91 -91
@@ 17,58 17,58 @@ module REXML
   # Document has a single child that can be accessed by root().
   # Note that if you want to have an XML declaration written for a document
   # you create, you must add one; REXML documents do not write a default
-	# 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
+  # 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
+	# 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
 
     def node_type
       :document
     end
 
-		# Should be obvious
-		def clone
-			Document.new self
-		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
+	# 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
+	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
+	# 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
         child.parent = self
-			elsif child.kind_of? DocType
+	  elsif child.kind_of? DocType
         # Find first Element or DocType node and insert the decl right 
         # before it.  If there is no such node, just insert the child at the
         # end.  If there is a child and it is an DocType, then replace it.

          
@@ 86,60 86,60 @@ module REXML
         else  # Insert at end of list
           @children[insert_before_index] = child
         end
-				child.parent = self
-			else
-				rv = super
-				raise "attempted adding second root element to document" if @elements.size > 1
-				rv
-			end
-		end
-		alias :<< :add
+		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
+	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
+	# @return the root Element of the document, or nil if this document
+	# has no children.
+	def root
       elements[1]
       #self
       #@children.find { |item| item.kind_of? Element }
-		end
+	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 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]
+	# @return the XMLDecl of this document; if no XMLDecl has been
+	# set, the default declaration is returned.
+	def xml_decl
+	  rv = @children[0]
       return rv if rv.kind_of? XMLDecl
       rv = @children.unshift(XMLDecl.default)[0]
-		end
+	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 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 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
+	# @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
 
     # Write the XML tree out, optionally with indent.  This writes out the
     # entire XML document, including XML declarations, doctype declarations,

          
@@ 194,16 194,16 @@ module REXML
 		REXML::Formatters::Default.new( ie_hack )
 	  end
       formatter.write( self, output )
-		end
+	end
 
 		
-		def Document::parse_stream( source, listener )
-			Parsers::StreamParser.new( source, listener ).parse
-		end
+	def Document::parse_stream( source, listener )
+	  Parsers::StreamParser.new( source, listener ).parse
+	end
 
-		private
-		def build( source )
+	private
+	def build( source )
       Parsers::TreeParser.new( source, self ).parse
-		end
 	end
+  end
 end

          
M test/attributes.rb +1 -1
@@ 91,7 91,7 @@ class AttributesTester < Test::Unit::Tes
 
 	# Submitted by Kou
 	def test_namespace_conflict
-		assert_raises( ParseException, 
+		assert_raise( ParseException, 
 			"Declaring two attributes with the same namespace should be an error" ) do
 			REXML::Document.new <<-XML
 			<x xmlns:n1="http://www.w3.org" 

          
M test/core_test.rb +9 -9
@@ 55,7 55,7 @@ class Tester < Test::Unit::TestCase
       '<a' + [0x0371].pack('U') + ' />',
       '<a a' + [0x0371].pack('U') + '="" />',
     ].each do |src|
-      assert_raises( ParseException, %Q{Parse #{src.inspect} should have failed!} ) do
+      assert_raise( ParseException, %Q{Parse #{src.inspect} should have failed!} ) do
         Document.new(src)
       end
     end

          
@@ 134,10 134,10 @@ class Tester < Test::Unit::TestCase
     comment2 = Comment.new comment
     assert_equal(comment, comment2)
 
-    assert_raises(ParseException) {
+    assert_raise(ParseException) {
       REXML::Document.new("<d><!- foo --></d>")
     }
-    assert_raises(ParseException) {
+    assert_raise(ParseException) {
       REXML::Document.new("<d><!-- foo -></d>")
     }
   end

          
@@ 286,7 286,7 @@ class Tester < Test::Unit::TestCase
     instruction2 = d[0]
     assert_equal(instruction.to_s, instruction2.to_s)
 
-    assert_raises(ParseException) {
+    assert_raise(ParseException) {
       REXML::Document.new("<d><?foo bar></d>")
     }
   end

          
@@ 855,7 855,7 @@ EOL
   end
 
   def test_more_namespaces
-    assert_raises( REXML::UndefinedNamespaceException, 
+    assert_raise( REXML::UndefinedNamespaceException, 
                    %Q{Should have gotten an Undefined Namespace error} )  {
       doc1 = Document.new("<r><p><n:c/></p></r>")
     }

          
@@ 1044,7 1044,7 @@ EOL
 
   def test_null_element_name
     a = REXML::Document.new 
-    assert_raises( RuntimeError ) {
+    assert_raise( RuntimeError ) {
       a.add_element( nil ) 
     }
   end

          
@@ 1193,14 1193,14 @@ EOL
 
   def test_ticket_76
     src = "<div>at&t"
-    assert_raises( ParseException, %Q{"#{src}" is invalid XML} )  {
+    assert_raise( ParseException, %Q{"#{src}" is invalid XML} )  {
       REXML::Document.new(src)
     }
   end
 
   def test_ticket_21
     src = "<foo bar=value/>"
-    assert_raises( ParseException, "invalid XML should be caught" ) {
+    assert_raise( ParseException, "invalid XML should be caught" ) {
       d = REXML::Document.new(src)
     }
     begin

          
@@ 1324,7 1324,7 @@ ENDXML
 
   def test_ticket_14
     # Per .2.5 Node Tests of XPath spec 
-    assert_raises( REXML::UndefinedNamespaceException, 
+    assert_raise( REXML::UndefinedNamespaceException, 
                    %Q{Should have gotten an Undefined Namespace error} )  {
       d = Document.new("<a><n:b/></a>") 
     }

          
M test/pullparser.rb +1 -1
@@ 32,7 32,7 @@ class PullParserTester < Test::Unit::Tes
   def test_bad_document
     source = "<a><b></a>"
     parser = REXML::Parsers::PullParser.new(source)
-    assert_raises(ParseException, "Parsing should have failed") { 
+    assert_raise(ParseException, "Parsing should have failed") { 
       results = parser.pull while parser.has_next? 
     }
   end

          
M test/validation_rng.rb +1 -1
@@ 778,7 778,7 @@ class RNGValidation < Test::Unit::TestCa
   def error( validator, source )
     parser = REXML::Parsers::TreeParser.new( source )
     parser.add_listener( validator.reset )
-    assert_raises( REXML::Validation::ValidationException, 
+    assert_raise( REXML::Validation::ValidationException, 
                   "Expected a validation error" ) { parser.parse }
   end
 

          
M test/xpath_test.rb +1 -1
@@ 587,7 587,7 @@ class XPathTester < Test::Unit::TestCase
 	end
 
 	def test_name
-    assert_raises( UndefinedNamespaceException, "x should be undefined" ) {
+    assert_raise( UndefinedNamespaceException, "x should be undefined" ) {
       d = REXML::Document.new("<a x='foo'><b/><x:b/></a>")
     }
 		d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")