rubysl-rexml 1.0.0 → 2.0.1

data/lib/rexml/encoding.rb

@@ -1,71 +1,50 @@
-# -*- mode: ruby; ruby-indent-level: 2; indent-tabs-mode: t; tab-width: 2 -*- vim: sw=2 ts=2
+# coding: US-ASCII
 module REXML
   module Encoding
-    @encoding_methods = {}
-    def self.register(enc, &block)
-      @encoding_methods[enc] = block
-    end
-    def self.apply(obj, enc)
-      @encoding_methods[enc][obj]
-    end
-    def self.encoding_method(enc)
-      @encoding_methods[enc]
-    end
-
-    # Native, default format is UTF-8, so it is declared here rather than in
-    # an encodings/ definition.
-    UTF_8 = 'UTF-8'
-    UTF_16 = 'UTF-16'
-    UNILE = 'UNILE'
-
     # ID ---> Encoding name
     attr_reader :encoding
-    def encoding=( enc )
-      old_verbosity = $VERBOSE
-      begin
-        $VERBOSE = false
-        enc = enc.nil? ? nil : enc.upcase
-        return false if defined? @encoding and enc == @encoding
-        if enc and enc != UTF_8
-          @encoding = enc
-          raise ArgumentError, "Bad encoding name #@encoding" unless @encoding =~ /^[\w-]+$/
-          @encoding.untaint 
-          begin
-            require 'rexml/encodings/ICONV.rb'
-            Encoding.apply(self, "ICONV")
-          rescue LoadError, Exception
-            begin
-              enc_file = File.join( "rexml", "encodings", "#@encoding.rb" )
-              require enc_file
-              Encoding.apply(self, @encoding)
-            rescue LoadError => err
-              puts err.message
-              raise ArgumentError, "No decoder found for encoding #@encoding.  Please install iconv."
-            end
-          end
-        else
-          @encoding = UTF_8
-          require 'rexml/encodings/UTF-8.rb'
-          Encoding.apply(self, @encoding)
+    def encoding=(encoding)
+      encoding = encoding.name if encoding.is_a?(Encoding)
+      if encoding.is_a?(String)
+        original_encoding = encoding
+        encoding = find_encoding(encoding)
+        unless encoding
+          raise ArgumentError, "Bad encoding name #{original_encoding}"
         end
-      ensure
-        $VERBOSE = old_verbosity
+      end
+      return false if defined?(@encoding) and encoding == @encoding
+      if encoding
+        @encoding = encoding.upcase
+      else
+        @encoding = 'UTF-8'
       end
       true
     end
 
-    def check_encoding str
-      # We have to recognize UTF-16, LSB UTF-16, and UTF-8
-      if str[0] == 0xfe && str[1] == 0xff
-        str[0,2] = ""
-        return UTF_16
-      elsif str[0] == 0xff && str[1] == 0xfe
-        str[0,2] = ""
-        return UNILE
+    def encode(string)
+      string.encode(@encoding)
+    end
+
+    def decode(string)
+      string.encode(::Encoding::UTF_8, @encoding)
+    end
+
+    private
+    def find_encoding(name)
+      case name
+      when /\Ashift-jis\z/i
+        return "SHIFT_JIS"
+      when /\ACP-(\d+)\z/
+        name = "CP#{$1}"
+      when /\AUTF-8\z/i
+        return name
+      end
+      begin
+        ::Encoding::Converter.search_convpath(name, 'UTF-8')
+      rescue ::Encoding::ConverterNotFoundError
+        return nil
       end
-      str =~ /^\s*<\?xml\s+version\s*=\s*(['"]).*?\1\s+encoding\s*=\s*(["'])(.*?)\2/um
-      return $3.upcase if $3
-      return UTF_8
+      name
     end
   end
 end

data/lib/rexml/entity.rb

@@ -3,164 +3,164 @@ require 'rexml/source'
 require 'rexml/xmltokens'
 
 module REXML
-	# God, I hate DTDs.  I really do.  Why this idiot standard still
-	# plagues us is beyond me.
-	class Entity < Child
-		include XMLTokens
-		PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
-		SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}
-		PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
-		EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
-		NDATADECL = "\\s+NDATA\\s+#{NAME}"
-		PEREFERENCE = "%#{NAME};"
-		ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
-		PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
-		ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
-		PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
-		GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
-		ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
+  # God, I hate DTDs.  I really do.  Why this idiot standard still
+  # plagues us is beyond me.
+  class Entity < Child
+    include XMLTokens
+    PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
+    SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}
+    PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
+    EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
+    NDATADECL = "\\s+NDATA\\s+#{NAME}"
+    PEREFERENCE = "%#{NAME};"
+    ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
+    PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
+    ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
+    PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
+    GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
+    ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
 
-		attr_reader :name, :external, :ref, :ndata, :pubid
+    attr_reader :name, :external, :ref, :ndata, :pubid
 
-		# Create a new entity.  Simple entities can be constructed by passing a
-		# name, value to the constructor; this creates a generic, plain entity
-		# reference. For anything more complicated, you have to pass a Source to
-		# the constructor with the entity definiton, or use the accessor methods.
-		# +WARNING+: There is no validation of entity state except when the entity
-		# is read from a stream.  If you start poking around with the accessors,
-		# you can easily create a non-conformant Entity.  The best thing to do is
-		# dump the stupid DTDs and use XMLSchema instead.
-		# 
-		#  e = Entity.new( 'amp', '&' )
-		def initialize stream, value=nil, parent=nil, reference=false
-			super(parent)
-			@ndata = @pubid = @value = @external = nil
-			if stream.kind_of? Array
-				@name = stream[1]
-				if stream[-1] == '%'
-					@reference = true 
-					stream.pop
-				else
-					@reference = false
-				end
-				if stream[2] =~ /SYSTEM|PUBLIC/
-					@external = stream[2]
-					if @external == 'SYSTEM'
-						@ref = stream[3]
-						@ndata = stream[4] if stream.size == 5
-					else
-						@pubid = stream[3]
-						@ref = stream[4]
-					end
-				else
-					@value = stream[2]
-				end
-			else
-				@reference = reference
-				@external = nil
-				@name = stream
-				@value = value
-			end
-		end
+    # Create a new entity.  Simple entities can be constructed by passing a
+    # name, value to the constructor; this creates a generic, plain entity
+    # reference. For anything more complicated, you have to pass a Source to
+    # the constructor with the entity definition, or use the accessor methods.
+    # +WARNING+: There is no validation of entity state except when the entity
+    # is read from a stream.  If you start poking around with the accessors,
+    # you can easily create a non-conformant Entity.  The best thing to do is
+    # dump the stupid DTDs and use XMLSchema instead.
+    #
+    #  e = Entity.new( 'amp', '&' )
+    def initialize stream, value=nil, parent=nil, reference=false
+      super(parent)
+      @ndata = @pubid = @value = @external = nil
+      if stream.kind_of? Array
+        @name = stream[1]
+        if stream[-1] == '%'
+          @reference = true
+          stream.pop
+        else
+          @reference = false
+        end
+        if stream[2] =~ /SYSTEM|PUBLIC/
+          @external = stream[2]
+          if @external == 'SYSTEM'
+            @ref = stream[3]
+            @ndata = stream[4] if stream.size == 5
+          else
+            @pubid = stream[3]
+            @ref = stream[4]
+          end
+        else
+          @value = stream[2]
+        end
+      else
+        @reference = reference
+        @external = nil
+        @name = stream
+        @value = value
+      end
+    end
 
-		# Evaluates whether the given string matchs an entity definition,
-		# returning true if so, and false otherwise.
-		def Entity::matches? string
-			(ENTITYDECL =~ string) == 0
-		end
+    # Evaluates whether the given string matchs an entity definition,
+    # returning true if so, and false otherwise.
+    def Entity::matches? string
+      (ENTITYDECL =~ string) == 0
+    end
 
-		# Evaluates to the unnormalized value of this entity; that is, replacing
-		# all entities -- both %ent; and &ent; entities.  This differs from
-		# +value()+ in that +value+ only replaces %ent; entities.
-		def unnormalized
-                        document.record_entity_expansion unless document.nil?
-			v = value()
-			return nil if v.nil?
-			@unnormalized = Text::unnormalize(v, parent)
-			@unnormalized
-		end
+    # Evaluates to the unnormalized value of this entity; that is, replacing
+    # all entities -- both %ent; and &ent; entities.  This differs from
+    # +value()+ in that +value+ only replaces %ent; entities.
+    def unnormalized
+      document.record_entity_expansion unless document.nil?
+      v = value()
+      return nil if v.nil?
+      @unnormalized = Text::unnormalize(v, parent)
+      @unnormalized
+    end
 
-		#once :unnormalized
+    #once :unnormalized
 
-		# Returns the value of this entity unprocessed -- raw.  This is the
-		# normalized value; that is, with all %ent; and &ent; entities intact
-		def normalized
-			@value
-		end
+    # Returns the value of this entity unprocessed -- raw.  This is the
+    # normalized value; that is, with all %ent; and &ent; entities intact
+    def normalized
+      @value
+    end
 
-		# Write out a fully formed, correct entity definition (assuming the Entity
-		# object itself is valid.)
+    # Write out a fully formed, correct entity definition (assuming the Entity
+    # object itself is valid.)
     #
     # out::
     #   An object implementing <TT>&lt;&lt;<TT> to which the entity will be
     #   output
     # indent::
     #   *DEPRECATED* and ignored
-		def write out, indent=-1
-			out << '<!ENTITY '
-			out << '% ' if @reference
-			out << @name
-			out << ' '
-			if @external
-				out << @external << ' '
-				if @pubid
-					q = @pubid.include?('"')?"'":'"'
-					out << q << @pubid << q << ' '
-				end
-				q = @ref.include?('"')?"'":'"'
-				out << q << @ref << q
-				out << ' NDATA ' << @ndata if @ndata
-			else
-				q = @value.include?('"')?"'":'"'
-				out << q << @value << q
-			end
-			out << '>'
-		end
+    def write out, indent=-1
+      out << '<!ENTITY '
+      out << '% ' if @reference
+      out << @name
+      out << ' '
+      if @external
+        out << @external << ' '
+        if @pubid
+          q = @pubid.include?('"')?"'":'"'
+          out << q << @pubid << q << ' '
+        end
+        q = @ref.include?('"')?"'":'"'
+        out << q << @ref << q
+        out << ' NDATA ' << @ndata if @ndata
+      else
+        q = @value.include?('"')?"'":'"'
+        out << q << @value << q
+      end
+      out << '>'
+    end
 
-		# Returns this entity as a string.  See write().
-		def to_s
-			rv = ''
-			write rv
-			rv
-		end
+    # Returns this entity as a string.  See write().
+    def to_s
+      rv = ''
+      write rv
+      rv
+    end
 
-		PEREFERENCE_RE = /#{PEREFERENCE}/um
-		# Returns the value of this entity.  At the moment, only internal entities
-		# are processed.  If the value contains internal references (IE,
-		# %blah;), those are replaced with their values.  IE, if the doctype
-		# contains:
-		#  <!ENTITY % foo "bar">
-		#  <!ENTITY yada "nanoo %foo; nanoo>
-		# then:
-		#  doctype.entity('yada').value   #-> "nanoo bar nanoo"
-		def value
-			if @value
-				matches = @value.scan(PEREFERENCE_RE)
-				rv = @value.clone
-				if @parent
-					matches.each do |entity_reference|
-						entity_value = @parent.entity( entity_reference[0] )
-						rv.gsub!( /%#{entity_reference};/um, entity_value )
-					end
-				end
-				return rv
-			end
-			nil
-		end
-	end
+    PEREFERENCE_RE = /#{PEREFERENCE}/um
+    # Returns the value of this entity.  At the moment, only internal entities
+    # are processed.  If the value contains internal references (IE,
+    # %blah;), those are replaced with their values.  IE, if the doctype
+    # contains:
+    #  <!ENTITY % foo "bar">
+    #  <!ENTITY yada "nanoo %foo; nanoo>
+    # then:
+    #  doctype.entity('yada').value   #-> "nanoo bar nanoo"
+    def value
+      if @value
+        matches = @value.scan(PEREFERENCE_RE)
+        rv = @value.clone
+        if @parent
+          matches.each do |entity_reference|
+            entity_value = @parent.entity( entity_reference[0] )
+            rv.gsub!( /%#{entity_reference.join};/um, entity_value )
+          end
+        end
+        return rv
+      end
+      nil
+    end
+  end
 
-	# This is a set of entity constants -- the ones defined in the XML
-	# specification.  These are +gt+, +lt+, +amp+, +quot+ and +apos+.
-	module EntityConst
-		# +>+
-		GT = Entity.new( 'gt', '>' )
-		# +<+
-		LT = Entity.new( 'lt', '<' )
-		# +&+
-		AMP = Entity.new( 'amp', '&' )
-		# +"+
-		QUOT = Entity.new( 'quot', '"' )
-		# +'+
-		APOS = Entity.new( 'apos', "'" )
-	end
+  # This is a set of entity constants -- the ones defined in the XML
+  # specification.  These are +gt+, +lt+, +amp+, +quot+ and +apos+.
+  module EntityConst
+    # +>+
+    GT = Entity.new( 'gt', '>' )
+    # +<+
+    LT = Entity.new( 'lt', '<' )
+    # +&+
+    AMP = Entity.new( 'amp', '&' )
+    # +"+
+    QUOT = Entity.new( 'quot', '"' )
+    # +'+
+    APOS = Entity.new( 'apos', "'" )
+  end
 end

data/lib/rexml/formatters/default.rb

@@ -21,8 +21,8 @@ module REXML
       def write( node, output )
         case node
 
-        when Document 
-          if node.xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+        when Document
+          if node.xml_decl.encoding != 'UTF-8' && !output.kind_of?(Output)
             output = Output.new( output, node.xml_decl.encoding )
           end
           write_document( node, output )
@@ -63,14 +63,16 @@ module REXML
       def write_element( node, output )
         output << "<#{node.expanded_name}"
 
-        node.attributes.each_attribute do |attr|
+        node.attributes.to_a.map { |a|
+          Hash === a ? a.values : a
+        }.flatten.sort_by {|attr| attr.name}.each do |attr|
           output << " "
           attr.write( output )
         end unless node.attributes.empty?
 
         if node.children.empty?
           output << " " if @ie_hack
-          output << "/" 
+          output << "/"
         else
           output << ">"
           node.children.each { |child|

data/lib/rexml/formatters/pretty.rb

@@ -24,13 +24,14 @@ module REXML
       #   is undefined.  Defaults to 2.
       # ie_hack::
       #   If true, the printer will insert whitespace before closing empty
-      #   tags, thereby allowing Internet Explorer's feeble XML parser to
+      #   tags, thereby allowing Internet Explorer's XML parser to
       #   function. Defaults to false.
       def initialize( indentation=2, ie_hack=false )
         @indentation = indentation
         @level = 0
         @ie_hack = ie_hack
         @width = 80
+        @compact = false
       end
 
       protected
@@ -47,7 +48,7 @@ module REXML
           if @ie_hack
             output << " "
           end
-          output << "/" 
+          output << "/"
         else
           output << ">"
           # If compact and all children are text, and if the formatted output
@@ -87,7 +88,7 @@ module REXML
         s = node.to_s()
         s.gsub!(/\s/,' ')
         s.squeeze!(" ")
-        s = wrap(s, 80-@level)
+        s = wrap(s, @width - @level)
         s = indent_text(s, @level, " ", true)
         output << (' '*@level + s)
       end
@@ -125,11 +126,13 @@ module REXML
       end
 
       def wrap(string, width)
-        # Recursively wrap string at width.
-        return string if string.length <= width
-        place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
-        return string if place.nil?
-        return string[0,place] + "\n" + wrap(string[place+1..-1], width)
+        parts = []
+        while string.length > width and place = string.rindex(' ', width)
+          parts << string[0...place]
+          string = string[place+1..-1]
+        end
+        parts << string
+        parts.join("\n")
       end
 
     end