* {ext,lib,test}/**/*.rb: removed trailing spaces.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22784 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

6 files changed, 46 insertions, 46 deletions

diff --git a/lib/rexml/parsers/baseparser.rb b/lib/rexml/parsers/baseparser.rb
index 162d029a62..2f758265bb 100644
--- a/lib/rexml/parsers/baseparser.rb
+++ b/lib/rexml/parsers/baseparser.rb
@@ -105,11 +105,11 @@ module REXML
 
       EREFERENCE = /&(?!#{NAME};)/
 
-      DEFAULT_ENTITIES = { 
-        'gt' => [/>/, '>', '>', />/], 
-        'lt' => [/&lt;/, '&lt;', '<', /</], 
-        'quot' => [/&quot;/, '&quot;', '"', /"/], 
-        "apos" => [/&apos;/, "&apos;", "'", /'/] 
+      DEFAULT_ENTITIES = {
+        'gt' => [/&gt;/, '&gt;', '>', />/],
+        'lt' => [/&lt;/, '&lt;', '<', /</],
+        'quot' => [/&quot;/, '&quot;', '"', /"/],
+        "apos" => [/&apos;/, "&apos;", "'", /'/]
       }
 
 
@@ -180,9 +180,9 @@ module REXML
       # Peek at the +depth+ event in the stack.  The first element on the stack
       # is at depth 0.  If +depth+ is -1, will parse to the end of the input
       # stream and return the last event, which is always :end_document.
-      # Be aware that this causes the stream to be parsed up to the +depth+ 
-      # event, so you can effectively pre-parse the entire document (pull the 
-      # entire thing into memory) using this method.  
+      # Be aware that this causes the stream to be parsed up to the +depth+
+      # event, so you can effectively pre-parse the entire document (pull the
+      # entire thing into memory) using this method.
       def peek depth=0
         raise %Q[Illegal argument "#{depth}"] if depth < -1
         temp = []
@@ -265,7 +265,7 @@ module REXML
         if @document_status == :in_doctype
           md = @source.match(/\s*(.*?>)/um)
           case md[1]
-          when SYSTEMENTITY 
+          when SYSTEMENTITY
             match = @source.match( SYSTEMENTITY, true )[1]
             return [ :externalentity, match ]
 
@@ -344,7 +344,7 @@ module REXML
               #md = @source.match_to_consume( '>', CLOSE_MATCH)
               md = @source.match( CLOSE_MATCH, true )
               raise REXML::ParseException.new( "Missing end tag for "+
-                "'#{last_tag}' (got \"#{md[1]}\")", 
+                "'#{last_tag}' (got \"#{md[1]}\")",
                 @source) unless last_tag == md[1]
               return [ :end_element, last_tag ]
             elsif @source.buffer[1] == ?!
@@ -377,7 +377,7 @@ module REXML
               unless md
                 # Check for missing attribute quotes
                 raise REXML::ParseException.new("missing attribute quote", @source) if @source.match(MISSING_ATTRIBUTE_QUOTES )
-                raise REXML::ParseException.new("malformed XML: missing tag start", @source) 
+                raise REXML::ParseException.new("malformed XML: missing tag start", @source)
               end
               attributes = {}
               prefixes = Set.new
@@ -386,7 +386,7 @@ module REXML
               if md[4].size > 0
                 attrs = md[4].scan( ATTRIBUTE_PATTERN )
                 raise REXML::ParseException.new( "error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"", @source) if $' and $'.strip.size > 0
-                attrs.each { |a,b,c,d,e| 
+                attrs.each { |a,b,c,d,e|
                   if b == "xmlns"
                     if c == "xml"
                       if d != "http://www.w3.org/XML/1998/namespace"
@@ -409,10 +409,10 @@ module REXML
                     raise REXML::ParseException.new( msg, @source, self)
                   end
 
-                  attributes[a] = e 
+                  attributes[a] = e
                 }
               end
-        
+
               # Verify that all of the prefixes have been defined
               for prefix in prefixes
                 unless @nsstack.find{|k| k.member?(prefix)}
@@ -466,7 +466,7 @@ module REXML
         # Doing it like this rather than in a loop improves the speed
         copy.gsub!( EREFERENCE, '&amp;' )
         entities.each do |key, value|
-          copy.gsub!( value, "&#{key};" ) unless entity_filter and 
+          copy.gsub!( value, "&#{key};" ) unless entity_filter and
                                       entity_filter.include?(entity)
         end if entities
         copy.gsub!( EREFERENCE, '&amp;' )
diff --git a/lib/rexml/parsers/pullparser.rb b/lib/rexml/parsers/pullparser.rb
index 36dc7160c3..68a4ff7eae 100644
--- a/lib/rexml/parsers/pullparser.rb
+++ b/lib/rexml/parsers/pullparser.rb
@@ -68,7 +68,7 @@ module REXML
         event = @parser.pull
         case event[0]
         when :entitydecl
-          @entities[ event[1] ] = 
+          @entities[ event[1] ] =
             event[2] unless event[2] =~ /PUBLIC|SYSTEM/
         when :text
           unnormalized = @parser.unnormalize( event[1], @entities )
diff --git a/lib/rexml/parsers/sax2parser.rb b/lib/rexml/parsers/sax2parser.rb
index 72131401c3..d0f0c5155e 100644
--- a/lib/rexml/parsers/sax2parser.rb
+++ b/lib/rexml/parsers/sax2parser.rb
@@ -20,7 +20,7 @@ module REXML
       def source
         @parser.source
       end
-      
+
       def add_listener( listener )
         @parser.add_listener( listener )
       end
@@ -44,7 +44,7 @@ module REXML
       # :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
       #
       # There is an additional symbol that can be listened for: :progress.
-      # This will be called for every event generated, passing in the current 
+      # This will be called for every event generated, passing in the current
       # stream position.
       #
       # Array contains regular expressions or strings which will be matched
@@ -72,7 +72,7 @@ module REXML
           add([nil, nil, args[0]])
         end
       end
-      
+
       def deafen( listener=nil, &blok )
         if listener
           @listeners.delete_if {|item| item[-1] == listener }
@@ -81,10 +81,10 @@ module REXML
           @procs.delete_if {|item| item[-1] == blok }
         end
       end
-      
+
       def parse
         @procs.each { |sym,match,block| block.call if sym == :start_document }
-        @listeners.each { |sym,match,block| 
+        @listeners.each { |sym,match,block|
           block.start_document if sym == :start_document or sym.nil?
         }
         root = context = []
@@ -126,8 +126,8 @@ module REXML
             listeners = get_listeners( :start_element, event[1] )
             # notify observers
             procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
-            listeners.each { |ob| 
-              ob.start_element( uri, local, event[1], event[2] ) 
+            listeners.each { |ob|
+              ob.start_element( uri, local, event[1], event[2] )
             } if listeners
           when :end_element
             @tag_stack.pop
@@ -140,8 +140,8 @@ module REXML
             listeners = get_listeners( :end_element, event[1] )
             # notify observers
             procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
-            listeners.each { |ob| 
-              ob.end_element( uri, local, event[1] ) 
+            listeners.each { |ob|
+              ob.end_element( uri, local, event[1] )
             } if listeners
 
             namespace_mapping = @namespace_stack.pop
@@ -160,7 +160,7 @@ module REXML
             #handle( :characters, normalized )
             copy = event[1].clone
 
-            esub = proc { |match| 
+            esub = proc { |match|
               if @entities.has_key?($1)
                 @entities[$1].gsub(Text::REFERENCE, &esub)
               else
@@ -178,7 +178,7 @@ module REXML
           when :entitydecl
             @entities[ event[1] ] = event[2] if event.size == 3
             handle( *event )
-          when :processing_instruction, :comment, :attlistdecl, 
+          when :processing_instruction, :comment, :attlistdecl,
             :elementdecl, :cdata, :notationdecl, :xmldecl
             handle( *event )
           end
@@ -193,8 +193,8 @@ module REXML
         listeners = get_listeners( symbol, tag )
         # notify observers
         procs.each { |ob| ob.call( *arguments ) } if procs
-        listeners.each { |l| 
-          l.send( symbol.to_s, *arguments ) 
+        listeners.each { |l|
+          l.send( symbol.to_s, *arguments )
         } if listeners
       end
 
@@ -205,7 +205,7 @@ module REXML
         @procs.find_all do |sym, match, block|
           #puts sym.inspect+"=="+symbol.inspect+ "\t"+match.inspect+"=="+name.inspect+ "\t"+( (sym.nil? or symbol == sym) and ((name.nil? and match.nil?) or match.nil? or ( (name == match) or (match.kind_of? Regexp and name =~ match)))).to_s
           (
-            (sym.nil? or symbol == sym) and 
+            (sym.nil? or symbol == sym) and
             ((name.nil? and match.nil?) or match.nil? or (
               (name == match) or
               (match.kind_of? Regexp and name =~ match)
@@ -218,7 +218,7 @@ module REXML
         return nil if @listeners.size == 0
         @listeners.find_all do |sym, match, block|
           (
-            (sym.nil? or symbol == sym) and 
+            (sym.nil? or symbol == sym) and
             ((name.nil? and match.nil?) or match.nil? or (
               (name == match) or
               (match.kind_of? Regexp and name =~ match)
@@ -237,7 +237,7 @@ module REXML
         end
       end
 
-      def get_namespace( prefix ) 
+      def get_namespace( prefix )
         uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
           (@namespace_stack.find { |ns| not ns[nil].nil? })
         uris[-1][prefix] unless uris.nil? or 0 == uris.size
diff --git a/lib/rexml/parsers/streamparser.rb b/lib/rexml/parsers/streamparser.rb
index 256d0f611c..073fcc2c21 100644
--- a/lib/rexml/parsers/streamparser.rb
+++ b/lib/rexml/parsers/streamparser.rb
@@ -5,11 +5,11 @@ module REXML
         @listener = listener
         @parser = BaseParser.new( source )
       end
-      
+
       def add_listener( listener )
         @parser.add_listener( listener )
       end
-      
+
       def parse
         # entity string
         while true
diff --git a/lib/rexml/parsers/treeparser.rb b/lib/rexml/parsers/treeparser.rb
index 30327d0dfd..7f618cb319 100644
--- a/lib/rexml/parsers/treeparser.rb
+++ b/lib/rexml/parsers/treeparser.rb
@@ -42,8 +42,8 @@ module REXML
                 if @build_context[-1].instance_of? Text
                   @build_context[-1] << event[1]
                 else
-                  @build_context.add( 
-                    Text.new(event[1], @build_context.whitespace, nil, true) 
+                  @build_context.add(
+                    Text.new(event[1], @build_context.whitespace, nil, true)
                   ) unless (
                     @build_context.ignore_whitespace_nodes and
                     event[1].strip.size==0
diff --git a/lib/rexml/parsers/xpathparser.rb b/lib/rexml/parsers/xpathparser.rb
index 49450b4aef..aafa72ab9e 100644
--- a/lib/rexml/parsers/xpathparser.rb
+++ b/lib/rexml/parsers/xpathparser.rb
@@ -53,8 +53,8 @@ module REXML
             string << "*"
           when :text
             string << "text()"
-          when :following, :following_sibling, 
-                :ancestor, :ancestor_or_self, :descendant, 
+          when :following, :following_sibling,
+                :ancestor, :ancestor_or_self, :descendant,
                 :namespace, :preceding, :preceding_sibling
             string << "/" unless string.size == 0
             string << op.to_s.tr("_", "-")
@@ -97,7 +97,7 @@ module REXML
           case op
           when :node
             string << "node()"
-          when :attribute, :child, :following, :following_sibling, 
+          when :attribute, :child, :following, :following_sibling,
                 :ancestor, :ancestor_or_self, :descendant, :descendant_or_self,
                 :namespace, :preceding, :preceding_sibling, :self, :parent
             string << "/" unless string.size == 0
@@ -249,7 +249,7 @@ module REXML
 
             parsed.concat(n)
           end
-          
+
           if path.size > 0
             if path[0] == ?/
               if path[1] == ?/
@@ -332,12 +332,12 @@ module REXML
           predicates << expr[1..-2] if expr
         end
         #puts "PREDICATES = #{predicates.inspect}"
-        predicates.each{ |pred| 
+        predicates.each{ |pred|
           #puts "ORING #{pred}"
           preds = []
           parsed << :predicate
           parsed << preds
-          OrExpr(pred, preds) 
+          OrExpr(pred, preds)
         }
         #puts "PREDICATES = #{predicates.inspect}"
         path
@@ -600,13 +600,13 @@ module REXML
           #puts "LITERAL or NUMBER: #$1"
           varname = $1.nil? ? $2 : $1
           path = $'
-          parsed << :literal 
+          parsed << :literal
           parsed << (varname.include?('.') ? varname.to_f : varname.to_i)
         when LITERAL
           #puts "LITERAL or NUMBER: #$1"
           varname = $1.nil? ? $2 : $1
           path = $'
-          parsed << :literal 
+          parsed << :literal
           parsed << varname
         when /^\(/                                               #/
           path, contents = get_group(path)
@@ -649,7 +649,7 @@ module REXML
         return nil unless depth==0
         [string[ind..-1], string[0..ind-1]]
       end
-      
+
       def parse_args( string )
         arguments = []
         ind = 0
@@ -683,7 +683,7 @@ module REXML
                   s = string[0,ind].strip
                   arguments << s unless s == ""
                   string = string[ind+1..-1]
-                  ind = -1 
+                  ind = -1
                 end
               end
             end