rhodes 2.0.0.beta1 → 2.0.0.beta2

data/lib/extensions/rhoxml/rexml/encoding.rb

@@ -0,0 +1,71 @@
+# -*- mode: ruby; ruby-indent-level: 2; indent-tabs-mode: t; tab-width: 2 -*- vim: sw=2 ts=2
+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)
+        end
+      ensure
+        $VERBOSE = old_verbosity
+      end
+      true
+    end
+
+    def check_encoding str
+      # We have to recognize UTF-16, LSB UTF-16, and UTF-8
+      if str[0,2] == "\xfe\xff"
+        str[0,2] = ""
+        return UTF_16
+      elsif str[0,2] == "\xff\xfe"
+        str[0,2] = ""
+        return UNILE
+      end
+      str =~ /^\s*<\?xml\s+version\s*=\s*(['"]).*?\1\s+encoding\s*=\s*(["'])(.*?)\2/m
+      return $3.upcase if $3
+      return UTF_8
+    end
+  end
+end

data/lib/extensions/rhoxml/rexml/encodings/US-ASCII.rb

@@ -0,0 +1,30 @@
+module REXML
+  module Encoding
+    # Convert from UTF-8
+    def encode_ascii content
+      array_utf8 = content.unpack('U*')
+      array_enc = []
+      array_utf8.each do |num|
+        if num <= 0x7F
+          array_enc << num
+        else
+          # Numeric entity (&#nnnn;); shard by  Stefan Scholl
+          array_enc.concat "&\##{num};".unpack('C*')
+        end
+      end
+      array_enc.pack('C*')
+    end
+
+    # Convert to UTF-8
+    def decode_ascii(str)
+      str.unpack('C*').pack('U*')
+    end
+
+    register("US-ASCII") do |obj|
+      class << obj
+        alias decode decode_ascii
+        alias encode encode_ascii
+      end
+    end
+  end
+end

data/lib/extensions/rhoxml/rexml/encodings/UTF-16.rb

@@ -0,0 +1,35 @@
+module REXML
+  module Encoding
+    def encode_utf16 content
+      array_utf8 = content.unpack("U*")
+      array_enc = []
+      array_utf8.each do |num|
+        if ((num>>16) > 0)
+          array_enc << 0
+          array_enc << ??
+        else
+          array_enc << (num >> 8)
+          array_enc << (num & 0xFF)
+        end
+      end
+      array_enc.pack('C*')
+    end
+
+    def decode_utf16(str)
+      str = str[2..-1] if /^\376\377/n =~ str
+      array_enc=str.unpack('C*')
+      array_utf8 = []
+      0.step(array_enc.size-1, 2){|i| 
+        array_utf8 << (array_enc.at(i+1) + array_enc.at(i)*0x100)
+      }
+      array_utf8.pack('U*')
+    end
+
+    register(UTF_16) do |obj|
+      class << obj
+        alias decode decode_utf16
+        alias encode encode_utf16
+      end
+    end
+  end
+end

data/lib/extensions/rhoxml/rexml/encodings/UTF-8.rb

@@ -0,0 +1,18 @@
+module REXML
+  module Encoding
+    def encode_utf8 content
+      content
+    end
+
+    def decode_utf8(str)
+      str
+    end
+
+    register(UTF_8) do |obj|
+      class << obj
+        alias decode decode_utf8
+        alias encode encode_utf8
+      end
+    end
+  end
+end

data/lib/extensions/rhoxml/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/extensions/rhoxml/rexml/node.rb

@@ -0,0 +1,76 @@
+#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
+      self
+    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/extensions/rhoxml/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