nexus_parser 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. data/VERSION +1 -1
  2. data/lib/lexer.rb +4 -4
  3. data/lib/{nexus_file.rb → nexus_parser.rb} +20 -21
  4. data/lib/parser.rb +92 -92
  5. data/lib/tokens.rb +40 -40
  6. data/nexus_parser.gemspec +61 -0
  7. data/test/MX_test_03.nex +234 -234
  8. data/test/test_nexus_parser.rb +210 -213
  9. metadata +5 -4
data/test/test_nexus_parser.rb CHANGED
@@ -2,7 +2,7 @@ require 'test/unit'
2
2
  require 'rubygems'
3
3
  require 'ruby-debug'
4
4
 
5
- require File.expand_path(File.join(File.dirname(__FILE__), '../lib/nexus_file'))
5
+ require File.expand_path(File.join(File.dirname(__FILE__), '../lib/nexus_parser'))
6
6
 
7
7
  class NexusParserTest < Test::Unit::TestCase
8
8
  def test_truth
@@ -10,9 +10,9 @@ class NexusParserTest < Test::Unit::TestCase
10
10
  end
11
11
  end
12
12
 
13
- class Test_NexusFile_Builder < Test::Unit::TestCase
13
+ class Test_NexusParser_Builder < Test::Unit::TestCase
14
14
  def test_builder
15
- b = NexusFile::Builder.new
15
+ b = NexusParser::Builder.new
16
16
  assert foo = b.nexus_file
17
17
  assert_equal [], foo.taxa
18
18
  assert_equal [], foo.characters
@@ -34,221 +34,221 @@ end
34
34
 
35
35
  class Test_Lexer < Test::Unit::TestCase
36
36
  def test_lexer
37
- lexer = NexusFile::Lexer.new("[ foo ] BEGIN taxa; BLORF end;")
38
- assert lexer.pop(NexusFile::Tokens::LBracket)
39
- assert id = lexer.pop(NexusFile::Tokens::ID)
37
+ lexer = NexusParser::Lexer.new("[ foo ] BEGIN taxa; BLORF end;")
38
+ assert lexer.pop(NexusParser::Tokens::LBracket)
39
+ assert id = lexer.pop(NexusParser::Tokens::ID)
40
40
  assert_equal(id.value, "foo")
41
- assert lexer.pop(NexusFile::Tokens::RBracket)
42
- assert lexer.pop(NexusFile::Tokens::BeginBlk)
43
- assert lexer.pop(NexusFile::Tokens::TaxaBlk)
44
- assert foo = lexer.pop(NexusFile::Tokens::ID)
41
+ assert lexer.pop(NexusParser::Tokens::RBracket)
42
+ assert lexer.pop(NexusParser::Tokens::BeginBlk)
43
+ assert lexer.pop(NexusParser::Tokens::TaxaBlk)
44
+ assert foo = lexer.pop(NexusParser::Tokens::ID)
45
45
  assert_equal("BLORF", foo.value) # truncating whitespace
46
- assert lexer.pop(NexusFile::Tokens::BlkEnd)
46
+ assert lexer.pop(NexusParser::Tokens::BlkEnd)
47
47
 
48
- lexer2 = NexusFile::Lexer.new("[ foo ] begin authors; BLORF end; [] () some crud here")
49
- assert lexer2.pop(NexusFile::Tokens::LBracket)
50
- assert id = lexer2.pop(NexusFile::Tokens::ID)
48
+ lexer2 = NexusParser::Lexer.new("[ foo ] begin authors; BLORF end; [] () some crud here")
49
+ assert lexer2.pop(NexusParser::Tokens::LBracket)
50
+ assert id = lexer2.pop(NexusParser::Tokens::ID)
51
51
  assert_equal(id.value, "foo")
52
- assert lexer2.pop(NexusFile::Tokens::RBracket)
53
- assert lexer2.pop(NexusFile::Tokens::BeginBlk)
54
- assert lexer2.pop(NexusFile::Tokens::AuthorsBlk)
55
- assert lexer2.pop(NexusFile::Tokens::LBracket)
56
- assert lexer2.pop(NexusFile::Tokens::RBracket)
57
- assert lexer2.pop(NexusFile::Tokens::LParen)
58
- assert lexer2.pop(NexusFile::Tokens::RParen)
59
-
60
-
61
- lexer3 = NexusFile::Lexer.new("[ foo ] Begin Characters; BLORF end; [] () some crud here")
62
- assert lexer3.pop(NexusFile::Tokens::LBracket)
63
- assert id = lexer3.pop(NexusFile::Tokens::ID)
52
+ assert lexer2.pop(NexusParser::Tokens::RBracket)
53
+ assert lexer2.pop(NexusParser::Tokens::BeginBlk)
54
+ assert lexer2.pop(NexusParser::Tokens::AuthorsBlk)
55
+ assert lexer2.pop(NexusParser::Tokens::LBracket)
56
+ assert lexer2.pop(NexusParser::Tokens::RBracket)
57
+ assert lexer2.pop(NexusParser::Tokens::LParen)
58
+ assert lexer2.pop(NexusParser::Tokens::RParen)
59
+
60
+
61
+ lexer3 = NexusParser::Lexer.new("[ foo ] Begin Characters; BLORF end; [] () some crud here")
62
+ assert lexer3.pop(NexusParser::Tokens::LBracket)
63
+ assert id = lexer3.pop(NexusParser::Tokens::ID)
64
64
  assert_equal(id.value, "foo")
65
- assert lexer3.pop(NexusFile::Tokens::RBracket)
66
- assert lexer3.pop(NexusFile::Tokens::BeginBlk)
67
- assert lexer3.pop(NexusFile::Tokens::ChrsBlk)
68
- assert foo = lexer3.pop(NexusFile::Tokens::ID)
65
+ assert lexer3.pop(NexusParser::Tokens::RBracket)
66
+ assert lexer3.pop(NexusParser::Tokens::BeginBlk)
67
+ assert lexer3.pop(NexusParser::Tokens::ChrsBlk)
68
+ assert foo = lexer3.pop(NexusParser::Tokens::ID)
69
69
  assert_equal("BLORF", foo.value)
70
- assert lexer3.pop(NexusFile::Tokens::BlkEnd)
70
+ assert lexer3.pop(NexusParser::Tokens::BlkEnd)
71
71
 
72
- lexer4 = NexusFile::Lexer.new("Begin Characters; 123123123 end; [] () some crud here")
73
- assert lexer4.pop(NexusFile::Tokens::BeginBlk)
74
- assert lexer4.pop(NexusFile::Tokens::ChrsBlk)
75
- assert foo = lexer4.pop(NexusFile::Tokens::Number)
72
+ lexer4 = NexusParser::Lexer.new("Begin Characters; 123123123 end; [] () some crud here")
73
+ assert lexer4.pop(NexusParser::Tokens::BeginBlk)
74
+ assert lexer4.pop(NexusParser::Tokens::ChrsBlk)
75
+ assert foo = lexer4.pop(NexusParser::Tokens::Number)
76
76
  assert_equal(123123123, foo.value)
77
- assert lexer4.pop(NexusFile::Tokens::BlkEnd)
77
+ assert lexer4.pop(NexusParser::Tokens::BlkEnd)
78
78
 
79
- lexer5 = NexusFile::Lexer.new("(0,1)")
80
- assert lexer5.pop(NexusFile::Tokens::LParen)
81
- assert foo = lexer5.pop(NexusFile::Tokens::Number)
79
+ lexer5 = NexusParser::Lexer.new("(0,1)")
80
+ assert lexer5.pop(NexusParser::Tokens::LParen)
81
+ assert foo = lexer5.pop(NexusParser::Tokens::Number)
82
82
  assert_equal(0, foo.value)
83
- assert lexer5.pop(NexusFile::Tokens::Comma)
84
- assert foo = lexer5.pop(NexusFile::Tokens::Number)
83
+ assert lexer5.pop(NexusParser::Tokens::Comma)
84
+ assert foo = lexer5.pop(NexusParser::Tokens::Number)
85
85
  assert_equal(1, foo.value)
86
- assert lexer5.pop(NexusFile::Tokens::RParen)
86
+ assert lexer5.pop(NexusParser::Tokens::RParen)
87
87
 
88
- lexer6 = NexusFile::Lexer.new(" 210(0,1)10A1\n")
89
- assert foo = lexer6.pop(NexusFile::Tokens::RowVec)
88
+ lexer6 = NexusParser::Lexer.new(" 210(0,1)10A1\n")
89
+ assert foo = lexer6.pop(NexusParser::Tokens::RowVec)
90
90
  assert_equal(["2","1","0",["0","1"],"1","0","A","1"], foo.value)
91
91
 
92
- lexer6a = NexusFile::Lexer.new(" 21a(0 1)0b{3 4 5}(0)(1 a)\n")
93
- assert foo = lexer6a.pop(NexusFile::Tokens::RowVec)
92
+ lexer6a = NexusParser::Lexer.new(" 21a(0 1)0b{3 4 5}(0)(1 a)\n")
93
+ assert foo = lexer6a.pop(NexusParser::Tokens::RowVec)
94
94
  assert_equal(["2", "1", "a", ["0", "1"], "0", "b", ["3", "4", "5"], "0", ["1", "a"]], foo.value)
95
95
 
96
- lexer6b = NexusFile::Lexer.new(" 201{0 1}{0 1}0100)\x0A") # *nix line ending
97
- assert foo = lexer6b.pop(NexusFile::Tokens::RowVec)
96
+ lexer6b = NexusParser::Lexer.new(" 201{0 1}{0 1}0100)\x0A") # *nix line ending
97
+ assert foo = lexer6b.pop(NexusParser::Tokens::RowVec)
98
98
  assert_equal(["2", "0", "1", ["0", "1"], ["0", "1"], "0", "1", "0", "0"], foo.value)
99
99
 
100
- lexer6c = NexusFile::Lexer.new(" 201{0 1}{0 1}0100)\x0D\x0A") # * dos line ending
101
- assert foo = lexer6c.pop(NexusFile::Tokens::RowVec)
100
+ lexer6c = NexusParser::Lexer.new(" 201{0 1}{0 1}0100)\x0D\x0A") # * dos line ending
101
+ assert foo = lexer6c.pop(NexusParser::Tokens::RowVec)
102
102
  assert_equal(["2", "0", "1", ["0", "1"], ["0", "1"], "0", "1", "0", "0"], foo.value)
103
103
 
104
104
 
105
- lexer7 = NexusFile::Lexer.new("read nothing till Nexus, not that nexus 13243 Block [] ();, this one: #nexus FOO")
106
- assert foo = lexer7.pop(NexusFile::Tokens::NexusStart)
105
+ lexer7 = NexusParser::Lexer.new("read nothing till Nexus, not that nexus 13243 Block [] ();, this one: #nexus FOO")
106
+ assert foo = lexer7.pop(NexusParser::Tokens::NexusStart)
107
107
  assert_equal('#nexus', foo.value)
108
108
 
109
109
 
110
110
  ## we strip comments before parsing now
111
- # lexer8 = NexusFile::Lexer.new("[ foo ] Begin Characters; BLORF end; [] () some crud here")
112
- # assert foo = lexer8.pop(NexusFile::Tokens::NexusComment)
111
+ # lexer8 = NexusParser::Lexer.new("[ foo ] Begin Characters; BLORF end; [] () some crud here")
112
+ # assert foo = lexer8.pop(NexusParser::Tokens::NexusComment)
113
113
  # assert_equal "foo", foo.value
114
114
 
115
- # assert lexer.pop(NexusFile::Tokens::Colon)
116
- # assert num = lexer.pop(NexusFile::Tokens::Number)
115
+ # assert lexer.pop(NexusParser::Tokens::Colon)
116
+ # assert num = lexer.pop(NexusParser::Tokens::Number)
117
117
  # assert_equal(num.value, 0.0)
118
- # assert lexer.pop(NexusFile::Tokens::Comma)
119
- # assert lexer.pop(NexusFile::Tokens::SemiColon)
118
+ # assert lexer.pop(NexusParser::Tokens::Comma)
119
+ # assert lexer.pop(NexusParser::Tokens::SemiColon)
120
120
  end
121
121
 
122
122
  def test_row_vec
123
- lexer = NexusFile::Lexer.new("0?(0 1)10(A BD , C)1(0,1,2)1-\n")
124
- assert foo = lexer.pop(NexusFile::Tokens::RowVec)
123
+ lexer = NexusParser::Lexer.new("0?(0 1)10(A BD , C)1(0,1,2)1-\n")
124
+ assert foo = lexer.pop(NexusParser::Tokens::RowVec)
125
125
  assert_equal(["0", "?", ["0", "1"], "1", "0", ["A", "BD", "C"], "1", ["0", "1", "2"], "1", "-"], foo.value)
126
126
  end
127
127
 
128
128
  def test_punctuation
129
- lexer = NexusFile::Lexer.new(',/=](\'NOT23\'[);,')
130
- assert lexer.peek(NexusFile::Tokens::Comma)
131
- assert lexer.pop(NexusFile::Tokens::Comma)
132
- assert lexer.pop(NexusFile::Tokens::BckSlash)
133
- assert lexer.pop(NexusFile::Tokens::Equals)
134
- assert lexer.pop(NexusFile::Tokens::RBracket)
135
- assert lexer.pop(NexusFile::Tokens::LParen)
136
- assert foo = lexer.pop(NexusFile::Tokens::Label)
129
+ lexer = NexusParser::Lexer.new(',/=](\'NOT23\'[);,')
130
+ assert lexer.peek(NexusParser::Tokens::Comma)
131
+ assert lexer.pop(NexusParser::Tokens::Comma)
132
+ assert lexer.pop(NexusParser::Tokens::BckSlash)
133
+ assert lexer.pop(NexusParser::Tokens::Equals)
134
+ assert lexer.pop(NexusParser::Tokens::RBracket)
135
+ assert lexer.pop(NexusParser::Tokens::LParen)
136
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
137
137
  assert_equal "NOT23", foo.value
138
- assert lexer.pop(NexusFile::Tokens::LBracket)
139
- assert lexer.pop(NexusFile::Tokens::RParen)
140
- assert lexer.pop(NexusFile::Tokens::SemiColon)
141
- assert lexer.pop(NexusFile::Tokens::Comma)
138
+ assert lexer.pop(NexusParser::Tokens::LBracket)
139
+ assert lexer.pop(NexusParser::Tokens::RParen)
140
+ assert lexer.pop(NexusParser::Tokens::SemiColon)
141
+ assert lexer.pop(NexusParser::Tokens::Comma)
142
142
 
143
143
  end
144
144
 
145
145
  def test_tax_labels
146
- lexer = NexusFile::Lexer.new("Taxlabels 'foo' bar blorf \"stuff things\" stuff 'and foo';")
147
- assert foo = lexer.pop(NexusFile::Tokens::Taxlabels)
146
+ lexer = NexusParser::Lexer.new("Taxlabels 'foo' bar blorf \"stuff things\" stuff 'and foo';")
147
+ assert foo = lexer.pop(NexusParser::Tokens::Taxlabels)
148
148
  assert_equal("Taxlabels ", foo.value)
149
149
  end
150
150
 
151
151
  def test_EndBlk
152
- lexer = NexusFile::Lexer.new(" \n\n End ;")
153
- assert foo = lexer.pop(NexusFile::Tokens::EndBlk)
154
- lexer = NexusFile::Lexer.new("\n\nEnd;")
155
- assert foo = lexer.pop(NexusFile::Tokens::EndBlk)
152
+ lexer = NexusParser::Lexer.new(" \n\n End ;")
153
+ assert foo = lexer.pop(NexusParser::Tokens::EndBlk)
154
+ lexer = NexusParser::Lexer.new("\n\nEnd;")
155
+ assert foo = lexer.pop(NexusParser::Tokens::EndBlk)
156
156
 
157
- lexer = NexusFile::Lexer.new("123123 \n\nEnd;")
158
- assert !lexer.peek(NexusFile::Tokens::EndBlk)
159
- lexer = NexusFile::Lexer.new("this is not an \"end\"\n\nEnd;")
160
- assert !lexer.peek(NexusFile::Tokens::EndBlk)
157
+ lexer = NexusParser::Lexer.new("123123 \n\nEnd;")
158
+ assert !lexer.peek(NexusParser::Tokens::EndBlk)
159
+ lexer = NexusParser::Lexer.new("this is not an \"end\"\n\nEnd;")
160
+ assert !lexer.peek(NexusParser::Tokens::EndBlk)
161
161
  end
162
162
 
163
163
  def test_semicolon
164
- lexer = NexusFile::Lexer.new("; Matrix foo")
165
- assert lexer.peek(NexusFile::Tokens::SemiColon)
166
- assert foo = lexer.pop(NexusFile::Tokens::SemiColon)
164
+ lexer = NexusParser::Lexer.new("; Matrix foo")
165
+ assert lexer.peek(NexusParser::Tokens::SemiColon)
166
+ assert foo = lexer.pop(NexusParser::Tokens::SemiColon)
167
167
  end
168
168
 
169
169
  def test_label
170
- lexer = NexusFile::Lexer.new(' \'foo\' bar, blorf; "stuff things" stuff \'and foo\' 23434 ""asdf"" \'Foo_And_Stuff\' ')
171
- assert foo = lexer.pop(NexusFile::Tokens::Label)
170
+ lexer = NexusParser::Lexer.new(' \'foo\' bar, blorf; "stuff things" stuff \'and foo\' 23434 ""asdf"" \'Foo_And_Stuff\' ')
171
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
172
172
  assert_equal "foo", foo.value
173
- assert foo = lexer.pop(NexusFile::Tokens::Label)
173
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
174
174
  assert_equal "bar", foo.value
175
- assert lexer.pop(NexusFile::Tokens::Comma)
176
- assert foo = lexer.pop(NexusFile::Tokens::Label)
175
+ assert lexer.pop(NexusParser::Tokens::Comma)
176
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
177
177
  assert_equal "blorf", foo.value
178
- assert lexer.pop(NexusFile::Tokens::SemiColon)
179
- assert foo = lexer.pop(NexusFile::Tokens::Label)
178
+ assert lexer.pop(NexusParser::Tokens::SemiColon)
179
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
180
180
  assert_equal "stuff things", foo.value
181
- assert foo = lexer.pop(NexusFile::Tokens::Label)
181
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
182
182
  assert_equal "stuff", foo.value
183
- assert foo = lexer.pop(NexusFile::Tokens::Label)
183
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
184
184
  assert_equal "and foo", foo.value
185
- assert foo = lexer.pop(NexusFile::Tokens::Label)
185
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
186
186
  assert_equal "23434", foo.value
187
- assert foo = lexer.pop(NexusFile::Tokens::Label)
187
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
188
188
  assert_equal '"asdf"', foo.value
189
- assert foo = lexer.pop(NexusFile::Tokens::Label)
189
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
190
190
  assert_equal 'Foo_And_Stuff', foo.value
191
191
  end
192
192
 
193
193
  def test_odd_labels
194
- lexer = NexusFile::Lexer.new("blorf 'fan shaped, narrow base and broad tip (Selkirkiella, Kochiura)' \"\"\" foo \"\"\" '''rupununi''' '''tanzania''' '''cup-shaped''' bar blorf\n;")
195
- assert foo = lexer.pop(NexusFile::Tokens::Label)
194
+ lexer = NexusParser::Lexer.new("blorf 'fan shaped, narrow base and broad tip (Selkirkiella, Kochiura)' \"\"\" foo \"\"\" '''rupununi''' '''tanzania''' '''cup-shaped''' bar blorf\n;")
195
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
196
196
  assert_equal "blorf", foo.value
197
- assert foo = lexer.pop(NexusFile::Tokens::Label)
197
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
198
198
  assert_equal "fan shaped, narrow base and broad tip (Selkirkiella, Kochiura)", foo.value
199
- assert foo = lexer.pop(NexusFile::Tokens::Label)
199
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
200
200
  assert_equal '"" foo ""', foo.value
201
- assert foo = lexer.pop(NexusFile::Tokens::Label)
201
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
202
202
  assert_equal "''rupununi''", foo.value
203
- assert foo = lexer.pop(NexusFile::Tokens::Label)
203
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
204
204
  assert_equal "''tanzania''", foo.value
205
- assert foo = lexer.pop(NexusFile::Tokens::Label)
205
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
206
206
  assert_equal "''cup-shaped''", foo.value
207
- assert foo = lexer.pop(NexusFile::Tokens::Label)
207
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
208
208
  assert_equal "bar", foo.value
209
- assert foo = lexer.pop(NexusFile::Tokens::Label)
209
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
210
210
  assert_equal "blorf", foo.value
211
- assert foo = lexer.pop(NexusFile::Tokens::SemiColon)
211
+ assert foo = lexer.pop(NexusParser::Tokens::SemiColon)
212
212
  end
213
213
 
214
214
  def test_title
215
- lexer = NexusFile::Lexer.new( "TITLE 'Scharff&Coddington_1997_Araneidae';")
216
- assert foo = lexer.pop(NexusFile::Tokens::Title)
215
+ lexer = NexusParser::Lexer.new( "TITLE 'Scharff&Coddington_1997_Araneidae';")
216
+ assert foo = lexer.pop(NexusParser::Tokens::Title)
217
217
  assert_equal "TITLE 'Scharff&Coddington_1997_Araneidae';", foo.value
218
218
  end
219
219
 
220
220
 
221
221
  def test_dimensions
222
222
  input = " DIMENSIONS NCHAR= 10"
223
- lexer = NexusFile::Lexer.new(input)
224
- assert foo = lexer.pop(NexusFile::Tokens::Dimensions)
223
+ lexer = NexusParser::Lexer.new(input)
224
+ assert foo = lexer.pop(NexusParser::Tokens::Dimensions)
225
225
  assert_equal "DIMENSIONS", foo.value
226
226
  end
227
227
 
228
228
  def test_format
229
229
  input = " format NCHAR= 10"
230
- lexer = NexusFile::Lexer.new(input)
231
- assert foo = lexer.pop(NexusFile::Tokens::Format)
230
+ lexer = NexusParser::Lexer.new(input)
231
+ assert foo = lexer.pop(NexusParser::Tokens::Format)
232
232
  assert_equal "format", foo.value
233
233
  end
234
234
 
235
235
  def test_odd_value_pair
236
- lexer = NexusFile::Lexer.new(" TEXT CHARACTER = 3 TEXT = A62.003;
236
+ lexer = NexusParser::Lexer.new(" TEXT CHARACTER = 3 TEXT = A62.003;
237
237
 
238
238
  TEXT CHARACTER = 4 TEXT = A62.004; \n end; ")
239
- assert foo = lexer.pop(NexusFile::Tokens::Label)
240
- assert foo = lexer.pop(NexusFile::Tokens::ValuePair)
239
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
240
+ assert foo = lexer.pop(NexusParser::Tokens::ValuePair)
241
241
  blorf = {:character => "3"}
242
242
  assert_equal blorf , foo.value
243
- assert foo = lexer.pop(NexusFile::Tokens::ValuePair)
243
+ assert foo = lexer.pop(NexusParser::Tokens::ValuePair)
244
244
  blorf = {:text => "A62.003"}
245
245
  assert_equal blorf , foo.value
246
- assert foo = lexer.pop(NexusFile::Tokens::Label)
246
+ assert foo = lexer.pop(NexusParser::Tokens::Label)
247
247
  assert_equal "TEXT", foo.value
248
- assert foo = lexer.pop(NexusFile::Tokens::ValuePair)
248
+ assert foo = lexer.pop(NexusParser::Tokens::ValuePair)
249
249
  blorf = {:character => "4"}
250
250
  assert_equal blorf , foo.value
251
- assert foo = lexer.pop(NexusFile::Tokens::ValuePair)
251
+ assert foo = lexer.pop(NexusParser::Tokens::ValuePair)
252
252
  blorf = {:text => "A62.004"}
253
253
  assert_equal blorf , foo.value
254
254
 
@@ -257,92 +257,92 @@ class Test_Lexer < Test::Unit::TestCase
257
257
 
258
258
  def test_value_pair
259
259
 
260
- lexer0 = NexusFile::Lexer.new(' DATATYPE=STANDARD ')
261
- assert foo = lexer0.pop(NexusFile::Tokens::ValuePair)
260
+ lexer0 = NexusParser::Lexer.new(' DATATYPE=STANDARD ')
261
+ assert foo = lexer0.pop(NexusParser::Tokens::ValuePair)
262
262
  blorf = {:datatype => "STANDARD"}
263
263
  assert_equal blorf , foo.value
264
264
 
265
- lexer = NexusFile::Lexer.new(' DATATYPE = STANDARD ')
266
- assert foo = lexer.pop(NexusFile::Tokens::ValuePair)
265
+ lexer = NexusParser::Lexer.new(' DATATYPE = STANDARD ')
266
+ assert foo = lexer.pop(NexusParser::Tokens::ValuePair)
267
267
  blorf = {:datatype => "STANDARD"}
268
268
  assert_equal blorf , foo.value
269
269
 
270
- lexer2 = NexusFile::Lexer.new(' DATATYPE ="STANDARD" ')
271
- assert foo = lexer2.pop(NexusFile::Tokens::ValuePair)
270
+ lexer2 = NexusParser::Lexer.new(' DATATYPE ="STANDARD" ')
271
+ assert foo = lexer2.pop(NexusParser::Tokens::ValuePair)
272
272
  assert_equal blorf, foo.value
273
273
 
274
- lexer3 = NexusFile::Lexer.new('DATATYPE= "STANDARD" ')
275
- assert foo = lexer3.pop(NexusFile::Tokens::ValuePair)
274
+ lexer3 = NexusParser::Lexer.new('DATATYPE= "STANDARD" ')
275
+ assert foo = lexer3.pop(NexusParser::Tokens::ValuePair)
276
276
  assert_equal blorf, foo.value
277
277
 
278
278
  input= " NCHAR=10 ntaxa =10 nfoo='999' nbar = \" a b c \" ; "
279
- lexer4 = NexusFile::Lexer.new(input)
280
- assert foo = lexer4.pop(NexusFile::Tokens::ValuePair)
279
+ lexer4 = NexusParser::Lexer.new(input)
280
+ assert foo = lexer4.pop(NexusParser::Tokens::ValuePair)
281
281
  smorf = {:nchar => '10'}
282
282
  assert_equal smorf, foo.value
283
- assert foo = lexer4.pop(NexusFile::Tokens::ValuePair)
283
+ assert foo = lexer4.pop(NexusParser::Tokens::ValuePair)
284
284
  smorf = {:ntaxa => '10'}
285
285
  assert_equal smorf, foo.value
286
- assert foo = lexer4.pop(NexusFile::Tokens::ValuePair)
286
+ assert foo = lexer4.pop(NexusParser::Tokens::ValuePair)
287
287
  smorf = {:nfoo => '999'}
288
288
  assert_equal smorf, foo.value
289
- assert foo = lexer4.pop(NexusFile::Tokens::ValuePair)
289
+ assert foo = lexer4.pop(NexusParser::Tokens::ValuePair)
290
290
  smorf = {:nbar => 'a b c'}
291
291
  assert_equal smorf, foo.value
292
292
 
293
- lexer5 = NexusFile::Lexer.new(' symbols= " a c b d 1 " ')
294
- assert foo = lexer5.pop(NexusFile::Tokens::ValuePair)
293
+ lexer5 = NexusParser::Lexer.new(' symbols= " a c b d 1 " ')
294
+ assert foo = lexer5.pop(NexusParser::Tokens::ValuePair)
295
295
  smorf = {:symbols => 'a c b d 1'}
296
296
  assert_equal smorf, foo.value
297
297
 
298
- lexer6 = NexusFile::Lexer.new(' missing = - ')
299
- assert foo = lexer6.pop(NexusFile::Tokens::ValuePair)
298
+ lexer6 = NexusParser::Lexer.new(' missing = - ')
299
+ assert foo = lexer6.pop(NexusParser::Tokens::ValuePair)
300
300
  smorf = {:missing => '-'}
301
301
  assert_equal smorf, foo.value
302
302
 
303
- lexer6a = NexusFile::Lexer.new("ntaxa=1;\n")
304
- assert foo = lexer6a.pop(NexusFile::Tokens::ValuePair)
303
+ lexer6a = NexusParser::Lexer.new("ntaxa=1;\n")
304
+ assert foo = lexer6a.pop(NexusParser::Tokens::ValuePair)
305
305
  smorf = {:ntaxa => '1'}
306
306
  assert_equal smorf, foo.value
307
307
 
308
- lexer7 = NexusFile::Lexer.new("ntaxa =1;\n")
309
- assert foo = lexer7.pop(NexusFile::Tokens::ValuePair)
308
+ lexer7 = NexusParser::Lexer.new("ntaxa =1;\n")
309
+ assert foo = lexer7.pop(NexusParser::Tokens::ValuePair)
310
310
  smorf = {:ntaxa => '1'}
311
311
  assert_equal smorf, foo.value
312
312
 
313
- lexer8 = NexusFile::Lexer.new(" ntaxa = 1 ;\n")
314
- assert foo = lexer8.pop(NexusFile::Tokens::ValuePair)
313
+ lexer8 = NexusParser::Lexer.new(" ntaxa = 1 ;\n")
314
+ assert foo = lexer8.pop(NexusParser::Tokens::ValuePair)
315
315
  smorf = {:ntaxa => '1'}
316
316
  assert_equal smorf, foo.value
317
317
 
318
- lexer9 = NexusFile::Lexer.new(" TF = (CM 'This is an annotation that haa a hard return in it^n^n^n^nSo there!') ")
319
- assert foo = lexer9.pop(NexusFile::Tokens::ValuePair)
318
+ lexer9 = NexusParser::Lexer.new(" TF = (CM 'This is an annotation that haa a hard return in it^n^n^n^nSo there!') ")
319
+ assert foo = lexer9.pop(NexusParser::Tokens::ValuePair)
320
320
  smorf = {:tf => "(CM 'This is an annotation that haa a hard return in it^n^n^n^nSo there!')" }
321
321
  assert_equal smorf, foo.value
322
322
 
323
- lexer10 = NexusFile::Lexer.new(" TF = (CM 'This is an value pair that has (parens) within the value, twice! ()') ; some stuff left here ")
324
- assert foo = lexer10.pop(NexusFile::Tokens::ValuePair)
323
+ lexer10 = NexusParser::Lexer.new(" TF = (CM 'This is an value pair that has (parens) within the value, twice! ()') ; some stuff left here ")
324
+ assert foo = lexer10.pop(NexusParser::Tokens::ValuePair)
325
325
  smorf = {:tf => "(CM 'This is an value pair that has (parens) within the value, twice! ()')" }
326
326
  assert_equal smorf, foo.value
327
327
 
328
- lexer11 = NexusFile::Lexer.new("CHARACTER = 1 TEXT = A62.001;")
329
- assert_equal true, !lexer11.peek(NexusFile::Tokens::SemiColon)
330
- assert_equal true, lexer11.peek(NexusFile::Tokens::ValuePair)
331
- assert foo = lexer11.pop(NexusFile::Tokens::ValuePair)
328
+ lexer11 = NexusParser::Lexer.new("CHARACTER = 1 TEXT = A62.001;")
329
+ assert_equal true, !lexer11.peek(NexusParser::Tokens::SemiColon)
330
+ assert_equal true, lexer11.peek(NexusParser::Tokens::ValuePair)
331
+ assert foo = lexer11.pop(NexusParser::Tokens::ValuePair)
332
332
  smorf = {:character => "1" }
333
333
  assert_equal smorf, foo.value
334
- assert foo = lexer11.pop(NexusFile::Tokens::ValuePair)
334
+ assert foo = lexer11.pop(NexusParser::Tokens::ValuePair)
335
335
  end
336
336
 
337
337
  def test_MesquiteIDs
338
- lexer = NexusFile::Lexer.new('IDS JC1191fcddc3b425 JC1191fcddc3b426 JC1191fcddc3b427 JC1191fcddc3b428 JC1191fcddc3b429 JC1191fcddc3b430 JC1191fcddc3b431 JC1191fcddc3b432 JC1191fcddc3b433 JC1191fcddc3b434 ;
338
+ lexer = NexusParser::Lexer.new('IDS JC1191fcddc3b425 JC1191fcddc3b426 JC1191fcddc3b427 JC1191fcddc3b428 JC1191fcddc3b429 JC1191fcddc3b430 JC1191fcddc3b431 JC1191fcddc3b432 JC1191fcddc3b433 JC1191fcddc3b434 ;
339
339
  BLOCKID JC1191fcddc0c0;')
340
- assert lexer.pop(NexusFile::Tokens::MesquiteIDs)
341
- assert lexer.pop(NexusFile::Tokens::MesquiteBlockID)
340
+ assert lexer.pop(NexusParser::Tokens::MesquiteIDs)
341
+ assert lexer.pop(NexusParser::Tokens::MesquiteBlockID)
342
342
  end
343
343
 
344
344
  def test_TreesBlk
345
- lexer = NexusFile::Lexer.new("BEGIN TREES;
345
+ lexer = NexusParser::Lexer.new("BEGIN TREES;
346
346
  Title Imported_trees;
347
347
  LINK Taxa = 'Scharff&Coddington_1997_Araneidae';
348
348
  TRANSLATE
@@ -377,25 +377,25 @@ class Test_Lexer < Test::Unit::TestCase
377
377
 
378
378
  END;")
379
379
 
380
- assert lexer.pop(NexusFile::Tokens::BeginBlk)
381
- assert foo = lexer.pop(NexusFile::Tokens::TreesBlk)
380
+ assert lexer.pop(NexusParser::Tokens::BeginBlk)
381
+ assert foo = lexer.pop(NexusParser::Tokens::TreesBlk)
382
382
  assert_equal 'TREES', foo.value.slice(0,5)
383
383
  assert_equal 'END;', foo.value.slice(-4,4)
384
- assert lexer.pop(NexusFile::Tokens::BeginBlk)
385
- assert lexer.pop(NexusFile::Tokens::LabelsBlk)
384
+ assert lexer.pop(NexusParser::Tokens::BeginBlk)
385
+ assert lexer.pop(NexusParser::Tokens::LabelsBlk)
386
386
 
387
387
  end
388
388
 
389
389
  def test_NotesBlk
390
390
  input = "BEGIN NOTES ;"
391
- lexer = NexusFile::Lexer.new(input)
392
- assert lexer.pop(NexusFile::Tokens::BeginBlk)
393
- assert foo = lexer.pop(NexusFile::Tokens::NotesBlk)
391
+ lexer = NexusParser::Lexer.new(input)
392
+ assert lexer.pop(NexusParser::Tokens::BeginBlk)
393
+ assert foo = lexer.pop(NexusParser::Tokens::NotesBlk)
394
394
  assert "NOTES", foo.value
395
395
  end
396
396
 
397
397
  def test_LabelsBlk
398
- lexer = NexusFile::Lexer.new("
398
+ lexer = NexusParser::Lexer.new("
399
399
  LABELS;
400
400
  CHARGROUPLABEL MM_Genitalia COLOR = (RGB 1.0 0.4 0.4) ;
401
401
  CHARGROUPLABEL Somatic COLOR = (RGB 0.6 1.0 0.33333333) ;
@@ -407,29 +407,27 @@ class Test_Lexer < Test::Unit::TestCase
407
407
 
408
408
  BEGIN some other block;")
409
409
 
410
- assert foo = lexer.pop(NexusFile::Tokens::LabelsBlk)
410
+ assert foo = lexer.pop(NexusParser::Tokens::LabelsBlk)
411
411
  assert_equal 'LABELS', foo.value.slice(0,6)
412
412
  assert_equal 'END;', foo.value.slice(-4,4)
413
413
  end
414
414
 
415
415
  def test_SetsBlk
416
- lexer = NexusFile::Lexer.new("
416
+ lexer = NexusParser::Lexer.new("
417
417
  SETS;
418
418
  CHARPARTITION * UNTITLED = Somatic : 1 - 2 4, MM_Genitalia : 5 - 8 10;
419
419
 
420
420
  END;
421
421
  BEGIN some other block;")
422
422
 
423
- assert foo = lexer.pop(NexusFile::Tokens::SetsBlk)
423
+ assert foo = lexer.pop(NexusParser::Tokens::SetsBlk)
424
424
  assert_equal 'SETS', foo.value.slice(0,4)
425
425
  assert_equal 'END;', foo.value.slice(-4,4)
426
426
  end
427
427
 
428
-
429
-
430
428
  def test_lexer_errors
431
- lexer = NexusFile::Lexer.new("*&")
432
- assert_raise(NexusFile::ParseError) {lexer.peek(NexusFile::Tokens::ID)}
429
+ lexer = NexusParser::Lexer.new("*&")
430
+ assert_raise(NexusParser::ParseError) {lexer.peek(NexusParser::Tokens::ID)}
433
431
  end
434
432
  end
435
433
 
@@ -437,7 +435,7 @@ end
437
435
  class Test_Parser < Test::Unit::TestCase
438
436
  def setup
439
437
  # a Mesquite 2.n or higher file
440
- @nf = File.read('MX_test_03.nex') # MX_test_01.nex
438
+ @nf = File.read(File.expand_path(File.join(File.dirname(__FILE__), '../test/MX_test_03.nex')))
441
439
  end
442
440
 
443
441
  def teardown
@@ -447,7 +445,7 @@ class Test_Parser < Test::Unit::TestCase
447
445
  def test_that_file_might_be_nexus
448
446
  begin
449
447
  assert !parse_nexus_file("#Nexblux Begin Natrix end;")
450
- rescue NexusFile::ParseError
448
+ rescue NexusParser::ParseError
451
449
  assert true
452
450
  end
453
451
  end
@@ -483,9 +481,9 @@ class Test_Parser < Test::Unit::TestCase
483
481
  BLOCKID JC1191fcddc0c4;
484
482
  END;"
485
483
 
486
- builder = NexusFile::Builder.new
487
- lexer = NexusFile::Lexer.new(input)
488
- NexusFile::Parser.new(lexer,builder).parse_taxa_blk
484
+ builder = NexusParser::Builder.new
485
+ lexer = NexusParser::Lexer.new(input)
486
+ NexusParser::Parser.new(lexer,builder).parse_taxa_blk
489
487
  foo = builder.nexus_file
490
488
 
491
489
  assert_equal 10, foo.taxa.size
@@ -505,9 +503,9 @@ class Test_Parser < Test::Unit::TestCase
505
503
  ;
506
504
  END;"
507
505
 
508
- builder = NexusFile::Builder.new
509
- lexer = NexusFile::Lexer.new(input)
510
- NexusFile::Parser.new(lexer,builder).parse_taxa_blk
506
+ builder = NexusParser::Builder.new
507
+ lexer = NexusParser::Lexer.new(input)
508
+ NexusParser::Parser.new(lexer,builder).parse_taxa_blk
511
509
  foo = builder.nexus_file
512
510
 
513
511
  assert_equal 10, foo.taxa.size
@@ -544,8 +542,8 @@ class Test_Parser < Test::Unit::TestCase
544
542
 
545
543
  END;"
546
544
 
547
- builder = NexusFile::Builder.new
548
- @lexer = NexusFile::Lexer.new(input)
545
+ builder = NexusParser::Builder.new
546
+ @lexer = NexusParser::Lexer.new(input)
549
547
 
550
548
  # add the taxa, assumes we have them for comparison purposes, though we (shouldn't) ultimately need them
551
549
  # foo.taxa = ["Dictyna", "Uloborus", "Deinopis", "Nephila&Herennia", "Nephilenygys_cruentata", "Meta", "Leucauge_venusta", "Pachygnatha", "Theridiosoma_01", "Tetragnatha"]
@@ -553,7 +551,7 @@ class Test_Parser < Test::Unit::TestCase
553
551
  # stub the taxa, they would otherwise get added in dimensions or taxa block
554
552
  (0..9).each{|i| builder.stub_taxon}
555
553
 
556
- NexusFile::Parser.new(@lexer,builder).parse_characters_blk
554
+ NexusParser::Parser.new(@lexer,builder).parse_characters_blk
557
555
  foo = builder.nexus_file
558
556
 
559
557
  assert_equal 10, foo.characters.size
@@ -595,8 +593,8 @@ class Test_Parser < Test::Unit::TestCase
595
593
  ;
596
594
  END;"
597
595
 
598
- builder = NexusFile::Builder.new
599
- @lexer = NexusFile::Lexer.new(input)
596
+ builder = NexusParser::Builder.new
597
+ @lexer = NexusParser::Lexer.new(input)
600
598
 
601
599
  # add the taxa, assumes we have them for comparison purposes, though we (shouldn't) ultimately need them
602
600
  # foo.taxa = ["Dictyna", "Uloborus", "Deinopis", "Nephila&Herennia", "Nephilenygys_cruentata", "Meta", "Leucauge_venusta", "Pachygnatha", "Theridiosoma_01", "Tetragnatha"]
@@ -604,7 +602,7 @@ class Test_Parser < Test::Unit::TestCase
604
602
  # stub the taxa, they would otherwise get added in dimensions or taxa block
605
603
  (0..9).each{|i| builder.stub_taxon}
606
604
 
607
- NexusFile::Parser.new(@lexer,builder).parse_characters_blk
605
+ NexusParser::Parser.new(@lexer,builder).parse_characters_blk
608
606
  foo = builder.nexus_file
609
607
 
610
608
  assert_equal 10, foo.characters.size
@@ -630,10 +628,10 @@ class Test_Parser < Test::Unit::TestCase
630
628
 
631
629
  def test_parse_dimensions
632
630
  input= " DIMENSIONS NCHAR=10 ntaxa =10 nfoo='999' nbar = \" a b c \" blorf=2; "
633
- builder = NexusFile::Builder.new
634
- lexer = NexusFile::Lexer.new(input)
631
+ builder = NexusParser::Builder.new
632
+ lexer = NexusParser::Lexer.new(input)
635
633
 
636
- NexusFile::Parser.new(lexer,builder).parse_dimensions
634
+ NexusParser::Parser.new(lexer,builder).parse_dimensions
637
635
  foo = builder.nexus_file
638
636
 
639
637
  assert_equal "10", foo.vars[:nchar]
@@ -646,10 +644,10 @@ class Test_Parser < Test::Unit::TestCase
646
644
 
647
645
  def test_parse_format
648
646
  input = "FORMAT DATATYPE = STANDARD GAP = - MISSING = ? SYMBOLS = \" 0 1 2 3 4 5 6 7 8 9 A\";"
649
- builder = NexusFile::Builder.new
650
- lexer = NexusFile::Lexer.new(input)
647
+ builder = NexusParser::Builder.new
648
+ lexer = NexusParser::Lexer.new(input)
651
649
 
652
- NexusFile::Parser.new(lexer,builder).parse_format
650
+ NexusParser::Parser.new(lexer,builder).parse_format
653
651
  foo = builder.nexus_file
654
652
 
655
653
  assert_equal "STANDARD", foo.vars[:datatype]
@@ -665,12 +663,12 @@ class Test_Parser < Test::Unit::TestCase
665
663
  MATRIX
666
664
  fooo 01 more stuff here that should not be hit"
667
665
 
668
- builder = NexusFile::Builder.new
669
- lexer = NexusFile::Lexer.new(input)
666
+ builder = NexusParser::Builder.new
667
+ lexer = NexusParser::Lexer.new(input)
670
668
 
671
669
  (0..9).each{builder.stub_chr()}
672
670
 
673
- NexusFile::Parser.new(lexer,builder).parse_chr_state_labels
671
+ NexusParser::Parser.new(lexer,builder).parse_chr_state_labels
674
672
 
675
673
  foo = builder.nexus_file
676
674
  assert_equal 10, foo.characters.size
@@ -720,12 +718,12 @@ class Test_Parser < Test::Unit::TestCase
720
718
  Matrix
721
719
  fooo 01 more stuff here that should not be hit"
722
720
 
723
- builder = NexusFile::Builder.new
724
- lexer = NexusFile::Lexer.new(input)
721
+ builder = NexusParser::Builder.new
722
+ lexer = NexusParser::Lexer.new(input)
725
723
 
726
724
  (0..29).each{builder.stub_chr()}
727
725
 
728
- NexusFile::Parser.new(lexer,builder).parse_chr_state_labels
726
+ NexusParser::Parser.new(lexer,builder).parse_chr_state_labels
729
727
 
730
728
  foo = builder.nexus_file
731
729
 
@@ -746,12 +744,12 @@ class Test_Parser < Test::Unit::TestCase
746
744
  MATRIX
747
745
  fooo 01 more stuff here that should not be hit"
748
746
 
749
- builder = NexusFile::Builder.new
750
- lexer = NexusFile::Lexer.new(input)
747
+ builder = NexusParser::Builder.new
748
+ lexer = NexusParser::Lexer.new(input)
751
749
 
752
750
  (0..147).each{builder.stub_chr()}
753
751
 
754
- NexusFile::Parser.new(lexer,builder).parse_chr_state_labels
752
+ NexusParser::Parser.new(lexer,builder).parse_chr_state_labels
755
753
 
756
754
  foo = builder.nexus_file
757
755
  assert_equal 10, foo.characters.size
@@ -823,24 +821,24 @@ class Test_Parser < Test::Unit::TestCase
823
821
 
824
822
  # note the second last note note embedds parens in the value
825
823
 
826
- builder = NexusFile::Builder.new
827
- lexer = NexusFile::Lexer.new(input)
824
+ builder = NexusParser::Builder.new
825
+ lexer = NexusParser::Lexer.new(input)
828
826
 
829
827
  # stubs
830
828
  (0..9).each{builder.stub_chr()}
831
829
  (0..9).each{builder.stub_taxon()}
832
830
  builder.nexus_file.codings[3] = []
833
- builder.nexus_file.codings[3][7] = NexusFile::NexusFile::Coding.new()
831
+ builder.nexus_file.codings[3][7] = NexusParser::NexusParser::Coding.new()
834
832
  builder.nexus_file.codings[8] = []
835
- builder.nexus_file.codings[8][2] = NexusFile::NexusFile::Coding.new()
833
+ builder.nexus_file.codings[8][2] = NexusParser::NexusParser::Coding.new()
836
834
  builder.nexus_file.codings[1] = []
837
- builder.nexus_file.codings[1][5] = NexusFile::NexusFile::Coding.new()
835
+ builder.nexus_file.codings[1][5] = NexusParser::NexusParser::Coding.new()
838
836
  builder.nexus_file.codings[6] = []
839
- builder.nexus_file.codings[6][9] = NexusFile::NexusFile::Coding.new()
837
+ builder.nexus_file.codings[6][9] = NexusParser::NexusParser::Coding.new()
840
838
  builder.nexus_file.codings[3] = []
841
- builder.nexus_file.codings[3][7] = NexusFile::NexusFile::Coding.new()
839
+ builder.nexus_file.codings[3][7] = NexusParser::NexusParser::Coding.new()
842
840
 
843
- NexusFile::Parser.new(lexer,builder).parse_notes_blk
841
+ NexusParser::Parser.new(lexer,builder).parse_notes_blk
844
842
 
845
843
  foo = builder.nexus_file
846
844
 
@@ -890,12 +888,12 @@ class Test_Parser < Test::Unit::TestCase
890
888
 
891
889
  # note the second last note note embeds parens in the value
892
890
 
893
- builder = NexusFile::Builder.new
894
- lexer = NexusFile::Lexer.new(input)
891
+ builder = NexusParser::Builder.new
892
+ lexer = NexusParser::Lexer.new(input)
895
893
  # stubs
896
894
  (0..9).each{builder.stub_chr()}
897
895
 
898
- NexusFile::Parser.new(lexer,builder).parse_notes_blk
896
+ NexusParser::Parser.new(lexer,builder).parse_notes_blk
899
897
 
900
898
  foo = builder.nexus_file
901
899
 
@@ -910,11 +908,10 @@ class Test_Parser < Test::Unit::TestCase
910
908
  assert_equal 'A62.006', foo.characters[5].notes[0].note
911
909
  assert_equal 'A62.007', foo.characters[6].notes[0].note
912
910
  assert_equal 'A62.008', foo.characters[7].notes[0].note
913
- assert_equal NexusFile::NexusFile::Character, foo.characters[7].class
911
+ assert_equal NexusParser::NexusParser::Character, foo.characters[7].class
914
912
  assert_equal 1, foo.characters[7].notes.size
915
913
  end
916
914
 
917
-
918
915
  def test_parse_trees_block
919
916
  end
920
917