r4x 0.5.0

data/LICENSE

@@ -0,0 +1,168 @@
+.
+
+                 GNU LESSER GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+   Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+   Everyone is permitted to copy and distribute verbatim copies
+   of this license document, but changing it is not allowed.
+
+
+    This version of the GNU Lesser General Public License incorporates
+  the terms and conditions of version 3 of the GNU General Public
+  License, supplemented by the additional permissions listed below.
+
+    0. Additional Definitions. 
+
+    As used herein, "this License" refers to version 3 of the GNU Lesser
+  General Public License, and the "GNU GPL" refers to version 3 of the GNU
+  General Public License.
+
+    "The Library" refers to a covered work governed by this License,
+  other than an Application or a Combined Work as defined below.
+
+    An "Application" is any work that makes use of an interface provided
+  by the Library, but which is not otherwise based on the Library.
+  Defining a subclass of a class defined by the Library is deemed a mode
+  of using an interface provided by the Library.
+
+    A "Combined Work" is a work produced by combining or linking an
+  Application with the Library.  The particular version of the Library
+  with which the Combined Work was made is also called the "Linked
+  Version".
+
+    The "Minimal Corresponding Source" for a Combined Work means the
+  Corresponding Source for the Combined Work, excluding any source code
+  for portions of the Combined Work that, considered in isolation, are
+  based on the Application, and not on the Linked Version.
+
+    The "Corresponding Application Code" for a Combined Work means the
+  object code and/or source code for the Application, including any data
+  and utility programs needed for reproducing the Combined Work from the
+  Application, but excluding the System Libraries of the Combined Work.
+
+    1. Exception to Section 3 of the GNU GPL.
+
+    You may convey a covered work under sections 3 and 4 of this License
+  without being bound by section 3 of the GNU GPL.
+
+    2. Conveying Modified Versions.
+
+    If you modify a copy of the Library, and, in your modifications, a
+  facility refers to a function or data to be supplied by an Application
+  that uses the facility (other than as an argument passed when the
+  facility is invoked), then you may convey a copy of the modified
+  version:
+
+     a) under this License, provided that you make a good faith effort to
+     ensure that, in the event an Application does not supply the
+     function or data, the facility still operates, and performs
+     whatever part of its purpose remains meaningful, or
+
+     b) under the GNU GPL, with none of the additional permissions of
+     this License applicable to that copy.
+
+    3. Object Code Incorporating Material from Library Header Files.
+
+    The object code form of an Application may incorporate material from
+  a header file that is part of the Library.  You may convey such object
+  code under terms of your choice, provided that, if the incorporated
+  material is not limited to numerical parameters, data structure
+  layouts and accessors, or small macros, inline functions and templates
+  (ten or fewer lines in length), you do both of the following:
+
+     a) Give prominent notice with each copy of the object code that the
+     Library is used in it and that the Library and its use are
+     covered by this License.
+
+     b) Accompany the object code with a copy of the GNU GPL and this license
+     document.
+
+    4. Combined Works.
+
+    You may convey a Combined Work under terms of your choice that,
+  taken together, effectively do not restrict modification of the
+  portions of the Library contained in the Combined Work and reverse
+  engineering for debugging such modifications, if you also do each of
+  the following:
+
+     a) Give prominent notice with each copy of the Combined Work that
+     the Library is used in it and that the Library and its use are
+     covered by this License.
+
+     b) Accompany the Combined Work with a copy of the GNU GPL and this license
+     document.
+
+     c) For a Combined Work that displays copyright notices during
+     execution, include the copyright notice for the Library among
+     these notices, as well as a reference directing the user to the
+     copies of the GNU GPL and this license document.
+
+     d) Do one of the following:
+
+         0) Convey the Minimal Corresponding Source under the terms of this
+         License, and the Corresponding Application Code in a form
+         suitable for, and under terms that permit, the user to
+         recombine or relink the Application with a modified version of
+         the Linked Version to produce a modified Combined Work, in the
+         manner specified by section 6 of the GNU GPL for conveying
+         Corresponding Source.
+
+         1) Use a suitable shared library mechanism for linking with the
+         Library.  A suitable mechanism is one that (a) uses at run time
+         a copy of the Library already present on the user's computer
+         system, and (b) will operate properly with a modified version
+         of the Library that is interface-compatible with the Linked
+         Version. 
+
+     e) Provide Installation Information, but only if you would otherwise
+     be required to provide such information under section 6 of the
+     GNU GPL, and only to the extent that such information is
+     necessary to install and execute a modified version of the
+     Combined Work produced by recombining or relinking the
+     Application with a modified version of the Linked Version. (If
+     you use option 4d0, the Installation Information must accompany
+     the Minimal Corresponding Source and Corresponding Application
+     Code. If you use option 4d1, you must provide the Installation
+     Information in the manner specified by section 6 of the GNU GPL
+     for conveying Corresponding Source.)
+
+    5. Combined Libraries.
+
+    You may place library facilities that are a work based on the
+  Library side by side in a single library together with other library
+  facilities that are not Applications and are not covered by this
+  License, and convey such a combined library under terms of your
+  choice, if you do both of the following:
+
+     a) Accompany the combined library with a copy of the same work based
+     on the Library, uncombined with any other library facilities,
+     conveyed under the terms of this License.
+
+     b) Give prominent notice with the combined library that part of it
+     is a work based on the Library, and explaining where to find the
+     accompanying uncombined form of the same work.
+
+    6. Revised Versions of the GNU Lesser General Public License.
+
+    The Free Software Foundation may publish revised and/or new versions
+  of the GNU Lesser General Public License from time to time. Such new
+  versions will be similar in spirit to the present version, but may
+  differ in detail to address new problems or concerns.
+
+    Each version is given a distinguishing version number. If the
+  Library as you received it specifies that a certain numbered version
+  of the GNU Lesser General Public License "or any later version"
+  applies to it, you have the option of following the terms and
+  conditions either of that published version or of any later version
+  published by the Free Software Foundation. If the Library as you
+  received it does not specify a version number of the GNU Lesser
+  General Public License, you may choose any version of the GNU Lesser
+  General Public License ever published by the Free Software Foundation.
+
+    If the Library as you received it specifies that a proxy can decide
+  whether future versions of the GNU Lesser General Public License shall
+  apply, that proxy's public statement of acceptance of any version is
+  permanent authorization for you to choose that version for the
+  Library.
+

data/MANIFEST

@@ -0,0 +1,19 @@
+#!mast lib meta [A-Z]*
+lib
+lib/r4x
+lib/r4x/e4x.rb
+lib/r4x/emcascript.rb
+lib/r4x/qname.rb
+lib/r4x/xml_delegate.rb
+lib/r4x/xmllist_delegate.rb
+meta
+meta/abstract
+meta/authors
+meta/contact
+meta/package
+meta/project
+meta/repository
+meta/version
+LICENSE
+README
+HISTORY

data/README

@@ -0,0 +1,13 @@
+= R4X
+
+R4X is a pure-Ruby implementation of E4X.
+
+== STATUS
+
+This implementation follows the E4X specification to the letter.
+At thei point it is only about half complete.
+
+One difficulty with the implementation is that Ruby can not
+support the exact syntax E4X designates, so an alternative
+needs to be used --which has not yet been fully settled upon.
+

data/lib/r4x/e4x.rb

@@ -0,0 +1,330 @@
+
+# E4X (Lite)
+#
+# This is a E4X library making it easy to parse and manipulate XML documents.
+# It is not a compliant implementaion of E4X, but it is very close to being so
+# from the end-user's point-of-view.
+#
+# This library uses REXML as a backend. An option to use libxml may be added in
+# the future for speed.
+
+require 'rexml/document'
+require 'rexml/xpath'
+
+#require 'facet/object/deepcopy'
+require 'facet/string/shift'
+require 'facet/string/pop'
+
+require 'e4x/qname'
+require 'e4x/xml_delegate'
+require 'e4x/xmllist_delegate'
+
+
+def xml( xmldata )
+  Xml.new(xmldata)
+end
+
+class Xml
+
+  # This is used it identify strings that conform to canonical XML element text.
+  module XmlCanonical
+    module_function
+    def ===( str )
+      str = str.to_s.strip
+      #str[0,1] == '<' && str[-1,1] == '>'  # should make more robust (TODO)
+      md = (%r{\A \< (\w+) (.*?) \>}mix).match( str )
+      return false unless md #[2] =~ %r{xml:cdata=['"]\d+['"]}
+      ed = (%r{\< \/ #{md[1]} [ ]* \> \Z}mix).match(str)
+      return false unless ed
+      true
+    end
+  end
+
+
+  VALID_CLASSES = [ :element, :text, :comment, :instruction, :attribute ]
+
+  # These are for a special usage (non-standard XML); ignored for all standard purposes.
+  #VERB_INDICATOR = '|'
+  #VERB_REGEX = %r{ \< ([\w.:]+) (.*?) ([#{VERB_INDICATOR}]\d*) \> }mix
+
+  class << self
+    alias :__new :new
+    def new( xmldata, parent=nil )
+      case xmldata
+      when nil, ''
+        raise ArgumentError
+      when Xml, Symbol, XmlCanonical
+        __new( xmldata, parent )
+      when REXML::Element, REXML::Text, REXML::Attribute, REXML::Instruction
+        __new( xmldata, parent )
+      else
+        XmlList.new(xmldata, parent)
+      end
+    end
+  end
+
+  def initialize( xmldata, parent=nil )
+    @parent = parent
+    case xmldata
+    when Xml
+      @node = xmldata.__node.dup
+      @class = xmldata.__class.dup
+      @name = xmldata.__node.name.dup
+    when Symbol
+      #@node = REXML::Document.new( "<#{xmldata}></#{xmldata}>" ).root
+      #@node = REXML::Element.new( "<#{xmldata}></#{xmldata}>" ).root
+      @node = REXML::Element.new( xmldata )
+      @class = :element
+      @name = @node.name
+    when XmlCanonical
+      xmldata = xmldata.to_s
+      @node = REXML::Document.new( xmldata.strip ).root
+      #@node = REXML::Element.new( xmldata.strip )
+      @class = :element
+      @name = @node.name
+    when REXML::Element
+      @node = xmldata
+      @class = :element
+      @name = @node.name
+    when REXML::Text
+      @node = xmldata
+      @class = :text
+      @name = nil
+    when REXML::Attribute
+      @node = xmldata
+      @class = :attribute
+      @name = xmldata.name
+    when REXML::Instruction
+      @node = xmldata
+      @class = :instruction
+      @name = xmldata.target
+    else
+      raise ArgumentError, "invlaid xml"
+    end
+    @self ||= XmlDelegate.new(self)
+  end
+
+  # These are reserved tag names, i.e. they can't be used as xml tags
+  # and then accessed via the call syntax of E4X.
+  #
+  #   self
+  #   __node
+  #   __class
+  #   to_s
+  #   to_i
+  #   each
+  #
+
+  # This is how to access the underlying Xml object, i.e. via the delegate.
+  def self ; @self ; end
+
+  # This is how the delegate accesses the node.
+  def __node  ; @node ; end
+
+  # This is how the delegate accesses the node classification.
+  def __class ; @class ; end
+
+  # Important for this to work in string interpolation.
+  def to_s() @node.to_s ; end
+
+  # ?
+  def to_i() @node.to_s.to_i; end
+
+  # (neccessary?) FIX!!!
+  def each()
+    @node.each_child { |c| yield(c) }
+  end
+
+  # Shortcut for add.
+  def <<( n )
+    @self.add( n )
+  end
+
+  # XPath for all elements.
+  def * ; @self.get('*') ; end
+
+  # Shortcut for XPath '@*', meaning all attributes.
+  def _ ; @self.get('@*') ; end
+
+  # XPath get operator.
+  def []( key )
+    @self.get( key )
+  end
+
+  #XPath put operator.
+  def []=( key, val )
+    @self.put( key, val )
+  end
+
+  # Here's where all the fun's at!
+  # It's more complicated then it looks ;-)
+  def method_missing( sym, *args )
+    sym = sym.to_s
+    if sym.slice(-1) == '='
+      self["#{sym.pop}"] = args[0]
+    else
+      self["#{sym}"]
+    end
+  end
+
+end
+
+#
+# XmlList
+#
+class XmlList
+
+  class << self
+    alias_method( :__new, :new )
+    def new( xd=[], to=nil, tp=nil )
+      case xd
+      when XmlList
+        xd
+      else
+        __new( xd, to, tp )
+      end
+    end
+  end
+
+  def initialize( xd=[], to=nil, tp=nil )
+    @self = XmlListDelegate.new(self)
+    case xd
+    when []
+      @list = []
+      @target_object = to
+      @target_property = tp
+    when Xml
+      @list = [xd]
+      @target_object = xd.self.parent
+      @target_property = xd.self.name
+    else
+      xd = REXML::Document.new(%{<_>#{xd}</_>}).root
+      a = []; xd.each{ |n| a << Xml.new(n) }
+      @list = a
+      @target_object = nil
+      @target_property = nil
+    end
+  end
+
+  # This is how to access the underlying Xml object, i.e. via the delegate.
+  def self ; @self ; end
+
+  # This is how the delegate accesses the node.
+  def __list  ; @list ; end
+
+  # This is how the delegate accesses the node classification.
+  def __class ; :xmllist ; end
+
+  # This is how the delegate accesses the node classification.
+  def __target_object ; @target_object ; end
+  def __target_object=(to) ; @target_object = to ; end
+
+  # This is how the delegate accesses the node classification.
+  def __target_property ; @target_property ; end
+  def __target_property=(tp) ; @target_property = tp ; end
+
+  # Important for this to work in string interpolation.
+  def to_s() @list.to_s ; end
+
+  # ?
+  def to_i() @list.to_s.to_i; end
+
+  # each
+  def each(&blk) ; @list.each(&blk) ; end
+
+  # Shortcut for add.
+  def <<( n )
+    @self.add( n )
+  end
+
+  # XPath for all elements.
+  def * ; @self.get('*') ; end
+
+  # Shortcut for XPath '@*', meaning all attributes.
+  def _ ; @self.get('@*') ; end
+
+  def []( v )
+    @self.get( v )
+  end
+
+  def []=( prop, v )
+    @self.put( prop , v )
+  end
+
+  #
+  def method_missing( sym, *args )
+    sym = sym.to_s
+p sym
+    if (args.size > 0)
+      self[0].send( sym, args )
+    else
+      self[0].send( sym )
+    end
+  end
+
+end
+
+
+
+# test
+if $0 == __FILE__
+
+  XmlList.new('abc <tab>123</tab>')
+
+  x = xml %Q{
+    <people id="666-99-0989" lick="me">
+    <person username="trans">
+      <name>
+        Tom
+        ...
+          123
+      </name>
+      <age>35</age>
+    </person>
+    <person username="jenasmom">
+      <name>Becky</name>
+      <age>32</age>
+    </person>
+    </people>
+  }
+
+  puts x.*
+  puts x._
+
+  puts x.self.name
+  puts x.self.attributes
+
+  puts x.person
+  puts x['person']
+  puts x._id
+  puts x['@id']
+p x
+  puts x[1]  # skip whatespace?
+puts "HERE"
+  x << xml(%{<fred id="10">Timmy</fred>})
+
+  puts x['@*']
+
+end
+
+
+
+# SCRAP
+
+#   def __verb?(str)
+#     str = str.strip
+#     return nil unless __tag?(str)
+#     md = (%r{\A \< (\w+) (.*?) \>}mix).match( str )
+# p md
+#     return nil unless md[2] =~ %r{xml:cdata=['"]\d+['"]}
+#     ed = (%r{\< \/ #{n} [ ]* \> \Z}mix).match(str)
+#     return nil unless ed
+#     c = md[0] + '<![CDATA[' + str[md.end(0)...ed.begin] + ']]>' + ed[0]
+# p c
+# c
+#     #str = str.sub( %r{\A \< (\w+) .*? \>}mix ) { |m| n=$1 ; "#{m}<![CDATA[" }
+#     #str = str.sub( %r{\< \/ #{n} [ ]* \> \Z}mix ) { |m| "]]>#{m}" }
+# #       n << md.post_match.gsub(%r{\< \/ #{md[1]} [ ]* \> \Z}mix, '')   #[0...(md.post_match.rindex('<'))]  # not robust enough
+# #       n << "]]>"
+# #       n << "</#{md[1]}>"
+#   end

data/lib/r4x/emcascript.rb

@@ -0,0 +1,4 @@
+
+module EMCAScript
+
+end

data/lib/r4x/qname.rb

@@ -0,0 +1,87 @@
+
+# Defines QName and AttributeName classes.
+
+class QName
+
+  class << self
+
+    alias :__new :new
+
+    def new( name_or_namespace, name=nil )
+      case name_or_namespace
+      when QName
+        return name_or_namespace
+      when nil
+        if QName === name or name.class == "QName"
+          return name.dup
+        else
+          __new(name_or_namespace, name)
+        end
+      else
+        __new(name_or_namespace, name )
+      end
+    end
+
+  end
+
+  attr :name
+  attr :local_name
+  attr :uri
+  attr :prefix
+
+  def initialize( namespace, name )
+    @name = name.local_name.to_s # to_String
+    case namespace
+    when nil, ''
+      namespace = (name == '*' ? nil : get_default_namespace )
+    end
+    @local_name = name
+    unless namespace
+      @uri = nil
+      @prefix = nil
+    else
+      namespace = Namespace.new( namespace )
+      @uri = namespace.uri
+      @prefix = namespace.prefix
+    end
+  end
+
+  #
+  def to_s
+    s = ''
+    if uri != ''
+      unless uri
+        s = '*::'
+      else
+        s = "#{uri}::"
+      end
+    end
+    "#{s}#{local_name}"
+  end
+
+  #
+  def get_namespace( in_scope_namespaces=nil )
+    raise 'no uri [should not have occured]' unless uri
+    in_scope_namespaces ||= []
+    ns = in_scope_namespaces.find { |n| uri == n.uri }  # prefix == n.prefix ?
+    ns = Namespace.new( uri ) unless ns  # or ns = Namespace.new( prefix, uri ) ?
+    ns
+  end
+
+end
+
+
+class AttributeName
+
+  attr :name
+
+  def initialize( s )
+    @name = QName.new(s)
+  end
+
+  def to_s
+    "@#{@name}"
+  end
+
+end
+

data/lib/r4x/xml_delegate.rb

@@ -0,0 +1,297 @@
+
+class Xml #< BlankSlate
+
+  class XmlDelegate
+
+    include Enumerable
+
+    def initialize( x )
+      @x = x
+    end
+
+    def node ; @x.__node      ; end
+    def name ; @x.__node.name ; end
+    def text ; @x.__node.text ; end
+
+    def klass      ; @x.__class                  ; end
+    def parent     ; @x.__parent                 ; end
+    def attributes ; @x.__node.attributes        ; end
+    def value      ; @x.__node.children.join('') ; end
+
+    #
+    def get(prop)
+      if Integer === prop
+        l = to_XmlList
+        return l.__get__(prop)
+      end
+      n = prop.self.to_XmlName
+      l = XmlList.new([],@x,n)
+      if AttributeName === n
+        @x.attributes.each { |a|
+          if ( ( n.name.local_name =='*' ||  n.name.local_name == a.name.local_name ) and
+               ( n.name.uri == nil || n.name.uri == a.name.uri ) )
+            l.append(a)
+          end
+        }
+        return l
+      end
+      (0...length).each { |k|
+        if ( (n.local_name == '*') or
+             ((Element === @x[k]) and (@x[k].name.local_name == a.name.local_name)) ) and
+           ( (n.uri == nil) or ((@x[k].__class__ == "element") and (n.uri == @x[k].name.uri)) )
+          l.append(@x[k])
+        end
+      }
+      return l
+    end
+
+#     def get( prop )
+#       if prop.kind_of?(Integer)
+#         l = to_XmlList
+#         return l.self.get( prop )
+#       end
+#       #n = prop.to_XmlName
+#       l = XmlList.new([], @x, prop)
+# #       if prop =~ /^[@_]/
+# #         @x.__node.attributes.each{ |a|
+# #           l.self.append a
+# #         }
+# #         return l
+# #       end
+#       REXML::XPath.each( @x.__node, prop.to_s ) { |elem|
+#         l.self.append( Xml.new( elem ) )
+#       }
+#       return l
+#     end
+
+#     def put( key, val )
+#       if key =~ /^[@_]/
+#         @x.__node.attributes[ key.shift ] = value
+#       elsif gk = get(key)
+#         case gk.size
+#         when 0
+#           add "<#{key}>#{val}</#{key}>"
+#         when 1
+#           gk[0]  #?
+#         else
+#           raise "unimplemented"
+#           #? What to do then?
+#         end
+#       else
+#         insert( key, val )
+#       end
+#     end
+
+    #
+    def put( prop, val )
+      if !(Xml === val or XmlList === val) or ( [:text,:attribute].include?(val.self.class) )
+        c = val.to_s
+      else
+        c = val.self.deepcopy
+      end
+      raise ArgumentError if Numeric === prop
+      return if [:text,:attribute,:comment,:instruction].include?( klass )
+      n = prop.to_XmlName
+      default_namespace = get_default_namespace()
+      if AttributeName === n
+        return unless is_XmlName(n.self.name)
+        if XmlList === c
+          if c.length === 0
+            c = ''
+          else
+            #s = c[0].to_s
+            #(1...c.length).each { |i| s += " #{c[i].to_s}"
+            s = c.join(' ')
+          end
+        else
+          c = c.to_s
+        end
+        a = nil
+        x.attributes.each { |j|
+          if (n.name.local_name == j.name.local_name) and (n.name.uri == nil or n.name.uri == j.name.uri)
+            a = j unless a
+          else
+            x.delete(j.name)
+          end
+        }
+        unless a
+          unless n.name.uri
+            nons = Namespace.new
+            name = QName.new( nons, n.name )
+          else
+            name = QName.new( n.name )
+          end
+          a = Xml.new { |s| s.name=name ; s.classification=:attribute ; s.parent=x }
+          x.attributes << a
+          ns = name.get_namespace
+          x.add_in_scope_namespace(ns)
+        end
+        a.value = c
+        return
+      end
+      is_valid_name = is_XmlName(n)
+      return if !is_valid_name and n.local_name != '*'
+      i = nil
+      primitive_assign = ((!(Xml === c or XmlList === c)) and n.local_name != '*')
+      (x.length-1).downto(0) { |k|
+        if ( (n.local_name == '*') or ( (@x[k].classification == :element) and (@x[k].name.locall_name == n.local_name) ) ) and
+           ( (n.uri == nil) or ( (@x[k].classification==:element) and (n.uri == @x[k].name.uri) ) )
+          if i
+            x.delete_by_index(i.to_s)
+            i = k
+          end
+        end
+      }
+      unless i
+        i = x.length
+        if primitive_assign
+          unless n.uri
+            name = QName.new( default_namespace, n )
+          else
+            name = QName.new(n)
+          end
+          y=Xml.new{|s| s.name=name; s.classification=:element; s.parent=x}
+          ns=name.get_namespace
+          x.replace(i.to_s,y)
+          y.add_in_scope_namespace(ns)
+        end
+      end
+      if primitive_asign
+        # x[i].delete_all_properties
+        s = c.to_s
+        x[i].replace("0",s) if s != ''
+      else
+        x.replace(i.to_s,c)
+      end
+      return
+    end
+
+    def add( nodes )
+      case nodes
+      when XmlList
+        nodes.each { |n| @x.__node << n.__node }
+      else
+        @x.__node << nodes.__node
+      end
+      @x
+    end
+
+    #
+    def delete(prop)
+      raise ArgumentError if Numeric === prop
+      n = prop.self.to_XmlName
+      if AttributeName === n
+        attribs = attributes.collect{|a|
+          if ((n.name.local_name == '*') or (n.name.local_name == a.name.local_name)) and
+             ((n.name.uri == nil) or (n.name.uri == a.name.uri))
+            a.parent = nil
+            nil
+          else
+            a
+          end
+        }.compact
+        return true
+      end
+      dp = 0
+      (0...length).each { |q|
+        if ((n.local_name == '*') or
+           (@x[q].self.class == :element and @x[q].self.name.local_namespace == n.local_name)) and
+           ((n.uri == nil) or (@x[q].self.class == :element and n.uri == @x[q].self.name.uri))
+          x[q].parent = nil
+          x.delete_at(q)
+          dp+=1
+        else
+          if dp > 0
+            @x[q - dp] = x[q]
+            @x.delete_at(q)
+          end
+        end
+      }
+      return true
+    end
+
+    #
+    def delete_by_index(prop)
+    end
+
+    #
+    def default_value
+    end
+
+    #
+    def has_property
+    end
+
+    #
+    def deep_copy
+    end
+
+    #
+    def descendents(prop)
+    end
+
+    #
+    def equals(value)
+    end
+
+    #
+    def resolve_value
+      @x
+    end
+
+    #
+    def insert(prop,value)
+    end
+
+    #
+    def replace(prop,value)
+    end
+
+    #
+    def add_in_scope_namespace__(namespace)
+    end
+
+    def delete( key )
+      @x.__node.delete_element( key ) #string key is an xpath
+    end
+
+
+    # Conversions
+
+    def to_XmlList
+      XmlList.new( @x )
+    end
+
+#     def to_XmlList
+#       target_object = self.__parent__
+#       target_poperty = self.__name__
+#       l = XmlList.new([self], target_object, target_property)
+#     end
+
+    def to_XmlName
+      s = to_String
+      if s =~ /^[_@]/
+        to_AttributeName( s.shift )
+      else
+        QName.new(s)
+      end
+    end
+
+    def to_String
+      return value if [:attribute, :text].include?(@x)
+      if has_simple_content
+        s = ''
+        @x.each { |e| s << e unless [:comment,:instruction].include?(e.self.class) }
+        return s
+      else
+        to_XmlString
+      end
+    end
+
+    def to_XmlString( ancestor_namespaces=nil, indent_level=nil )
+
+    end
+
+  end
+
+end

data/lib/r4x/xmllist_delegate.rb

@@ -0,0 +1,165 @@
+
+class XmlList
+
+  class XmlListDelegate
+
+    def initialize( x )
+      @x = x
+    end
+
+    def list            ; @x.__list             ; end
+    def class           ; @x.__class            ; end
+
+    def target_object        ; @x.__target_object         ; end
+    def target_property      ; @x.__target_property       ; end
+    def target_object=(to)   ; @x.__target_object = to    ; end
+    def target_property=(tp) ; @x.__target_property = tp  ; end
+
+    def get( prop )
+      if prop.kind_of?(Integer)
+        return @x.__list.at( prop )
+      end
+      l = XmlList.new( [], @x, prop )
+      0...length { |i|
+        gq = @x[i].self.get( prop )
+        l.self.append( gq ) if gq.self.length > 0
+      }
+      return l
+    end
+
+    def put( prop, v )
+      if prop.kind_of?(Integer)
+        i = prop
+        if @x.__target_object
+          r = @x.__target_object.self.resolve_value
+          return unless r
+        else
+          r = nil
+        end
+        if i >= @x.__list.length
+          if r.is_a?(XmlList)
+            return if r.self.length != 1
+          else
+            r = r[0]
+          end
+          y = Xml.new( @x.__target_property.to_sym, r )
+          if @x.__target_property =~ /^[@_]/
+            attribute_exists = r.self.get( y.self.name )
+            return if attributes_exists.self.length > 0
+            y.self.class = :attribute
+          elsif (!@x.__target_property) or @x.__target_property.local_name== '*'
+            y.self.name = nil
+            y.self.class = :text
+          else
+            t.self.class = :element
+          end
+          i = length
+          if y.self.class != :attribute
+            if y.self.parent
+              if i > 0
+                j = 0
+                while ((j < (y.self.parent.self.length - 1)) and (y.self.parent[j] != @x[i-1])) do
+                  j += 1
+                end
+              else
+                j = y.self.parent.self.length - 1
+              end
+            end
+            if v.is_a?(Xml)
+              y.self.name = v.slef.name
+            elsif v.is_a?(XmlList)
+              y.self.name = v.self.property_name
+            else
+              raise "invalid type"
+            end
+          end
+          @x.self.append y
+        end
+        if ( !( v.is_a?(Xml) or v.is_a?(XmlList) ) or [:text, :attribute].include?(v.self.class) )
+          v = v.to_s #to_String
+        end
+        if @x[i].self.class == :attribute
+          @x[i].self.parent.self.put( x[i].self.name, v )
+          attr = x[i].self.parent.self.get( x[i].self.name )
+          x[i] = attr[0]
+        elsif v.is_a?(XmlList)
+          c = v.dup
+          parent = x[i].self.parent
+          if parent
+            q = parent.self.index(@x[i])
+            parent.self.replace( q, c )
+            (0...c.self.length).each { |j| c[j] = parent[q+j] }
+          end
+          (c.self.length-1..i).each { |j| @x[j+c.self.length] = @x[j] }
+          (0...c.self.length).each { |j| @x[i+j] = c[j] }
+        elsif v.is_a?(Xml) or [:text, :comment, :instruction].include?(@x[i].self.class)
+          parent = @x[i].self.parent
+          if parent
+            q = parent.self.index(@x[i])
+            parent.self.replace( q, v )
+            v = parent[q]
+          end
+          x[i] = v
+        else
+          x[i].self.put( '*', v )
+        end
+      else
+        if length == 0
+          r = @x.resolve_value
+          return if !r or r.self.length != 1
+          @x.self.append( r )
+        end
+        @x[0].self.put( prop, v )
+      end
+      return
+    end
+
+    def append( v )
+      i = @x.self.length
+      n = 1
+      case v
+      when XmlList
+        @x.__target_object = v.self.target_object
+        @x.__target_property = v.self.target_property
+        n = v.self.length
+        return if n == 0
+        (0...v.self.length).each { |i| @x[i+j] = v[j] }
+      when Xml
+        @x.__target_object = v.self.parent
+        if v.self.class == :instruction
+          @x.__target_property = nil
+        else
+          @x.__target_property = v.self.name
+        end
+        @x[i] = v
+        # @x.length += n
+      else
+        raise 'Xml or XmlList expected'
+      end
+    end
+
+    def resolve_value
+      return if length > 0
+      unless target_object and target_property
+        if target_property =~ /^[_@]/ or target_property.local_name == '*'
+          return nil
+        end
+      end
+      base = target_object.self.resolve_value  # recursive
+      return nil unless base
+      target = base.self.get( target_property )
+      if target.self.length == 0
+        return nil if base.is_a?(XmlList) and base.self.length > 1
+        base.self.put( target_property, '' )
+        target = base.self.get( target_property )
+      end
+      return target
+    end
+
+    def length
+      @x.__list.length
+    end
+
+  end
+
+end

data/meta/abstract

@@ -0,0 +1 @@
+R4X is an implementation of E4X for Ruby.

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/contact

@@ -0,0 +1 @@
+rubyworks-mailinglist@rubyforge.org

data/meta/package

@@ -0,0 +1 @@
+r4x

data/meta/project

@@ -0,0 +1 @@
+rubyworks

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/rubyworks/r4x.git

data/meta/version

@@ -0,0 +1 @@
+0.5.0

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: r4x
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- rubyworks-mailinglist@rubyforge.org
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: R4X is an implementation of E4X for Ruby.
+email: rubyworks-mailinglist@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MANIFEST
+- LICENSE
+- HISTORY
+files: 
+- lib/r4x/e4x.rb
+- lib/r4x/emcascript.rb
+- lib/r4x/qname.rb
+- lib/r4x/xml_delegate.rb
+- lib/r4x/xmllist_delegate.rb
+- meta/abstract
+- meta/authors
+- meta/contact
+- meta/package
+- meta/project
+- meta/repository
+- meta/version
+- LICENSE
+- README
+- HISTORY
+- MANIFEST
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --title
+- r4x api
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: r4x
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: R4X is an implementation of E4X for Ruby.
+test_files: []
+