rubysl-rexml 1.0.0

data/lib/rexml/light/node.rb

@@ -0,0 +1,196 @@
+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>
+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
+end

data/lib/rexml/namespace.rb

@@ -0,0 +1,47 @@
+require 'rexml/xmltokens'
+
+module REXML
+	# Adds named attributes to an object.
+	module Namespace
+		# The name of the object, valid if set
+		attr_reader :name, :expanded_name
+		# The expanded name of the object, valid if name is set
+		attr_accessor :prefix
+		include XMLTokens
+		NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
+
+		# Sets the name and the expanded name
+		def name=( name )
+			@expanded_name = name
+			name =~ NAMESPLIT
+			if $1
+				@prefix = $1
+			else
+				@prefix = ""
+				@namespace = ""
+			end
+			@name = $2
+		end
+
+		# Compares names optionally WITH namespaces
+		def has_name?( other, ns=nil )
+			if ns
+				return (namespace() == ns and name() == other)
+			elsif other.include? ":"
+				return fully_expanded_name == other
+			else
+				return name == other
+			end
+		end
+
+		alias :local_name :name
+
+		# Fully expand the name, even if the prefix wasn't specified in the
+		# source file.
+		def fully_expanded_name
+			ns = prefix
+			return "#{ns}:#@name" if ns.size > 0 
+			return @name
+		end
+	end
+end

data/lib/rexml/node.rb

@@ -0,0 +1,75 @@
+require "rexml/parseexception"
+require "rexml/formatters/pretty"
+require "rexml/formatters/default"
+
+module REXML
+	# Represents a node in the tree.  Nodes are never encountered except as
+	# superclasses of other objects.  Nodes have siblings.
+	module Node
+		# @return the next sibling (nil if unset)
+		def next_sibling_node
+			return nil if @parent.nil?
+			@parent[ @parent.index(self) + 1 ]
+		end
+
+		# @return the previous sibling (nil if unset)
+		def previous_sibling_node
+			return nil if @parent.nil?
+			ind = @parent.index(self)
+			return nil if ind == 0
+			@parent[ ind - 1 ]
+		end
+
+    # indent::
+    #   *DEPRECATED* This parameter is now ignored.  See the formatters in the
+    #   REXML::Formatters package for changing the output style.
+		def to_s indent=nil
+      unless indent.nil?
+        Kernel.warn( "#{self.class.name}.to_s(indent) parameter is deprecated" )
+        f = REXML::Formatters::Pretty.new( indent )
+        f.write( self, rv = "" )
+      else
+        f = REXML::Formatters::Default.new
+        f.write( self, rv = "" )
+      end
+      return rv
+		end
+
+		def indent to, ind
+ 			if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
+ 				indentstyle = @parent.context[:indentstyle]
+ 			else
+ 				indentstyle = '  '
+ 			end
+ 			to << indentstyle*ind unless ind<1
+		end
+
+		def parent?
+			false;
+		end
+
+
+		# Visit all subnodes of +self+ recursively
+		def each_recursive(&block) # :yields: node
+			self.elements.each {|node|
+				block.call(node)
+				node.each_recursive(&block)
+			}
+		end
+
+		# Find (and return) first subnode (recursively) for which the block 
+    # evaluates to true. Returns +nil+ if none was found.
+		def find_first_recursive(&block) # :yields: node
+      each_recursive {|node|
+        return node if block.call(node)
+      }
+      return nil
+    end
+
+    # Returns the position that +self+ holds in its parent's array, indexed
+    # from 1.
+    def index_in_parent
+      parent.index(self)+1
+    end
+	end
+end

data/lib/rexml/output.rb

@@ -0,0 +1,24 @@
+require 'rexml/encoding'
+
+module REXML
+	class Output
+		include Encoding
+    
+    attr_reader :encoding
+
+		def initialize real_IO, encd="iso-8859-1"
+			@output = real_IO
+			self.encoding = encd
+
+			@to_utf = encd == UTF_8 ? false : true
+		end
+
+		def <<( content )
+			@output << (@to_utf ? self.encode(content) : content)
+		end
+
+    def to_s
+      "Output[#{encoding}]"
+    end
+	end
+end

data/lib/rexml/parent.rb

@@ -0,0 +1,166 @@
+require "rexml/child"
+
+module REXML
+  # A parent has children, and has methods for accessing them.  The Parent
+  # class is never encountered except as the superclass for some other
+  # object.
+  class Parent < Child
+    include Enumerable
+    
+    # Constructor
+    # @param parent if supplied, will be set as the parent of this object
+    def initialize parent=nil
+      super(parent)
+      @children = []
+    end
+    
+    def add( object )
+      #puts "PARENT GOTS #{size} CHILDREN"
+      object.parent = self
+      @children << object
+      #puts "PARENT NOW GOTS #{size} CHILDREN"
+      object
+    end
+    
+    alias :push :add
+    alias :<< :push
+    
+    def unshift( object )
+      object.parent = self
+      @children.unshift object
+    end
+    
+    def delete( object )
+      found = false
+      @children.delete_if {|c| c.equal?(object) and found = true }
+      object.parent = nil if found
+    end
+    
+    def each(&block)
+      @children.each(&block)
+    end
+    
+    def delete_if( &block )
+      @children.delete_if(&block)
+    end
+    
+    def delete_at( index )
+      @children.delete_at index
+    end
+    
+    def each_index( &block )
+      @children.each_index(&block)
+    end
+    
+    # Fetches a child at a given index
+    # @param index the Integer index of the child to fetch
+    def []( index )
+      @children[index]
+    end
+    
+    alias :each_child :each
+    
+    
+    
+    # Set an index entry.  See Array.[]=
+    # @param index the index of the element to set
+    # @param opt either the object to set, or an Integer length
+    # @param child if opt is an Integer, this is the child to set
+    # @return the parent (self)
+    def []=( *args )
+      args[-1].parent = self
+      @children[*args[0..-2]] = args[-1]
+    end
+    
+    # Inserts an child before another child
+    # @param child1 this is either an xpath or an Element.  If an Element,
+    # child2 will be inserted before child1 in the child list of the parent.
+    # If an xpath, child2 will be inserted before the first child to match
+    # the xpath.
+    # @param child2 the child to insert
+    # @return the parent (self)
+    def insert_before( child1, child2 )
+      if child1.kind_of? String
+        child1 = XPath.first( self, child1 )
+        child1.parent.insert_before child1, child2
+      else
+        ind = index(child1)
+        child2.parent.delete(child2) if child2.parent
+        @children[ind,0] = child2
+        child2.parent = self
+      end
+      self
+    end
+    
+    # Inserts an child after another child
+    # @param child1 this is either an xpath or an Element.  If an Element,
+    # child2 will be inserted after child1 in the child list of the parent.
+    # If an xpath, child2 will be inserted after the first child to match
+    # the xpath.
+    # @param child2 the child to insert
+    # @return the parent (self)
+    def insert_after( child1, child2 )
+      if child1.kind_of? String
+        child1 = XPath.first( self, child1 )
+        child1.parent.insert_after child1, child2
+      else
+        ind = index(child1)+1
+        child2.parent.delete(child2) if child2.parent
+        @children[ind,0] = child2
+        child2.parent = self
+      end
+      self
+    end
+    
+    def to_a
+      @children.dup
+    end
+    
+    # Fetches the index of a given child
+    # @param child the child to get the index of
+    # @return the index of the child, or nil if the object is not a child
+    # of this parent.
+    def index( child )
+      count = -1
+      @children.find { |i| count += 1 ; i.hash == child.hash }
+      count
+    end
+    
+    # @return the number of children of this parent
+    def size
+      @children.size
+    end
+    
+    alias :length :size
+    
+    # Replaces one child with another, making sure the nodelist is correct
+    # @param to_replace the child to replace (must be a Child)
+    # @param replacement the child to insert into the nodelist (must be a 
+    # Child)
+    def replace_child( to_replace, replacement )
+      @children.map! {|c| c.equal?( to_replace ) ? replacement : c }
+      to_replace.parent = nil
+      replacement.parent = self
+    end
+    
+    # Deeply clones this object.  This creates a complete duplicate of this
+    # Parent, including all descendants.
+    def deep_clone
+      cl = clone()
+      each do |child|
+        if child.kind_of? Parent
+          cl << child.deep_clone
+        else
+          cl << child.clone
+        end
+      end
+      cl
+    end
+    
+    alias :children :to_a
+    
+    def parent?
+      true
+    end
+  end
+end