From 11dbedfaad4a9a9521ece2198a8dc491678b1902 Mon Sep 17 00:00:00 2001
From: shyouhei <shyouhei@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Wed, 29 Aug 2007 04:06:12 +0000
Subject: add tag v1_8_6_5001

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_8_6_5001@13304 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 ruby_1_8_6/lib/rexml/source.rb | 247 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 247 insertions(+)
 create mode 100644 ruby_1_8_6/lib/rexml/source.rb

(limited to 'ruby_1_8_6/lib/rexml/source.rb')

diff --git a/ruby_1_8_6/lib/rexml/source.rb b/ruby_1_8_6/lib/rexml/source.rb
new file mode 100644
index 0000000000..ada876cde5
--- /dev/null
+++ b/ruby_1_8_6/lib/rexml/source.rb
@@ -0,0 +1,247 @@
+require 'rexml/encoding'
+
+module REXML
+  # Generates Source-s.  USE THIS CLASS.
+  class SourceFactory
+    # Generates a Source object
+    # @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?
+        IOSource.new(arg)
+      elsif arg.kind_of? Source
+        arg
+      else
+        raise "#{source.class} is not a valid input stream.  It must walk \n"+
+        "like either a String, IO, or Source."
+      end
+    end
+  end
+
+  # A Source can be searched for patterns, and wraps buffers and other
+  # objects and provides consumption of text
+  class Source
+    include Encoding
+    # The current buffer (what we're going to read next)
+    attr_reader :buffer
+    # The line number of the last consumed text
+    attr_reader :line
+    attr_reader :encoding
+
+    # Constructor
+    # @param arg must be a String, and should be a valid XML document
+    # @param encoding if non-null, sets the encoding of the source to this
+    # value, overriding all encoding detection
+    def initialize(arg, encoding=nil)
+      @orig = @buffer = arg
+      if encoding
+        self.encoding = encoding
+      else
+        self.encoding = check_encoding( @buffer )
+      end
+      @line = 0
+    end
+
+
+    # Inherited from Encoding
+    # 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
+    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 
+    # 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
+    # will be returned; the second group is used if the consume flag is
+    # set.
+    # @param consume if true, the pattern returned will be consumed, leaving
+    # everything after it in the Source.
+    # @return the pattern, if found, or nil if the Source is empty or the
+    # pattern is not found.
+    def scan(pattern, cons=false)
+      return nil if @buffer.nil?
+      rv = @buffer.scan(pattern)
+      @buffer = $' if cons and rv.size>0
+      rv
+    end
+
+    def read
+    end
+
+    def consume( pattern )
+      @buffer = $' if pattern.match( @buffer )
+    end
+
+    def match_to( char, pattern )
+      return pattern.match(@buffer)
+    end
+
+    def match_to_consume( char, pattern )
+      md = pattern.match(@buffer)
+      @buffer = $'
+      return md
+    end
+
+    def match(pattern, cons=false)
+      md = pattern.match(@buffer)
+      @buffer = $' if cons and md
+      return md
+    end
+
+    # @return true if the Source is exhausted
+    def empty?
+      @buffer == ""
+    end
+
+    def position
+      @orig.index( @buffer )
+    end
+
+    # @return the current line in the source
+    def current_line
+      lines = @orig.split
+      res = lines.grep @buffer[0..30]
+      res = res[-1] if res.kind_of? Array
+      lines.index( res ) if res
+    end
+  end
+
+  # A Source that wraps an IO.  See the Source class for method
+  # documentation
+  class IOSource < Source
+    #attr_reader :block_size
+
+    # block_size has been deprecated
+    def initialize(arg, block_size=500, encoding=nil)
+      @er_source = @source = arg
+      @to_utf = false
+      # 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 /\A(?:\xfe\xff|\xff\xfe)/n =~ str
+        self.encoding = check_encoding( str )
+      elsif (0xef == str[0] && 0xbb == str[1])
+        str += @source.read(1)
+        str = '' if (0xbf == str[2])
+      else
+        @line_break = '>'
+      end
+      super str+@source.readline( @line_break )
+    end
+
+    def scan(pattern, cons=false)
+      rv = super
+      # You'll notice that this next section is very similar to the same
+      # section in match(), but just a liiittle different.  This is
+      # because it is a touch faster to do it this way with scan()
+      # than the way match() does it; enough faster to warrent duplicating
+      # some code
+      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
+          rescue Iconv::IllegalSequence
+            raise
+          rescue
+            @source = nil
+          end
+        end
+        rv = super
+      end
+      rv.taint
+      rv
+    end
+
+    def read
+      begin
+        str = @source.readline(@line_break)
+        str = decode(str) if @to_utf and str 
+        @buffer << str
+      rescue Exception, NameError
+        @source = nil
+      end
+    end
+
+    def consume( pattern )
+      match( pattern, true )
+    end
+
+    def match( pattern, cons=false )
+      rv = pattern.match(@buffer)
+      @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
+          rv = pattern.match(@buffer)
+          @buffer = $' if cons and rv
+        rescue
+          @source = nil
+        end
+      end
+      rv.taint
+      rv
+    end
+    
+    def empty?
+      super and ( @source.nil? || @source.eof? )
+    end
+
+    def position
+      @er_source.stat.pipe? ? 0 : @er_source.pos
+    end
+
+    # @return the current line in the source
+    def current_line
+      begin
+        pos = @er_source.pos        # The byte position in the source
+        lineno = @er_source.lineno  # The XML < position in the source
+        @er_source.rewind
+        line = 0                    # The \r\n position in the source
+        begin
+          while @er_source.pos < pos
+            @er_source.readline
+            line += 1
+          end
+        rescue
+        end
+      rescue IOError
+        pos = -1
+        line = -1
+      end
+      [pos, lineno, line]
+    end
+  end
+end
-- 
cgit v1.2.3