rubysl-rexml 1.0.0 → 2.0.1

data/lib/rexml/formatters/transitive.rb

@@ -12,9 +12,10 @@ module REXML
     # formatted.  Since this formatter does not alter whitespace nodes, the
     # results of formatting already formatted XML will be odd.
     class Transitive < Default
-      def initialize( indentation=2 )
+      def initialize( indentation=2, ie_hack=false )
         @indentation = indentation
         @level = 0
+        @ie_hack = ie_hack
       end
 
       protected
@@ -29,13 +30,13 @@ module REXML
         output << "\n"
         output << ' '*@level
         if node.children.empty?
-          output << "/" 
+          output << " " if @ie_hack
+          output << "/"
         else
           output << ">"
           # If compact and all children are text, and if the formatted output
           # is less than the specified width, then try to print everything on
           # one line
-          skip = false
           @level += @indentation
           node.children.each { |child|
             write( child, output )

data/lib/rexml/functions.rb

@@ -28,6 +28,7 @@ module REXML
       end
     end
 
+    # Returns the last node of the given list of nodes.
     def Functions::last( )
       @@context[:size]
     end
@@ -36,6 +37,7 @@ module REXML
       @@context[:index]
     end
 
+    # Returns the size of the given list of nodes.
     def Functions::count( node_set )
       node_set.size
     end
@@ -48,7 +50,7 @@ module REXML
     # UNTESTED
     def Functions::local_name( node_set=nil )
       get_namespace( node_set ) do |node|
-        return node.local_name 
+        return node.local_name
       end
     end
 
@@ -57,7 +59,7 @@ module REXML
     end
 
     def Functions::name( node_set=nil )
-      get_namespace( node_set ) do |node| 
+      get_namespace( node_set ) do |node|
         node.expanded_name
       end
     end
@@ -66,7 +68,7 @@ module REXML
     def Functions::get_namespace( node_set = nil )
       if node_set == nil
         yield @@context[:node] if defined? @@context[:node].namespace
-      else  
+      else
         if node_set.respond_to? :each
           node_set.each { |node| yield node if defined? node.namespace }
         elsif node_set.respond_to? :namespace
@@ -81,15 +83,15 @@ module REXML
     #
     # A number is converted to a string as follows
     #
-    # NaN is converted to the string NaN 
+    # NaN is converted to the string NaN
     #
-    # positive zero is converted to the string 0 
+    # positive zero is converted to the string 0
     #
-    # negative zero is converted to the string 0 
+    # negative zero is converted to the string 0
     #
-    # positive infinity is converted to the string Infinity 
+    # positive infinity is converted to the string Infinity
     #
-    # negative infinity is converted to the string -Infinity 
+    # negative infinity is converted to the string -Infinity
     #
     # if the number is an integer, the number is represented in decimal form
     # as a Number with no decimal point and no leading zeros, preceded by a
@@ -129,6 +131,11 @@ module REXML
       end
     end
 
+    # A node-set is converted to a string by
+    # returning the concatenation of the string-value
+    # of each of the children of the node in the
+    # node-set that is first in document order.
+    # If the node-set is empty, an empty string is returned.
     def Functions::string_value( o )
       rv = ""
       o.children.each { |e|
@@ -156,7 +163,7 @@ module REXML
       string(string).include?(string(test))
     end
 
-    # Kouhei fixed this 
+    # Kouhei fixed this
     def Functions::substring_before( string, test )
       ruby_string = string(string)
       ruby_index = ruby_string.index(string(test))
@@ -166,20 +173,19 @@ module REXML
         ruby_string[ 0...ruby_index ]
       end
     end
- 
+
     # Kouhei fixed this too
     def Functions::substring_after( string, test )
       ruby_string = string(string)
-      test_string = string(test)
       return $1 if ruby_string =~ /#{test}(.*)/
       ""
     end
 
-    # Take equal portions of Mike Stok and Sean Russell; mix 
+    # Take equal portions of Mike Stok and Sean Russell; mix
     # vigorously, and pour into a tall, chilled glass.  Serves 10,000.
     def Functions::substring( string, start, length=nil )
       ruby_string = string(string)
-      ruby_length = if length.nil? 
+      ruby_length = if length.nil?
                       ruby_string.length.to_f
                     else
                       number(length)
@@ -188,15 +194,15 @@ module REXML
 
       # Handle the special cases
       return '' if (
-        ruby_length.nan? or 
+        ruby_length.nan? or
         ruby_start.nan? or
         ruby_start.infinite?
       )
 
       infinite_length = ruby_length.infinite? == 1
       ruby_length = ruby_string.length if infinite_length
-        
-      # Now, get the bounds.  The XPath bounds are 1..length; the ruby bounds 
+
+      # Now, get the bounds.  The XPath bounds are 1..length; the ruby bounds
       # are 0..length.  Therefore, we have to offset the bounds by one.
       ruby_start = ruby_start.round - 1
       ruby_length = ruby_length.round
@@ -247,7 +253,7 @@ module REXML
       0.upto(from.length - 1) { |pos|
         from_char = from[pos]
         unless map.has_key? from_char
-          map[from_char] = 
+          map[from_char] =
           if pos < to.length
             to[pos]
           else
@@ -256,9 +262,15 @@ module REXML
         end
       }
 
-      string(string).unpack('U*').collect { |c|
-        if map.has_key? c then map[c] else c end
-      }.compact.pack('U*')
+      if ''.respond_to? :chars
+        string(string).chars.collect { |c|
+          if map.has_key? c then map[c] else c end
+        }.compact.join
+      else
+        string(string).unpack('U*').collect { |c|
+          if map.has_key? c then map[c] else c end
+        }.compact.pack('U*')
+      end
     end
 
     # UNTESTED
@@ -353,7 +365,7 @@ module REXML
       nodes = [nodes] unless nodes.kind_of? Array
       nodes.inject(0) { |r,n| r += number(string(n)) }
     end
-    
+
     def Functions::floor( number )
       number(number).floor
     end

data/lib/rexml/instruction.rb

@@ -2,62 +2,62 @@ require "rexml/child"
 require "rexml/source"
 
 module REXML
-	# Represents an XML Instruction; IE, <? ... ?>
-	# TODO: Add parent arg (3rd arg) to constructor
-	class Instruction < Child
-		START = '<\?'
-		STOP = '\?>'
+  # Represents an XML Instruction; IE, <? ... ?>
+  # TODO: Add parent arg (3rd arg) to constructor
+  class Instruction < Child
+    START = '<\?'
+    STOP = '\?>'
 
-		# target is the "name" of the Instruction; IE, the "tag" in <?tag ...?>
-		# content is everything else.
-		attr_accessor :target, :content
+    # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?>
+    # content is everything else.
+    attr_accessor :target, :content
 
-		# Constructs a new Instruction
-		# @param target can be one of a number of things.  If String, then 
-		# the target of this instruction is set to this.  If an Instruction,
-		# then the Instruction is shallowly cloned (target and content are
-		# copied).  If a Source, then the source is scanned and parsed for
-		# an Instruction declaration.
-		# @param content Must be either a String, or a Parent.  Can only
-		# be a Parent if the target argument is a Source.  Otherwise, this
-		# String is set as the content of this instruction.
-		def initialize(target, content=nil)
-			if target.kind_of? String
-				super()
-				@target = target
-				@content = content
-			elsif target.kind_of? Instruction
-				super(content)
-				@target = target.target
-				@content = target.content
-			end
-			@content.strip! if @content
-		end
+    # Constructs a new Instruction
+    # @param target can be one of a number of things.  If String, then
+    # the target of this instruction is set to this.  If an Instruction,
+    # then the Instruction is shallowly cloned (target and content are
+    # copied).  If a Source, then the source is scanned and parsed for
+    # an Instruction declaration.
+    # @param content Must be either a String, or a Parent.  Can only
+    # be a Parent if the target argument is a Source.  Otherwise, this
+    # String is set as the content of this instruction.
+    def initialize(target, content=nil)
+      if target.kind_of? String
+        super()
+        @target = target
+        @content = content
+      elsif target.kind_of? Instruction
+        super(content)
+        @target = target.target
+        @content = target.content
+      end
+      @content.strip! if @content
+    end
+
+    def clone
+      Instruction.new self
+    end
 
-		def clone
-			Instruction.new self
-		end
-		
     # == DEPRECATED
     # See the rexml/formatters package
     #
-		def write writer, indent=-1, transitive=false, ie_hack=false
+    def write writer, indent=-1, transitive=false, ie_hack=false
       Kernel.warn( "#{self.class.name}.write is deprecated" )
-			indent(writer, indent)
-			writer << START.sub(/\\/u, '')
-			writer << @target
-			writer << ' '
-			writer << @content
-			writer << STOP.sub(/\\/u, '')
-		end
+      indent(writer, indent)
+      writer << START.sub(/\\/u, '')
+      writer << @target
+      writer << ' '
+      writer << @content
+      writer << STOP.sub(/\\/u, '')
+    end
 
-		# @return true if other is an Instruction, and the content and target
-		# of the other matches the target and content of this object.
-		def ==( other )
-			other.kind_of? Instruction and
-			other.target == @target and
-			other.content == @content
-		end
+    # @return true if other is an Instruction, and the content and target
+    # of the other matches the target and content of this object.
+    def ==( other )
+      other.kind_of? Instruction and
+      other.target == @target and
+      other.content == @content
+    end
 
     def node_type
       :processing_instruction
@@ -66,5 +66,5 @@ module REXML
     def inspect
       "<?p-i #{target} ...?>"
     end
-	end
+  end
 end

data/lib/rexml/light/node.rb

@@ -1,196 +1,195 @@
 require 'rexml/xmltokens'
-require 'rexml/light/node'
 
 # [ :element, parent, name, attributes, children* ]
-	# a = Node.new
-	# a << "B"		# => <a>B</a>
-	# a.b			# => <a>B<b/></a>
-	# a.b[1]			# => <a>B<b/><b/><a>
-	# a.b[1]["x"] = "y"	# => <a>B<b/><b x="y"/></a>
-	# a.b[0].c		# => <a>B<b><c/></b><b x="y"/></a>
-	# a.b.c << "D"		# => <a>B<b><c>D</c></b><b x="y"/></a>
+  # a = Node.new
+  # a << "B"            # => <a>B</a>
+  # a.b                 # => <a>B<b/></a>
+  # a.b[1]                      # => <a>B<b/><b/><a>
+  # a.b[1]["x"] = "y"   # => <a>B<b/><b x="y"/></a>
+  # a.b[0].c            # => <a>B<b><c/></b><b x="y"/></a>
+  # a.b.c << "D"                # => <a>B<b><c>D</c></b><b x="y"/></a>
 module REXML
-	module Light
-		# Represents a tagged XML element.  Elements are characterized by
-		# having children, attributes, and names, and can themselves be
-		# children.
-		class Node
-			NAMESPLIT = /^(?:(#{XMLTokens::NCNAME_STR}):)?(#{XMLTokens::NCNAME_STR})/u
-			PARENTS = [ :element, :document, :doctype ]
-			# Create a new element.
-			def initialize node=nil
-				@node = node
-				if node.kind_of? String
-					node = [ :text, node ]
-				elsif node.nil?
-					node = [ :document, nil, nil ]
-				elsif node[0] == :start_element
-					node[0] = :element
-				elsif node[0] == :start_doctype
-					node[0] = :doctype
-				elsif node[0] == :start_document
-					node[0] = :document
-				end
-			end
-
-			def size
-				if PARENTS.include? @node[0]
-					@node[-1].size
-				else
-					0
-				end
-			end
-
-			def each( &block )
-				size.times { |x| yield( at(x+4) ) }
-			end
-
-			def name
-				at(2)
-			end
-
-			def name=( name_str, ns=nil )
-				pfx = ''
-				pfx = "#{prefix(ns)}:" if ns
-				_old_put(2, "#{pfx}#{name_str}")
-			end
-
-			def parent=( node )
-				_old_put(1,node)
-			end
-
-			def local_name
-				namesplit
-				@name
-			end
-
-			def local_name=( name_str )
-				_old_put( 1, "#@prefix:#{name_str}" )
-			end
-
-			def prefix( namespace=nil )
-				prefix_of( self, namespace )
-			end
-
-			def namespace( prefix=prefix() )
-				namespace_of( self, prefix )
-			end
-
-			def namespace=( namespace )
-				@prefix = prefix( namespace )
-				pfx = ''
-				pfx = "#@prefix:" if @prefix.size > 0
-				_old_put(1, "#{pfx}#@name")
-			end
-
-			def []( reference, ns=nil )
-				if reference.kind_of? String
-					pfx = ''
-					pfx = "#{prefix(ns)}:" if ns
-					at(3)["#{pfx}#{reference}"]
-				elsif reference.kind_of? Range
-					_old_get( Range.new(4+reference.begin, reference.end, reference.exclude_end?) )
-				else
-					_old_get( 4+reference )
-				end
-			end
-
-			def =~( path )
-				XPath.match( self, path )
-			end
-
-			# Doesn't handle namespaces yet
-			def []=( reference, ns, value=nil )
-				if reference.kind_of? String
-					value = ns unless value
-					at( 3 )[reference] = value
-				elsif reference.kind_of? Range
-					_old_put( Range.new(3+reference.begin, reference.end, reference.exclude_end?), ns )
-				else
-					if value
-						_old_put( 4+reference, ns, value )
-					else
-						_old_put( 4+reference, ns )
-					end
-				end
-			end
-
-			# Append a child to this element, optionally under a provided namespace.
-			# The namespace argument is ignored if the element argument is an Element
-			# object.  Otherwise, the element argument is a string, the namespace (if
-			# provided) is the namespace the element is created in.
-			def << element
-				if node_type() == :text
-					at(-1) << element
-				else
-					newnode = Node.new( element )
-					newnode.parent = self
-					self.push( newnode )
-				end
-				at(-1)
-			end
-
-			def node_type
-				_old_get(0)
-			end
-
-			def text=( foo )
-				replace = at(4).kind_of?(String)? 1 : 0
-				self._old_put(4,replace, normalizefoo)
-			end
-
-			def root
-				context = self
-				context = context.at(1) while context.at(1)
-			end
-
-			def has_name?( name, namespace = '' )
-				at(3) == name and namespace() == namespace
-			end
-
-			def children
-				self
-			end
-
-			def parent
-				at(1)
-			end
-
-			def to_s
-
-			end
-
-			private
-
-			def namesplit
-				return if @name.defined?
-				at(2) =~ NAMESPLIT
-				@prefix = '' || $1
-				@name = $2
-			end
-
-			def namespace_of( node, prefix=nil )
-				if not prefix
-					name = at(2)
-					name =~ NAMESPLIT
-					prefix = $1
-				end
-				to_find = 'xmlns'
-				to_find = "xmlns:#{prefix}" if not prefix.nil?
-				ns = at(3)[ to_find ]
-				ns ? ns : namespace_of( @node[0], prefix )
-			end
-
-			def prefix_of( node, namespace=nil )
-				if not namespace
-					name = node.name
-					name =~ NAMESPLIT
-					$1
-				else
-					ns = at(3).find { |k,v| v == namespace }
-					ns ? ns : prefix_of( node.parent, namespace )
-				end
-			end
-		end
-	end
+  module Light
+    # Represents a tagged XML element.  Elements are characterized by
+    # having children, attributes, and names, and can themselves be
+    # children.
+    class Node
+      NAMESPLIT = /^(?:(#{XMLTokens::NCNAME_STR}):)?(#{XMLTokens::NCNAME_STR})/u
+      PARENTS = [ :element, :document, :doctype ]
+      # Create a new element.
+      def initialize node=nil
+        @node = node
+        if node.kind_of? String
+          node = [ :text, node ]
+        elsif node.nil?
+          node = [ :document, nil, nil ]
+        elsif node[0] == :start_element
+          node[0] = :element
+        elsif node[0] == :start_doctype
+          node[0] = :doctype
+        elsif node[0] == :start_document
+          node[0] = :document
+        end
+      end
+
+      def size
+        if PARENTS.include? @node[0]
+          @node[-1].size
+        else
+          0
+        end
+      end
+
+      def each
+        size.times { |x| yield( at(x+4) ) }
+      end
+
+      def name
+        at(2)
+      end
+
+      def name=( name_str, ns=nil )
+        pfx = ''
+        pfx = "#{prefix(ns)}:" if ns
+        _old_put(2, "#{pfx}#{name_str}")
+      end
+
+      def parent=( node )
+        _old_put(1,node)
+      end
+
+      def local_name
+        namesplit
+        @name
+      end
+
+      def local_name=( name_str )
+        _old_put( 1, "#@prefix:#{name_str}" )
+      end
+
+      def prefix( namespace=nil )
+        prefix_of( self, namespace )
+      end
+
+      def namespace( prefix=prefix() )
+        namespace_of( self, prefix )
+      end
+
+      def namespace=( namespace )
+        @prefix = prefix( namespace )
+        pfx = ''
+        pfx = "#@prefix:" if @prefix.size > 0
+        _old_put(1, "#{pfx}#@name")
+      end
+
+      def []( reference, ns=nil )
+        if reference.kind_of? String
+          pfx = ''
+          pfx = "#{prefix(ns)}:" if ns
+          at(3)["#{pfx}#{reference}"]
+        elsif reference.kind_of? Range
+          _old_get( Range.new(4+reference.begin, reference.end, reference.exclude_end?) )
+        else
+          _old_get( 4+reference )
+        end
+      end
+
+      def =~( path )
+        XPath.match( self, path )
+      end
+
+      # Doesn't handle namespaces yet
+      def []=( reference, ns, value=nil )
+        if reference.kind_of? String
+          value = ns unless value
+          at( 3 )[reference] = value
+        elsif reference.kind_of? Range
+          _old_put( Range.new(3+reference.begin, reference.end, reference.exclude_end?), ns )
+        else
+          if value
+            _old_put( 4+reference, ns, value )
+          else
+            _old_put( 4+reference, ns )
+          end
+        end
+      end
+
+      # Append a child to this element, optionally under a provided namespace.
+      # The namespace argument is ignored if the element argument is an Element
+      # object.  Otherwise, the element argument is a string, the namespace (if
+      # provided) is the namespace the element is created in.
+      def << element
+        if node_type() == :text
+          at(-1) << element
+        else
+          newnode = Node.new( element )
+          newnode.parent = self
+          self.push( newnode )
+        end
+        at(-1)
+      end
+
+      def node_type
+        _old_get(0)
+      end
+
+      def text=( foo )
+        replace = at(4).kind_of?(String)? 1 : 0
+        self._old_put(4,replace, normalizefoo)
+      end
+
+      def root
+        context = self
+        context = context.at(1) while context.at(1)
+      end
+
+      def has_name?( name, namespace = '' )
+        at(3) == name and namespace() == namespace
+      end
+
+      def children
+        self
+      end
+
+      def parent
+        at(1)
+      end
+
+      def to_s
+
+      end
+
+      private
+
+      def namesplit
+        return if @name.defined?
+        at(2) =~ NAMESPLIT
+        @prefix = '' || $1
+        @name = $2
+      end
+
+      def namespace_of( node, prefix=nil )
+        if not prefix
+          name = at(2)
+          name =~ NAMESPLIT
+          prefix = $1
+        end
+        to_find = 'xmlns'
+        to_find = "xmlns:#{prefix}" if not prefix.nil?
+        ns = at(3)[ to_find ]
+        ns ? ns : namespace_of( @node[0], prefix )
+      end
+
+      def prefix_of( node, namespace=nil )
+        if not namespace
+          name = node.name
+          name =~ NAMESPLIT
+          $1
+        else
+          ns = at(3).find { |k,v| v == namespace }
+          ns ? ns : prefix_of( node.parent, namespace )
+        end
+      end
+    end
+  end
 end