rubysl-rexml 1.0.0 → 2.0.1

data/lib/rexml/rexml.rb

@@ -5,27 +5,26 @@
 # non-validating[http://www.w3.org/TR/2004/REC-xml-20040204/#sec-conformance]
 # toolkit with an intuitive API.  REXML passes 100% of the non-validating Oasis
 # tests[http://www.oasis-open.org/committees/xml-conformance/xml-test-suite.shtml],
-# and provides tree, stream, SAX2, pull, and lightweight APIs.  REXML also 
-# includes a full XPath[http://www.w3c.org/tr/xpath] 1.0 implementation. Since 
+# and provides tree, stream, SAX2, pull, and lightweight APIs.  REXML also
+# includes a full XPath[http://www.w3c.org/tr/xpath] 1.0 implementation. Since
 # Ruby 1.8, REXML is included in the standard Ruby distribution.
 #
 # Main page:: http://www.germane-software.com/software/rexml
 # Author:: Sean Russell <serATgermaneHYPHENsoftwareDOTcom>
-# Version:: 3.1.7.2
-# Date:: 2007/275
-# Revision:: $Revision$
-# 
+# Date:: 2008/019
+# Version:: 3.1.7.3
+#
 # This API documentation can be downloaded from the REXML home page, or can
 # be accessed online[http://www.germane-software.com/software/rexml_doc]
 #
 # A tutorial is available in the REXML distribution in docs/tutorial.html,
-# or can be accessed 
+# or can be accessed
 # online[http://www.germane-software.com/software/rexml/docs/tutorial.html]
 module REXML
-  COPYRIGHT = "Copyright \xC2\xA9 2001-2006 Sean Russell <ser@germane-software.com>"
+  COPYRIGHT = "Copyright © 2001-2008 Sean Russell <ser@germane-software.com>"
+  DATE = "2008/019"
   VERSION = "3.1.7.3"
-  DATE = "2007/275"
-  REVISION = "$Revision$".gsub(/\$Revision:|\$/,'').strip
+  REVISION = %w$Revision: 39528 $[1] || ''
 
   Copyright = COPYRIGHT
   Version = VERSION

data/lib/rexml/sax2listener.rb

@@ -1,97 +1,97 @@
 module REXML
-	# A template for stream parser listeners.
-	# Note that the declarations (attlistdecl, elementdecl, etc) are trivially
-	# processed; REXML doesn't yet handle doctype entity declarations, so you 
-	# have to parse them out yourself.
-	# === Missing methods from SAX2
-	#  ignorable_whitespace
-	# === Methods extending SAX2 
-	# +WARNING+
-	# These methods are certainly going to change, until DTDs are fully
-	# supported.  Be aware of this.
-	#  start_document
-	#  end_document
-	#  doctype
-	#  elementdecl
-	#  attlistdecl
-	#  entitydecl
-	#  notationdecl
-	#  cdata
-	#  xmldecl
-	#  comment
-	module SAX2Listener
-		def start_document
-		end
-		def end_document
-		end
-		def start_prefix_mapping prefix, uri
-		end
-		def end_prefix_mapping prefix
-		end
-		def start_element uri, localname, qname, attributes
-		end
-		def end_element uri, localname, qname
-		end
-		def characters text
-		end
-		def processing_instruction target, data
-		end
-		# Handles a doctype declaration. Any attributes of the doctype which are
-		# not supplied will be nil.  # EG, <!DOCTYPE me PUBLIC "foo" "bar">
-		# @p name the name of the doctype; EG, "me"
-		# @p pub_sys "PUBLIC", "SYSTEM", or nil.  EG, "PUBLIC"
-		# @p long_name the supplied long name, or nil.  EG, "foo"
-		# @p uri the uri of the doctype, or nil.  EG, "bar"
-		def doctype name, pub_sys, long_name, uri
-		end
-		# If a doctype includes an ATTLIST declaration, it will cause this
-		# method to be called.  The content is the declaration itself, unparsed.
-		# EG, <!ATTLIST el attr CDATA #REQUIRED> will come to this method as "el
-		# attr CDATA #REQUIRED".  This is the same for all of the .*decl
-		# methods.
-		def attlistdecl(element, pairs, contents)
-		end
-		# <!ELEMENT ...>
-		def elementdecl content
-		end
-		# <!ENTITY ...>
-		# The argument passed to this method is an array of the entity
-		# declaration.  It can be in a number of formats, but in general it
-		# returns (example, result):
-		#  <!ENTITY % YN '"Yes"'>  
-		#  ["%", "YN", "'\"Yes\"'", "\""]
-		#  <!ENTITY % YN 'Yes'>
-		#  ["%", "YN", "'Yes'", "s"]
-		#  <!ENTITY WhatHeSaid "He said %YN;">
-		#  ["WhatHeSaid", "\"He said %YN;\"", "YN"]
-		#  <!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
-		#  ["open-hatch", "SYSTEM", "\"http://www.textuality.com/boilerplate/OpenHatch.xml\""]
-		#  <!ENTITY open-hatch PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN" "http://www.textuality.com/boilerplate/OpenHatch.xml">
-		#  ["open-hatch", "PUBLIC", "\"-//Textuality//TEXT Standard open-hatch boilerplate//EN\"", "\"http://www.textuality.com/boilerplate/OpenHatch.xml\""]
-		#  <!ENTITY hatch-pic SYSTEM "../grafix/OpenHatch.gif" NDATA gif>
-		#  ["hatch-pic", "SYSTEM", "\"../grafix/OpenHatch.gif\"", "\n\t\t\t\t\t\t\tNDATA gif", "gif"]
-		def entitydecl name, decl
-		end
-		# <!NOTATION ...>
-		def notationdecl content
-		end
-		# Called when <![CDATA[ ... ]]> is encountered in a document.
-		# @p content "..."
-		def cdata content
-		end
-		# Called when an XML PI is encountered in the document.
-		# EG: <?xml version="1.0" encoding="utf"?>
-		# @p version the version attribute value.  EG, "1.0"
-		# @p encoding the encoding attribute value, or nil.  EG, "utf"
-		# @p standalone the standalone attribute value, or nil.  EG, nil
+  # A template for stream parser listeners.
+  # Note that the declarations (attlistdecl, elementdecl, etc) are trivially
+  # processed; REXML doesn't yet handle doctype entity declarations, so you
+  # have to parse them out yourself.
+  # === Missing methods from SAX2
+  #  ignorable_whitespace
+  # === Methods extending SAX2
+  # +WARNING+
+  # These methods are certainly going to change, until DTDs are fully
+  # supported.  Be aware of this.
+  #  start_document
+  #  end_document
+  #  doctype
+  #  elementdecl
+  #  attlistdecl
+  #  entitydecl
+  #  notationdecl
+  #  cdata
+  #  xmldecl
+  #  comment
+  module SAX2Listener
+    def start_document
+    end
+    def end_document
+    end
+    def start_prefix_mapping prefix, uri
+    end
+    def end_prefix_mapping prefix
+    end
+    def start_element uri, localname, qname, attributes
+    end
+    def end_element uri, localname, qname
+    end
+    def characters text
+    end
+    def processing_instruction target, data
+    end
+    # Handles a doctype declaration. Any attributes of the doctype which are
+    # not supplied will be nil.  # EG, <!DOCTYPE me PUBLIC "foo" "bar">
+    # @p name the name of the doctype; EG, "me"
+    # @p pub_sys "PUBLIC", "SYSTEM", or nil.  EG, "PUBLIC"
+    # @p long_name the supplied long name, or nil.  EG, "foo"
+    # @p uri the uri of the doctype, or nil.  EG, "bar"
+    def doctype name, pub_sys, long_name, uri
+    end
+    # If a doctype includes an ATTLIST declaration, it will cause this
+    # method to be called.  The content is the declaration itself, unparsed.
+    # EG, <!ATTLIST el attr CDATA #REQUIRED> will come to this method as "el
+    # attr CDATA #REQUIRED".  This is the same for all of the .*decl
+    # methods.
+    def attlistdecl(element, pairs, contents)
+    end
+    # <!ELEMENT ...>
+    def elementdecl content
+    end
+    # <!ENTITY ...>
+    # The argument passed to this method is an array of the entity
+    # declaration.  It can be in a number of formats, but in general it
+    # returns (example, result):
+    #  <!ENTITY % YN '"Yes"'>
+    #  ["%", "YN", "\"Yes\""]
+    #  <!ENTITY % YN 'Yes'>
+    #  ["%", "YN", "Yes"]
+    #  <!ENTITY WhatHeSaid "He said %YN;">
+    #  ["WhatHeSaid", "He said %YN;"]
+    #  <!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
+    #  ["open-hatch", "SYSTEM", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+    #  <!ENTITY open-hatch PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN" "http://www.textuality.com/boilerplate/OpenHatch.xml">
+    # ["open-hatch", "PUBLIC", "-//Textuality//TEXT Standard open-hatch boilerplate//EN", "http://www.textuality.com/boilerplate/OpenHatch.xml"]
+    #  <!ENTITY hatch-pic SYSTEM "../grafix/OpenHatch.gif" NDATA gif>
+    #  ["hatch-pic", "SYSTEM", "../grafix/OpenHatch.gif", "NDATA", "gif"]
+    def entitydecl declaration
+    end
+    # <!NOTATION ...>
+    def notationdecl name, public_or_system, public_id, system_id
+    end
+    # Called when <![CDATA[ ... ]]> is encountered in a document.
+    # @p content "..."
+    def cdata content
+    end
+    # Called when an XML PI is encountered in the document.
+    # EG: <?xml version="1.0" encoding="utf"?>
+    # @p version the version attribute value.  EG, "1.0"
+    # @p encoding the encoding attribute value, or nil.  EG, "utf"
+    # @p standalone the standalone attribute value, or nil.  EG, nil
     # @p spaced the declaration is followed by a line break
-		def xmldecl version, encoding, standalone
-		end
-		# Called when a comment is encountered.
-		# @p comment The content of the comment
-		def comment comment
-		end
+    def xmldecl version, encoding, standalone
+    end
+    # Called when a comment is encountered.
+    # @p comment The content of the comment
+    def comment comment
+    end
     def progress position
     end
-	end	
+  end
 end

data/lib/rexml/security.rb

@@ -0,0 +1,27 @@
+module REXML
+  module Security
+    @@entity_expansion_limit = 10_000
+
+    # Set the entity expansion limit. By default the limit is set to 10000.
+    def self.entity_expansion_limit=( val )
+      @@entity_expansion_limit = val
+    end
+
+    # Get the entity expansion limit. By default the limit is set to 10000.
+    def self.entity_expansion_limit
+      return @@entity_expansion_limit
+    end
+
+    @@entity_expansion_text_limit = 10_240
+
+    # Set the entity expansion limit. By default the limit is set to 10240.
+    def self.entity_expansion_text_limit=( val )
+      @@entity_expansion_text_limit = val
+    end
+
+    # Get the entity expansion limit. By default the limit is set to 10240.
+    def self.entity_expansion_text_limit
+      return @@entity_expansion_text_limit
+    end
+  end
+end

data/lib/rexml/source.rb

@@ -1,3 +1,4 @@
+# coding: US-ASCII
 require 'rexml/encoding'
 
 module REXML
@@ -7,13 +8,14 @@ module REXML
     # @param arg Either a String, or an IO
     # @return a Source, or nil if a bad argument was given
     def SourceFactory::create_from(arg)
-      if arg.kind_of? String
-        Source.new(arg)
-      elsif arg.respond_to? :read and
-            arg.respond_to? :readline and
-            arg.respond_to? :nil? and
-            arg.respond_to? :eof?
+      if arg.respond_to? :read and
+          arg.respond_to? :readline and
+          arg.respond_to? :nil? and
+          arg.respond_to? :eof?
         IOSource.new(arg)
+      elsif arg.respond_to? :to_str
+        require 'stringio'
+        IOSource.new(StringIO.new(arg))
       elsif arg.kind_of? Source
         arg
       else
@@ -42,7 +44,7 @@ module REXML
       if encoding
         self.encoding = encoding
       else
-        self.encoding = check_encoding( @buffer )
+        detect_encoding
       end
       @line = 0
     end
@@ -52,22 +54,16 @@ module REXML
     # Overridden to support optimized en/decoding
     def encoding=(enc)
       return unless super
-      @line_break = encode( '>' )
-      if enc != UTF_8
-        @buffer = decode(@buffer)
-        @to_utf = true
-      else
-        @to_utf = false
-      end
+      encoding_updated
     end
 
     # Scans the source for a given pattern.  Note, that this is not your
     # usual scan() method.  For one thing, the pattern argument has some
     # requirements; for another, the source can be consumed.  You can easily
     # confuse this method.  Originally, the patterns were easier
-    # to construct and this method more robust, because this method 
-    # generated search regexes on the fly; however, this was 
-    # computationally expensive and slowed down the entire REXML package 
+    # to construct and this method more robust, because this method
+    # generated search regexes on the fly; however, this was
+    # computationally expensive and slowed down the entire REXML package
     # considerably, since this is by far the most commonly called method.
     # @param pattern must be a Regexp, and must be in the form of
     # /^\s*(#{your pattern, with no groups})(.*)/.  The first group
@@ -123,6 +119,38 @@ module REXML
       res = res[-1] if res.kind_of? Array
       lines.index( res ) if res
     end
+
+    private
+    def detect_encoding
+      buffer_encoding = @buffer.encoding
+      detected_encoding = "UTF-8"
+      begin
+        @buffer.force_encoding("ASCII-8BIT")
+        if @buffer[0, 2] == "\xfe\xff"
+          @buffer[0, 2] = ""
+          detected_encoding = "UTF-16BE"
+        elsif @buffer[0, 2] == "\xff\xfe"
+          @buffer[0, 2] = ""
+          detected_encoding = "UTF-16LE"
+        elsif @buffer[0, 3] == "\xef\xbb\xbf"
+          @buffer[0, 3] = ""
+          detected_encoding = "UTF-8"
+        end
+      ensure
+        @buffer.force_encoding(buffer_encoding)
+      end
+      self.encoding = detected_encoding
+    end
+
+    def encoding_updated
+      if @encoding != 'UTF-8'
+        @buffer = decode(@buffer)
+        @to_utf = true
+      else
+        @to_utf = false
+        @buffer.force_encoding ::Encoding::UTF_8
+      end
+    end
   end
 
   # A Source that wraps an IO.  See the Source class for method
@@ -134,30 +162,22 @@ module REXML
     def initialize(arg, block_size=500, encoding=nil)
       @er_source = @source = arg
       @to_utf = false
+      @pending_buffer = nil
 
-      # Determining the encoding is a deceptively difficult issue to resolve.
-      # First, we check the first two bytes for UTF-16.  Then we
-      # assume that the encoding is at least ASCII enough for the '>', and
-      # we read until we get one of those.  This gives us the XML declaration,
-      # if there is one.  If there isn't one, the file MUST be UTF-8, as per
-      # the XML spec.  If there is one, we can determine the encoding from
-      # it.
-      @buffer = ""
-      str = @source.read( 2 )
       if encoding
-        self.encoding = encoding
-      elsif 0xfe == str[0] && 0xff == str[1]
-        @line_break = "\000>"
-      elsif 0xff == str[0] && 0xfe == str[1]
-        @line_break = ">\000"
-      elsif 0xef == str[0] && 0xbb == str[1]
-        str += @source.read(1)
-        str = '' if (0xbf == str[2])
-        @line_break = ">"
+        super("", encoding)
+      else
+        super(@source.read(3) || "")
+      end
+
+      if !@to_utf and
+          @buffer.respond_to?(:force_encoding) and
+          @source.respond_to?(:external_encoding) and
+          @source.external_encoding != ::Encoding::UTF_8
+        @force_utf8 = true
       else
-        @line_break = ">"
+        @force_utf8 = false
       end
-      super str+@source.readline( @line_break )
     end
 
     def scan(pattern, cons=false)
@@ -170,11 +190,7 @@ module REXML
       if rv.size == 0
         until @buffer =~ pattern or @source.nil?
           begin
-            # READLINE OPT
-            #str = @source.read(@block_size)
-            str = @source.readline(@line_break)
-            str = decode(str) if @to_utf and str
-            @buffer << str
+            @buffer << readline
           rescue Iconv::IllegalSequence
             raise
           rescue
@@ -189,9 +205,7 @@ module REXML
 
     def read
       begin
-        str = @source.readline(@line_break)
-        str = decode(str) if @to_utf and str 
-        @buffer << str
+        @buffer << readline
       rescue Exception, NameError
         @source = nil
       end
@@ -206,9 +220,7 @@ module REXML
       @buffer = $' if cons and rv
       while !rv and @source
         begin
-          str = @source.readline(@line_break)
-          str = decode(str) if @to_utf and str
-          @buffer << str
+          @buffer << readline
           rv = pattern.match(@buffer)
           @buffer = $' if cons and rv
         rescue
@@ -218,13 +230,13 @@ module REXML
       rv.taint
       rv
     end
-    
+
     def empty?
       super and ( @source.nil? || @source.eof? )
     end
 
     def position
-      @er_source.stat.pipe? ? 0 : @er_source.pos
+      @er_source.pos rescue 0
     end
 
     # @return the current line in the source
@@ -247,5 +259,38 @@ module REXML
       end
       [pos, lineno, line]
     end
+
+    private
+    def readline
+      str = @source.readline(@line_break)
+      if @pending_buffer
+        if str.nil?
+          str = @pending_buffer
+        else
+          str = @pending_buffer + str
+        end
+        @pending_buffer = nil
+      end
+      return nil if str.nil?
+
+      if @to_utf
+        decode(str)
+      else
+        str.force_encoding(::Encoding::UTF_8) if @force_utf8
+        str
+      end
+    end
+
+    def encoding_updated
+      case @encoding
+      when "UTF-16BE", "UTF-16LE"
+        @source.binmode
+        @source.set_encoding(@encoding)
+      end
+      @line_break = encode(">")
+      @pending_buffer, @buffer = @buffer, ""
+      @pending_buffer.force_encoding(@encoding)
+      super
+    end
   end
 end