blib/lib/Perl/Critic/Policy/CodeLayout/ProhibitParensWithBuiltins.pm

filter: Statementstmt 51.3% 39 / 76 Branchbran 19.0% 8 / 42 Conditioncond 0.0% 0 / 21 MC/DCmcdc 0.0% 0 / 14 Subroutinesub 61.1% 11 / 18 Podpod 80.0% 4 / 5 totaltotal 35.2% 62 / 176 CC 29 SCAR 32.7
CC
29
Cov
34%
_is_sort_exemption
72.0
violates
30.4
_is_named_unary_with_operator_following_parens_exemption
30.0
CRAP 26.3
« blib/lib/Perl/Critic/Policy/BuiltinFunctions/ProhibitShiftRef.pm ↑ Summary blib/lib/Perl/Critic/Policy/InputOutput/RequireBracedFileHandleWithPrint.pm »
1 package Perl::Critic::Policy::CodeLayout::ProhibitParensWithBuiltins;
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 40 ▶use Readonly;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 40 use Perl::Critic::Utils qw{
9 :booleans :severities :data_conversion :classification :language
10 40 ▶};
Subroutine BEGIN: called CC=1 SCAR=0.0
11 40 ▶use parent 'Perl::Critic::Policy';
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 40 our $VERSION = '1.150';
14  
15 #-----------------------------------------------------------------------------
16  
17 40 Readonly::Array my @ALLOW => qw( my our local return state );
18 40 Readonly::Hash my %ALLOW => hashify( @ALLOW );
19  
20 40 Readonly::Scalar my $DESC => q{Builtin function called with parentheses};
21 40 Readonly::Scalar my $EXPL => [ 13 ];
22  
23 40 Readonly::Scalar my $PRECEDENCE_OF_LIST => precedence_of(q{>>}) + 1;
24 40 Readonly::Scalar my $PRECEDENCE_OF_COMMA => precedence_of(q{,});
25  
26 #-----------------------------------------------------------------------------
27 # These are all the functions that are considered named unary
28 # operators. These frequently require parentheses because they have lower
29 # precedence than ordinary function calls.
30  
31 40 Readonly::Array my @NAMED_UNARY_OPS => qw(
32 alarm glob rand
33 caller gmtime readlink
34 chdir hex ref
35 chroot int require
36 cos lc return
37 defined lcfirst rmdir
38 delete length scalar
39 do localtime sin
40 eval lock sleep
41 exists log sqrt
42 exit lstat srand
43 getgrp my stat
44 gethostbyname oct uc
45 getnetbyname ord ucfirst
46 getprotobyname quotemeta umask
47 undef
48 );
49 40 Readonly::Hash my %NAMED_UNARY_OPS => hashify( @NAMED_UNARY_OPS );
50  
51 #-----------------------------------------------------------------------------
52  
53 90 ▶sub supported_parameters { return () }
Subroutine supported_parameters: called CC=1 SCAR=0.0
Pod undocumented
54 75 ▶sub default_severity { return $SEVERITY_LOWEST }
Subroutine default_severity: called CC=1 SCAR=0.0
Pod documented
55 84 ▶sub default_themes { return qw( core pbp cosmetic ) }
Subroutine default_themes: called CC=1 SCAR=0.0
Pod documented
56 31 ▶sub applies_to { return 'PPI::Token::Word' }
Subroutine applies_to: called CC=1 SCAR=0.0
Pod documented
57  
58 #-----------------------------------------------------------------------------
59  
60 sub violates {
61 332 ▶ my ( $self, $elem, undef ) = @_;
Subroutine violates: called CC=11 SCAR=34.1
Pod documented
62  
63 332 ▶ return if exists $ALLOW{$elem};
Branch: 1 branch
BranchTrueFalseTotal
if exists $ALLOW{$elem} 96 236 332
64 236 ▶ return if not is_perl_builtin($elem);
Branch: 1 branch
BranchTrueFalseTotal
unless is_perl_builtin($elem) 163 73 236
65 73 ▶ return if not is_function_call($elem);
Branch: 1 branch
BranchTrueFalseTotal
unless is_function_call($elem) 3 70 73
66  
67 70 my $sibling = $elem->snext_sibling();
68 70 ▶ return if not $sibling;
Branch: 1 branch
BranchTrueFalseTotal
unless $sibling 0 70 70
69 70 ▶ if ( $sibling->isa('PPI::Structure::List') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sibling->isa("PPI::Structure::List")) 0 70 70
70 0 my $elem_after_parens = $sibling->snext_sibling();
71  
72 0 ▶ return if _is_named_unary_with_operator_inside_parens_exemption($elem, $sibling);
Branch: 1 branch
BranchTrueFalseTotal
if _is_named_unary_with_operator_inside_parens_exemption($elem, $sibling) 0 0 0
73 0 ▶ return if _is_named_unary_with_operator_following_parens_exemption($elem, $elem_after_parens);
Branch: 1 branch
BranchTrueFalseTotal
if _is_named_unary_with_operator_following_parens_exemption($elem, $elem_after_parens) 0 0 0
74 0 ▶ return if _is_precedence_exemption($elem_after_parens);
Branch: 1 branch
BranchTrueFalseTotal
if _is_precedence_exemption($elem_after_parens) 0 0 0
75 0 ▶ return if _is_equals_exemption($sibling);
Branch: 1 branch
BranchTrueFalseTotal
if _is_equals_exemption($sibling) 0 0 0
76 0 ▶ return if _is_sort_exemption($elem, $sibling);
Branch: 1 branch
BranchTrueFalseTotal
if _is_sort_exemption($elem, $sibling) 0 0 0
77  
78 # If we get here, it must be a violation
79 0 return $self->violation( $DESC, $EXPL, $elem );
80 }
81 70 return; #ok!
82 }
83  
84 #-----------------------------------------------------------------------------
85 # EXCEPTION 1: If the function is a named unary and there is an
86 # operator with higher precedence right after the parentheses.
87 # Example: int( 1.5 ) + 0.5;
88  
89 sub _is_named_unary_with_operator_following_parens_exemption {
90 0 ▶ my ($elem, $elem_after_parens) = @_;
Subroutine _is_named_unary_with_operator_following_parens_exemption: not called CC=5 SCAR=34.0
91  
92 0 ▶ if ( _is_named_unary( $elem ) && $elem_after_parens ){
Branch: 1 branch
BranchTrueFalseTotal
if (_is_named_unary($elem) and $elem_after_parens) 0 0 0
Condition0%0/3
_is_named_unary($elem) and $elem_after_parens
!ll&&!rl&&r
000
MC/DC0%0/2
_is_named_unary($elem) and $elem_after_parens
_is_named_unary($elem) $elem_after_parens
Truth table0%0/3
A and B
A= _is_named_unary($elem)B= $elem_after_parens
ABresult
0X0
100
111
93 # Smaller numbers mean higher precedence
94 0 my $precedence = precedence_of( $elem_after_parens );
95 0 ▶ return $TRUE if defined $precedence && $precedence < $PRECEDENCE_OF_LIST;
Branch: 1 branch
BranchTrueFalseTotal
if defined $precedence and $precedence < $PRECEDENCE_OF_LIST 0 0 0
Condition0%0/3
defined $precedence and $precedence < $PRECEDENCE_OF_LIST
!ll&&!rl&&r
000
MC/DC0%0/2
defined $precedence and $precedence < $PRECEDENCE_OF_LIST
defined $precedence $precedence < $PRECEDENCE_OF_LIST
Truth table0%0/3
A and B
A= defined $precedenceB= $precedence < $PRECEDENCE_OF_LIST
ABresult
0X0
100
111
96 }
97  
98 0 return $FALSE;
99 }
100  
101 sub _is_named_unary {
102 0 ▶ my ($elem) = @_;
Subroutine _is_named_unary: not called CC=1 SCAR=6.9
103  
104 0 return exists $NAMED_UNARY_OPS{$elem->content};
105 }
106  
107 #-----------------------------------------------------------------------------
108 # EXCEPTION 2, If there is an operator immediately after the
109 # parentheses, and that operator has precedence greater than
110 # or equal to a comma.
111 # Example: join($delim, @list) . "\n";
112  
113 sub _is_precedence_exemption {
114 0 ▶ my ($elem_after_parens) = @_;
Subroutine _is_precedence_exemption: not called CC=4 SCAR=30.0
115  
116 0 ▶ if ( $elem_after_parens ){
Branch: 1 branch
BranchTrueFalseTotal
if ($elem_after_parens) 0 0 0
117 # Smaller numbers mean higher precedence
118 0 my $precedence = precedence_of( $elem_after_parens );
119 0 ▶ return $TRUE if defined $precedence && $precedence <= $PRECEDENCE_OF_COMMA;
Branch: 1 branch
BranchTrueFalseTotal
if defined $precedence and $precedence <= $PRECEDENCE_OF_COMMA 0 0 0
Condition0%0/3
defined $precedence and $precedence <= $PRECEDENCE_OF_COMMA
!ll&&!rl&&r
000
MC/DC0%0/2
defined $precedence and $precedence <= $PRECEDENCE_OF_COMMA
defined $precedence $precedence <= $PRECEDENCE_OF_COMMA
Truth table0%0/3
A and B
A= defined $precedenceB= $precedence <= $PRECEDENCE_OF_COMMA
ABresult
0X0
100
111
120 }
121  
122 0 return $FALSE;
123 }
124  
125 #-----------------------------------------------------------------------------
126 # EXCEPTION 3: If the first operator within the parentheses is '='
127 # Example: chomp( my $foo = <STDIN> );
128  
129 sub _is_equals_exemption {
130 0 ▶ my ($sibling) = @_;
Subroutine _is_equals_exemption: not called CC=3 SCAR=24.8
131  
132 0 ▶ if ( my $first_op = $sibling->find_first('PPI::Token::Operator') ){
Branch: 1 branch
BranchTrueFalseTotal
if (my $first_op = $sibling->find_first("PPI::Token::Operator")) 0 0 0
133 0 ▶ return $TRUE if $first_op eq q{=};
Branch: 1 branch
BranchTrueFalseTotal
if $first_op eq "=" 0 0 0
134 }
135  
136 0 return $FALSE;
137 }
138  
139 #-----------------------------------------------------------------------------
140 # EXCEPTION 4: sort with default comparator but a function for the list data
141 # Example: sort(foo(@x))
142  
143 sub _is_sort_exemption {
144 0 ▶ my ($elem, $sibling) = @_;
Subroutine _is_sort_exemption: not called CC=8 SCAR=42.8
145  
146 0 ▶ if ( $elem eq 'sort' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($elem eq "sort") 0 0 0
147 0 my $first_arg = $sibling->schild(0);
148 0 ▶ if ( $first_arg && $first_arg->isa('PPI::Statement::Expression') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($first_arg and $first_arg->isa("PPI::Statement::Expression")) 0 0 0
Condition0%0/3
$first_arg and $first_arg->isa("PPI::Statement::Expression")
!ll&&!rl&&r
000
MC/DC0%0/2
$first_arg and $first_arg->isa("PPI::Statement::Expression")
$first_arg $first_arg->isa("PPI::Statement::Expression")
Truth table0%0/3
A and B
A= $first_argB= $first_arg->isa("PPI::Statement::Expression")
ABresult
0X0
100
111
149 0 $first_arg = $first_arg->schild(0);
150 }
151 0 ▶ if ( $first_arg && $first_arg->isa('PPI::Token::Word') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($first_arg and $first_arg->isa("PPI::Token::Word")) 0 0 0
Condition0%0/3
$first_arg and $first_arg->isa("PPI::Token::Word")
!ll&&!rl&&r
000
MC/DC0%0/2
$first_arg and $first_arg->isa("PPI::Token::Word")
$first_arg $first_arg->isa("PPI::Token::Word")
Truth table0%0/3
A and B
A= $first_argB= $first_arg->isa("PPI::Token::Word")
ABresult
0X0
100
111
152 0 my $next_arg = $first_arg->snext_sibling;
153 0 ▶ return $TRUE if $next_arg && $next_arg->isa('PPI::Structure::List');
Branch: 1 branch
BranchTrueFalseTotal
if $next_arg and $next_arg->isa("PPI::Structure::List") 0 0 0
Condition0%0/3
$next_arg and $next_arg->isa("PPI::Structure::List")
!ll&&!rl&&r
000
MC/DC0%0/2
$next_arg and $next_arg->isa("PPI::Structure::List")
$next_arg $next_arg->isa("PPI::Structure::List")
Truth table0%0/3
A and B
A= $next_argB= $next_arg->isa("PPI::Structure::List")
ABresult
0X0
100
111
154 }
155 }
156  
157 0 return $FALSE;
158 }
159  
160 #-----------------------------------------------------------------------------
161 # EXCEPTION 5: If the function is a named unary and there is an operator
162 # inside the parentheses.
163 # Example: length($foo || $bar);
164  
165 sub _is_named_unary_with_operator_inside_parens_exemption {
166 0 ▶ my ($elem, $parens) = @_;
Subroutine _is_named_unary_with_operator_inside_parens_exemption: not called CC=2 SCAR=17.9
167 0 ▶ return _is_named_unary($elem) && _contains_operators($parens);
Condition0%0/3
_is_named_unary($elem) && _contains_operators($parens)
!ll&&!rl&&r
000
MC/DC0%0/2
_is_named_unary($elem) && _contains_operators($parens)
_is_named_unary($elem) _contains_operators($parens)
Truth table0%0/3
A && B
A= _is_named_unary($elem)B= _contains_operators($parens)
ABresult
0X0
100
111
168 }
169  
170 sub _contains_operators {
171 0 ▶ my ($parens) = @_;
Subroutine _contains_operators: not called CC=2 SCAR=17.9
172 0 ▶ return $TRUE if $parens->find_first('PPI::Token::Operator');
Branch: 1 branch
BranchTrueFalseTotal
if $parens->find_first("PPI::Token::Operator") 0 0 0
173 0 return $FALSE;
174 }
175  
176 #-----------------------------------------------------------------------------
177 40 1;
178  
179 __END__
180  
181  
182 =pod
183  
184 =for stopwords disambiguates builtins
185  
186 =head1 NAME
187  
188 Perl::Critic::Policy::CodeLayout::ProhibitParensWithBuiltins - Write C<open $handle, $path> instead of C<open($handle, $path)>.
189  
190  
191 =head1 AFFILIATION
192  
193 This Policy is part of the core L<Perl::Critic|Perl::Critic>
194 distribution.
195  
196  
197 =head1 DESCRIPTION
198  
199 Conway suggests that all built-in functions be called without
200 parentheses around the argument list. This reduces visual clutter and
201 disambiguates built-in functions from user functions. Exceptions are
202 made for C<my>, C<local>, and C<our> which require parentheses when
203 called with multiple arguments.
204  
205 open($handle, '>', $filename); #not ok
206 open $handle, '>', $filename; #ok
207  
208 split(/$pattern/, @list); #not ok
209 split /$pattern/, @list; #ok
210  
211  
212 =head1 CONFIGURATION
213  
214 This Policy is not configurable except for the standard options.
215  
216  
217 =head1 NOTES
218  
219 Coding with parentheses can sometimes lead to verbose and awkward
220 constructs, so I think the intent of Conway's guideline is to remove
221 only the F<unnecessary> parentheses. This policy makes exceptions for
222 some common situations where parentheses are usually required.
223 However, you may find other situations where the parentheses are
224 necessary to enforce precedence, but they cause still violations. In
225 those cases, consider using the '## no critic' comments to silence
226 Perl::Critic.
227  
228  
229 =head1 BUGS
230  
231 Some builtin functions (particularly those that take a variable number
232 of scalar arguments) should probably get parentheses. This policy
233 should be enhanced to allow the user to specify a list of builtins
234 that are exempt from the policy.
235  
236  
237 =head1 AUTHOR
238  
239 Jeffrey Ryan Thalhammer <jeff@imaginative-software.com>
240  
241  
242 =head1 COPYRIGHT
243  
244 Copyright (c) 2005-2011 Imaginative Software Systems. All rights reserved.
245  
246 This program is free software; you can redistribute it and/or modify
247 it under the same terms as Perl itself. The full text of this license
248 can be found in the LICENSE file included with this module.
249  
250 =cut
251  
252 # Local Variables:
253 # mode: cperl
254 # cperl-indent-level: 4
255 # fill-column: 78
256 # indent-tabs-mode: nil
257 # c-indentation-style: bsd
258 # End:
259 # ex: set ts=8 sts=4 sw=4 tw=78 ft=perl expandtab shiftround :
« blib/lib/Perl/Critic/Policy/BuiltinFunctions/ProhibitShiftRef.pm ↑ Summary blib/lib/Perl/Critic/Policy/InputOutput/RequireBracedFileHandleWithPrint.pm »