blib/lib/Perl/Critic/Utils/PPI.pm

filter: Statementstmt 78.8% 71 / 90 Branchbran 59.2% 45 / 76 Conditioncond 25.6% 10 / 39 MC/DCmcdc 5.5% 1 / 18 Subroutinesub 88.2% 15 / 17 Podpod 100% 10 / 10 totaltotal 60.8% 152 / 250 CC 52 SCAR 29.1
CC
52
Cov
61%
get_constant_name_element_from_declaring_statement
72.0
is_ppi_constant_element
30.2
get_next_element_in_same_simple_statement
16.1
CRAP 18.4
« blib/lib/Perl/Critic/Policy/TestingAndDebugging/RequireUseStrict.pm ↑ Summary blib/lib/Perl/Critic/Policy/ValuesAndExpressions/ProhibitComplexVersion.pm »
1 package Perl::Critic::Utils::PPI;
2  
3 40 ▶use 5.010001;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 40 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 40 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 40 ▶use Readonly;
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9 40 ▶use Scalar::Util qw< blessed >;
Subroutine BEGIN: called CC=1 SCAR=0.0
10  
11 40 ▶use Exporter 'import';
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 40 our $VERSION = '1.150';
14  
15 #-----------------------------------------------------------------------------
16  
17 40 our @EXPORT_OK = qw(
18 is_ppi_expression_or_generic_statement
19 is_ppi_generic_statement
20 is_ppi_statement_subclass
21 is_ppi_simple_statement
22 is_ppi_constant_element
23 is_subroutine_declaration
24 is_in_subroutine
25 get_constant_name_element_from_declaring_statement
26 get_next_element_in_same_simple_statement
27 get_previous_module_used_on_same_line
28 );
29  
30 40 our %EXPORT_TAGS = (
31 all => \@EXPORT_OK,
32 );
33  
34 #-----------------------------------------------------------------------------
35  
36 sub is_ppi_expression_or_generic_statement {
37 302 ▶ my $element = shift;
Subroutine is_ppi_expression_or_generic_statement: called CC=5 SCAR=16.1
Pod documented
38  
39 302 ▶ return if not $element;
Branch: 1 branch
BranchTrueFalseTotal
unless $element 1 301 302
40 301 ▶ return if not $element->isa('PPI::Statement');
Branch: 1 branch
BranchTrueFalseTotal
unless $element->isa("PPI::Statement") 1 300 301
41 300 ▶ return 1 if $element->isa('PPI::Statement::Expression');
Branch: 1 branch
BranchTrueFalseTotal
if $element->isa("PPI::Statement::Expression") 90 210 300
42  
43 210 my $element_class = blessed($element);
44  
45 210 ▶ return if not $element_class;
Branch: 1 branch
BranchTrueFalseTotal
unless $element_class 0 210 210
46 210 return $element_class eq 'PPI::Statement';
47 }
48  
49 #-----------------------------------------------------------------------------
50  
51 sub is_ppi_generic_statement {
52 65 ▶ my $element = shift;
Subroutine is_ppi_generic_statement: called CC=3 SCAR=11.0
Pod documented
53  
54 65 my $element_class = blessed($element);
55  
56 65 ▶ return if not $element_class;
Branch: 1 branch
BranchTrueFalseTotal
unless $element_class 1 64 65
57 64 ▶ return if not $element->isa('PPI::Statement');
Branch: 1 branch
BranchTrueFalseTotal
unless $element->isa("PPI::Statement") 23 41 64
58  
59 41 return $element_class eq 'PPI::Statement';
60 }
61  
62 #-----------------------------------------------------------------------------
63  
64 sub is_ppi_statement_subclass {
65 312 ▶ my $element = shift;
Subroutine is_ppi_statement_subclass: called CC=3 SCAR=11.0
Pod documented
66  
67 312 my $element_class = blessed($element);
68  
69 312 ▶ return if not $element_class;
Branch: 1 branch
BranchTrueFalseTotal
unless $element_class 1 311 312
70 311 ▶ return if not $element->isa('PPI::Statement');
Branch: 1 branch
BranchTrueFalseTotal
unless $element->isa("PPI::Statement") 1 310 311
71  
72 310 return $element_class ne 'PPI::Statement';
73 }
74  
75 #-----------------------------------------------------------------------------
76  
77 # Can not use hashify() here because Perl::Critic::Utils already depends on
78 # this module.
79 40 Readonly::Hash my %SIMPLE_STATEMENT_CLASS => map { $_ => 1 } qw<
80 PPI::Statement
81 PPI::Statement::Break
82 PPI::Statement::Include
83 PPI::Statement::Null
84 PPI::Statement::Package
85 PPI::Statement::Variable
86 >;
87  
88 sub is_ppi_simple_statement {
89 189 ▶ my $element = shift or return;
Subroutine is_ppi_simple_statement: called CC=3 SCAR=11.7
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
my $element = shift() or return 0 189 189
90  
91 189 ▶ my $element_class = blessed( $element ) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $element_class = builtin::blessed($element) or return 0 189 189
92  
93 189 return $SIMPLE_STATEMENT_CLASS{ $element_class };
94 }
95  
96 #-----------------------------------------------------------------------------
97  
98 sub is_ppi_constant_element {
99 27 ▶ my $element = shift or return;
Subroutine is_ppi_constant_element: called CC=9 SCAR=34.1
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
my $element = shift() or return 0 27 27
100  
101 27 ▶ blessed( $element ) or return;
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($element) or return 0 27 27
102  
103 # TODO implement here documents once PPI::Token::HereDoc grows the
104 # necessary PPI::Token::Quote interface.
105 return
106 27 ▶ $element->isa( 'PPI::Token::Number' )
Condition22%4/18
$element->isa('PPI::Token::Number') || $element->isa('PPI::Token::Quote::Literal') || $element->isa('PPI::Token::Quote::Single') || $element->isa('PPI::Token::QuoteLike::Words') || ($element->isa('PPI::Token::Quote::Double') || $element->isa('PPI::Token::Quote::Interpolate')) && !($element->string =~ / (?: \A | [^\\] ) (?: \\\\)* [\$\@] /msx)
l!l&&r!l&&!r
2700
$element->isa("PPI::Token::Number") or $element->isa("PPI::Token::Quote::Literal") or $element->isa("PPI::Token::Quote::Single") or $element->isa("PPI::Token::QuoteLike::Words")
l!l&&r!l&&!r
2700
$element->isa("PPI::Token::Number") or $element->isa("PPI::Token::Quote::Literal") or $element->isa("PPI::Token::Quote::Single")
l!l&&r!l&&!r
2700
$element->isa("PPI::Token::Number") or $element->isa("PPI::Token::Quote::Literal")
l!l&&r!l&&!r
2700
$element->isa("PPI::Token::Quote::Double") || $element->isa("PPI::Token::Quote::Interpolate") and not $element->string =~ / (?: \A | [^\\] ) (?: \\\\)* [\$\@] /msx
!ll&&!rl&&r
000
$element->isa("PPI::Token::Quote::Double") or $element->isa("PPI::Token::Quote::Interpolate")
l!l&&r!l&&!r
000
MC/DC0%0/7
$element->isa('PPI::Token::Number') || $element->isa('PPI::Token::Quote::Literal') || $element->isa('PPI::Token::Quote::Single') || $element->isa('PPI::Token::QuoteLike::Words') || ($element->isa('PPI::Token::Quote::Double') || $element->isa('PPI::Token::Quote::Interpolate')) && !($element->string =~ / (?: \A | [^\\] ) (?: \\\\)* [\$\@] /msx)
$element->isa("PPI::Token::Number") $element->isa("PPI::Token::Quote::Literal") $element->isa("PPI::Token::Quote::Single") $element->isa("PPI::Token::QuoteLike::Words") $element->isa("PPI::Token::Quote::Double") $element->isa("PPI::Token::Quote::Interpolate") not $element->string =~ / (?: \A | [^\\] ) (?: \\\\)* [\$\@] /msx
Truth table11%1/9
A or B or C or D || E or F and not(G)
A= $element->isa("PPI::Token::Number")B= $element->isa("PPI::Token::Quote::Literal")C= $element->isa("PPI::Token::Quote::Single")D= $element->isa("PPI::Token::QuoteLike::Words")E= $element->isa("PPI::Token::Quote::Double")F= $element->isa("PPI::Token::Quote::Interpolate")G= not $element->string =~ / (?: \A | [^\\] ) (?: \\\\)* [\$\@] /msx
ABCDEFGresult
1XXXXXX1
01XXXXX1
001XXXX1
0001XXX1
00001X11
00000111
000000X0
00001X00
00000100
107 || $element->isa( 'PPI::Token::Quote::Literal' )
108 || $element->isa( 'PPI::Token::Quote::Single' )
109 || $element->isa( 'PPI::Token::QuoteLike::Words' )
110 || (
111 $element->isa( 'PPI::Token::Quote::Double' )
112 || $element->isa( 'PPI::Token::Quote::Interpolate' ) )
113 && $element->string() !~ m< (?: \A | [^\\] ) (?: \\\\)* [\$\@] >smx
114 ;
115 }
116  
117 #-----------------------------------------------------------------------------
118  
119 sub is_subroutine_declaration {
120 54 ▶ my $element = shift;
Subroutine is_subroutine_declaration: called CC=7 SCAR=19.5
Pod documented
121  
122 54 ▶ return if not $element;
Branch: 1 branch
BranchTrueFalseTotal
unless $element 1 53 54
123  
124 53 ▶ return 1 if $element->isa('PPI::Statement::Sub');
Branch: 1 branch
BranchTrueFalseTotal
if $element->isa("PPI::Statement::Sub") 4 49 53
125  
126 49 ▶ if ( is_ppi_generic_statement($element) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_ppi_generic_statement($element)) 4 45 49
127 4 my $first_element = $element->first_element();
128  
129 4 ▶ return 1 if
Branch: 1 branch
BranchTrueFalseTotal
if $first_element and $first_element->isa("PPI::Token::Word") and $first_element->content eq "sub" 3 1 4
Condition66%4/6
$first_element and $first_element->isa("PPI::Token::Word") and $first_element->content eq "sub"
!ll&&!rl&&r
103
$first_element and $first_element->isa("PPI::Token::Word")
!ll&&!rl&&r
013
MC/DC33%1/3
$first_element and $first_element->isa("PPI::Token::Word") and $first_element->content eq "sub"
$first_element $first_element->isa("PPI::Token::Word") $first_element->content eq "sub"
Truth table50%2/4
A and B and C
A= $first_elementB= $first_element->isa("PPI::Token::Word")C= $first_element->content eq "sub"
ABCresult
0XX0
10X0
1100
1111
130 $first_element
131 and $first_element->isa('PPI::Token::Word')
132 and $first_element->content() eq 'sub';
133 }
134  
135 46 return;
136 }
137  
138 #-----------------------------------------------------------------------------
139  
140 sub is_in_subroutine {
141 15 ▶ my ($element) = @_;
Subroutine is_in_subroutine: called CC=5 SCAR=16.1
Pod documented
142  
143 15 ▶ return if not $element;
Branch: 1 branch
BranchTrueFalseTotal
unless $element 2 13 15
144 13 ▶ return 1 if is_subroutine_declaration($element);
Branch: 1 branch
BranchTrueFalseTotal
if is_subroutine_declaration($element) 0 13 13
145  
146 13 ▶ while ( $element = $element->parent() ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($element = $element->parent) 35 9 44
147 35 ▶ return 1 if is_subroutine_declaration($element);
Branch: 1 branch
BranchTrueFalseTotal
if is_subroutine_declaration($element) 4 31 35
148 }
149  
150 9 return;
151 }
152  
153 #-----------------------------------------------------------------------------
154  
155 sub get_constant_name_element_from_declaring_statement {
156 0 ▶ my ($element) = @_;
Subroutine get_constant_name_element_from_declaring_statement: not called CC=8 SCAR=42.8
Pod documented
157  
158 0 warnings::warnif(
159 'deprecated',
160 'Perl::Critic::Utils::PPI::get_constant_name_element_from_declaring_statement() is deprecated. Use PPIx::Utils::Traversal::get_constant_name_elements_from_declaring_statement() instead.',
161 );
162  
163 0 ▶ return if not $element;
Branch: 1 branch
BranchTrueFalseTotal
unless $element 0 0 0
164 0 ▶ return if not $element->isa('PPI::Statement');
Branch: 1 branch
BranchTrueFalseTotal
unless $element->isa("PPI::Statement") 0 0 0
165  
166 0 ▶ if ( $element->isa('PPI::Statement::Include') ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($element->isa('PPI::Statement::Include')) { } 0 0 0
elsif (is_ppi_generic_statement($element) and $element->schild(0)->content =~ / \A Readonly \b /msx) { } 0 0 0
167 0 my $pragma;
168 0 ▶ if ( $pragma = $element->pragma() and $pragma eq 'constant' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pragma = $element->pragma and $pragma eq "constant") 0 0 0
Condition0%0/3
$pragma = $element->pragma and $pragma eq "constant"
!ll&&!rl&&r
000
MC/DC0%0/2
$pragma = $element->pragma and $pragma eq "constant"
$pragma = $element->pragma $pragma eq "constant"
Truth table0%0/3
A and B
A= $pragma = $element->pragmaB= $pragma eq "constant"
ABresult
0X0
100
111
169 0 return _constant_name_from_constant_pragma($element);
170 }
171 }
172 ▶ elsif (
Condition0%0/3
is_ppi_generic_statement($element) and $element->schild(0)->content =~ / \A Readonly \b /msx
!ll&&!rl&&r
000
MC/DC0%0/2
is_ppi_generic_statement($element) and $element->schild(0)->content =~ / \A Readonly \b /msx
is_ppi_generic_statement($element) $element->schild(0)->content =~ / \A Readonly \b /msx
Truth table0%0/3
A and B
A= is_ppi_generic_statement($element)B= $element->schild(0)->content =~ / \A Readonly \b /msx
ABresult
0X0
100
111
173 is_ppi_generic_statement($element)
174 and $element->schild(0)->content() =~ m< \A Readonly \b >xms
175 ) {
176 0 return $element->schild(2);
177 }
178  
179 0 return;
180 }
181  
182 sub _constant_name_from_constant_pragma {
183 0 ▶ my ($include) = @_;
Subroutine _constant_name_from_constant_pragma: not called CC=3 SCAR=24.8
184  
185 0 ▶ my @arguments = $include->arguments() or return;
Branch: 1 branch
BranchTrueFalseTotal
my(@arguments) = $include->arguments or return 0 0 0
186  
187 0 my $follower = $arguments[0];
188 0 ▶ return if not defined $follower;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $follower 0 0 0
189  
190 0 return $follower;
191 }
192  
193 #-----------------------------------------------------------------------------
194  
195 sub get_next_element_in_same_simple_statement {
196 81 ▶ my $element = shift or return;
Subroutine get_next_element_in_same_simple_statement: called CC=7 SCAR=27.8
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
my $element = shift() or return 0 81 81
197  
198 81 ▶ while ( $element and (
Branch: 1 branch
BranchTrueFalseTotal
if ($element and !is_ppi_simple_statement($element) || $element->parent && $element->parent->isa("PPI::Structure::List")) 81 0 81
Condition22%2/9
$element and !is_ppi_simple_statement($element) || $element->parent && $element->parent->isa("PPI::Structure::List")
!ll&&!rl&&r
0810
not is_ppi_simple_statement($element) or $element->parent and $element->parent->isa("PPI::Structure::List")
l!l&&r!l&&!r
8100
$element->parent and $element->parent->isa("PPI::Structure::List")
!ll&&!rl&&r
000
MC/DC0%0/4
$element and !is_ppi_simple_statement($element) || $element->parent && $element->parent->isa("PPI::Structure::List")
$element not is_ppi_simple_statement($element) $element->parent $element->parent->isa("PPI::Structure::List")
Truth table0%0/5
A and not(B) or C and D
A= $elementB= not is_ppi_simple_statement($element)C= $element->parentD= $element->parent->isa("PPI::Structure::List")
ABCDresult
0XXX0
100X0
10100
11XX1
10111
199 not is_ppi_simple_statement( $element )
200 or $element->parent()
201 and $element->parent()->isa( 'PPI::Structure::List' ) ) ) {
202 81 my $next;
203 81 ▶ $next = $element->snext_sibling() and return $next;
Branch: 1 branch
BranchTrueFalseTotal
$next = $element->snext_sibling and return $next 81 0 81
204 0 $element = $element->parent();
205 }
206 0 return;
207  
208 }
209  
210 #-----------------------------------------------------------------------------
211  
212 sub get_previous_module_used_on_same_line {
213 27 ▶ my $element = shift or return;
Subroutine get_previous_module_used_on_same_line: called CC=9 SCAR=26.1
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
my $element = shift() or return 0 27 27
214  
215 27 ▶ my ( $line ) = @{ $element->location() || []};
Branch: 1 branch
BranchTrueFalseTotal
$element->location or [] 0 27 27
216  
217 27 ▶ while (not is_ppi_simple_statement( $element )) {
Branch: 1 branch
BranchTrueFalseTotal
unless (is_ppi_simple_statement($element)) 27 27 54
218 27 ▶ $element = $element->parent() or return;
Branch: 1 branch
BranchTrueFalseTotal
$element = $element->parent or return 0 27 27
219 }
220  
221 27 ▶ while ( $element = $element->sprevious_sibling() ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($element = $element->sprevious_sibling) 27 0 27
222 27 ▶ ( @{ $element->location() || []} )[0] == $line or return;
Branch: 2 branches
BranchTrueFalseTotal
(@{$element->location or [];})[0] == $line or return 27 0 27
$element->location or [] 0 27 27
223 0 ▶ $element->isa( 'PPI::Statement::Include' )
Branch: 1 branch
BranchTrueFalseTotal
$element->isa("PPI::Statement::Include") and return $element->schild(1) 0 0 0
224 and return $element->schild( 1 );
225 }
226  
227 0 return;
228 }
229  
230 #-----------------------------------------------------------------------------
231  
232 40 1;
233  
234 __END__
235  
236 =pod
237  
238 =for stopwords
239  
240 =head1 NAME
241  
242 Perl::Critic::Utils::PPI - Utility functions for dealing with PPI objects.
243  
244  
245 =head1 DESCRIPTION
246  
247 Provides classification of L<PPI::Elements|PPI::Elements>.
248  
249  
250 =head1 INTERFACE SUPPORT
251  
252 This is considered to be a public module. Any changes to its
253 interface will go through a deprecation cycle.
254  
255  
256 =head1 IMPORTABLE SUBS
257  
258 =over
259  
260 =item C<is_ppi_expression_or_generic_statement( $element )>
261  
262 Answers whether the parameter is an expression or an undifferentiated
263 statement. I.e. the parameter either is a
264 L<PPI::Statement::Expression|PPI::Statement::Expression> or the class
265 of the parameter is L<PPI::Statement|PPI::Statement> and not one of
266 its subclasses other than C<Expression>.
267  
268  
269 =item C<is_ppi_generic_statement( $element )>
270  
271 Answers whether the parameter is an undifferentiated statement, i.e.
272 the parameter is a L<PPI::Statement|PPI::Statement> but not one of its
273 subclasses.
274  
275  
276 =item C<is_ppi_statement_subclass( $element )>
277  
278 Answers whether the parameter is a specialized statement, i.e. the
279 parameter is a L<PPI::Statement|PPI::Statement> but the class of the
280 parameter is not L<PPI::Statement|PPI::Statement>.
281  
282  
283 =item C<is_ppi_simple_statement( $element )>
284  
285 Answers whether the parameter represents a simple statement, i.e. whether the
286 parameter is a L<PPI::Statement|PPI::Statement>,
287 L<PPI::Statement::Break|PPI::Statement::Break>,
288 L<PPI::Statement::Include|PPI::Statement::Include>,
289 L<PPI::Statement::Null|PPI::Statement::Null>,
290 L<PPI::Statement::Package|PPI::Statement::Package>, or
291 L<PPI::Statement::Variable|PPI::Statement::Variable>.
292  
293  
294 =item C<is_ppi_constant_element( $element )>
295  
296 Answers whether the parameter represents a constant value, i.e. whether the
297 parameter is a L<PPI::Token::Number|PPI::Token::Number>,
298 L<PPI::Token::Quote::Literal|PPI::Token::Quote::Literal>,
299 L<PPI::Token::Quote::Single|PPI::Token::Quote::Single>, or
300 L<PPI::Token::QuoteLike::Words|PPI::Token::QuoteLike::Words>, or is a
301 L<PPI::Token::Quote::Double|PPI::Token::Quote::Double> or
302 L<PPI::Token::Quote::Interpolate|PPI::Token::Quote::Interpolate> which does
303 not in fact contain any interpolated variables.
304  
305 This subroutine does B<not> interpret any form of here document as a constant
306 value, and may not until L<PPI::Token::HereDoc|PPI::Token::HereDoc> acquires
307 the relevant portions of the L<PPI::Token::Quote|PPI::Token::Quote> interface.
308  
309 This subroutine also does B<not> interpret entities created by the
310 L<Readonly|Readonly> module or the L<constant|constant> pragma as constants,
311 because the infrastructure to detect these appears not to be present, and the
312 author of this subroutine (B<not> Mr. Shank or Mr. Thalhammer) lacks the
313 knowledge/expertise/gumption to put it in place.
314  
315  
316 =item C<is_subroutine_declaration( $element )>
317  
318 Is the parameter a subroutine declaration, named or not?
319  
320  
321 =item C<is_in_subroutine( $element )>
322  
323 Is the parameter a subroutine or inside one?
324  
325  
326 =item C<get_constant_name_element_from_declaring_statement($statement)>
327  
328 B<This subroutine is deprecated.> You should use
329 L<PPIx::Utils::Traversal/get_constant_name_elements_from_declaring_statement()>
330 instead.
331  
332 Given a L<PPI::Statement|PPI::Statement>, if the statement is a C<use
333 constant> or L<Readonly|Readonly> declaration statement, return the name of
334 the thing being defined.
335  
336 Given
337  
338 use constant 1.16 FOO => 'bar';
339  
340 this will return "FOO". Similarly, given
341  
342 Readonly::Hash my %FOO => ( bar => 'baz' );
343  
344 this will return "%FOO".
345  
346 B<Caveat:> in the case where multiple constants are declared using the same
347 C<use constant> statement (e.g. C<< use constant { FOO => 1, BAR => 2 }; >>),
348 this subroutine will return the declaring
349 L<PPI::Structure::Constructor|PPI::Structure::Constructor>. In the case of
350 C<< use constant 1.16 { FOO => 1, BAR => 2 }; >> it may return a
351 L<PPI::Structure::Block|PPI::Structure::Block> instead of a
352 L<PPI::Structure::Constructor|PPI::Structure::Constructor>, due to a parse
353 error in L<PPI|PPI>.
354  
355  
356 =item C<get_next_element_in_same_simple_statement( $element )>
357  
358 Given a L<PPI::Element|PPI::Element>, this subroutine returns the next element
359 in the same simple statement as defined by is_ppi_simple_statement(). If no
360 next element can be found, this subroutine simply returns.
361  
362 If the $element is undefined or unblessed, we simply return.
363  
364 If the $element satisfies C<is_ppi_simple_statement()>, we return, B<unless>
365 it has a parent which is a L<PPI::Structure::List|PPI::Structure::List>.
366  
367 If the $element is the last significant element in its L<PPI::Node|PPI::Node>,
368 we replace it with its parent and iterate again.
369  
370 Otherwise, we return C<< $element->snext_sibling() >>.
371  
372  
373 =item C<get_previous_module_used_on_same_line( $element )>
374  
375 Given a L<PPI::Element|PPI::Element>, returns the L<PPI::Element|PPI::Element>
376 representing the name of the module included by the previous C<use> or
377 C<require> on the same line as the $element. If none is found, simply returns.
378  
379 For example, with the line
380  
381 use version; our $VERSION = ...;
382  
383 given the L<PPI::Token::Symbol|PPI::Token::Symbol> instance for C<$VERSION>, this will return
384 "version".
385  
386 If the given element is in a C<use> or <require>, the return is from the
387 previous C<use> or C<require> on the line, if any.
388  
389  
390 =back
391  
392  
393 =head1 AUTHOR
394  
395 Elliot Shank <perl@galumph.com>
396  
397  
398 =head1 COPYRIGHT
399  
400 Copyright (c) 2007-2011 Elliot Shank.
401  
402 This program is free software; you can redistribute it and/or modify
403 it under the same terms as Perl itself. The full text of this license
404 can be found in the LICENSE file included with this module.
405  
406 =cut
407  
408 # Local Variables:
409 # mode: cperl
410 # cperl-indent-level: 4
411 # fill-column: 78
412 # indent-tabs-mode: nil
413 # c-indentation-style: bsd
414 # End:
415 # ex: set ts=8 sts=4 sw=4 tw=78 ft=perl expandtab shiftround :
« blib/lib/Perl/Critic/Policy/TestingAndDebugging/RequireUseStrict.pm ↑ Summary blib/lib/Perl/Critic/Policy/ValuesAndExpressions/ProhibitComplexVersion.pm »