bio-nexml 0.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (57) hide show
  1. data/Gemfile +15 -0
  2. data/Gemfile.lock +24 -0
  3. data/LICENSE.txt +20 -0
  4. data/README.rdoc +47 -0
  5. data/Rakefile +55 -0
  6. data/TODO.txt +6 -0
  7. data/VERSION +1 -0
  8. data/bio-nexml.gemspec +126 -0
  9. data/extconf.rb +2 -0
  10. data/lib/bio-nexml.rb +0 -0
  11. data/lib/bio.rb +321 -0
  12. data/lib/bio/db/nexml.rb +109 -0
  13. data/lib/bio/db/nexml/mapper.rb +113 -0
  14. data/lib/bio/db/nexml/mapper/framework.rb +157 -0
  15. data/lib/bio/db/nexml/mapper/inflection.rb +99 -0
  16. data/lib/bio/db/nexml/mapper/repository.rb +59 -0
  17. data/lib/bio/db/nexml/matrix.rb +1046 -0
  18. data/lib/bio/db/nexml/parser.rb +622 -0
  19. data/lib/bio/db/nexml/schema/README.txt +21 -0
  20. data/lib/bio/db/nexml/schema/abstract.xsd +159 -0
  21. data/lib/bio/db/nexml/schema/characters/README.txt +1 -0
  22. data/lib/bio/db/nexml/schema/characters/abstractcharacters.xsd +361 -0
  23. data/lib/bio/db/nexml/schema/characters/characters.xsd +22 -0
  24. data/lib/bio/db/nexml/schema/characters/continuous.xsd +190 -0
  25. data/lib/bio/db/nexml/schema/characters/dna.xsd +282 -0
  26. data/lib/bio/db/nexml/schema/characters/protein.xsd +280 -0
  27. data/lib/bio/db/nexml/schema/characters/restriction.xsd +239 -0
  28. data/lib/bio/db/nexml/schema/characters/rna.xsd +283 -0
  29. data/lib/bio/db/nexml/schema/characters/standard.xsd +261 -0
  30. data/lib/bio/db/nexml/schema/external/sawsdl.xsd +21 -0
  31. data/lib/bio/db/nexml/schema/external/xhtml-datatypes-1.xsd +177 -0
  32. data/lib/bio/db/nexml/schema/external/xlink.xsd +75 -0
  33. data/lib/bio/db/nexml/schema/external/xml.xsd +145 -0
  34. data/lib/bio/db/nexml/schema/meta/README.txt +2 -0
  35. data/lib/bio/db/nexml/schema/meta/annotations.xsd +100 -0
  36. data/lib/bio/db/nexml/schema/meta/meta.xsd +294 -0
  37. data/lib/bio/db/nexml/schema/nexml.xsd +104 -0
  38. data/lib/bio/db/nexml/schema/taxa/README.txt +2 -0
  39. data/lib/bio/db/nexml/schema/taxa/taxa.xsd +39 -0
  40. data/lib/bio/db/nexml/schema/trees/README.txt +2 -0
  41. data/lib/bio/db/nexml/schema/trees/abstracttrees.xsd +135 -0
  42. data/lib/bio/db/nexml/schema/trees/network.xsd +113 -0
  43. data/lib/bio/db/nexml/schema/trees/tree.xsd +149 -0
  44. data/lib/bio/db/nexml/schema/trees/trees.xsd +36 -0
  45. data/lib/bio/db/nexml/taxa.rb +147 -0
  46. data/lib/bio/db/nexml/trees.rb +663 -0
  47. data/lib/bio/db/nexml/writer.rb +265 -0
  48. data/test/data/nexml/test.xml +69 -0
  49. data/test/test_bio-nexml.rb +17 -0
  50. data/test/unit/bio/db/nexml/tc_factory.rb +119 -0
  51. data/test/unit/bio/db/nexml/tc_mapper.rb +78 -0
  52. data/test/unit/bio/db/nexml/tc_matrix.rb +551 -0
  53. data/test/unit/bio/db/nexml/tc_parser.rb +21 -0
  54. data/test/unit/bio/db/nexml/tc_taxa.rb +118 -0
  55. data/test/unit/bio/db/nexml/tc_trees.rb +370 -0
  56. data/test/unit/bio/db/nexml/tc_writer.rb +633 -0
  57. metadata +253 -0
@@ -0,0 +1,633 @@
1
+ require 'bio/db/nexml/writer'
2
+
3
+ module Bio
4
+ module NeXML
5
+
6
+ module TestWriterHelper
7
+ # This module defines test helpers.
8
+ # TEST_FILE_PATH points to a very small nexml file that defines all the nexml elements.
9
+ # The idea is to initialize two XML::Node objects: first, by parsing the test file, and
10
+ # the second by calling serialize_* methods on NeXML::Writer object and assert their equality.
11
+ # If they are equal, the NeXML::Writer#serialize_* methods pass the test. This equality is
12
+ # asserted by the match? helper method defined in this module.
13
+
14
+ TEST_FILE_PATH = File.join File.dirname(__FILE__), ['..'] * 4, 'data', 'nexml', 'test.xml'
15
+
16
+ # Parse the test file.
17
+ def parse
18
+ @doc = XML::Document.file TEST_FILE_PATH, :options => XML::Parser::Options::NOBLANKS
19
+ end
20
+
21
+ # Return the first occurence of a tag by name in the test file.
22
+ def element( name )
23
+ @doc.find( "//nex:#{name}", 'nex:http://www.nexml.org/2009' )
24
+ end
25
+
26
+ # If an attribte is associated with a namespace, say: 'xsi:type', the XML::Attr#name function
27
+ # returns the name without the namespace prefix. The redefined XML::Attr#name returns the
28
+ # qualified name( with the prefix ) of the node.
29
+ XML::Attr.class_eval do
30
+ alias old_name name
31
+ def name
32
+ return old_name unless self.ns?
33
+ "#{self.ns.prefix}:#{old_name}"
34
+ end
35
+ end
36
+
37
+ # Compare two XML::Nodes for equality based on the following criteria:
38
+ # * same name,
39
+ # * same attributes( irrespective of the order )
40
+ # * same children( irrespective of the order )
41
+ def match?( node1, node2 )
42
+ # not equal if their names do not match
43
+
44
+ attributes1 = node1.attributes.map( &:to_s )
45
+ attributes2 = node2.attributes.map( &:to_s )
46
+
47
+ # not equal if both do not have the same number of attributes
48
+ return false unless attributes1.length == attributes2.length
49
+
50
+ # if the nodes have same number of attributes, compare them
51
+ unless attributes1.empty? and attributes2.empty?
52
+ attributes1.each do |attr1|
53
+ # not equal if attr1 can not be found in attributes2
54
+ return false unless attributes2.find{ |attr2| attr1 == attr2 }
55
+ end
56
+ end
57
+
58
+ children1 = node1.children
59
+ children2 = node2.children
60
+
61
+ # not equal if number of child nodes do not match
62
+ return false unless children1.length == children2.length
63
+
64
+ # if the nodes have same number of children, compare them
65
+ unless children1.empty? and children2.empty?
66
+ children1.each do |child1|
67
+ #not equal if child1 can't be found in children2
68
+ return false unless children2.find{ |child2| match?( child1, child2 ) }
69
+ end
70
+ end
71
+
72
+ true
73
+ end
74
+
75
+ end
76
+
77
+ class TestTestWriterHelper < Test::Unit::TestCase
78
+ include TestWriterHelper
79
+
80
+ # should pass the criteria( see the definition of match? ) of a node's equality.
81
+ def test_match
82
+ # two nodes with same name
83
+ node1 = XML::Node.new( 'nexml' )
84
+ node2 = XML::Node.new( 'nexml' )
85
+
86
+ # same attributes
87
+ node1.attributes = { :version => '0.9', :generator => 'bioruby' }
88
+ node2.attributes = { :generator => 'bioruby', :version => '0.9' }
89
+
90
+ # childe nodes for node1
91
+ child11 = XML::Node.new( 'otus' )
92
+ child12 = XML::Node.new( 'otus' )
93
+ child11.attributes = { :id => 'taxa1', :label => 'Taxa 1' }
94
+ child12.attributes = { :id => 'taxa2', :label => 'Taxa 2' }
95
+
96
+ # childe nodes for node2
97
+ child21 = XML::Node.new( 'otus' )
98
+ child22 = XML::Node.new( 'otus' )
99
+ child21.attributes = { :id => 'taxa1', :label => 'Taxa 1' }
100
+ child22.attributes = { :id => 'taxa2', :label => 'Taxa 2' }
101
+
102
+ # same children
103
+ node1 << child11
104
+ node1 << child12
105
+ node2 << child22
106
+ node2 << child21
107
+
108
+ assert match?( node1, node2 )
109
+ end
110
+ end
111
+
112
+ class TestWriter < Test::Unit::TestCase
113
+ include TestWriterHelper
114
+
115
+ def setup
116
+ @writer = Bio::NeXML::Writer.new; parse
117
+ end
118
+
119
+ # should respond properly to :id, and :label
120
+ def test_attributes_1
121
+ otu1 = Bio::NeXML::Otu.new( 'o1', :label => 'otu 1' )
122
+ otu2 = Bio::NeXML::Otu.new( 'o2' )
123
+
124
+ ae1 = { :id => 'o1', :label => 'otu 1' }
125
+ ae2 = { :id => 'o2' }
126
+
127
+ aa1 = @writer.send( :attributes, otu1, :id, :label )
128
+ aa2 = @writer.send( :attributes, otu2, :id, :label )
129
+
130
+ assert_equal ae1, aa1
131
+ assert_equal ae2, aa2
132
+ end
133
+
134
+ # should respond properly to :symbol
135
+ def test_attributes_2
136
+ ds = Bio::NeXML::State.new( 'ds1', 'A' )
137
+ ss = Bio::NeXML::State.new( 'ss1', '1' )
138
+
139
+ ae1 = { :symbol => 'A' }
140
+ ae2 = { :symbol => '1' }
141
+
142
+ aa1 = @writer.send( :attributes, ds, :symbol )
143
+ aa2 = @writer.send( :attributes, ss, :symbol )
144
+
145
+ assert_equal ae1, aa1
146
+ assert_equal ae2, aa2
147
+ end
148
+
149
+ # should respond properly to :"xsi:type"
150
+ def test_attributes_3
151
+ t = Bio::NeXML::IntTree.new 'tree1'
152
+ n = Bio::NeXML::FloatNetwork.new 'network1'
153
+ dc1 = Bio::NeXML::DnaSeqs.new( 'dnacharacters1' )
154
+ dc2 = Bio::NeXML::DnaCells.new( 'dnacharacters2' )
155
+
156
+ ae1 = { :"xsi:type" => "nex:IntTree" }
157
+ ae2 = { :"xsi:type" => "nex:FloatNetwork" }
158
+ ae3 = { :"xsi:type" => "nex:DnaSeqs" }
159
+ ae4 = { :"xsi:type" => "nex:DnaCells" }
160
+
161
+ aa1 = @writer.send( :attributes, t, :"xsi:type" )
162
+ aa2 = @writer.send( :attributes, n, :"xsi:type" )
163
+ aa3 = @writer.send( :attributes, dc1, :"xsi:type" )
164
+ aa4 = @writer.send( :attributes, dc2, :"xsi:type" )
165
+
166
+ assert_equal ae1, aa1
167
+ assert_equal ae2, aa2
168
+ assert_equal ae3, aa3
169
+ assert_equal ae4, aa4
170
+ end
171
+
172
+ # should respond properly to :root and :otu
173
+ def test_attributes_4
174
+ o = Bio::NeXML::Otu.new( 'o1' )
175
+ n1 = Bio::NeXML::Node.new( 'n1', :otu => o, :root => true )
176
+ n2 = Bio::NeXML::Node.new( 'n2' )
177
+
178
+ ae1 = { :otu => 'o1', :root => 'true' }
179
+ ae2 = {}
180
+
181
+ aa1 = @writer.send( :attributes, n1, :otu, :root )
182
+ aa2 = @writer.send( :attributes, n2, :otu, :root )
183
+
184
+ assert_equal ae1, aa1
185
+ assert_equal ae2, aa2
186
+ end
187
+
188
+ # should respond properly to :otus
189
+ def test_attributes_5
190
+ o = Bio::NeXML::Otus.new( 'o1' )
191
+ t = Bio::NeXML::Trees.new( 't1', :otus => o )
192
+
193
+ ae = { :otus => 'o1' }
194
+ aa = @writer.send( :attributes, t, :otus )
195
+
196
+ assert_equal ae, aa
197
+ end
198
+
199
+ # shold respond properly to :char and :state
200
+ def test_attributes_6
201
+ cc = Bio::NeXML::ContinuousCell.new
202
+ cc.char = Bio::NeXML::Char.new( 'cc1' )
203
+ cc.state = '-0.9'
204
+ dc = Bio::NeXML::Cell.new
205
+ dc.char = Bio::NeXML::Char.new( 'dc1', nil )
206
+ dc.state = Bio::NeXML::State.new 'ds1', 'A'
207
+
208
+ ae1 = { :char => 'cc1', :state => '-0.9' }
209
+ ae2 = { :char => 'dc1', :state => 'ds1' }
210
+
211
+ aa1 = @writer.send( :attributes, cc, :char, :state )
212
+ aa2 = @writer.send( :attributes, dc, :char, :state )
213
+
214
+ assert_equal ae1, aa1
215
+ assert_equal ae2, aa2
216
+ end
217
+
218
+ # shold respond properly to :source and :target and :length
219
+ def test_attributes_7
220
+ n1 = Bio::NeXML::Node.new 'n1'
221
+ n2 = Bio::NeXML::Node.new 'n2'
222
+ e = Bio::NeXML::IntEdge.new 'e1', :source => n1, :target => n2
223
+ re = Bio::NeXML::RootEdge.new 're1', :target => n1, :length => 2
224
+
225
+ ae1 = { :source => 'n1', :target => 'n2', :length => '0' }
226
+ ae2 = { :target => 'n1', :length => '2' }
227
+
228
+ aa1 = @writer.send( :attributes, e, :source, :target, :length )
229
+ aa2 = @writer.send( :attributes, re, :source, :target, :length )
230
+
231
+ assert_equal ae1, aa1
232
+ assert_equal ae2, aa2
233
+ end
234
+
235
+ # shold respond properly to :states
236
+ def test_attributes_8
237
+ ds = Bio::NeXML::States.new( 'ds1' )
238
+ dc = Bio::NeXML::Char.new( 'dc1', :states => ds )
239
+
240
+ ae = { :states => 'ds1' }
241
+
242
+ aa = @writer.send( :attributes, dc, :states )
243
+
244
+ assert_equal ae, aa
245
+ end
246
+
247
+ # tag should create a XML::Node
248
+ def test_create_node
249
+ node1 = XML::Node.new( 'nexml' )
250
+ node1.attributes = { :version => '0.9' }
251
+
252
+ node2 = @writer.send( :create_node, 'nexml', :version => '0.9' )
253
+
254
+ assert_equal node1, node2
255
+ end
256
+
257
+ def test_serialize_otu
258
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
259
+ output = o1.to_xml
260
+ parsed = element( 'otu' ).first
261
+ assert match?( parsed, output )
262
+ end
263
+
264
+ def test_serialize_otus
265
+ taxa1 = Bio::NeXML::Otus.new 'taxa1', :label => 'A taxa block'
266
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
267
+ o2 = Bio::NeXML::Otu.new 'o2', :label => 'A taxon'
268
+ taxa1.add_otu( o1 )
269
+ taxa1.add_otu( o2 )
270
+
271
+ output = taxa1.to_xml
272
+ parsed = element( 'otus' ).first
273
+
274
+ assert match?( parsed, output )
275
+ end
276
+
277
+ def test_serialize_node
278
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
279
+ n1 = Bio::NeXML::Node.new 'n1', :otu => o1, :root => true, :label => 'A node'
280
+
281
+ output = n1.to_xml
282
+ parsed = element( 'node' ).first
283
+
284
+ assert match?( parsed, output )
285
+ end
286
+
287
+ def test_serialize_edge
288
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
289
+ o2 = Bio::NeXML::Otu.new 'o2', :label => 'A taxon'
290
+ n1 = Bio::NeXML::Node.new 'n1', :otu => o1, :root => true, :label => 'A node'
291
+ n2 = Bio::NeXML::Node.new 'n2', :otu => o2, :root => false, :label => 'A node'
292
+ e1 = Bio::NeXML::Edge.new 'e1', :source => n1, :target => n2, :length => 0.4353, :label => 'An edge'
293
+
294
+ output = e1.to_xml
295
+ parsed = element( 'edge' ).first
296
+
297
+ assert match?( parsed, output )
298
+ end
299
+
300
+ def test_serailize_rootedge
301
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
302
+ n1 = Bio::NeXML::Node.new 'n1', :otu => o1, :root => true, :label => 'A node'
303
+ re1 = Bio::NeXML::RootEdge.new 're1', :target => n1, :length => 0.5, :label => 'A rootedge'
304
+
305
+ output = re1.to_xml
306
+ parsed = element( 'rootedge' ).first
307
+
308
+ assert match?( parsed, output )
309
+ end
310
+
311
+ def test_serialize_tree
312
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
313
+ n1 = Bio::NeXML::Node.new 'n1', :otu => o1, :root => true, :label => 'A node'
314
+ n2 = Bio::NeXML::Node.new 'n2', :otu => nil, :root => false, :label => 'A node'
315
+ re1 = Bio::NeXML::RootEdge.new 're1', :target => n1, :length => 0.5, :label => 'A rootedge'
316
+ e1 = Bio::NeXML::Edge.new 'e1', :source => n1, :target => n2, :length => 0.4353, :label => 'An edge'
317
+ tree1 = Bio::NeXML::FloatTree.new 'tree1', :label => 'A float tree'
318
+ tree1.add_node n1
319
+ tree1.add_node n2
320
+ tree1.add_rootedge re1
321
+ tree1.add_edge e1
322
+
323
+ output = tree1.to_xml
324
+ parsed = element( 'tree' ).first
325
+ assert match?( parsed, output )
326
+ end
327
+
328
+ def test_serialize_network
329
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
330
+ n1 = Bio::NeXML::Node.new 'n1n1', :otu => o1, :root => true, :label => 'A node'
331
+ n2 = Bio::NeXML::Node.new 'n1n2', :otu => nil, :root => false, :label => 'A node'
332
+ e1 = Bio::NeXML::Edge.new 'n1e1', :source => n1, :target => n2, :length => 1, :label => 'An edge'
333
+ e2 = Bio::NeXML::Edge.new 'n1e2', :source => n2, :target => n2, :length => 0, :label => 'An edge'
334
+ network1 = Bio::NeXML::IntNetwork.new 'network1', :label => 'An int network'
335
+ network1.add_node n1
336
+ network1.add_node n2
337
+ network1.add_edge e1
338
+ network1.add_edge e2
339
+
340
+ output = network1.to_xml
341
+ parsed = element( 'network' ).first
342
+
343
+ assert match?( parsed, output )
344
+ end
345
+
346
+ def test_serialize_trees
347
+ o1 = Bio::NeXML::Otu.new 'o1', :label => 'A taxon'
348
+
349
+ n1 = Bio::NeXML::Node.new 'n1', :otu => o1, :root => true, :label => 'A node'
350
+ n2 = Bio::NeXML::Node.new 'n2', :otu => nil, :root => false, :label => 'A node'
351
+ re1 = Bio::NeXML::RootEdge.new 're1', :target => n1, :length => 0.5, :label => 'A rootedge'
352
+ e1 = Bio::NeXML::Edge.new 'e1', :source => n1, :target => n2, :length => 0.4353, :label => 'An edge'
353
+ tree1 = Bio::NeXML::FloatTree.new 'tree1', :label => 'A float tree'
354
+
355
+ tree1.add_node n1
356
+ tree1.add_node n2
357
+ tree1.add_rootedge re1
358
+ tree1.add_edge e1
359
+
360
+ n1 = Bio::NeXML::Node.new 'n1n1', :otu => o1, :root => true, :label => 'A node'
361
+ n2 = Bio::NeXML::Node.new 'n1n2', :otu => nil, :root => false, :label => 'A node'
362
+ e1 = Bio::NeXML::Edge.new 'n1e1', :source => n1, :target => n2, :length => 1, :label => 'An edge'
363
+ e2 = Bio::NeXML::Edge.new 'n1e2', :source => n2, :target => n2, :length => 0, :label => 'An edge'
364
+ network1 = Bio::NeXML::IntNetwork.new 'network1', :label => 'An int network'
365
+
366
+ network1.add_node n1
367
+ network1.add_node n2
368
+ network1.add_edge e1
369
+ network1.add_edge e2
370
+
371
+ taxa1 = Bio::NeXML::Otus.new 'taxa1'
372
+ trees1 = Bio::NeXML::Trees.new 'trees1', :otus => taxa1, :label => 'A tree container'
373
+ trees1 << tree1
374
+ trees1 << network1
375
+
376
+ output = trees1.to_xml
377
+ parsed = element( 'trees' ).first
378
+ assert match?( parsed, output )
379
+ end
380
+
381
+ def test_serialize_uncertain_state_set
382
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
383
+ ss2 = Bio::NeXML::State.new 'ss2', :symbol => '2'
384
+ uss1 = Bio::NeXML::State.new 'ss5', :symbol => '5'
385
+ uss1.ambiguity = :uncertain
386
+ uss1.add_member( ss1 )
387
+ uss1.add_member( ss2 )
388
+
389
+ output = uss1.to_xml
390
+ parsed = element( 'uncertain_state_set' ).first
391
+
392
+ assert match?( parsed, output )
393
+ end
394
+
395
+ def test_serialize_polymorphic_state_set
396
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
397
+ ss2 = Bio::NeXML::State.new 'ss2', :symbol => '2'
398
+ pss1 = Bio::NeXML::State.new 'ss4', :symbol => '4'
399
+ pss1.ambiguity = :polymorphic
400
+ pss1.add_member( ss1 )
401
+ pss1.add_member( ss2 )
402
+
403
+ output = pss1.to_xml
404
+ parsed = element( 'polymorphic_state_set' ).first
405
+
406
+ assert match?( parsed, output )
407
+ end
408
+
409
+ def test_serialize_state
410
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
411
+
412
+ output = ss1.to_xml
413
+ parsed = element( 'state' ).first
414
+
415
+ assert match?( parsed, output )
416
+ end
417
+
418
+ def test_serialize_states
419
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
420
+ ss2 = Bio::NeXML::State.new 'ss2', :symbol => '2'
421
+ sss1 = Bio::NeXML::States.new 'sss1'
422
+
423
+ pss1 = Bio::NeXML::State.new 'ss4', :symbol => '4'
424
+ pss1.ambiguity = :polymorphic
425
+ pss1.add_member( ss1 )
426
+ pss1.add_member( ss2 )
427
+
428
+ uss1 = Bio::NeXML::State.new 'ss5', :symbol => '5'
429
+ uss1.ambiguity = :uncertain
430
+ uss1.add_member( ss1 )
431
+ uss1.add_member( ss2 )
432
+
433
+ sss1.add_state( ss1 )
434
+ sss1.add_state( ss2 )
435
+
436
+ sss1.add_state( uss1 )
437
+ sss1.add_state( pss1 )
438
+
439
+ output = sss1.to_xml
440
+ parsed = element( 'states' ).first
441
+
442
+ assert match?( parsed, output )
443
+ end
444
+
445
+ def test_char
446
+ sss1 = Bio::NeXML::States.new 'sss1'
447
+ sc1 = Bio::NeXML::Char.new 'sc1', :states => sss1
448
+
449
+ output = sc1.to_xml
450
+ parsed = element( 'char' ).first
451
+
452
+ assert match?( parsed, output )
453
+ end
454
+
455
+ def test_format
456
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
457
+ ss2 = Bio::NeXML::State.new 'ss2', :symbol => '2'
458
+ sss1 = Bio::NeXML::States.new 'sss1'
459
+
460
+ pss1 = Bio::NeXML::State.new 'ss4', :symbol => '4'
461
+ pss1.ambiguity = :polymorphic
462
+ pss1.add_member( ss1 )
463
+ pss1.add_member( ss2 )
464
+
465
+ uss1 = Bio::NeXML::State.new 'ss5', :symbol => '5'
466
+ uss1.ambiguity = :uncertain
467
+ uss1.add_member( ss1 )
468
+ uss1.add_member( ss2 )
469
+
470
+ sss1.add_state( ss1 )
471
+ sss1.add_state( ss2 )
472
+ sss1.add_state( uss1 )
473
+ sss1.add_state( pss1 )
474
+
475
+ sc1 = Bio::NeXML::Char.new 'sc1', :states => sss1
476
+ sc2 = Bio::NeXML::Char.new 'sc2', :states => sss1
477
+
478
+ sf1 = Bio::NeXML::Format.new
479
+ sf1.add_states( sss1 )
480
+ sf1.add_char( sc1 )
481
+ sf1.add_char( sc2 )
482
+
483
+ output = sf1.to_xml
484
+ parsed = element( 'format' ).first
485
+
486
+ assert match?( parsed, output )
487
+ end
488
+
489
+ def test_serialize_seq
490
+ sseq1 = Bio::NeXML::Sequence.new
491
+ sseq1.value = "1 2"
492
+
493
+ output = sseq1.to_xml
494
+ parsed = element( 'seq' ).first
495
+
496
+ assert match?( parsed, output )
497
+ end
498
+
499
+ def test_serialize_cell
500
+ sss2 = Bio::NeXML::States.new 'sss2'
501
+ ss6 = Bio::NeXML::State.new 'ss6', :symbol => '1'
502
+ sc3 = Bio::NeXML::Char.new 'sc3', :states => sss2
503
+
504
+ scell1 = Bio::NeXML::Cell.new
505
+ scell1.char = sc3
506
+ scell1.state = ss6
507
+
508
+ output = scell1.to_xml
509
+ parsed = element( 'cell' ).first
510
+
511
+ assert match?( parsed, output )
512
+ end
513
+
514
+ def test_sereialize_seq_row
515
+ o1 = Bio::NeXML::Otu.new 'o1'
516
+ sseq1 = Bio::NeXML::Sequence.new
517
+ sseq1.value = "1 2"
518
+ sr1 = Bio::NeXML::SeqRow.new 'sr1', :otu => o1
519
+ sr1.add_sequence( sseq1 )
520
+
521
+ output = sr1.to_xml
522
+ parsed = element( 'row' ).first
523
+
524
+ assert match?( parsed, output )
525
+ end
526
+
527
+ def test_serialize_cell_row
528
+ o1 = Bio::NeXML::Otu.new 'o1'
529
+ sss2 = Bio::NeXML::States.new 'sss2'
530
+ ss6 = Bio::NeXML::State.new 'ss6', :symbol => '1'
531
+ sc3 = Bio::NeXML::Char.new 'sc3', :states => sss2
532
+
533
+ scell1 = Bio::NeXML::Cell.new
534
+ scell1.char = sc3
535
+ scell1.state = ss6
536
+
537
+ sr3 = Bio::NeXML::CellRow.new 'sr3', :otu => o1
538
+ sr3.add_cell( scell1 )
539
+
540
+ output = sr3.to_xml
541
+ parsed = element( 'row' ).last
542
+
543
+ assert match?( parsed, output )
544
+ end
545
+
546
+ def test_serialize_matrix
547
+ o1 = Bio::NeXML::Otu.new 'o1'
548
+ o2 = Bio::NeXML::Otu.new 'o2'
549
+
550
+ sseq1 = Bio::NeXML::Sequence.new
551
+ sseq1.value = "1 2"
552
+
553
+ sseq2 = Bio::NeXML::Sequence.new
554
+ sseq2.value = "2 2"
555
+
556
+ sr1 = Bio::NeXML::SeqRow.new 'sr1', :otu => o1
557
+ sr2 = Bio::NeXML::SeqRow.new 'sr2', :otu => o2
558
+
559
+ sr1.add_sequence( sseq1 )
560
+ sr2.add_sequence( sseq2 )
561
+
562
+ m = Bio::NeXML::Matrix.new
563
+ m.add_row( sr1 )
564
+ m.add_row( sr2 )
565
+
566
+ output = m.to_xml
567
+ parsed = element( 'matrix' ).first
568
+
569
+ assert match?( parsed, output )
570
+ end
571
+
572
+ def test_serialize_characters
573
+ ss1 = Bio::NeXML::State.new 'ss1', :symbol => '1'
574
+ ss2 = Bio::NeXML::State.new 'ss2', :symbol => '2'
575
+ sss1 = Bio::NeXML::States.new 'sss1'
576
+
577
+ pss1 = Bio::NeXML::State.new 'ss4', :symbol => '4'
578
+ pss1.ambiguity = :polymorphic
579
+ pss1.add_member( ss1 )
580
+ pss1.add_member( ss2 )
581
+
582
+ uss1 = Bio::NeXML::State.new 'ss5', :symbol => '5'
583
+ uss1.ambiguity = :uncertain
584
+ uss1.add_member( ss1 )
585
+ uss1.add_member( ss2 )
586
+
587
+ sss1.add_state( ss1 )
588
+ sss1.add_state( ss2 )
589
+ sss1.add_state( uss1 )
590
+ sss1.add_state( pss1 )
591
+
592
+ sc1 = Bio::NeXML::Char.new 'sc1', :states => sss1
593
+ sc2 = Bio::NeXML::Char.new 'sc2', :states => sss1
594
+
595
+ sf1 = Bio::NeXML::Format.new
596
+ sf1.add_states( sss1 )
597
+ sf1.add_char( sc1 )
598
+ sf1.add_char( sc2 )
599
+
600
+ o1 = Bio::NeXML::Otu.new 'o1'
601
+ o2 = Bio::NeXML::Otu.new 'o2'
602
+
603
+ sseq1 = Bio::NeXML::Sequence.new
604
+ sseq1.value = "1 2"
605
+
606
+ sseq2 = Bio::NeXML::Sequence.new
607
+ sseq2.value = "2 2"
608
+
609
+ sr1 = Bio::NeXML::SeqRow.new 'sr1', :otu => o1
610
+ sr2 = Bio::NeXML::SeqRow.new 'sr2', :otu => o2
611
+
612
+ sr1.add_sequence( sseq1 )
613
+ sr2.add_sequence( sseq2 )
614
+
615
+ m = Bio::NeXML::Matrix.new
616
+ m.add_row( sr1 )
617
+ m.add_row( sr2 )
618
+
619
+ taxa1 = Bio::NeXML::Otus.new 'taxa1'
620
+
621
+ c1 = Bio::NeXML::StandardSeqs.new 'standardchars6', :otus => taxa1, :label => 'Standard sequences'
622
+ c1.format = sf1
623
+ c1.matrix = m
624
+
625
+ output = c1.to_xml
626
+ parsed = element( 'characters' ).first
627
+ assert match?( parsed, output )
628
+ end
629
+
630
+ end # end class TestWriter
631
+
632
+ end # end module NeXML
633
+ end # end module Bio