xmlcodec 0.0.1

data/lib/XMLStreamParser.rb

@@ -0,0 +1,116 @@
+require "rexml/document"
+require "XMLUtils"
+
+module XMLUtils
+  class XMLSParserContents
+    def initialize
+      @contents = []
+    end
+    
+    def add(content)
+      @contents << content
+    end
+    
+    def <<(content)
+      add(content)
+    end
+    
+    def array_from(start)
+      @contents[start..-1]
+    end
+    
+    def text_from(start)
+      @contents[start..-1].join
+    end
+    
+    def size
+      @contents.size
+    end
+    
+    def erase_from(start)
+      @contents = @contents[0..(start-1)]
+    end
+  end
+
+  class XMLSParserElement
+    attr_reader :name
+    attr_reader :element_id
+    attr_reader :parent_id
+    attr_reader :elstart
+
+    def initialize(name, elstart, parser, parent_id)
+      @name = name
+      @parser = parser
+      @elstart = elstart
+      @element_id = parser.new_element_id
+      @parent_id = parent_id
+    end
+    
+    def self.root(parser)
+      self.new("__XML_ROOT__", 0, parser, nil)
+    end
+    
+    def content
+      @parser.contents.text_from(@elstart)
+    end
+    
+    def consume
+      @parser.consume
+    end
+  end
+
+  class XMLStreamParser
+    attr_reader :contents
+    
+    def initialize(listener=nil)
+      @listener = listener
+      @contents = XMLSParserContents.new
+      @elid = 0
+      @elements = [XMLSParserElement.root(self)]
+    end
+
+    def new_element_id
+      previous = @elid
+      @elid += 1
+      previous
+    end
+
+    def parse(text)
+      REXML::Document.parse_stream(text, self)
+    end
+    
+    def tag_start(name, attrs)
+      @elements << XMLSParserElement.new(name, @contents.size, 
+                                              self, @elements[-1].element_id)
+      @contents << XMLUtils.create_open_tag(name, attrs)
+    end
+    
+    def text(text)
+      @contents << text
+    end
+    
+    def tag_end(name)
+      @contents << "</"+name+">"
+      element(name)
+      @elements.pop()
+    end
+    
+    def content
+      @contents.text_from(@elements[-1].elstart)
+    end
+    
+    def element(name)
+      if @listener
+        @listener.element(@elements[-1])
+      end
+    end
+    
+    def consume
+      @contents.erase_from(@elements[-1].elstart)
+    end
+    
+    # Ignore everything except tags and text for now
+    def method_missing(methId, *args)
+    end
+  end
+end

data/lib/XMLSubElements.rb

@@ -0,0 +1,103 @@
+require 'XMLUtils'
+
+module XMLCodec
+  # A simple element that has only text inside. This is used inside 
+  # XMLSubElements to be able to directly add strings to it and have them be 
+  # treated as XML text elements.
+  class XMLTextElement
+    attr_accessor :__parent
+  
+    # Create a new element for the given string.
+    def initialize(string)
+      @value = XMLUtils::escape_xml(string)
+    end
+    
+    # Simple to_s method that just returns the included string
+    def to_s
+      @value
+    end
+    
+    # Creates the XML for the element by using add_text on the value.
+    def create_xml(parent)
+      parent.add_text(@value)
+    end
+    
+    # The XML text of the element is simply it's string value.
+    def xml_text
+      @value
+    end
+    
+    def end_partial_export(file)
+    end
+    
+    def partial_export(file, except=nil)
+      file << __parent.indentation(1)+self.xml_text+"\n"
+    end
+  end
+  
+  # This is the container class used to hold the elements for the xmlsubelements
+  # and xmlsubel_mult in a XMLElement.
+  class XMLSubElements
+    include Enumerable
+  
+    # Create a new instance of the container
+    def initialize(parent)
+      @elements = []
+      @parent = parent
+    end
+    
+  private
+    # Get the class for a given element name
+    def elclass(name)
+      XMLElement.get_element_class(name)
+    end
+  
+  public
+    # Adds a value to the collection. The value may be either a String or a 
+    # descendant of XMLElement. If it's a string it's converted into a 
+    # XMLTextElement
+    def <<(value)
+      if value.instance_of? String
+        value = XMLTextElement.new(value)
+      end
+      value.__parent = @parent
+      @elements << value
+    end
+    
+    # Get the element with the given number
+    def [](num)
+      @elements[num]
+    end
+    
+    # Get the number of elements in the container
+    def size
+      @elements.size
+    end
+    
+    # Create the XML of all the elements by creating the XML for each of them.
+    def create_xml(parent)
+      @elements.each{|e| e.create_xml(parent)}
+    end
+    
+    # Import the XML of all the elements
+    def import_xml(xmlelements)
+      xmlelements.each do |xmlel|
+        if xmlel.kind_of? REXML::Text
+          self << xmlel.to_s
+        else
+          self << elclass(xmlel.name.to_sym).import_xml(xmlel)
+        end
+      end
+    end
+    
+    # Iterate all the values in the collection
+    def each
+      @elements.each {|e| yield e}
+    end
+    
+    # Delete a certain element from the collection
+    def delete_element(element)
+      @elements.delete(element)
+    end
+  end
+end

data/lib/XMLUtils.rb

@@ -0,0 +1,58 @@
+require "rexml/document"
+
+# This module holds generic XML utilities. The module's methods are simple 
+# XML utilities. The module also contains XMLStreamParser, a Generic XML Stream 
+# parser whose events are the text of whole elements instead of start and end 
+# tags.
+
+module XMLUtils
+  # Gets the REXML DOM for a given filename that must be a XML file.
+  def self.getdoc(filename)
+    file = File.new(filename, 'r')
+    REXML::Document.new file
+  end
+
+  # Count the number of elements that correspond to a given xpath in a file.
+  def self.count_elements(path, filename)
+    doc = getdoc(filename)
+    i = 0
+    XPath.each(doc, path) {|element| i+=1}
+    return i
+  end
+
+  # Test if a given xpath exists in the file.
+  def self.element_exists(path, filename)
+    count_elements(path,filename)>0
+  end
+
+  # Get a xpath from a REXML document.
+  def self.select_path_doc(path, doc)
+    element = REXML::XPath.first(doc, path)
+    return "" if not element
+    if element.respond_to?("value")
+      return element.value || ""
+    end
+    return element.text || ""
+  end
+
+  # Get a xpath from a file.
+  def self.select_path(path, filename)
+    XMLUtils::select_path_doc(path, getdoc(filename))
+  end
+  
+  # Create an open tag.
+  def self.create_open_tag(name, attrs)
+    str = "<"+name
+    attrs.each {|name, value| str << " #{name}='#{value}'"}
+    str << ">"
+    str
+  end
+  
+  # Escape a string so that it can be included in a XML document
+  def self.escape_xml(string)
+    t = REXML::Text.new('')
+    str = ''
+    t.write_with_substitution(str, string)
+    str
+  end
+end

data/lib/xmlcodec.rb

@@ -0,0 +1,4 @@
+require 'XMLElement'
+require 'XMLUtils'
+require 'XMLStreamObjectParser'
+require 'XMLStreamParser'

data/test/TestPartialExport.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+require 'XMLUtils'
+require 'simple_objects'
+
+class TestPartialExport < Test::Unit::TestCase
+  def validate_well_formed(filename)
+		assert(system("rxp", "-xs", filename))
+	end
+
+  def compare_xpath(value, filename, path)
+		assert_equal(value.strip, XMLUtils::select_path(path, filename).strip)
+	end
+
+  def test_simple
+    value = "somevalue"
+    filename = 'test_partial_export_simple.xml'
+  
+    file = File.open(filename, "w")
+    sel = SimpleElement.new(value)
+    sel.partial_export(file)
+    file.close
+  
+    validate_well_formed(filename)
+    compare_xpath(value, filename, "/abc")
+  end
+  
+  def test_double
+    value = 'somevalue'
+    filename = 'test_partial_export_double.xml'
+    
+    file = File.open(filename, "w")
+    sel = SimpleElement.new(value)
+    el = TestElement.new
+    el.abc = sel
+    
+    sel.partial_export(file)
+    el.end_partial_export(file)
+    file.close
+    
+    validate_well_formed(filename)
+    compare_xpath(value, filename, "/subel/abc")
+  end
+  
+  def test_triple
+    value = 'somevalue'
+    filename = 'test_partial_export_double.xml'
+    
+    file = File.open(filename, "w")
+    sel = SimpleElement.new(value)
+    el1 = TestElement.new
+    el2 = TestElement.new
+    el1.subel = el2
+    el2.abc = sel
+    
+    sel.partial_export(file)
+    el1.end_partial_export(file)
+    file.close
+    
+    validate_well_formed(filename)
+    compare_xpath(value, filename, "/subel/subel/abc")
+  end
+  
+  def test_attr
+    value = 'somevalue'
+    filename = 'test_partial_export_double.xml'
+    
+    file = File.open(filename, "w")
+    el = TestElement.new
+    el.someattr = value
+    
+    el.partial_export(file)
+    file.close
+    
+    compare_xpath(value, filename, "/subel/@someattr")
+  end
+  
+  def test_mult
+    value1 = 'somevalue1'
+    value2 = 'somevalue2'
+    filename = 'test_partial_export_mult.xml'
+    
+    file = File.open(filename, "w")
+    sel1 = SimpleElement.new(value1)
+    sel2 = SimpleElement.new(value2)
+    
+    el = SubelMultElement.new
+    el.abc << sel1    
+    sel1.partial_export(file)
+    
+    el.abc << sel2
+    sel2.partial_export(file)
+    el.end_partial_export(file)
+    
+    file.close
+    
+    validate_well_formed(filename)
+    compare_xpath(value1, filename, "/mult/abc[1]")
+    compare_xpath(value2, filename, "/mult/abc[2]")
+  end
+  
+  def test_subelements
+    value1 = 'somevalue1'
+    value2 = 'somevalue2'
+    filename = 'test_partial_export_subelements.xml'
+    
+    file = File.open(filename, "w")
+    sel1 = SimpleElement.new(value1)
+    sel2 = SimpleElement.new(value2)
+    
+    el = SubelElement.new
+    el.subelements << sel1    
+    sel1.partial_export(file)
+    
+    el.subelements << sel2
+    sel2.partial_export(file)
+    el.end_partial_export(file)
+    
+    file.close
+    
+    validate_well_formed(filename)
+    compare_xpath(value1, filename, "/subels/abc[1]")
+    compare_xpath(value2, filename, "/subels/abc[2]")
+  end
+  
+  def test_subelements_multiple
+    value1 = 'somevalue1'
+    value2 = 'somevalue2'
+    filename = 'test_partial_export_subelements2.xml'
+    
+    file = File.open(filename, "w")
+    sel1 = SimpleElement.new(value1)
+    sel2 = SimpleElement.new(value2)
+    
+    el = SubelElement.new
+    el.subelements << sel1
+    el.subelements << sel2
+    el.partial_export(file)
+    
+    file.close
+    
+    validate_well_formed(filename)
+    compare_xpath(value1, filename, "/subels/abc[1]")
+    compare_xpath(value2, filename, "/subels/abc[2]")
+  end
+end

data/test/TestXMLElement.rb

@@ -0,0 +1,177 @@
+require 'test/unit'
+require 'xmlcodec'
+require 'rexml/document'
+require 'simple_objects'
+
+class TestXMLElement < Test::Unit::TestCase
+  def test_xmlsubel
+    value = 'test'
+  
+    el = TestElement.new
+    sel = SimpleElement.new(value)
+    
+    el.abc = sel
+    assert_equal(sel, el.abc)
+    assert_equal(value, sel.value)
+    assert_equal(el, sel.__parent)
+    
+    assert_equal('<abc>'+value+'</abc>', sel.xml_text)
+    assert_equal('<subel><abc>'+value+'</abc></subel>', el.xml_text)
+
+    dom = REXML::Document.new
+    el.create_xml(dom)
+    
+    assert_equal 1, dom.elements.size
+    eldom = dom.elements['subel']
+    assert_not_nil eldom
+    assert_equal 1, eldom.elements.size
+    
+    seldom = eldom.elements['abc']
+    assert_not_nil seldom
+    assert_equal value, seldom.text
+    
+    el = TestElement.import_xml(dom)
+    assert_equal value, el.abc.value
+  end
+  
+  def test_xmlattr
+    value = 'test'
+    el = TestElement.new
+    
+    el.someattr = value
+    assert_equal(value, el.someattr) 
+    
+    assert_equal("<subel someattr='"+value+"'></subel>", el.xml_text)
+    
+    dom = REXML::Document.new
+    el.create_xml(dom)
+    
+    assert_equal 1, dom.elements.size
+    eldom = dom.elements['subel']
+    assert_not_nil eldom
+    assert_equal value, eldom.attributes['someattr']
+    
+    el = TestElement.import_xml(dom)
+    assert_equal value, el.someattr
+  end
+  
+  def test_xmlsubelements
+    value = 'test'
+    el = SubelElement.new
+    sel = SimpleElement.new(value)
+    
+    el.subelements << sel
+    assert_equal(sel, el.subelements[0])
+    assert_equal(el, sel.__parent)
+    
+    assert_equal('<subels><abc>'+value+'</abc></subels>', el.xml_text)
+    
+    dom = REXML::Document.new
+    el.create_xml(dom)
+    
+    assert_equal 1, dom.elements.size
+    eldom = dom.elements['subels']
+    assert_not_nil eldom
+    assert_equal 1, eldom.elements.size
+    
+    seldom = eldom.elements['abc']
+    assert_not_nil seldom
+    assert_equal value, seldom.text
+    
+    el = SubelElement.import_xml(dom)
+    assert_equal 1, el.subelements.size
+    assert_equal value, el.subelements[0].value
+  end
+  
+  def test_xmlsubel_mult
+    value1 = 'test'
+    value2 = 'test2'
+    el = SubelMultElement.new
+    sel1 = SimpleElement.new(value1)
+    sel2 = SimpleElement.new(value2)
+    
+    el.abc << sel1
+    el.abc << sel2
+    
+    assert_equal(sel1, el.abc[0])
+    assert_equal(el, sel1.__parent)
+    assert_equal(el, sel2.__parent)
+    
+    assert_equal('<mult><abc>'+value1+'</abc><abc>'+value2+'</abc></mult>', el.xml_text)
+    
+    dom = REXML::Document.new
+    el.create_xml(dom)
+    
+    assert_equal 1, dom.elements.size
+    eldom = dom.elements['mult']
+    assert_not_nil eldom
+    assert_equal 2, eldom.elements.size
+    
+    [value1, value2].each_with_index do |value, index|
+      seldom = eldom.elements[index+1]
+      assert_not_nil seldom
+      assert_equal value, seldom.text
+      assert_equal 'abc', seldom.name
+    end
+    
+    el = SubelMultElement.import_xml(dom)
+    assert_equal 2, el.abc.size
+    assert_equal value1, el.abc[0].value
+    assert_equal value2, el.abc[1].value
+  end
+  
+  def test_delete_element_simple
+    el = TestElement.new
+    sel = SimpleElement.new('')
+    el.abc = sel
+    assert_equal sel, el.abc
+    
+    el.delete_element(sel)
+    assert_nil el.abc
+  end
+  
+  def test_delete_element_double
+    el = TestElement.new
+    sel1 = SimpleElement.new('')
+    sel2 = SimpleElement2.new('')
+    el.abc = sel1
+    el.abc2 = sel2
+    
+    assert_equal sel1, el.abc
+    assert_equal sel2, el.abc2
+    
+    el.delete_element(sel1)
+    assert_nil el.abc
+    assert_equal sel2, el.abc2
+  end
+  
+  def test_delete_element_multiple
+    el = SubelMultElement.new
+    sel = SimpleElement.new('')
+    el.abc << sel
+    assert_equal sel, el.abc[0]
+    
+    el.delete_element(sel)
+    assert_nil el.abc[0]
+  end
+  
+  def test_delete_element_subelements
+    el = SubelElement.new
+    sel1 = SimpleElement.new('')
+    sel2 = SimpleElement.new('')
+    el.subelements << sel1
+    el.subelements << sel2
+    
+    assert_equal 2, el.subelements.size
+    assert_equal sel1, el.subelements[0]
+    assert_equal sel2, el.subelements[1]
+    
+    el.delete_element(sel1)
+    assert_equal 1, el.subelements.size
+    assert_equal sel2, el.subelements[0]
+    
+    el.delete_element(sel2)
+    assert_equal 0, el.subelements.size
+    assert_nil el.subelements[0]
+  end
+end