| Perl::Critic::PolicySummary - Description of the bundled Policy modules |
Perl::Critic::PolicySummary - Description of the bundled Policy modules
The following Policy modules are distributed with Perl::Critic. The
Policy modules have been categorized according to the table of
contents in Damian Conway's book Perl Best Practices. Since most
coding standards take the form ``do this...'' or ``don't do that...'', I
have adopted the convention of naming each module RequireSomething
or ProhibitSomething. Each Policy is listed here with its default
severity. If you don't agree with the default severity, you can
change it in your .perlcriticrc file. See the documentation of
each module for its specific details.
Use List::MoreUtils::any instead of grep in boolean context. [Severity 2]
Map blocks should have a single statement. [Severity 3]
Use 4-argument substr instead of writing substr($foo, 2, 6) = $bar. [Severity 3]
Forbid $b before $a in sort blocks. [Severity 1]
Use the Time::HiRes manpage instead of something like select(undef, undef, undef, .05). [Severity 5]
Write eval { my $foo; bar($foo) } instead of eval "my $foo; bar($foo);". [Severity 5]
Write split /-/, $string instead of split '-', $string. [Severity 2]
Write eval { $foo->can($name) } instead of UNIVERSAL::can($foo, $name). [Severity 3]
Write eval { $foo->isa($pkg) } instead of UNIVERSAL::isa($foo, $pkg). [Severity 3]
Don't use grep in void contexts. [Severity 3]
Don't use map in void contexts. [Severity 3]
Write grep { $_ =~ /$pattern/ } @list instead of grep /$pattern/, @list. [Severity 4]
Write map { $_ =~ /$pattern/ } @list instead of map /$pattern/, @list. [Severity 4]
Use glob q{*} instead of <*>. [Severity 5]
Sort blocks should have a single statement. [Severity 3]
AUTOLOAD methods should be avoided. [Severity 3]
Employ use base instead of @ISA. [Severity 3]
Write bless {}, $class; instead of just bless {};. [Severity 5]
Use spaces instead of tabs. [Severity 3]
Write open $handle, $path instead of open($handle, $path). [Severity 1]
Write qw(foo bar baz) instead of ('foo', 'bar', 'baz'). [Severity 2]
Don't use whitespace at the end of lines. [Severity 1]
Use the same newline through the source. [Severity 4]
Must run code through perltidy. [Severity 1]
Put a comma at the end of every multi-line list declaration, including the last one. [Severity 1]
Write for(0..20) instead of for($i=0; $i<=20; $i++). [Severity 2]
Don't write long ``if-elsif-elsif-elsif-elsif...else'' chains. [Severity 3]
Don't write deeply nested loops and conditionals. [Severity 3]
Don't modify $_ in list functions. [Severity 5]
Don't use operators like not, !~, and le within until and unless. [Severity 3]
Write if($condition){ do_something() } instead of do_something() if $condition. [Severity 2]
Write if(! $condition) instead of unless($condition). [Severity 2]
Don't write code after an unconditional die, exit, or next. [Severity 4]
Write while(! $condition) instead of until($condition). [Severity 2]
Check your spelling. [Severity 1]
All POD should be after __END__. [Severity 1]
Organize your POD into the customary sections. [Severity 2]
Use functions from the Carp manpage instead of warn or die. [Severity 3]
Discourage stuff like @files = `ls $directory`. [Severity 3]
Write open my $fh, q{<}, $filename; instead of open FH, q{<}, $filename;. [Severity 5]
Use ``<>'' or ``<ARGV>'' or a prompting module instead of ``<STDIN>''. [Severity 4]
Use prompt() instead of -t. [Severity 5]
Use ``local $/ = undef'' or File::Slurp instead of joined readline. [Severity 3]
Never write select($fh). [Severity 4]
Write while( $line = <> ){...} instead of for(<>){...}. [Severity 4]
Write open $fh, q{<}, $filename; instead of open $fh, "<$filename";. [Severity 5]
Close filehandles as soon as possible after opening them. [Severity 4]
Write my $error = close $fh; instead of close $fh;. [Severity 2]
Write my $error = open $fh, $mode, $filename; instead of open $fh, $mode, $filename;. [Severity 3]
Return value of flagged function ignored. [Severity 1]
Write print {$FH} $foo, $bar; instead of print $FH $foo, $bar;. [Severity 1]
Do not use format. [Severity 3]
Do not use tie. [Severity 2]
Put source-control keywords in every file. [Severity 2]
Export symbols via @EXPORT_OK or %EXPORT_TAGS instead of @EXPORT. [Severity 4]
Ban modules that aren't blessed by your shop. [Severity 5]
Minimize complexity in code that is outside of subroutines. [Severity 3]
Put packages (especially subclasses) in separate files. [Severity 4]
Write require Module instead of require 'Module.pm'. [Severity 5]
End each module with an explicitly 1; instead of some funky expression. [Severity 4]
Always make the package explicit. [Severity 4]
Package declaration must match filename. [Severity 5]
Give every module a $VERSION number. [Severity 2]
Don't use vague variable or subroutine names like 'last' or 'record'. [Severity 3]
Write sub my_function{} instead of sub MyFunction{}. [Severity 1]
Write $my_variable = 42 instead of $MyVariable = 42. [Severity 1]
Write @{ $array_ref } instead of @$array_ref. [Severity 2]
Capture variable used outside conditional. [Severity 3]
Split long regexps into smaller qr// chunks. [Severity 3]
Use named character classes instead of explicit character lists. [Severity 1]
Use character classes for literal metachars instead of escapes. [Severity 1]
Use eq or hash instead of fixed-pattern regexps. [Severity 2]
Use [abc] instead of a|b|c. [Severity 1]
Only use a capturing group if you plan to use the captured value. [Severity 3]
Use only // or {} to delimit regexps. [Severity 1]
Use { and } to delimit multi-line regexps. [Severity 1]
Always use the /x modifier with regular expressions. [Severity 3]
Always use the /m modifier with regular expressions. [Severity 2]
Don't call functions with a leading ampersand sigil. [Severity 2]
Don't declare your own open function. [Severity 4]
Minimize complexity by factoring code into smaller subroutines. [Severity 3]
Return failure with bare return instead of return undef. [Severity 5]
sub never { sub correct {} }. [Severity 5]
Too many arguments. [Severity 3]
Don't write sub my_function (@@) {}. [Severity 5]
Prevent access to private subs in other packages. [Severity 3]
Always unpack @_ first. [Severity 4]
End every path through a subroutine with an explicit return statement. [Severity 4]
Prohibit various flavors of no strict. [Severity 5]
Prohibit various flavors of no warnings. [Severity 4]
Don't turn off strict for large blocks of code. [Severity 4]
Tests should all have labels. [Severity 3]
Always use strict. [Severity 5]
Always use warnings. [Severity 4]
Don't use the comma operator as a statement separator. [Severity 4]
Don't use constant $FOO => 15. [Severity 4]
Write q{} instead of ''. [Severity 2]
Write "\N{DELETE}" instead of "\x7F", etc. [Severity 2]
Use concatenation or HEREDOCs instead of literal line breaks in strings. [Severity 3]
Always use single quotes for literal strings. [Severity 1]
Write oct(755) instead of 0755. [Severity 5]
Long chains of method calls indicate tightly coupled code. [Severity 2]
Don't mix numeric operators with string operands, or vice-versa. [Severity 3]
Write !$foo && $bar || $baz instead of not $foo && $bar or $baz. [Severity 4]
Use q{} or qq{} instead of quotes for awkward-looking strings. [Severity 2]
Don't use quotes (', ", `) as delimiters for the quote-like operators. [Severity 3]
Don't use strings like v1.4 or 1.4.5 when including other modules. [Severity 3]
Warns that you might have used single quotes when you really wanted double-quotes. [Severity 1]
Write 141_234_397.0145 instead of 141234397.0145 . [Severity 2]
Write print <<'THE_END' or print <<"THE_END" . [Severity 3]
Write <<'THE_END'; instead of <<'theEnd'; . [Severity 2]
Do not write my $foo = $bar if $baz; . [Severity 5]
Use my instead of local, except when you have to. [Severity 2]
Avoid $`, $&, $' and their English equivalents. [Severity 4]
Eliminate globals declared with our or use vars. [Severity 3]
Use double colon (::) to separate package name components instead of single quotes ('). [Severity 2]
Write $EVAL_ERROR instead of $@. [Severity 2]
Prevent access to private vars in other packages. [Severity 3]
Write local $foo = $bar; instead of just local $foo;. [Severity 3]
Write for my $element (@list) {...} instead of for $element (@list) {...}. [Severity 5]
Magic variables should be assigned as ``local''. [Severity 4]
Negative array index should be used. [Severity 4]
Jeffrey Ryan Thalhammer <thaljef@cpan.org>
Copyright (c) 2005-2007 Jeffrey Ryan Thalhammer. All rights reserved.
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. The full text of this license can be found in the LICENSE file included with this module.
| Perl::Critic::PolicySummary - Description of the bundled Policy modules |