blib/lib/XML/Twig/XPath.pm

filter: Statementstmt 77.7% 7 / 9 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 3 / 3 Podpod n/a totaltotal 83.3% 10 / 12 CC 1 SCAR 0.9
CC
1
Cov
78%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.1
« blib/lib/XML/Twig.pm ↑ Summary tools/xml_merge/xml_merge »
1 # $Id: /xmltwig/trunk/Twig/XPath.pm 32 2008-01-18T13:11:52.128782Z mrodrigu $
2 package XML::Twig::XPath;
3 36 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 36 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 0 ▶use XML::Twig;
Subroutine BEGIN: called CC=1 SCAR=2.6
6  
7 my $XPATH; # XPath engine (XML::XPath or XML::XPathEngine);
8 my $XPATH_NUMBER; # <$XPATH>::Number, the XPath number class
9 BEGIN
10 { foreach my $xpath_engine ( qw( XML::XPathEngine XML::XPath) )
11 { if( XML::Twig::_use( $xpath_engine) ) { $XPATH= $xpath_engine; last; } }
12 unless( $XPATH) { die "cannot use XML::Twig::XPath: neither XML::XPathEngine 0.09+ nor XML::XPath are available"; }
13 $XPATH_NUMBER= "${XPATH}::Number";
14 }
15  
16  
17 use vars qw($VERSION);
18 $VERSION="0.02";
19  
20 BEGIN
21 { package # hide from PAUSE
22 XML::XPath::NodeSet;
23 no warnings; # to avoid the "Subroutine sort redefined" message
24 # replace the native sort routine by a Twig'd one
25 sub sort
26 { my $self = CORE::shift;
27 @$self = CORE::sort { $a->node_cmp( $b) } @$self;
28 return $self;
29 }
30  
31 package # hide from PAUSE
32 XML::XPathEngine::NodeSet;
33 no warnings; # to avoid the "Subroutine sort redefined" message
34 # replace the native sort routine by a Twig'd one
35 sub sort
36 { my $self = CORE::shift;
37 @$self = CORE::sort { $a->node_cmp( $b) } @$self;
38 return $self;
39 }
40 }
41  
42 package XML::Twig::XPath;
43  
44 use base 'XML::Twig';
45  
46 my $XP; # the global xp object;
47  
48 sub to_number { return $XPATH_NUMBER->new( $_[0]->root->text); }
49  
50 sub new
51 { my $class= shift;
52 my $t= XML::Twig->new( elt_class => 'XML::Twig::XPath::Elt', @_);
53 $t->{twig_xp}= $XPATH->new();
54 bless $t, $class;
55 return $t;
56 }
57  
58  
59 sub set_namespace { my $t= shift; $t->{twig_xp}->set_namespace( @_); }
60 sub set_strict_namespaces { my $t= shift; $t->{twig_xp}->set_strict_namespaces( @_); }
61  
62 sub node_cmp($$) { return $_[1] == $_[0] ? 0 : -1; } # document is before anything but itself
63  
64 sub isElementNode { 0 }
65 sub isAttributeNode { 0 }
66 sub isTextNode { 0 }
67 sub isProcessingInstructionNode { 0 }
68 sub isPINode { 0 }
69 sub isCommentNode { 0 }
70 sub isNamespaceNode { 0 }
71 sub getAttributes { [] }
72 sub getValue { return $_[0]->root->text; }
73  
74 sub findnodes { my( $t, $path)= @_; return $t->{twig_xp}->findnodes( $path, $t); }
75 sub findnodes_as_string { my( $t, $path)= @_; return $t->{twig_xp}->findnodes_as_string( $path, $t); }
76 sub findvalue { my( $t, $path)= @_; return $t->{twig_xp}->findvalue( $path, $t); }
77 sub exists { my( $t, $path)= @_; return $t->{twig_xp}->exists( $path, $t); }
78 sub find { my( $t, $path)= @_; return $t->{twig_xp}->find( $path, $t); }
79 sub matches { my( $t, $path, $node)= @_; $node ||= $t; return $t->{twig_xp}->matches( $node, $path, $t) || 0; }
80  
81 sub getNamespaces { $_[0]->root->getNamespaces(); }
82  
83 #TODO: it would be nice to be able to pass in any object in this
84 #distribution and cast it to the proper $XPATH class to use as a
85 #variable (via 'nodes' argument or something)
86 sub set_var {
87 my ($t, $name, $value) = @_;
88 if( ! ref $value) { $value= $t->findnodes( qq{"$value"}); }
89 $t->{twig_xp}->set_var($name, $value);
90 }
91  
92 1;
93  
94 # adds the appropriate methods to XML::Twig::Elt so XML::XPath can be used as the XPath engine
95 package XML::Twig::XPath::Elt;
96 use base 'XML::Twig::Elt';
97  
98 *getLocalName= *XML::Twig::Elt::local_name;
99 *getValue = *XML::Twig::Elt::text;
100 sub isAttributeNode { 0 }
101 sub isNamespaceNode { 0 }
102  
103 sub to_number { return $XPATH_NUMBER->new( $_[0]->text); }
104  
105 sub getAttributes
106 { my $elt= shift;
107 my $atts= $elt->{att};
108 # alternate, faster but less clean, way
109 my @atts= map { bless( { name => $_, value => $atts->{$_}, elt => $elt },
110 'XML::Twig::XPath::Attribute')
111 }
112 sort keys %$atts;
113 # my @atts= map { XML::Twig::XPath::Attribute->new( $elt, $_) } sort keys %$atts;
114 return wantarray ? @atts : \@atts;
115 }
116  
117 sub getNamespace
118 { my $elt= shift;
119 my $prefix= shift() || $elt->ns_prefix;
120 if( my $expanded= $elt->namespace( $prefix))
121 { return XML::Twig::XPath::Namespace->new( $prefix, $expanded); }
122 else
123 { return XML::Twig::XPath::Namespace->new( $prefix, ''); }
124 }
125  
126 # returns namespaces declared in the element
127 sub getNamespaces #_get_namespaces
128 { my( $elt)= @_;
129 my @namespaces;
130 foreach my $att ($elt->att_names)
131 { if( $att=~ m{^xmlns(?::(\w+))?$})
132 { my $prefix= $1 || '';
133 my $expanded= $elt->{'att'}->{$att};
134 push @namespaces, XML::Twig::XPath::Namespace->new( $prefix, $expanded);
135 }
136 }
137 return wantarray() ? @namespaces : \@namespaces;
138 }
139  
140 sub node_cmp($$)
141 { my( $a, $b)= @_;
142 if( UNIVERSAL::isa( $b, 'XML::Twig::XPath::Elt'))
143 { # 2 elts, compare them
144 return $a->cmp( $b);
145 }
146 elsif( UNIVERSAL::isa( $b, 'XML::Twig::XPath::Attribute'))
147 { # elt <=> att, compare the elt to the att->{elt}
148 # if the elt is the att->{elt} (cmp return 0) then -1, elt is before att
149 return ($a->cmp( $b->{elt}) ) || -1 ;
150 }
151 elsif( UNIVERSAL::isa( $b, 'XML::Twig::XPath'))
152 { # elt <=> document, elt is after document
153 return 1;
154 }
155 else
156 { die "unknown node type ", ref( $b); }
157 }
158  
159 sub getParentNode
160 { return $_[0]->{parent}
161 || $_[0]->twig;
162 }
163  
164 sub findnodes { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->findnodes( $path, $elt); }
165 sub findnodes_as_string { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->findnodes_as_string( $path, $elt); }
166 sub findvalue { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->findvalue( $path, $elt); }
167 sub exists { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->exists( $path, $elt); }
168 sub find { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->find( $path, $elt); }
169 sub matches { my( $elt, $path)= @_; return $elt->twig->{twig_xp}->matches( $elt, $path, $elt->getParentNode) || 0; }
170  
171  
172 1;
173  
174 # this package is only used to allow XML::XPath as the XPath engine, otherwise
175 # attributes are just attached to their parent element and are not considered objects
176  
177 package XML::Twig::XPath::Attribute;
178  
179 sub new
180 { my( $class, $elt, $att)= @_;
181 return bless { name => $att, value => $elt->{'att'}->{$att}, elt => $elt }, $class;
182 }
183  
184 sub getValue { return $_[0]->{value}; }
185 sub getName { return $_[0]->{name} ; }
186 sub getLocalName { (my $name= $_[0]->{name}) =~ s{^.*:}{}; $name; }
187 sub string_value { return $_[0]->{value}; }
188 sub to_number { return $XPATH_NUMBER->new( $_[0]->{value}); }
189 sub isElementNode { 0 }
190 sub isAttributeNode { 1 }
191 sub isNamespaceNode { 0 }
192 sub isTextNode { 0 }
193 sub isProcessingInstructionNode { 0 }
194 sub isPINode { 0 }
195 sub isCommentNode { 0 }
196 sub toString { return qq{$_[0]->{name}="$_[0]->{value}"}; }
197  
198 sub getNamespace
199 { my $att= shift;
200 my $prefix= shift();
201 if( ! defined( $prefix))
202 { if($att->{name}=~ m{^(.*):}) { $prefix= $1; }
203 else { $prefix=''; }
204 }
205  
206 if( my $expanded= $att->{elt}->namespace( $prefix))
207 { return XML::Twig::XPath::Namespace->new( $prefix, $expanded); }
208 }
209  
210 sub node_cmp($$)
211 { my( $a, $b)= @_;
212 if( UNIVERSAL::isa( $b, 'XML::Twig::XPath::Attribute'))
213 { # 2 attributes, compare their elements, then their name
214 return ($a->{elt}->cmp( $b->{elt}) ) || ($a->{name} cmp $b->{name});
215 }
216 elsif( UNIVERSAL::isa( $b, 'XML::Twig::XPath::Elt'))
217 { # att <=> elt : compare the att->elt and the elt
218 # if att->elt is the elt (cmp returns 0) then 1 (elt is before att)
219 return ($a->{elt}->cmp( $b) ) || 1 ;
220 }
221 elsif( UNIVERSAL::isa( $b, 'XML::Twig::XPath'))
222 { # att <=> document, att is after document
223 return 1;
224 }
225 else
226 { die "unknown node type ", ref( $b); }
227 }
228  
229 *cmp=*node_cmp;
230  
231 1;
232  
233 package XML::Twig::XPath::Namespace;
234  
235 sub new
236 { my( $class, $prefix, $expanded)= @_;
237 bless { prefix => $prefix, expanded => $expanded }, $class;
238 }
239  
240 sub isNamespaceNode { 1; }
241  
242 sub getPrefix { $_[0]->{prefix}; }
243 sub getExpanded { $_[0]->{expanded}; }
244 sub getValue { $_[0]->{expanded}; }
245 sub getData { $_[0]->{expanded}; }
246  
247 sub node_cmp($$)
248 { my( $a, $b)= @_;
249 if( UNIVERSAL::isa( $b, 'XML::Twig::XPath::Namespace'))
250 { # 2 attributes, compare their elements, then their name
251 return $a->{prefix} cmp $b->{prefix};
252 }
253 else
254 { die "unknown node type ", ref( $b); }
255 }
256  
257 *cmp=*node_cmp;
258  
259 1
260  
« blib/lib/XML/Twig.pm ↑ Summary tools/xml_merge/xml_merge »