Phylo/Parsers/Cdao.pm untested

filter: Statementstmt 0.0% 0 / 220 Branchbran 0.0% 0 / 38 Conditioncond 0.0% 0 / 5 MC/DCmcdc n/a Subroutinesub 0.0% 0 / 17 Podpod 0.0% 0 / 12 totaltotal 0.0% 0 / 292 CC 20 SCAR 31.6
CC
20
Cov
0%
_process_edges
56.0
_process_annotation
42.0
_parse_predicate
20.0
CRAP 23.6
1 package Bio::Phylo::Parsers::Cdao;
2 use strict;
3 use base 'Bio::Phylo::Parsers::Abstract';
4 use Bio::Phylo::Util::Exceptions 'throw';
5 use Bio::Phylo::Util::CONSTANT qw'looks_like_instance :namespaces :objecttypes';
6 use Bio::Phylo::Util::Dependency qw'RDF::Trine::Node::Resource RDF::Query';
7  
8 =head1 NAME
9  
10 Bio::Phylo::Parsers::Cdao - Parser used by Bio::Phylo::IO, no serviceable parts inside
11  
12 =head1 DESCRIPTION
13  
14 This module is used for parsing CDAO RDF. The implementation is incomplete,
15 especially for character state matrices (trees and OTUs work fine).
16  
17 =cut
18  
19 my $ns_cdao = _NS_CDAO_;
20 my $ns_rdf = _NS_RDF_;
21 my $ns_rdfs = _NS_RDFS_;
22  
23 my %prefix_for_ns = (
24 $ns_cdao => 'cdao',
25 $ns_rdf => 'rdf',
26 $ns_rdfs => 'rdfs',
27 );
28  
29 my %objects;
30  
31 my $prefixes = <<"PREFIXES";
32 PREFIX rdf: <${ns_rdf}>
33 PREFIX cdao: <${ns_cdao}>
34 PREFIX rdfs: <${ns_rdfs}>
35 PREFIXES
36  
37 my $query = <<"QUERY";
38 ${prefixes}
39 SELECT
40 ?subject
41 WHERE {
42 ?subject rdf:type cdao:%s
43 }
44 QUERY
45  
46 my $subclass = <<"SUBCLASS";
47 ${prefixes}
48 SELECT
49 ?subject
50 WHERE {
51 ?subject rdfs:subClassOf cdao:%s
52 }
53 SUBCLASS
54  
55 my $states = <<"STATES";
56 ${prefixes}
57 SELECT
58 ?subject ?stateset ?state ?label
59 WHERE {
60 ?subject cdao:belongs_to_TU <%s> .
61 ?subject cdao:belongs_to_Character <%s> .
62 ?subject cdao:has_%sState ?state .
63 ?state rdfs:label ?label .
64 ?state rdf:type ?stateset
65 }
66 STATES
67  
68 sub _parse {
69 warn "***Please note: implementation is incomplete, character data are not yet read correctly.***\n";
70 my $self = shift;
71 %objects = ();
72 $self->_args->{'-opts'} = {
73 'lang' => 'sparql',
74 'base' => $self->_args->{'-base'},
75 'update' => 0,
76 'load_data' => 0,
77 };
78 $self->_project->set_base_uri($self->_args->{'-base'});
79 $self->_process_tus;
80 $self->_process_trees;
81 $self->_process_nodes;
82 $self->_process_edges;
83 $self->_process_matrices;
84
85 my $proj = $self->_project;
86 my @objects = ( @{ $proj->get_taxa }, @{ $proj->get_forests }, @{ $proj->get_matrices } );
87 $proj->clear;
88 return @objects;
89 }
90  
91 sub _object_from_resource {
92 my ( $self, $resource, $creator ) = @_;
93 my $fac = $self->_factory;
94 my $base = $self->_args->{'-base'};
95 my $uri = $resource->value;
96 my $id = $uri;
97 $id =~ s/^\Q$base\E#?//;
98 my $object = $fac->$creator( '-guid' => $id, '-xml_id' => $id );
99 my $iterator = $self->_args->{'-model'}->get_statements($resource,undef,undef);
100 while ( my $inner = $iterator->next ) {
101 my ( $predicate, $value ) = ( $inner->predicate, $inner->object );
102 $self->_process_annotation( $predicate->value, $value->value, $object );
103  
104 }
105 $objects{$uri} = $object;
106 }
107  
108 sub _parse_predicate {
109 my ( $self, $predicate ) = @_;
110 # attempt to split URI in namespace and term
111 my ( $ns, $term );
112
113 # this is for cases where the term is referenced as somewhere inside
114 # an ontology using an anchor '#', e.g. in CDAO
115 if ( $predicate =~ m/^(.+#)(.+?)$/ ) {
116 ( $ns, $term ) = ( $1, $2 );
117 }
118
119 # this is for cases where the term is a path fragment inside a namespace,
120 # i.e. preceded by a '/', as in dublin core
121 elsif ( $predicate =~ m/^(.+\/)([^\/]+?)$/ ) {
122 ( $ns, $term ) = ( $1, $2 );
123 }
124
125 # this is for cases where the term is relative to a urn:, i.e. preceded
126 # by a ':', as in the uBio predicates
127 elsif ( $predicate =~ m/^(.+:)([^:]+?)$/ ) {
128 ( $ns, $term ) = ( $1, $2 );
129 }
130
131 else {
132 $self->_logger->warn("Can't parse URI $predicate");
133 }
134 return $ns, $term;
135 }
136  
137 sub _process_annotation {
138 my ( $self, $predicate, $value, $object ) = @_;
139 my $fac = $self->_factory;
140 $predicate =~ s/^<(.+)>$/$1/;
141 return if $predicate eq _NS_RDF_ . 'type';
142
143 # attempt to split URI in namespace and term
144 my ( $ns, $term ) = $self->_parse_predicate( $predicate );
145
146 # check to see if we have a prefix for that namespace, or make one
147 my $prefix = $prefix_for_ns{$ns} || 'ns' . scalar(keys %prefix_for_ns);
148 $prefix_for_ns{$prefix} = $ns;
149
150 # maybe we know how to deal with this in the API
151 if ( "${prefix}:${term}" eq 'rdfs:label' ) {
152 $object->set_name( $value );
153 return;
154 }
155 if ( "${prefix}:${term}" eq 'cdao:represents_TU' ) {
156 $object->set_taxon( $objects{$value} );
157 return;
158 }
159 if ( "${prefix}:${term}" eq 'cdao:has_Ancestor' ) {
160 return; # don't need this, will reconstruct from edge links
161 }
162 if ( "${prefix}:${term}" eq 'cdao:has_Root' ) {
163 return; # don't need this, will be obvious from whether tree is rooted
164 }
165
166 # attach annotation
167 $object->set_namespaces( $prefix => $ns );
168 $object->add_meta(
169 $fac->create_meta(
170 '-triple' => { "${prefix}:${term}" => $value }
171 )
172 );
173 }
174  
175 sub _do_query {
176 my ( $self, $type, $type_query ) = @_;
177 $type_query = $query unless $type_query;
178 my $sth = RDF::Query->new( sprintf($type_query, $type), $self->_args->{'-opts'} );
179 return $sth->execute( $self->_args->{'-model'} );
180 }
181  
182 sub _process_matrices {
183 my $self = shift;
184 my $fac = $self->_factory;
185 my $model = $self->_args->{'-model'};
186 my $iter = $self->_do_query('CharacterStateDataMatrix');
187 while( my $row = $iter->next ) {
188 my $subject = $row->{'subject'};
189 my $matrix = $self->_object_from_resource( $subject, 'create_matrix' );
190 my ($taxa) = @{ $self->_project->get_taxa };
191 $matrix->set_taxa($taxa);
192
193 # create rows for taxa
194 my ( $rowlist, %row ) = $self->_create_rows($matrix);
195
196 # create columns
197 my ( $charlist, %char ) = $self->_create_characters($matrix);
198
199 # maps CDAO state type predicates to Bio::Phylo matrix types
200 my %types = (
201 'Nucleotide_' => 'dna',
202 'Continuous_' => 'continuous',
203 'Standard_' => 'standard',
204 '' => 'standard',
205 );
206 my $datatype;
207
208 for my $row_uri ( @{ $rowlist } ) {
209 for my $col_uri ( @{ $charlist } ) {
210 if ( not $datatype ) {
211 TYPE_SEARCH : for my $predicate ( keys %types ) {
212 my $state_query = sprintf($states, $row_uri, $col_uri, $predicate );
213 my $sth = RDF::Query->new( $state_query, $self->_args->{'-opts'} );
214 my $state_iterator = $sth->execute( $self->_args->{'-model'} );
215 if ( my $state = $state_iterator->next ) {
216 $datatype = $predicate;
217 $matrix->set_type($types{$predicate});
218 last TYPE_SEARCH;
219 }
220 }
221 }
222 else {
223 my $state_query = sprintf($states, $row_uri, $col_uri, $datatype );
224 my $sth = RDF::Query->new( $state_query, $self->_args->{'-opts'} );
225 my $state_iterator = $sth->execute( $self->_args->{'-model'} );
226 while ( my $state = $state_iterator->next ) {
227 if ( my $val = $state->{label}->value ) {
228 $row{$row_uri}->insert($val);
229 }
230 }
231 }
232 }
233 }
234 $self->_logger->debug($matrix->to_nexus);
235 }
236 }
237  
238 sub _create_rows {
239 my ( $self, $matrix ) = @_;
240 my $fac = $self->_factory;
241 my ( %row, @rowlist );
242 my $tu_metas = $matrix->get_meta('cdao:has_TU');
243 for my $tu_meta ( @{ $tu_metas } ) {
244 my $tu_uri = $tu_meta->get_object;
245 my $row = $fac->create_datum(
246 '-taxon' => $objects{$tu_uri},
247 '-name' => $objects{$tu_uri}->get_name,
248 );
249 $row{$tu_uri} = $row;
250 $matrix->insert( $row );
251 push @rowlist, $tu_uri;
252 }
253 return \@rowlist, %row;
254 }
255  
256 sub _create_characters {
257 my ( $self, $matrix ) = @_;
258 my ( %char, @charlist );
259 my $characters = $matrix->get_characters;
260 my $char_metas = $matrix->get_meta('cdao:has_Character');
261 for my $char_meta ( @{ $char_metas } ) {
262 my $char_uri = $char_meta->get_object;
263 my $char_resource = RDF::Trine::Node::Resource->new( $char_uri );
264 my $char = $self->_object_from_resource( $char_resource, 'create_character' );
265 $char{$char_uri} = $char;
266 $characters->insert($char);
267 push @charlist, $char_uri;
268 }
269 return \@charlist, %char;
270 }
271  
272 sub _process_tus {
273 my $self = shift;
274 my $fac = $self->_factory;
275 my $taxa = $fac->create_taxa;
276 my $model = $self->_args->{'-model'};
277 my $iter = $self->_do_query('TU');
278 while ( my $row = $iter->next ) {
279 my $subject = $row->{'subject'};
280 my $taxon = $self->_object_from_resource( $subject, 'create_taxon' );
281 $taxa->insert($taxon);
282 }
283 $self->_project->insert($taxa);
284 }
285  
286 sub _process_trees {
287 my $self = shift;
288 my $fac = $self->_factory;
289 my ($taxa) = @{ $self->_project->get_items(_TAXA_) };
290 my $forest = $fac->create_forest( '-taxa' => $taxa );
291 my $model = $self->_args->{'-model'};
292
293 # process rooted trees
294 my $rooted_iter = $self->_do_query('RootedTree');
295 while( my $row = $rooted_iter->next ) {
296 my $subject = $row->{'subject'};
297 my $tree = $self->_object_from_resource( $subject, 'create_tree' );
298 $forest->insert($tree);
299 }
300
301 # process unrooted trees
302 my $unrooted_iter = $self->_do_query('UnrootedTree');
303 while( my $row = $unrooted_iter->next ) {
304 my $subject = $row->{'subject'};
305 my $tree = $self->_object_from_resource( $subject, 'create_tree' );
306 $tree->set_as_unrooted;
307 $forest->insert($tree);
308 }
309
310 $self->_project->insert($forest);
311 }
312  
313 sub _process_nodes {
314 my $self = shift;
315 my $model = $self->_args->{'-model'};
316 my $logger = $self->_logger;
317
318 # this only assigns nodes to a tree object but doesn't resolve
319 # topology, that's done in _process_edges
320 my $node_iter = $self->_do_query('Node');
321 while( my $row = $node_iter->next ) {
322 my $subject = $row->{'subject'};
323 my $node = $self->_object_from_resource( $subject, 'create_node' );
324 my ($value) = @{ $node->get_meta('cdao:belongs_to_Tree') };
325 $objects{$value->get_object}->insert($node) if $objects{$value->get_object};
326 $node->remove_meta($value);
327 }
328 }
329  
330 sub _process_edges {
331 my $self = shift;
332 my $model = $self->_args->{'-model'};
333 my $logger = $self->_logger;
334
335 my $edge_iter = $self->_do_query('DirectedEdge');
336 while( my $row = $edge_iter->next ) {
337 my $subject = $row->{'subject'};
338 my $edge_statements = $model->get_statements($subject);
339 my ( $parent_uri, $child_uri, $branch_length );
340 LINK: while( my $st = $edge_statements->next ) {
341 my $predicate = $st->predicate->value;
342 $logger->debug($predicate);
343 if ( $predicate eq "${ns_cdao}has_Parent_Node" ) {
344 $parent_uri = $st->object->value;
345 }
346 elsif ( $predicate eq "${ns_cdao}has_Child_Node" ) {
347 $child_uri = $st->object->value;
348 }
349 elsif ( $predicate eq "${ns_cdao}has_Annotation" ) {
350 my $annotation_statements = $model->get_statements($st->object);
351 ANNO: while(my $anno = $annotation_statements->next) {
352 my $anno_pre = $anno->predicate->value;
353 if ( $anno_pre =~ /^\Q${ns_cdao}\Ehas_(?:Int|Float)_Value/ ) {
354 $branch_length = $anno->object->value;
355 last ANNO;
356 }
357 }
358 }
359 last LINK if $parent_uri && $child_uri;
360 }
361 $logger->debug("Parent: $parent_uri Child: $child_uri");
362 $objects{$parent_uri}->set_child($objects{$child_uri});
363 $objects{$child_uri}->set_branch_length($branch_length) if defined $branch_length;
364 }
365 }
366  
367 # podinherit_insert_token
368  
369 =head1 SEE ALSO
370  
371 There is a mailing list at L<https://groups.google.com/forum/#!forum/bio-phylo>
372 for any user or developer questions and discussions.
373  
374 =over
375  
376 =item L<Bio::Phylo::IO>
377  
378 The CDAO parser is called by the L<Bio::Phylo::IO> object.
379 Look there for examples.
380  
381 =item L<Bio::Phylo::Manual>
382  
383 Also see the manual: L<Bio::Phylo::Manual> and L<http://rutgervos.blogspot.com>.
384  
385 =back
386  
387 =head1 CITATION
388  
389 If you use Bio::Phylo in published research, please cite it:
390  
391 B<Rutger A Vos>, B<Jason Caravas>, B<Klaas Hartmann>, B<Mark A Jensen>
392 and B<Chase Miller>, 2011. Bio::Phylo - phyloinformatic analysis using Perl.
393 I<BMC Bioinformatics> B<12>:63.
394 L<http://dx.doi.org/10.1186/1471-2105-12-63>
395  
396 =cut
397  
398 1;