xml-mapping 0.8.1 → 0.9.1

data/test/inheritance_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__)+"/tests_init"
+
+require 'test/unit'
+require 'xml/mapping'
+require 'xml/xxpath_methods'
+
+class Base
+  attr_accessor :baseinit
+
+  def initialize(p)
+    self.baseinit = p
+  end
+end
+
+class Derived < Base
+  include XML::Mapping
+
+  text_node :mytext, "mytext"
+end
+
+class Derived2 < Base
+  include XML::Mapping
+
+  text_node :baseinit, "baseinit"
+end
+
+# test that tries to reproduce ticket #4783
+class InheritanceTest < Test::Unit::TestCase
+
+  def test_inheritance_simple
+    d = Derived.new "foo"
+    assert_equal "foo", d.baseinit
+    d.mytext = "hello"
+    dxml=d.save_to_xml
+    assert_equal "hello", dxml.first_xpath("mytext").text
+    d2 = Derived.load_from_xml(dxml)
+    assert_nil d2.baseinit
+    assert_equal "hello", d2.mytext
+  end
+
+  def test_inheritance_superclass_initializing_mappedattr
+    d = Derived2.new "foo"
+    assert_equal "foo", d.baseinit
+    dxml=d.save_to_xml
+    assert_equal "foo", dxml.first_xpath("baseinit").text
+    d2 = Derived2.load_from_xml(dxml)
+    assert_equal "foo", d2.baseinit
+  end
+
+end

data/test/multiple_mappings_test.rb

@@ -0,0 +1,155 @@
+require File.dirname(__FILE__)+"/tests_init"
+
+require 'test/unit'
+require 'triangle_mm'
+
+require 'xml/xxpath_methods'
+
+class MultipleMappingsTest < Test::Unit::TestCase
+  def setup
+    # need to undo mapping class definitions that may have been
+    # established by other tests (and outlive those tests)
+
+    # this requires some ugly hackery with internal variables
+    XML::Mapping.module_eval <<-EOS
+      Classes_by_rootelt_names.clear
+    EOS
+    Object.send(:remove_const, "Triangle")
+    $".delete "triangle_mm.rb"
+    $:.unshift File.dirname(__FILE__)  # test/unit may have undone this (see test/unit/collector/dir.rb)
+    require 'triangle_mm'
+  end
+
+  def test_read
+    t1=Triangle.load_from_file File.dirname(__FILE__) + "/fixtures/triangle_m1.xml", :mapping=>:m1
+    assert_raises(XML::MappingError) do
+      Triangle.load_from_file File.dirname(__FILE__) + "/fixtures/triangle_m1.xml", :mapping=>:m2
+    end
+    t2=Triangle.load_from_file File.dirname(__FILE__) + "/fixtures/triangle_m2.xml", :mapping=>:m2
+
+    t=Triangle.new('tri1','green',
+                   Point.new(3,0),Point.new(2,4),Point.new(0,1))
+
+    assert_equal t, t1
+    assert_equal t, t2
+    assert_equal t1, t2
+    assert_equal "default description", t2.descr
+    assert_nil t1.descr
+    assert_not_equal Triangle.allocate, t
+
+    # loading with default mapping should raise an exception because
+    # the default mapping was never used yet
+    assert_raises(XML::MappingError) do
+      Triangle.load_from_file(File.dirname(__FILE__) + "/fixtures/triangle_m1.xml")
+    end
+    assert_raises(XML::MappingError) do
+      Triangle.load_from_file(File.dirname(__FILE__) + "/fixtures/triangle_m2.xml")
+    end
+
+    # after using it once, we get empty objects
+    Triangle.class_eval "use_mapping :_default"
+    assert_equal Triangle.allocate,
+                 Triangle.load_from_file(File.dirname(__FILE__) + "/fixtures/triangle_m1.xml")
+    assert_equal Triangle.allocate,
+                 Triangle.load_from_file(File.dirname(__FILE__) + "/fixtures/triangle_m2.xml")
+  end
+
+
+  def test_read_polymorphic
+    t1=XML::Mapping.load_object_from_file File.dirname(__FILE__) + "/fixtures/triangle_m1.xml", :mapping=>:m1
+    t2=XML::Mapping.load_object_from_file File.dirname(__FILE__) + "/fixtures/triangle_m2.xml", :mapping=>:m2
+    t=Triangle.new('tri1','green',
+                   Point.new(3,0),Point.new(2,4),Point.new(0,1))
+
+    assert_equal t, t1
+    assert_equal t, t2
+    assert_equal t1, t2
+  end
+
+
+  def test_write
+    t1=XML::Mapping.load_object_from_file File.dirname(__FILE__) + "/fixtures/triangle_m1.xml", :mapping=>:m1
+    m1xml = t1.save_to_xml :mapping=>:m1
+    m2xml = t1.save_to_xml :mapping=>:m2
+
+    assert_equal t1.name, m1xml.first_xpath('@name').text
+    assert_equal t1.name, m2xml.first_xpath('name').text
+    assert_equal t1.p2, Point.load_from_xml(m1xml.first_xpath('pt2'), :mapping=>:m1)
+    assert_equal t1.p2, Point.load_from_xml(m2xml.first_xpath('points/point[2]'), :mapping=>:m1)
+  end
+
+
+  def test_root_element
+    t1=XML::Mapping.load_object_from_file File.dirname(__FILE__) + "/fixtures/triangle_m1.xml", :mapping=>:m1
+    m1xml = t1.save_to_xml :mapping=>:m1
+    m2xml = t1.save_to_xml :mapping=>:m2
+
+    assert_equal "triangle", Triangle.root_element_name(:mapping=>:m1)
+    assert_equal "triangle", Triangle.root_element_name(:mapping=>:m2)
+    assert_equal Triangle, XML::Mapping.class_for_root_elt_name("triangle",:mapping=>:m1)
+    assert_equal Triangle, XML::Mapping.class_for_root_elt_name("triangle",:mapping=>:m2)
+    assert_equal "triangle", t1.save_to_xml(:mapping=>:m1).name
+    assert_equal "triangle", t1.save_to_xml(:mapping=>:m2).name
+
+    Triangle.class_eval <<-EOS
+      use_mapping :m1
+      root_element_name 'foobar'
+    EOS
+
+    assert_equal "foobar", Triangle.root_element_name(:mapping=>:m1)
+    assert_equal "triangle", Triangle.root_element_name(:mapping=>:m2)
+    assert_nil XML::Mapping.class_for_root_elt_name("triangle",:mapping=>:m1)
+    assert_equal Triangle, XML::Mapping.class_for_root_elt_name("foobar",:mapping=>:m1)
+    assert_equal Triangle, XML::Mapping.class_for_root_elt_name("triangle",:mapping=>:m2)
+    assert_equal "foobar", t1.save_to_xml(:mapping=>:m1).name
+    assert_equal "triangle", t1.save_to_xml(:mapping=>:m2).name
+    assert_equal [Triangle,:m1], XML::Mapping.class_and_mapping_for_root_elt_name("foobar")
+    assert_raises(XML::MappingError) do
+      XML::Mapping.load_object_from_xml(m1xml, :mapping=>:m1)
+    end
+    assert_equal t1, XML::Mapping.load_object_from_xml(m2xml, :mapping=>:m2)
+    m1xml.name = "foobar"
+    assert_equal t1, XML::Mapping.load_object_from_xml(m1xml, :mapping=>:m1)
+
+    Triangle.class_eval <<-EOS
+      use_mapping :m1
+      root_element_name 'triangle'
+    EOS
+
+    assert_raises(XML::MappingError) do
+      XML::Mapping.load_object_from_xml(m1xml, :mapping=>:m1)
+    end
+    m1xml.name = "triangle"
+    assert_equal t1, XML::Mapping.load_object_from_xml(m1xml, :mapping=>:m1)
+  end
+
+
+  def test_node_initialization
+  end
+
+
+  def test_misc
+    m1nodes = Triangle.xml_mapping_nodes(:mapping=>:m1).map{|n|n.class}
+    m2nodes = Triangle.xml_mapping_nodes(:mapping=>:m2).map{|n|n.class}
+    allnodes = Triangle.xml_mapping_nodes.map{|n|n.class}
+
+    t=XML::Mapping::TextNode
+    o=XML::Mapping::ObjectNode
+    assert_equal [t,o,o,t,o], m1nodes
+    assert_equal [o,t,t,o,o,t], m2nodes
+    begin
+      assert_equal m1nodes+m2nodes, allnodes
+    rescue Test::Unit::AssertionFailedError
+      assert_equal m2nodes+m1nodes, allnodes
+    end
+
+    allm1nodes = Triangle.all_xml_mapping_nodes(:mapping=>:m1).map{|n|n.class}
+    allm2nodes = Triangle.all_xml_mapping_nodes(:mapping=>:m2).map{|n|n.class}
+    allallnodes = Triangle.all_xml_mapping_nodes.map{|n|n.class}
+
+    assert_equal allm1nodes, m1nodes
+    assert_equal allm2nodes, m2nodes
+    assert_equal allnodes, allallnodes
+  end
+
+end

data/test/rexml_xpath_benchmark.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__)+"/benchmark_fixtures"
+
+require "rexml/xpath"
+
+require 'benchmark'
+include Benchmark
+
+rootelt = @d.root
+foo2elt = rootelt.elements[3]
+res1=res2=res3=res4=res5=nil
+print "(#{@count} runs)\n"
+bmbm(12) do |x|
+  x.report("by_name") { @count.times { res1 = XPath.first(rootelt, @path_by_name) } }
+  x.report("by_idx") { @count.times { res2 = XPath.first(rootelt, @path_by_idx) } }
+  x.report("by_idx_idx") { @count.times { res3 = XPath.first(rootelt, @path_by_idx_idx) } }
+  x.report("by_attr_idx") { @count.times { res4 = XPath.first(rootelt, @path_by_attr_idx) } }
+  x.report("xxpath_by_attr") { (@count*4).times { res5 = XPath.first(foo2elt, @path_by_attr) } }
+end
+
+
+def assert_equal(expected,actual)
+  expected==actual or raise "expected: #{expected.inspect}, actual: #{actual.inspect}"
+end
+
+assert_equal "bar4-2", res1.text.strip
+assert_equal "bar6", res2.text.strip
+assert_equal "bar4-6", res3.text.strip
+assert_equal "bar4-6", res4.text.strip
+assert_equal "xy", res5.value.strip

data/test/triangle_mm.rb

@@ -0,0 +1,57 @@
+require 'xml/mapping'
+
+module XML::Mapping
+  def ==(other)
+    Marshal.dump(self) == Marshal.dump(other)
+  end
+end
+
+
+# forward declarations
+class Point; end
+
+class Triangle
+  include XML::Mapping
+
+  use_mapping :m1
+
+  text_node :name, "@name"
+  object_node :p1, "pt1", :class=>Point
+  object_node :p2, "points/point[2]", :class=>Point, :mapping=>:m2, :sub_mapping=>:m1
+  object_node :p3, "pt3", :class=>Point
+  text_node :color, "color"
+
+
+  use_mapping :m2
+
+  text_node :color, "@color"
+  text_node :name, "name"
+  object_node :p1, "points/point[1]", :class=>Point, :sub_mapping=>:m1
+  object_node :p2, "pt2", :class=>Point, :mapping=>:m1
+  object_node :p3, "points/point[3]", :class=>Point, :sub_mapping=>:m1
+
+  text_node :descr, "description", :default_value=>"default description"
+
+  def initialize(name,color,p1,p2,p3)
+    @name,@color,@p1,@p2,@p3 = name,color,p1,p2,p3
+  end
+
+  def ==(other)
+    name==other.name and color==other.color and
+      p1==other.p1 and p2==other.p2 and p3==other.p3
+  end
+end
+
+
+class Point
+  include XML::Mapping
+
+  use_mapping :m1
+
+  numeric_node :x, "x"
+  numeric_node :y, "y"
+
+  def initialize(x,y)
+    @x,@y = x,y
+  end
+end

data/test/xml_mapping_adv_test.rb

@@ -2,11 +2,22 @@ require File.dirname(__FILE__)+"/tests_init"
 
 require 'test/unit'
 require 'documents_folders'
-require 'multiple_mappings'
+require 'bookmarks'
 require 'yaml'
 
 class XmlMappingAdvancedTest < Test::Unit::TestCase
   def setup
+    XML::Mapping.module_eval <<-EOS
+      Classes_by_rootelt_names.clear
+    EOS
+    Object.send(:remove_const, "Document")
+    Object.send(:remove_const, "Folder")
+
+    $".delete "documents_folders.rb"
+    $".delete "bookmarks.rb"
+    require 'documents_folders'
+    require 'bookmarks'
+
     @f_xml = REXML::Document.new(File.new(File.dirname(__FILE__) + "/fixtures/documents_folders2.xml"))
     @f = XML::Mapping.load_object_from_xml(@f_xml.root)
 
@@ -34,6 +45,30 @@ class XmlMappingAdvancedTest < Test::Unit::TestCase
     EOS
   end
 
+  def test_write_polymorphic_object
+    xml = @f.save_to_xml
+    assert_equal "folder", xml.name
+    assert_equal "home", xml.elements[1].text
+    assert_equal "document", xml.elements[2].name
+    assert_equal "folder", xml.elements[3].name
+    assert_equal "name", xml.elements[3].elements[1].name
+    assert_equal "folder", xml.elements[3].elements[2].name
+    assert_equal "foo bar baz", xml.elements[3].elements[2].elements[2].elements[2].text
+
+    @f.append "etc", Folder.new
+    @f["etc"].append "passwd", Document.new
+    @f["etc"]["passwd"].contents = "foo:x:2:2:/bin/sh"
+    @f["etc"].append "hosts", Document.new
+    @f["etc"]["hosts"].contents = "127.0.0.1 localhost"
+
+    xml = @f.save_to_xml
+
+    xmletc = xml.elements[4]
+    assert_equal "etc", xmletc.elements[1].text
+    assert_equal "document", xmletc.elements[2].name
+    assert_equal "passwd", xmletc.elements[2].elements[1].text
+    assert_equal "foo:x:2:2:/bin/sh", xmletc.elements[2].elements[2].text
+  end
 
   def test_read_bookmars1_2
      expected = BMFolder.new{|x|

data/test/xml_mapping_test.rb

@@ -2,6 +2,7 @@ require File.dirname(__FILE__)+"/tests_init"
 
 require 'test/unit'
 require 'company'
+require 'xml/xxpath_methods'
 
 module XML::Mapping
   def ==(other)
@@ -16,13 +17,16 @@ class XmlMappingTest < Test::Unit::TestCase
 
     # this requires some ugly hackery with internal variables
     XML::Mapping.module_eval <<-EOS
-      Classes_w_default_rootelt_names.clear
-      Classes_w_nondefault_rootelt_names.clear
+      Classes_by_rootelt_names.clear
     EOS
     Object.send(:remove_const, "Company")
     Object.send(:remove_const, "Address")
     Object.send(:remove_const, "Office")
     Object.send(:remove_const, "Customer")
+    Object.send(:remove_const, "Thing")
+    Object.send(:remove_const, "Names1")
+    Object.send(:remove_const, "ReaderTest")
+    Object.send(:remove_const, "WriterTest")
     $".delete "company.rb"
     $:.unshift File.dirname(__FILE__)  # test/unit may have undone this (see test/unit/collector/dir.rb)
     require 'company'
@@ -52,12 +56,105 @@ class XmlMappingTest < Test::Unit::TestCase
       assert_equal exp, @c.customers[ckey].uid
     end
   end
-  
+
+
+  def test_getter_choice_node
+    assert_equal 4, @c.things.size
+    assert_equal "name1", @c.things[0].name
+    assert_equal "name2", @c.things[1].name
+    assert_equal "name3", @c.things[2].name
+    assert_equal "name4-elt", @c.things[3].name
+  end
+
+
+  def test_getter_choice_node_multiple_attrs
+    d = REXML::Document.new <<-EOS
+    <names1>
+      <names>
+        <name>multi1</name>
+        <name>multi2</name>
+      </names>
+      <name>single</name>
+    </names1>
+    EOS
+    n1 = Names1.load_from_xml d.root
+    assert_equal "single", n1.name
+    assert_nil n1.names
+
+    d.root.delete_element "name"
+    n1 = Names1.load_from_xml d.root
+    assert_nil n1.name
+    assert_equal ["multi1","multi2"], n1.names
+  end
+
+
+  def test_choice_node_presence
+    node = Thing.xml_mapping_nodes[0]
+    t = Thing.new
+    assert !(node.is_present_in? t)
+    t.name = "Mary"
+    assert node.is_present_in? t
+  end
+
+
   def test_getter_array_node
     assert_equal ["pencils", "weapons of mass destruction"],
           @c.offices.map{|o|o.speciality}
   end
-  
+
+
+  def test_reader
+    xml = REXML::Document.new("<test>
+                                 <foo>footext</foo>
+                                 <foo2>foo2text</foo2>
+                                 <foo3>foo3text</foo3>
+                                 <bar>bartext</bar>
+                              </test>").root
+    r = ReaderTest.load_from_xml xml
+    assert_equal 'footext', r.foo
+    assert_nil r.foo2
+    assert_equal 'foo3text', r.foo3
+    assert_equal 'bartext', r.bar
+    assert_equal [:foo2,:foo3], r.read
+
+    r.foo = 'foonew'
+    r.foo2 = 'foo2new'
+    r.foo3 = 'foo3new'
+    r.bar = 'barnew'
+    xml2 = r.save_to_xml
+    assert_equal 'foonew', xml2.first_xpath("foo").text
+    assert_equal 'foo2new', xml2.first_xpath("foo2").text
+    assert_equal 'foo3new', xml2.first_xpath("foo3").text
+    assert_equal 'barnew', xml2.first_xpath("bar").text
+  end
+
+
+  def test_writer
+    xml = REXML::Document.new("<test>
+                                 <foo>footext</foo>
+                                 <foo2>foo2text</foo2>
+                                 <foo3>foo3text</foo3>
+                                 <bar>bartext</bar>
+                              </test>").root
+    w = WriterTest.load_from_xml xml
+    assert_equal 'footext', w.foo
+    assert_equal 'foo2text', w.foo2
+    assert_equal 'foo3text', w.foo3
+    assert_equal 'bartext', w.bar
+
+    w.foo = 'foonew'
+    w.foo2 = 'foo2new'
+    w.foo3 = 'foo3new'
+    w.bar = 'barnew'
+    xml2 = w.save_to_xml
+    assert_equal 'foonew', xml2.first_xpath("foo").text
+    assert_nil xml2.first_xpath("foo2",:allow_nil=>true)
+    assert_equal 'foo3new', xml2.first_xpath("foo3").text
+    assert_equal 'barnew', xml2.first_xpath("bar").text
+
+    assert_equal %w{dingdong2 dingdong3}, xml2.all_xpath("quux").map{|elt|elt.text}
+  end
+
   
   def test_setter_text_node
     @c.ent2 = "lalala"
@@ -87,6 +184,35 @@ class XmlMappingTest < Test::Unit::TestCase
   end
 
 
+  def test_setter_choice_node
+    xml=@c.save_to_xml
+    thingselts = xml.all_xpath("stuff2/thing")
+    assert_equal @c.things.size, thingselts.size
+    assert_equal @c.things[0].name, thingselts[0].first_xpath("name").text
+    assert_equal @c.things[1].name, thingselts[1].first_xpath("name").text
+    assert_equal @c.things[2].name, thingselts[2].first_xpath("name").text
+    assert_equal @c.things[3].name, thingselts[3].first_xpath("name").text
+  end
+
+
+  def test_setter_choice_node_multiple_attrs
+    n1 = Names1.new
+    assert_raises(XML::MappingError) {
+      n1.save_to_xml   # no choice present in n1
+    }
+
+    n1.names = ["multi1","multi2"]
+    xml = n1.save_to_xml
+    assert_equal n1.names, xml.all_xpath("names/name").map{|elt|elt.text}
+    assert_nil xml.first_xpath("name", :allow_nil=>true)
+
+    n1.name = "foo"
+    xml = n1.save_to_xml
+    assert_equal [], xml.all_xpath("names/name").map{|elt|elt.text}
+    assert_equal n1.name, xml.first_xpath("name", :allow_nil=>true).text
+  end
+
+
   def test_root_element
     assert_equal @c, XML::Mapping.load_object_from_file(File.dirname(__FILE__) + "/fixtures/company1.xml")
     assert_equal @c, XML::Mapping.load_object_from_xml(@xml.root)
@@ -113,9 +239,12 @@ class XmlMappingTest < Test::Unit::TestCase
     assert_equal @c, XML::Mapping.load_object_from_xml(@xml.root)
 
     # white-box tests
-    assert_equal [["my-test", Company]], XML::Mapping::Classes_w_nondefault_rootelt_names.sort
-    assert_equal [["address", Address], ["customer", Customer], ["office", Office]],
-          XML::Mapping::Classes_w_default_rootelt_names.sort
+    #assert_equal [["my-test", {:_default=>Company}]], XML::Mapping::Classes_w_nondefault_rootelt_names.sort
+    #assert_equal [["address", {:_default=>Address}],
+    #              ["company", {}],
+    #              ["customer", {:_default=>Customer}],
+    #              ["office", {:_default=>Office}]],
+    #      XML::Mapping::Classes_w_default_rootelt_names.sort
   end