rubysl-rexml 1.0.0

data/lib/rexml/comment.rb

@@ -0,0 +1,80 @@
+require "rexml/child"
+
+module REXML
+	##
+	# Represents an XML comment; that is, text between \<!-- ... -->
+	class Comment < Child
+		include Comparable
+		START = "<!--"
+		STOP = "-->"
+
+		# The content text
+
+		attr_accessor :string
+
+		##
+		# Constructor.  The first argument can be one of three types:
+		# @param first If String, the contents of this comment are set to the 
+		# argument.  If Comment, the argument is duplicated.  If
+		# Source, the argument is scanned for a comment.
+		# @param second If the first argument is a Source, this argument 
+		# should be nil, not supplied, or a Parent to be set as the parent 
+		# of this object
+		def initialize( first, second = nil )
+			#puts "IN COMMENT CONSTRUCTOR; SECOND IS #{second.type}"
+			super(second)
+			if first.kind_of? String
+				@string = first
+			elsif first.kind_of? Comment
+				@string = first.string
+			end
+		end
+
+		def clone
+			Comment.new self
+		end
+
+    # == DEPRECATED
+    # See REXML::Formatters
+    #
+		# output::
+		#	 Where to write the string
+		# indent::
+		#	 An integer.	If -1, no indenting will be used; otherwise, the
+		#	 indentation will be this number of spaces, and children will be
+		#	 indented an additional amount.
+		# transitive::
+		#	 Ignored by this class.	The contents of comments are never modified.
+		# ie_hack::
+		#	 Needed for conformity to the child API, but not used by this class.
+		def write( output, indent=-1, transitive=false, ie_hack=false )
+      Kernel.warn("Comment.write is deprecated.  See REXML::Formatters")
+			indent( output, indent )
+			output << START
+			output << @string
+			output << STOP
+		end
+
+		alias :to_s :string
+
+		##
+		# Compares this Comment to another; the contents of the comment are used
+		# in the comparison.
+		def <=>(other)
+			other.to_s <=> @string
+		end
+
+		##
+		# Compares this Comment to another; the contents of the comment are used
+		# in the comparison.
+		def ==( other )
+			other.kind_of? Comment and
+			(other <=> self) == 0
+		end
+
+    def node_type
+      :comment
+    end
+	end
+end
+#vim:ts=2 sw=2 noexpandtab:

data/lib/rexml/doctype.rb

@@ -0,0 +1,271 @@
+require "rexml/parent"
+require "rexml/parseexception"
+require "rexml/namespace"
+require 'rexml/entity'
+require 'rexml/attlistdecl'
+require 'rexml/xmltokens'
+
+module REXML
+  # Represents an XML DOCTYPE declaration; that is, the contents of <!DOCTYPE
+  # ... >.  DOCTYPES can be used to declare the DTD of a document, as well as
+  # being used to declare entities used in the document.
+  class DocType < Parent
+    include XMLTokens
+    START = "<!DOCTYPE"
+    STOP = ">"
+    SYSTEM = "SYSTEM"
+    PUBLIC = "PUBLIC"
+    DEFAULT_ENTITIES = { 
+      'gt'=>EntityConst::GT, 
+      'lt'=>EntityConst::LT, 
+      'quot'=>EntityConst::QUOT, 
+      "apos"=>EntityConst::APOS 
+    }
+
+    # name is the name of the doctype
+    # external_id is the referenced DTD, if given
+    attr_reader :name, :external_id, :entities, :namespaces
+
+    # Constructor
+    #
+    #   dt = DocType.new( 'foo', '-//I/Hate/External/IDs' )
+    #   # <!DOCTYPE foo '-//I/Hate/External/IDs'>
+    #   dt = DocType.new( doctype_to_clone )
+    #   # Incomplete.  Shallow clone of doctype
+    #
+    # +Note+ that the constructor: 
+    #
+    #  Doctype.new( Source.new( "<!DOCTYPE foo 'bar'>" ) )
+    #
+    # is _deprecated_.  Do not use it.  It will probably disappear.
+    def initialize( first, parent=nil )
+      @entities = DEFAULT_ENTITIES
+      @long_name = @uri = nil
+      if first.kind_of? String
+        super()
+        @name = first
+        @external_id = parent
+      elsif first.kind_of? DocType
+        super( parent )
+        @name = first.name
+        @external_id = first.external_id
+      elsif first.kind_of? Array
+        super( parent )
+        @name = first[0]
+        @external_id = first[1]
+        @long_name = first[2]
+        @uri = first[3]
+      elsif first.kind_of? Source
+        super( parent )
+        parser = Parsers::BaseParser.new( first )
+        event = parser.pull
+        if event[0] == :start_doctype
+          @name, @external_id, @long_name, @uri, = event[1..-1]
+        end
+      else
+        super()
+      end
+    end
+
+    def node_type
+      :doctype
+    end
+
+    def attributes_of element
+      rv = []
+      each do |child|
+        child.each do |key,val|
+          rv << Attribute.new(key,val)
+        end if child.kind_of? AttlistDecl and child.element_name == element
+      end
+      rv
+    end
+
+    def attribute_of element, attribute
+      att_decl = find do |child|
+        child.kind_of? AttlistDecl and
+        child.element_name == element and
+        child.include? attribute
+      end
+      return nil unless att_decl
+      att_decl[attribute]
+    end
+
+    def clone
+      DocType.new self
+    end
+
+    # output::
+    #   Where to write the string
+    # indent::
+    #   An integer.  If -1, no indentation will be used; otherwise, the
+    #   indentation will be this number of spaces, and children will be
+    #   indented an additional amount.
+    # transitive::
+    #   Ignored
+    # ie_hack::
+    #   Ignored
+    def write( output, indent=0, transitive=false, ie_hack=false )
+      f = REXML::Formatters::Default.new
+      indent( output, indent )
+      output << START
+      output << ' '
+      output << @name
+      output << " #@external_id" if @external_id
+      output << " #{@long_name.inspect}" if @long_name
+      output << " #{@uri.inspect}" if @uri
+      unless @children.empty?
+        next_indent = indent + 1
+        output << ' ['
+        child = nil    # speed
+        @children.each { |child|
+          output << "\n"
+          f.write( child, output )
+        }
+        output << "\n]"
+      end
+      output << STOP
+    end
+
+    def context
+      @parent.context
+    end
+
+    def entity( name )
+      @entities[name].unnormalized if @entities[name]
+    end
+
+    def add child
+      super(child)
+      @entities = DEFAULT_ENTITIES.clone if @entities == DEFAULT_ENTITIES
+      @entities[ child.name ] = child if child.kind_of? Entity
+    end
+    
+    # This method retrieves the public identifier identifying the document's 
+    # DTD.
+    #
+    # Method contributed by Henrik Martensson
+    def public
+      case @external_id
+      when "SYSTEM"
+        nil
+      when "PUBLIC"
+        strip_quotes(@long_name)
+      end
+    end
+    
+    # This method retrieves the system identifier identifying the document's DTD
+    #
+    # Method contributed by Henrik Martensson
+    def system
+      case @external_id
+      when "SYSTEM"
+        strip_quotes(@long_name)
+      when "PUBLIC"
+        @uri.kind_of?(String) ? strip_quotes(@uri) : nil
+      end
+    end
+    
+    # This method returns a list of notations that have been declared in the
+    # _internal_ DTD subset. Notations in the external DTD subset are not 
+    # listed.
+    #
+    # Method contributed by Henrik Martensson
+    def notations
+      children().select {|node| node.kind_of?(REXML::NotationDecl)}
+    end
+    
+    # Retrieves a named notation. Only notations declared in the internal
+    # DTD subset can be retrieved.
+    #
+    # Method contributed by Henrik Martensson
+    def notation(name)
+      notations.find { |notation_decl|
+        notation_decl.name == name
+      }
+    end
+    
+    private
+    
+    # Method contributed by Henrik Martensson
+    def strip_quotes(quoted_string)
+      quoted_string =~ /^[\'\"].*[\´\"]$/ ?
+        quoted_string[1, quoted_string.length-2] :
+        quoted_string
+    end
+  end
+
+  # We don't really handle any of these since we're not a validating
+  # parser, so we can be pretty dumb about them.  All we need to be able
+  # to do is spew them back out on a write()
+
+  # This is an abstract class.  You never use this directly; it serves as a
+  # parent class for the specific declarations.
+  class Declaration < Child
+    def initialize src
+      super()
+      @string = src
+    end
+
+    def to_s
+      @string+'>'
+    end
+
+    # == DEPRECATED
+    # See REXML::Formatters
+    #
+    def write( output, indent )
+      output << to_s
+    end
+  end
+  
+  public
+  class ElementDecl < Declaration
+    def initialize( src )
+      super
+    end
+  end
+
+  class ExternalEntity < Child
+    def initialize( src )
+      super()
+      @entity = src
+    end
+    def to_s
+      @entity
+    end
+    def write( output, indent )
+      output << @entity
+    end
+  end
+
+  class NotationDecl < Child
+    attr_accessor :public, :system
+    def initialize name, middle, pub, sys
+      super(nil)
+      @name = name
+      @middle = middle
+      @public = pub
+      @system = sys
+    end
+
+    def to_s
+      "<!NOTATION #@name #@middle#{
+        @public ? ' ' + public.inspect : '' 
+      }#{
+        @system ? ' ' +@system.inspect : ''
+      }>"
+    end
+
+    def write( output, indent=-1 )
+      output << to_s
+    end
+    
+    # This method retrieves the name of the notation.
+    #
+    # Method contributed by Henrik Martensson
+    def name
+      @name
+    end
+  end
+end

data/lib/rexml/document.rb

@@ -0,0 +1,230 @@
+require "rexml/element"
+require "rexml/xmldecl"
+require "rexml/source"
+require "rexml/comment"
+require "rexml/doctype"
+require "rexml/instruction"
+require "rexml/rexml"
+require "rexml/parseexception"
+require "rexml/output"
+require "rexml/parsers/baseparser"
+require "rexml/parsers/streamparser"
+require "rexml/parsers/treeparser"
+
+module REXML
+  # Represents a full XML document, including PIs, a doctype, etc.  A
+  # 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
+
+		# 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 = {} )
+      @entity_expansion_count = 0
+			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
+
+		# 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
+        child.parent = self
+			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.
+        insert_before_index = 0
+        @children.find { |x| 
+          insert_before_index += 1
+          x.kind_of?(Element) || x.kind_of?(DocType)
+        }
+        if @children[ insert_before_index ] # Not null = not end of list
+          if @children[ insert_before_index ].kind_of DocType
+            @children[ insert_before_index ] = child
+          else
+            @children[ index_before_index-1, 0 ] = child
+          end
+        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
+
+		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
+      elements[1]
+      #self
+      #@children.find { |item| item.kind_of? Element }
+		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 rv if rv.kind_of? XMLDecl
+      rv = @children.unshift(XMLDecl.default)[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
+
+    # Write the XML tree out, optionally with indent.  This writes out the
+    # entire XML document, including XML declarations, doctype declarations,
+    # and processing instructions (if any are given).
+    #
+    # A controversial point is whether Document should always write the XML
+    # declaration (<?xml version='1.0'?>) whether or not one is given by the
+    # user (or source document).  REXML does not write one if one was not
+    # specified, because it adds unnecessary bandwidth to applications such
+    # as XML-RPC.
+    #
+    # See also the classes in the rexml/formatters package for the proper way
+    # to change the default formatting of XML output
+    #
+    # _Examples_
+    #   Document.new("<a><b/></a>").serialize
+    #
+    #   output_string = ""
+    #   tr = Transitive.new( output_string )
+    #   Document.new("<a><b/></a>").serialize( tr )
+    #
+    # output::
+    #	  output an object which supports '<< string'; this is where the
+    #   document will be written.
+    # indent::
+    #   An integer.  If -1, no indenting will be used; otherwise, the
+    #   indentation will be twice this number of spaces, and children will be
+    #   indented an additional amount.  For a value of 3, every item will be 
+    #   indented 3 more levels, or 6 more spaces (2 * 3). Defaults to -1
+    # trans::
+    #   If transitive is true and indent is >= 0, then the output will be
+    #   pretty-printed in such a way that the added whitespace does not affect
+    #   the absolute *value* of the document -- that is, it leaves the value
+    #   and number of Text nodes in the document unchanged.
+    # ie_hack::
+    #   Internet Explorer is the worst piece of crap to have ever been
+    #   written, with the possible exception of Windows itself.  Since IE is
+    #   unable to parse proper XML, we have to provide a hack to generate XML
+    #   that IE's limited abilities can handle.  This hack inserts a space 
+    #   before the /> on empty tags.  Defaults to false
+		def write( output=$stdout, indent=-1, trans=false, ie_hack=false )
+      if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+        output = Output.new( output, xml_decl.encoding )
+      end
+      formatter = if indent > -1
+          if trans
+            REXML::Formatters::Transitive.new( indent, ie_hack )
+          else
+            REXML::Formatters::Pretty.new( indent, ie_hack )
+          end
+        else
+          REXML::Formatters::Default.new( ie_hack )
+        end
+      formatter.write( self, output )
+		end
+
+		
+		def Document::parse_stream( source, listener )
+			Parsers::StreamParser.new( source, listener ).parse
+		end
+
+    @@entity_expansion_limit = 10_000
+
+    # Set the entity expansion limit. By default the limit is set to 10000.
+    def Document::entity_expansion_limit=( val )
+      @@entity_expansion_limit = val
+    end
+
+    # Get the entity expansion limit. By default the limit is set to 10000.
+    def Document::entity_expansion_limit
+      return @@entity_expansion_limit
+    end
+
+    attr_reader :entity_expansion_count
+    
+    def record_entity_expansion
+      @entity_expansion_count += 1
+      if @entity_expansion_count > @@entity_expansion_limit
+        raise "number of entity expansions exceeded, processing aborted."
+      end
+    end
+
+		private
+		def build( source )
+      Parsers::TreeParser.new( source, self ).parse
+		end
+	end
+end