#!perl# Note: This script is a CLI for Riap function /App/PerlCriticUtils/pcplist# and generated automatically using Perinci::CmdLine::Gen version 0.502use5.010001;usestrict;usewarnings;our$AUTHORITY='cpan:PERLANCAR';# AUTHORITYour$DATE='2023-01-17';# DATEour$DIST='App-PerlCriticUtils';# DISTour$VERSION='0.008';# VERSIONmy$cmdline= Perinci::CmdLine::Any->new(url=>"/App/PerlCriticUtils/pcplist",program_name=>"pcplist",read_config=> 0,read_env=> 0,);$cmdline->run;# ABSTRACT: List installed Perl::Critic policy modules# PODNAME: pcplist__END__=pod=encoding UTF-8=head1 NAMEpcplist - List installed Perl::Critic policy modules=head1 VERSIONThis document describes version 0.008 of pcplist (from Perl distribution App-PerlCriticUtils), released on 2023-01-17.=head1 SYNOPSISB<pcplist> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)B<pcplist> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)B<pcplist> [B<L<--default-severity|/"--default-severity=s">>=I<L<uint|Sah::Schema::uint>>] [B<L<--detail|/"--detail, -l">>|B<L<-l|/"--detail, -l">>|B<L<--no-detail|/"--detail, -l">>|B<L<--nodetail|/"--detail, -l">>] [B<L<--format|/"--format=s">>=I<name>|B<L<--json|/"--json">>] [B<L<--max-default-severity|/"--max-default-severity=s">>=I<L<uint|Sah::Schema::uint>>] [B<L<--min-default-severity|/"--min-default-severity=s">>=I<L<uint|Sah::Schema::uint>>] [B<L<--(no)naked-res|/"--naked-res">>] [B<L<--page-result|/"--page-result">>[=I<program>]|B<L<--view-result|/"--view-result">>[=I<program>]] -- [I<L<query|/"--query=s@">>] ...See examples in the L</EXAMPLES> section.=head1 OPTIONSC<*> marks required options.=head2 Main options=over=item B<--detail>, B<-l>(No description)=back=head2 Filtering options=over=item B<--default-severity>=I<s>(No description)=item B<--max-default-severity>=I<s>(No description)=item B<--min-default-severity>=I<s>(No description)=item B<--query-json>=I<s>Filter by name (JSON-encoded).See C<--query>.Can also be specified as the 1st command-line argument and onwards.=item B<--query>=I<s@>Filter by name.Can also be specified as the 1st command-line argument and onwards.Can be specified multiple times.=back=head2 Output options=over=item B<--format>=I<s>Choose output format, e.g. json, text.Default value:undefOutput can be displayed in multiple formats, and a suitable default format ischosen depending on the application and/or whether output destination isinteractive terminal (i.e. whether output is piped). This option specificallychooses an output format.=item B<--json>Set output format to json.=item B<--naked-res>When outputing as JSON, strip result envelope.Default value:0By default, when outputing as JSON, the full enveloped result is returned, e.g.:[200,"OK",[1,2,3],{"func.extra"=>4}]The reason is so you can get the status (1st element), status message (2ndelement) as well as result metadata/extra result (4th element) instead of justthe result (3rd element). However, sometimes you want just the result, e.g. whenyou want to pipe the result for more post-processing. In this case you can useC<--naked-res> so you just get:[1,2,3]=item B<--page-result>Filter output through a pager.This option will pipe the output to a specified pager program. If pager programis not specified, a suitable default e.g. C<less> is chosen.=item B<--view-result>View output using a viewer.This option will first save the output to a temporary file, then open a viewerprogram to view the temporary file. If a viewer program is not chosen, asuitable default, e.g. the browser, is chosen.=back=head2 Other options=over=item B<--help>, B<-h>, B<-?>Display help message and exit.=item B<--version>, B<-v>Display program's version and exit.=back=head1 COMPLETIONThis script has shell tab completion capability with support for severalshells.=head2 bashTo activate bash completion for this script, put:complete -C pcplist pcplistin your bash startup (e.g. F<~/.bashrc>). Your next shell session will thenrecognize tab completion for the command. Or, you can also directly execute theline above in your shell to activate immediately.It is recommended, however, that you install modules using L<cpanm-shcompgen>which can activate shell completion for scripts immediately.=head2 tcshTo activate tcsh completion for this script, put:complete pcplist 'p/*/`pcplist`/'in your tcsh startup (e.g. F<~/.tcshrc>). Your next shell session will thenrecognize tab completion for the command. Or, you can also directly execute theline above in your shell to activate immediately.It is also recommended to install L<shcompgen> (see above).=head2 other shellsFor fish and zsh, install L<shcompgen> as described above.=head1 EXAMPLES=head2 List installed policies% pcplistBuiltinFunctions::GrepWithSimpleValueBuiltinFunctions::ProhibitBooleanGrepBuiltinFunctions::ProhibitComplexMappingsBuiltinFunctions::ProhibitLvalueSubstrBuiltinFunctions::ProhibitReverseSortBlockBuiltinFunctions::ProhibitShiftRefBuiltinFunctions::ProhibitSleepViaSelectBuiltinFunctions::ProhibitStringyEvalBuiltinFunctions::ProhibitStringySplitBuiltinFunctions::ProhibitUniversalCanBuiltinFunctions::ProhibitUniversalIsaBuiltinFunctions::ProhibitUselessTopicBuiltinFunctions::ProhibitVoidGrepBuiltinFunctions::ProhibitVoidMapBuiltinFunctions::RequireBlockGrepBuiltinFunctions::RequireBlockMapBuiltinFunctions::RequireGlobFunctionBuiltinFunctions::RequireSimpleSortBlockClassHierarchies::ProhibitAutoloadingClassHierarchies::ProhibitExplicitISAClassHierarchies::ProhibitOneArgBlessCodeLayout::ProhibitHardTabsCodeLayout::ProhibitParensWithBuiltinsCodeLayout::ProhibitQuotedWordListsCodeLayout::ProhibitTrailingWhitespaceCodeLayout::RequireConsistentNewlinesCodeLayout::RequireTidyCodeCodeLayout::RequireTrailingCommasControlStructures::ProhibitCStyleForLoopsControlStructures::ProhibitCascadingIfElseControlStructures::ProhibitDeepNestsControlStructures::ProhibitLabelsWithSpecialBlockNamesControlStructures::ProhibitMutatingListFunctionsControlStructures::ProhibitNegativeExpressionsInUnlessAndUntilConditionsControlStructures::ProhibitPostfixControlsControlStructures::ProhibitUnlessBlocksControlStructures::ProhibitUnreachableCodeControlStructures::ProhibitUntilBlocksControlStructures::ProhibitYadaOperatorDocumentation::PodSpellingDocumentation::RequirePackageMatchesPodNameDocumentation::RequirePodAtEndDocumentation::RequirePodSectionsErrorHandling::RequireCarpingErrorHandling::RequireCheckingReturnValueOfEvalInputOutput::ProhibitBacktickOperatorsInputOutput::ProhibitBarewordFileHandlesInputOutput::ProhibitExplicitStdinInputOutput::ProhibitInteractiveTestInputOutput::ProhibitJoinedReadlineInputOutput::ProhibitOneArgSelectInputOutput::ProhibitReadlineInForLoopInputOutput::ProhibitTwoArgOpenInputOutput::RequireBracedFileHandleWithPrintInputOutput::RequireBriefOpenInputOutput::RequireCheckedCloseInputOutput::RequireCheckedOpenInputOutput::RequireCheckedSyscallsInputOutput::RequireEncodingWithUTF8LayerMiscellanea::ProhibitFormatsMiscellanea::ProhibitTiesMiscellanea::ProhibitUnrestrictedNoCriticMiscellanea::ProhibitUselessNoCriticModules::ProhibitAutomaticExportationModules::ProhibitConditionalUseStatementsModules::ProhibitEvilModulesModules::ProhibitExcessMainComplexityModules::ProhibitMultiplePackagesModules::RequireBarewordIncludesModules::RequireEndWithOneModules::RequireExplicitPackageModules::RequireFilenameMatchesPackageModules::RequireNoMatchVarsWithUseEnglishModules::RequireVersionVarNamingConventions::CapitalizationNamingConventions::ProhibitAmbiguousNamesObjects::ProhibitIndirectSyntaxReferences::ProhibitDoubleSigilsRegularExpressions::ProhibitCaptureWithoutTestRegularExpressions::ProhibitComplexRegexesRegularExpressions::ProhibitEnumeratedClassesRegularExpressions::ProhibitEscapedMetacharactersRegularExpressions::ProhibitFixedStringMatchesRegularExpressions::ProhibitSingleCharAlternationRegularExpressions::ProhibitUnusedCaptureRegularExpressions::ProhibitUnusualDelimitersRegularExpressions::ProhibitUselessTopicRegularExpressions::RequireBracesForMultilineRegularExpressions::RequireDotMatchAnythingRegularExpressions::RequireExtendedFormattingRegularExpressions::RequireLineBoundaryMatchingSubroutines::ProhibitAmpersandSigilsSubroutines::ProhibitBuiltinHomonymsSubroutines::ProhibitExcessComplexitySubroutines::ProhibitExplicitReturnUndefSubroutines::ProhibitManyArgsSubroutines::ProhibitNestedSubsSubroutines::ProhibitReturnSortSubroutines::ProhibitSubroutinePrototypesSubroutines::ProhibitUnusedPrivateSubroutinesSubroutines::ProtectPrivateSubsSubroutines::RequireArgUnpackingSubroutines::RequireFinalReturnTestingAndDebugging::ProhibitNoStrictTestingAndDebugging::ProhibitNoWarningsTestingAndDebugging::ProhibitProlongedStrictureOverrideTestingAndDebugging::RequireTestLabelsTestingAndDebugging::RequireUseStrictTestingAndDebugging::RequireUseWarningsValuesAndExpressions::ProhibitCommaSeparatedStatementsValuesAndExpressions::ProhibitComplexVersionValuesAndExpressions::ProhibitConstantPragmaValuesAndExpressions::ProhibitEmptyQuotesValuesAndExpressions::ProhibitEscapedCharactersValuesAndExpressions::ProhibitImplicitNewlinesValuesAndExpressions::ProhibitInterpolationOfLiteralsValuesAndExpressions::ProhibitLeadingZerosValuesAndExpressions::ProhibitLongChainsOfMethodCallsValuesAndExpressions::ProhibitMagicNumbersValuesAndExpressions::ProhibitMismatchedOperatorsValuesAndExpressions::ProhibitMixedBooleanOperatorsValuesAndExpressions::ProhibitNoisyQuotesValuesAndExpressions::ProhibitQuotesAsQuotelikeOperatorDelimitersValuesAndExpressions::ProhibitSpecialLiteralHeredocTerminatorValuesAndExpressions::ProhibitVersionStringsValuesAndExpressions::RequireConstantVersionValuesAndExpressions::RequireInterpolationOfMetacharsValuesAndExpressions::RequireNumberSeparatorsValuesAndExpressions::RequireQuotedHeredocTerminatorValuesAndExpressions::RequireUpperCaseHeredocTerminatorVariables::ProhibitAugmentedAssignmentInDeclarationVariables::ProhibitConditionalDeclarationsVariables::ProhibitEvilVariablesVariables::ProhibitFatCommaInDeclarationVariables::ProhibitLocalVarsVariables::ProhibitMatchVarsVariables::ProhibitPackageVarsVariables::ProhibitPerl4PackageNamesVariables::ProhibitPunctuationVarsVariables::ProhibitReusedNamesVariables::ProhibitUnusedVariablesVariables::ProtectPrivateVarsVariables::RequireInitializationForLocalVarsVariables::RequireLexicalLoopIteratorsVariables::RequireLocalizedPunctuationVarsVariables::RequireNegativeIndices=head2 List installed policies (show details)% pcplist -l+--------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-----------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+| name | abstract | applies_to | default_severity | default_themes | supported_parameters |+--------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-----------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+| BuiltinFunctions::GrepWithSimpleValue | Warn grep with simple value | PPI::Token::Word | 3 | core, bugs | || BuiltinFunctions::ProhibitBooleanGrep | Use C<List::MoreUtils::any> instead of C<grep> in boolean context. | PPI::Token::Word | 2 | core, pbp, performance, certrec | || BuiltinFunctions::ProhibitComplexMappings | Map blocks should have a single statement. | PPI::Token::Word | 3 | core, pbp, maintenance, complexity | max_statements || BuiltinFunctions::ProhibitLvalueSubstr | Use 4-argument C<substr> instead of writing C<substr($foo, 2, 6) = $bar>. | PPI::Token::Word | 3 | core, maintenance, pbp | || BuiltinFunctions::ProhibitReverseSortBlock | Forbid $b before $a in sort blocks. | PPI::Token::Word | 1 | core, pbp, cosmetic | || BuiltinFunctions::ProhibitShiftRef | Prohibit C<\shift> in code | PPI::Token::Word | 3 | core, bugs, tests | || BuiltinFunctions::ProhibitSleepViaSelect | Use L<Time::HiRes|Time::HiRes> instead of something like C<select(undef, undef, undef, .05)>. | PPI::Token::Word | 5 | core, pbp, bugs | || BuiltinFunctions::ProhibitStringyEval | Write C<eval { my $foo; bar($foo) }> instead of C<eval "my $foo; bar($foo);">. | PPI::Token::Word | 5 | core, pbp, bugs, certrule | allow_includes || BuiltinFunctions::ProhibitStringySplit | Write C<split /-/, $string> instead of C<split '-', $string>. | PPI::Token::Word | 2 | core, pbp, cosmetic, certrule | || BuiltinFunctions::ProhibitUniversalCan | Write C<< eval { $foo->can($name) } >> instead of C<UNIVERSAL::can($foo, $name)>. | PPI::Token::Word | 3 | core, maintenance, certrule | || BuiltinFunctions::ProhibitUniversalIsa | Write C<< eval { $foo->isa($pkg) } >> instead of C<UNIVERSAL::isa($foo, $pkg)>. | PPI::Token::Word | 3 | core, maintenance, certrule | || BuiltinFunctions::ProhibitUselessTopic | Don't pass $_ to built-in functions that assume it, or to most filetest operators. | PPI::Token::Word | 2 | core | || BuiltinFunctions::ProhibitVoidGrep | Don't use C<grep> in void contexts. | PPI::Token::Word | 3 | core, maintenance | || BuiltinFunctions::ProhibitVoidMap | Don't use C<map> in void contexts. | PPI::Token::Word | 3 | core, maintenance | || BuiltinFunctions::RequireBlockGrep | Write C<grep { /$pattern/ } @list> instead of C<grep /$pattern/, @list>. | PPI::Token::Word | 4 | core, bugs, pbp | || BuiltinFunctions::RequireBlockMap | Write C<map { /$pattern/ } @list> instead of C<map /$pattern/, @list>. | PPI::Token::Word | 4 | core, bugs, pbp | || BuiltinFunctions::RequireGlobFunction | Use C<glob q{*}> instead of <*>. | PPI::Token::QuoteLike::Readline | 5 | core, pbp, bugs | || BuiltinFunctions::RequireSimpleSortBlock | Sort blocks should have a single statement. | PPI::Token::Word | 3 | core, pbp, maintenance, complexity | || ClassHierarchies::ProhibitAutoloading | AUTOLOAD methods should be avoided. | PPI::Statement::Sub | 3 | core, maintenance, pbp | || ClassHierarchies::ProhibitExplicitISA | Employ C<use base> instead of C<@ISA>. | PPI::Token::Symbol | 3 | core, maintenance, pbp, certrec | || ClassHierarchies::ProhibitOneArgBless | Write C<bless {}, $class;> instead of just C<bless {};>. | PPI::Token::Word | 5 | core, pbp, bugs | || CodeLayout::ProhibitHardTabs | Use spaces instead of tabs. | PPI::Token | 3 | core, cosmetic, pbp | allow_leading_tabs || CodeLayout::ProhibitParensWithBuiltins | Write C<open $handle, $path> instead of C<open($handle, $path)>. | PPI::Token::Word | 1 | core, pbp, cosmetic | || CodeLayout::ProhibitQuotedWordLists | Write C<qw(foo bar baz)> instead of C<('foo', 'bar', 'baz')>. | PPI::Structure::List | 2 | core, cosmetic | min_elements, strict || CodeLayout::ProhibitTrailingWhitespace | Don't use whitespace at the end of lines. | PPI::Token::Whitespace | 1 | core, maintenance | || CodeLayout::RequireConsistentNewlines | Use the same newline through the source. | PPI::Document | 4 | core, bugs | || CodeLayout::RequireTidyCode | Must run code through L<perltidy|perltidy>. | PPI::Document | 1 | core, pbp, cosmetic | perltidyrc || CodeLayout::RequireTrailingCommas | Put a comma at the end of every multi-line list declaration, including the last one. | PPI::Structure::List | 1 | core, pbp, cosmetic | || ControlStructures::ProhibitCStyleForLoops | Write C<for(0..20)> instead of C<for($i=0; $i<=20; $i++)>. | PPI::Structure::For | 2 | core, pbp, maintenance | || ControlStructures::ProhibitCascadingIfElse | Don't write long "if-elsif-elsif-elsif-elsif...else" chains. | PPI::Statement::Compound | 3 | core, pbp, maintenance, complexity | max_elsif || ControlStructures::ProhibitDeepNests | Don't write deeply nested loops and conditionals. | PPI::Statement::Compound | 3 | core, maintenance, complexity | max_nests || ControlStructures::ProhibitLabelsWithSpecialBlockNames | Don't use labels that are the same as the special block names. | PPI::Token::Label | 4 | core, bugs | || ControlStructures::ProhibitMutatingListFunctions | Don't modify C<$_> in list functions. | PPI::Token::Word | 5 | core, bugs, pbp, certrule | list_funcs, add_list_funcs || ControlStructures::ProhibitNegativeExpressionsInUnlessAndUntilConditions | Don't use operators like C<not>, C<!~>, and C<le> within C<until> and C<unless>. | PPI::Token::Word | 3 | core, maintenance, pbp | || ControlStructures::ProhibitPostfixControls | Write C<if($condition){ do_something() }> instead of C<do_something() if $condition>. | PPI::Token::Word | 2 | core, pbp, cosmetic | allow, flowcontrol || ControlStructures::ProhibitUnlessBlocks | Write C<if(! $condition)> instead of C<unless($condition)>. | PPI::Statement::Compound | 2 | core, pbp, cosmetic | || ControlStructures::ProhibitUnreachableCode | Don't write code after an unconditional C<die, exit, or next>. | PPI::Token::Word | 4 | core, bugs, certrec | || ControlStructures::ProhibitUntilBlocks | Write C<while(! $condition)> instead of C<until($condition)>. | PPI::Statement | 2 | core, pbp, cosmetic | || ControlStructures::ProhibitYadaOperator | Never use C<...> in production code. | PPI::Token::Operator | 4 | core, pbp, maintenance | || Documentation::PodSpelling | Check your spelling. | PPI::Document | 1 | core, cosmetic, pbp | spell_command, stop_words, stop_words_file || Documentation::RequirePackageMatchesPodName | The C<=head1 NAME> section should match the package. | PPI::Document | 1 | core, cosmetic | || Documentation::RequirePodAtEnd | All POD should be after C<__END__>. | PPI::Document | 1 | core, cosmetic, pbp | || Documentation::RequirePodSections | Organize your POD into the customary sections. | PPI::Document | 2 | core, pbp, maintenance | lib_sections, script_sections, source, language || ErrorHandling::RequireCarping | Use functions from L<Carp|Carp> instead of C<warn> or C<die>. | PPI::Token::Word | 3 | core, pbp, maintenance, certrule | allow_messages_ending_with_newlines, allow_in_main_unless_in_subroutine || ErrorHandling::RequireCheckingReturnValueOfEval | You can't depend upon the value of C<$@>/C<$EVAL_ERROR> to tell whether an C<eval> failed. | PPI::Token::Word | 3 | core, bugs | || InputOutput::ProhibitBacktickOperators | Discourage stuff like C<@files = `ls $directory`>. | PPI::Token::QuoteLike::Command | 3 | core, maintenance | only_in_void_context || InputOutput::ProhibitBarewordFileHandles | Write C<open my $fh, q{<}, $filename;> instead of C<open FH, q{<}, $filename;>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || InputOutput::ProhibitExplicitStdin | Use "<>" or "<ARGV>" or a prompting module instead of "<STDIN>". | PPI::Token::QuoteLike::Readline | 4 | core, pbp, maintenance | || InputOutput::ProhibitInteractiveTest | Use prompt() instead of -t. | PPI::Token::Operator | 5 | core, pbp, bugs, certrule | || InputOutput::ProhibitJoinedReadline | Use C<local $/ = undef> or L<Path::Tiny|Path::Tiny> instead of joined readline. | PPI::Token::Word | 3 | core, pbp, performance | || InputOutput::ProhibitOneArgSelect | Never write C<select($fh)>. | PPI::Token::Word | 4 | core, bugs, pbp, certrule | || InputOutput::ProhibitReadlineInForLoop | Write C<< while( $line = <> ){...} >> instead of C<< for(<>){...} >>. | PPI::Statement::Compound | 4 | core, bugs, pbp | || InputOutput::ProhibitTwoArgOpen | Write C<< open $fh, q{<}, $filename; >> instead of C<< open $fh, "<$filename"; >>. | PPI::Token::Word | 5 | core, pbp, bugs, security, certrule | || InputOutput::RequireBracedFileHandleWithPrint | Write C<print {$FH} $foo, $bar;> instead of C<print $FH $foo, $bar;>. | PPI::Token::Word | 1 | core, pbp, cosmetic | || InputOutput::RequireBriefOpen | Close filehandles as soon as possible after opening them. | PPI::Token::Word | 4 | core, pbp, maintenance | lines || InputOutput::RequireCheckedClose | Write C<< my $error = close $fh; >> instead of C<< close $fh; >>. | PPI::Token::Word | 2 | core, maintenance, certrule | autodie_modules || InputOutput::RequireCheckedOpen | Write C<< my $error = open $fh, $mode, $filename; >> instead of C<< open $fh, $mode, $filename; >>. | PPI::Token::Word | 3 | core, maintenance, certrule | autodie_modules || InputOutput::RequireCheckedSyscalls | Return value of flagged function ignored. | PPI::Token::Word | 1 | core, maintenance, certrule | functions, exclude_functions, autodie_modules || InputOutput::RequireEncodingWithUTF8Layer | Write C<< open $fh, q{<:encoding(UTF-8)}, $filename; >> instead of C<< open $fh, q{<:utf8}, $filename; >>. | PPI::Token::Word | 5 | core, bugs, security | || Miscellanea::ProhibitFormats | Do not use C<format>. | PPI::Token::Word | 3 | core, maintenance, pbp, certrule | || Miscellanea::ProhibitTies | Do not use C<tie>. | PPI::Token::Word | 2 | core, pbp, maintenance | || Miscellanea::ProhibitUnrestrictedNoCritic | Forbid a bare C<## no critic> | PPI::Document | 3 | core, maintenance | || Miscellanea::ProhibitUselessNoCritic | Remove ineffective "## no critic" annotations. | PPI::Document | 2 | core, maintenance | || Modules::ProhibitAutomaticExportation | Export symbols via C<@EXPORT_OK> or C<%EXPORT_TAGS> instead of C<@EXPORT>. | PPI::Document | 4 | core, bugs | || Modules::ProhibitConditionalUseStatements | Avoid putting conditional logic around compile-time includes. | PPI::Statement::Include | 3 | core, bugs | || Modules::ProhibitEvilModules | Ban modules that aren't blessed by your shop. | PPI::Statement::Include | 5 | core, bugs, certrule | modules, modules_file || Modules::ProhibitExcessMainComplexity | Minimize complexity in code that is B<outside> of subroutines. | PPI::Document | 3 | core, complexity, maintenance | max_mccabe || Modules::ProhibitMultiplePackages | Put packages (especially subclasses) in separate files. | PPI::Document | 4 | core, bugs | || Modules::RequireBarewordIncludes | Write C<require Module> instead of C<require 'Module.pm'>. | PPI::Statement::Include | 5 | core, portability | || Modules::RequireEndWithOne | End each module with an explicitly C<1;> instead of some funky expression. | PPI::Document | 4 | core, bugs, pbp, certrule | || Modules::RequireExplicitPackage | Always make the C<package> explicit. | PPI::Document | 4 | core, bugs | exempt_scripts, allow_import_of || Modules::RequireFilenameMatchesPackage | Package declaration must match filename. | PPI::Document | 5 | core, bugs | || Modules::RequireNoMatchVarsWithUseEnglish | C<use English> must be passed a C<-no_match_vars> argument. | PPI::Statement::Include | 2 | core, performance | || Modules::RequireVersionVar | Give every module a C<$VERSION> number. | PPI::Document | 2 | core, pbp, readability | || NamingConventions::Capitalization | Distinguish different program components by case. | PPI::Token::Label | 1 | core, pbp, cosmetic | packages, package_exemptions, subroutines, subroutine_exemptions, local_lexical_variables, local_lexical_variable_exemptions, scoped_lexical_variables, scoped_lexical_variable_exemptions, file_lexical_variables, file_lexical_variable_exemptions, global_variables, global_variable_exemptions, constants, constant_exemptions, labels, label_exemptions || NamingConventions::ProhibitAmbiguousNames | Don't use vague variable or subroutine names like 'last' or 'record'. | PPI::Statement::Variable | 3 | core, pbp, maintenance | forbid || Objects::ProhibitIndirectSyntax | Prohibit indirect object call syntax. | PPI::Token::Word | 4 | core, pbp, maintenance, certrule | forbid || References::ProhibitDoubleSigils | Write C<@{ $array_ref }> instead of C<@$array_ref>. | PPI::Token::Cast | 2 | core, pbp, cosmetic | || RegularExpressions::ProhibitCaptureWithoutTest | Capture variable used outside conditional. | PPI::Token::Magic | 3 | core, pbp, maintenance, certrule | exception_source || RegularExpressions::ProhibitComplexRegexes | Split long regexps into smaller C<qr//> chunks. | PPI::Token::QuoteLike::Regexp | 3 | core, pbp, maintenance | max_characters || RegularExpressions::ProhibitEnumeratedClasses | Use named character classes instead of explicit character lists. | PPI::Token::QuoteLike::Regexp | 1 | core, pbp, cosmetic, unicode | || RegularExpressions::ProhibitEscapedMetacharacters | Use character classes for literal meta-characters instead of escapes. | PPI::Token::QuoteLike::Regexp | 1 | core, pbp, cosmetic | || RegularExpressions::ProhibitFixedStringMatches | Use C<eq> or hash instead of fixed-pattern regexps. | PPI::Token::QuoteLike::Regexp | 2 | core, pbp, performance | || RegularExpressions::ProhibitSingleCharAlternation | Use C<[abc]> instead of C<a|b|c>. | PPI::Token::QuoteLike::Regexp | 1 | core, pbp, performance | || RegularExpressions::ProhibitUnusedCapture | Only use a capturing group if you plan to use the captured value. | PPI::Token::Regexp::Substitute | 3 | core, pbp, maintenance | || RegularExpressions::ProhibitUnusualDelimiters | Use only C<//> or C<{}> to delimit regexps. | PPI::Token::QuoteLike::Regexp | 1 | core, pbp, cosmetic | allow_all_brackets || RegularExpressions::ProhibitUselessTopic | Don't use $_ to match against regexes. | PPI::Token::Magic | 2 | core | || RegularExpressions::RequireBracesForMultiline | Use C<{> and C<}> to delimit multi-line regexps. | PPI::Token::QuoteLike::Regexp | 1 | core, pbp, cosmetic | allow_all_brackets || RegularExpressions::RequireDotMatchAnything | Always use the C</s> modifier with regular expressions. | PPI::Token::QuoteLike::Regexp | 2 | core, pbp, cosmetic | || RegularExpressions::RequireExtendedFormatting | Always use the C</x> modifier with regular expressions. | PPI::Token::QuoteLike::Regexp | 3 | core, pbp, maintenance | minimum_regex_length_to_complain_about, strict || RegularExpressions::RequireLineBoundaryMatching | Always use the C</m> modifier with regular expressions. | PPI::Token::QuoteLike::Regexp | 2 | core, pbp, cosmetic | || Subroutines::ProhibitAmpersandSigils | Don't call functions with a leading ampersand sigil. | PPI::Token::Symbol | 2 | core, pbp, maintenance | || Subroutines::ProhibitBuiltinHomonyms | Don't declare your own C<open> function. | PPI::Statement::Sub | 4 | core, bugs, pbp, certrule | || Subroutines::ProhibitExcessComplexity | Minimize complexity by factoring code into smaller subroutines. | PPI::Statement::Sub | 3 | core, complexity, maintenance | max_mccabe || Subroutines::ProhibitExplicitReturnUndef | Return failure with bare C<return> instead of C<return undef>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || Subroutines::ProhibitManyArgs | Too many arguments. | PPI::Statement::Sub | 3 | core, pbp, maintenance | max_arguments, skip_object || Subroutines::ProhibitNestedSubs | C<sub never { sub correct {} }>. | PPI::Statement::Sub | 5 | core, bugs | || Subroutines::ProhibitReturnSort | Behavior of C<sort> is not defined if called in scalar context. | PPI::Token::Word | 5 | core, bugs, certrule | || Subroutines::ProhibitSubroutinePrototypes | Don't write C<sub my_function (@@) {}>. | PPI::Statement::Sub | 5 | core, pbp, bugs, certrec | || Subroutines::ProhibitUnusedPrivateSubroutines | Prevent unused private subroutines. | PPI::Statement::Sub | 3 | core, maintenance, certrec | private_name_regex, allow, skip_when_using, allow_name_regex || Subroutines::ProtectPrivateSubs | Prevent access to private subs in other packages. | PPI::Token::Word | 3 | core, maintenance, certrule | private_name_regex, allow || Subroutines::RequireArgUnpacking | Always unpack C<@_> first. | PPI::Statement::Sub | 4 | core, pbp, maintenance | short_subroutine_statements, allow_subscripts, allow_delegation_to || Subroutines::RequireFinalReturn | End every path through a subroutine with an explicit C<return> statement. | PPI::Statement::Sub | 4 | core, bugs, pbp, certrec | terminal_funcs, terminal_methods || TestingAndDebugging::ProhibitNoStrict | Prohibit various flavors of C<no strict>. | PPI::Statement::Include | 5 | core, pbp, bugs, certrec | allow || TestingAndDebugging::ProhibitNoWarnings | Prohibit various flavors of C<no warnings>. | PPI::Statement::Include | 4 | core, bugs, pbp, certrec | allow, allow_with_category_restriction || TestingAndDebugging::ProhibitProlongedStrictureOverride | Don't turn off strict for large blocks of code. | PPI::Statement::Include | 4 | core, pbp, bugs, certrec | statements || TestingAndDebugging::RequireTestLabels | Tests should all have labels. | PPI::Token::Word | 3 | core, maintenance, tests | modules || TestingAndDebugging::RequireUseStrict | Always C<use strict>. | PPI::Document | 5 | core, pbp, bugs, certrule, certrec | equivalent_modules || TestingAndDebugging::RequireUseWarnings | Always C<use warnings>. | PPI::Document | 4 | core, pbp, bugs, certrule | equivalent_modules || ValuesAndExpressions::ProhibitCommaSeparatedStatements | Don't use the comma operator as a statement separator. | PPI::Statement | 4 | core, bugs, pbp, certrule | allow_last_statement_to_be_comma_separated_in_map_and_grep || ValuesAndExpressions::ProhibitComplexVersion | Prohibit version values from outside the module. | PPI::Token::Symbol | 3 | core, maintenance | forbid_use_version || ValuesAndExpressions::ProhibitConstantPragma | Don't C<< use constant FOO => 15 >>. | PPI::Statement::Include | 4 | core, bugs, pbp | || ValuesAndExpressions::ProhibitEmptyQuotes | Write C<q{}> instead of C<''>. | PPI::Token::Quote | 2 | core, pbp, cosmetic | || ValuesAndExpressions::ProhibitEscapedCharacters | Write C<"\N{DELETE}"> instead of C<"\x7F">, etc. | PPI::Token::Quote::Interpolate | 2 | core, pbp, cosmetic | || ValuesAndExpressions::ProhibitImplicitNewlines | Use concatenation or HEREDOCs instead of literal line breaks in strings. | PPI::Token::Quote | 3 | core, pbp, cosmetic | || ValuesAndExpressions::ProhibitInterpolationOfLiterals | Always use single quotes for literal strings. | PPI::Token::Quote::Interpolate | 1 | core, pbp, cosmetic | allow, allow_if_string_contains_single_quote || ValuesAndExpressions::ProhibitLeadingZeros | Write C<oct(755)> instead of C<0755>. | PPI::Token::Number::Octal | 5 | core, pbp, bugs, certrec | strict || ValuesAndExpressions::ProhibitLongChainsOfMethodCalls | Long chains of method calls indicate tightly coupled code. | PPI::Statement | 2 | core, maintenance | max_chain_length || ValuesAndExpressions::ProhibitMagicNumbers | Don't use values that don't explain themselves. | PPI::Token::Number | 2 | core, maintenance, certrec | allowed_values, allowed_types, allow_to_the_right_of_a_fat_comma, constant_creator_subroutines || ValuesAndExpressions::ProhibitMismatchedOperators | Don't mix numeric operators with string operands, or vice-versa. | PPI::Token::Operator | 3 | core, bugs, certrule | || ValuesAndExpressions::ProhibitMixedBooleanOperators | Write C< !$foo && $bar || $baz > instead of C< not $foo && $bar or $baz>. | PPI::Statement | 4 | core, bugs, pbp, certrec | || ValuesAndExpressions::ProhibitNoisyQuotes | Use C<q{}> or C<qq{}> instead of quotes for awkward-looking strings. | PPI::Token::Quote::Single | 2 | core, pbp, cosmetic | || ValuesAndExpressions::ProhibitQuotesAsQuotelikeOperatorDelimiters | Don't use quotes (C<'>, C<">, C<`>) as delimiters for the quote-like operators. | PPI::Token::Regexp::Transliterate | 3 | core, maintenance | single_quote_allowed_operators, double_quote_allowed_operators, back_quote_allowed_operators || ValuesAndExpressions::ProhibitSpecialLiteralHeredocTerminator | Don't write C< print <<'__END__' >. | PPI::Token::HereDoc | 3 | core, maintenance | || ValuesAndExpressions::ProhibitVersionStrings | Don't use strings like C<v1.4> or C<1.4.5> when including other modules. | PPI::Statement::Include | 3 | core, pbp, maintenance | || ValuesAndExpressions::RequireConstantVersion | Require $VERSION to be a constant rather than a computed value. | PPI::Token::Symbol | 2 | core, maintenance | allow_version_without_use_on_same_line || ValuesAndExpressions::RequireInterpolationOfMetachars | Warns that you might have used single quotes when you really wanted double-quotes. | PPI::Token::Quote::Literal | 1 | core, pbp, cosmetic | rcs_keywords || ValuesAndExpressions::RequireNumberSeparators | Write C< 141_234_397.0145 > instead of C< 141234397.0145 >. | PPI::Token::Number | 2 | core, pbp, cosmetic | min_value || ValuesAndExpressions::RequireQuotedHeredocTerminator | Write C< print <<'THE_END' > or C< print <<"THE_END" >. | PPI::Token::HereDoc | 3 | core, pbp, maintenance | || ValuesAndExpressions::RequireUpperCaseHeredocTerminator | Write C< <<'THE_END'; > instead of C< <<'theEnd'; >. | PPI::Token::HereDoc | 2 | core, pbp, cosmetic | || Variables::ProhibitAugmentedAssignmentInDeclaration | Do not write C< my $foo .= 'bar'; >. | PPI::Statement::Variable | 4 | core, bugs | || Variables::ProhibitConditionalDeclarations | Do not write C< my $foo = $bar if $baz; >. | PPI::Statement::Variable | 5 | core, bugs | || Variables::ProhibitEvilVariables | Ban variables that aren't blessed by your shop. | PPI::Token::Symbol | 5 | core, bugs | variables, variables_file || Variables::ProhibitFatCommaInDeclaration | Prohibit fat comma in declaration | PPI::Statement::Variable | 4 | core, bugs | || Variables::ProhibitLocalVars | Use C<my> instead of C<local>, except when you have to. | PPI::Statement::Variable | 2 | core, pbp, maintenance | || Variables::ProhibitMatchVars | Avoid C<$`>, C<$&>, C<$'> and their English equivalents. | PPI::Statement::Include | 4 | core, performance, pbp | || Variables::ProhibitPackageVars | Eliminate globals declared with C<our> or C<use vars>. | PPI::Statement::Include | 3 | core, pbp, maintenance | packages, add_packages || Variables::ProhibitPerl4PackageNames | Use double colon (::) to separate package name components instead of single quotes ('). | PPI::Token::Symbol | 2 | core, maintenance, certrec | || Variables::ProhibitPunctuationVars | Write C<$EVAL_ERROR> instead of C<$@>. | PPI::Token::HereDoc | 2 | core, pbp, cosmetic | allow, string_mode || Variables::ProhibitReusedNames | Do not reuse a variable name in a lexical scope | PPI::Statement::Variable | 3 | core, bugs | allow || Variables::ProhibitUnusedVariables | Don't ask for storage you don't need. | PPI::Document | 3 | core, maintenance, certrec | || Variables::ProtectPrivateVars | Prevent access to private vars in other packages. | PPI::Token::Symbol | 3 | core, maintenance, certrule | || Variables::RequireInitializationForLocalVars | Write C<local $foo = $bar;> instead of just C<local $foo;>. | PPI::Statement::Variable | 3 | core, pbp, bugs, certrec | || Variables::RequireLexicalLoopIterators | Write C<for my $element (@list) {...}> instead of C<for $element (@list) {...}>. | PPI::Statement::Compound | 5 | core, pbp, bugs, certrec | || Variables::RequireLocalizedPunctuationVars | Magic variables should be assigned as "local". | PPI::Token::Operator | 4 | core, pbp, bugs, certrec | allow || Variables::RequireNegativeIndices | Negative array index should be used. | PPI::Structure::Subscript | 4 | core, maintenance, pbp | |+--------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-----------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+=head2 What's that policy that prohibits returning undef explicitly?% pcplist undefBuiltinFunctions::ProhibitSleepViaSelectInputOutput::ProhibitJoinedReadlineSubroutines::ProhibitExplicitReturnUndef=head2 What's that policy that requires using strict?% pcplist req strictTestingAndDebugging::RequireUseStrict=head2 List policies which have default severity of 5% pcplist '--default-severity=5' -l+--------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+----------------------------+| name | abstract | applies_to | default_severity | default_themes | supported_parameters |+--------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+----------------------------+| BuiltinFunctions::ProhibitSleepViaSelect | Use L<Time::HiRes|Time::HiRes> instead of something like C<select(undef, undef, undef, .05)>. | PPI::Token::Word | 5 | core, pbp, bugs | || BuiltinFunctions::ProhibitStringyEval | Write C<eval { my $foo; bar($foo) }> instead of C<eval "my $foo; bar($foo);">. | PPI::Token::Word | 5 | core, pbp, bugs, certrule | allow_includes || BuiltinFunctions::RequireGlobFunction | Use C<glob q{*}> instead of <*>. | PPI::Token::QuoteLike::Readline | 5 | core, pbp, bugs | || ClassHierarchies::ProhibitOneArgBless | Write C<bless {}, $class;> instead of just C<bless {};>. | PPI::Token::Word | 5 | core, pbp, bugs | || ControlStructures::ProhibitMutatingListFunctions | Don't modify C<$_> in list functions. | PPI::Token::Word | 5 | core, bugs, pbp, certrule | list_funcs, add_list_funcs || InputOutput::ProhibitBarewordFileHandles | Write C<open my $fh, q{<}, $filename;> instead of C<open FH, q{<}, $filename;>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || InputOutput::ProhibitInteractiveTest | Use prompt() instead of -t. | PPI::Token::Operator | 5 | core, pbp, bugs, certrule | || InputOutput::ProhibitTwoArgOpen | Write C<< open $fh, q{<}, $filename; >> instead of C<< open $fh, "<$filename"; >>. | PPI::Token::Word | 5 | core, pbp, bugs, security, certrule | || InputOutput::RequireEncodingWithUTF8Layer | Write C<< open $fh, q{<:encoding(UTF-8)}, $filename; >> instead of C<< open $fh, q{<:utf8}, $filename; >>. | PPI::Token::Word | 5 | core, bugs, security | || Modules::ProhibitEvilModules | Ban modules that aren't blessed by your shop. | PPI::Statement::Include | 5 | core, bugs, certrule | modules, modules_file || Modules::RequireBarewordIncludes | Write C<require Module> instead of C<require 'Module.pm'>. | PPI::Statement::Include | 5 | core, portability | || Modules::RequireFilenameMatchesPackage | Package declaration must match filename. | PPI::Document | 5 | core, bugs | || Subroutines::ProhibitExplicitReturnUndef | Return failure with bare C<return> instead of C<return undef>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || Subroutines::ProhibitNestedSubs | C<sub never { sub correct {} }>. | PPI::Statement::Sub | 5 | core, bugs | || Subroutines::ProhibitReturnSort | Behavior of C<sort> is not defined if called in scalar context. | PPI::Token::Word | 5 | core, bugs, certrule | || Subroutines::ProhibitSubroutinePrototypes | Don't write C<sub my_function (@@) {}>. | PPI::Statement::Sub | 5 | core, pbp, bugs, certrec | || TestingAndDebugging::ProhibitNoStrict | Prohibit various flavors of C<no strict>. | PPI::Statement::Include | 5 | core, pbp, bugs, certrec | allow || TestingAndDebugging::RequireUseStrict | Always C<use strict>. | PPI::Document | 5 | core, pbp, bugs, certrule, certrec | equivalent_modules || ValuesAndExpressions::ProhibitLeadingZeros | Write C<oct(755)> instead of C<0755>. | PPI::Token::Number::Octal | 5 | core, pbp, bugs, certrec | strict || Variables::ProhibitConditionalDeclarations | Do not write C< my $foo = $bar if $baz; >. | PPI::Statement::Variable | 5 | core, bugs | || Variables::ProhibitEvilVariables | Ban variables that aren't blessed by your shop. | PPI::Token::Symbol | 5 | core, bugs | variables, variables_file || Variables::RequireLexicalLoopIterators | Write C<for my $element (@list) {...}> instead of C<for $element (@list) {...}>. | PPI::Statement::Compound | 5 | core, pbp, bugs, certrec | |+--------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+----------------------------+=head2 List policies which have default severity between 4 and 5% pcplist '--min-default-severity=4' '--max-default-severity=5' -l+---------------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------+| name | abstract | applies_to | default_severity | default_themes | supported_parameters |+---------------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------+| BuiltinFunctions::ProhibitSleepViaSelect | Use L<Time::HiRes|Time::HiRes> instead of something like C<select(undef, undef, undef, .05)>. | PPI::Token::Word | 5 | core, pbp, bugs | || BuiltinFunctions::ProhibitStringyEval | Write C<eval { my $foo; bar($foo) }> instead of C<eval "my $foo; bar($foo);">. | PPI::Token::Word | 5 | core, pbp, bugs, certrule | allow_includes || BuiltinFunctions::RequireBlockGrep | Write C<grep { /$pattern/ } @list> instead of C<grep /$pattern/, @list>. | PPI::Token::Word | 4 | core, bugs, pbp | || BuiltinFunctions::RequireBlockMap | Write C<map { /$pattern/ } @list> instead of C<map /$pattern/, @list>. | PPI::Token::Word | 4 | core, bugs, pbp | || BuiltinFunctions::RequireGlobFunction | Use C<glob q{*}> instead of <*>. | PPI::Token::QuoteLike::Readline | 5 | core, pbp, bugs | || ClassHierarchies::ProhibitOneArgBless | Write C<bless {}, $class;> instead of just C<bless {};>. | PPI::Token::Word | 5 | core, pbp, bugs | || CodeLayout::RequireConsistentNewlines | Use the same newline through the source. | PPI::Document | 4 | core, bugs | || ControlStructures::ProhibitLabelsWithSpecialBlockNames | Don't use labels that are the same as the special block names. | PPI::Token::Label | 4 | core, bugs | || ControlStructures::ProhibitMutatingListFunctions | Don't modify C<$_> in list functions. | PPI::Token::Word | 5 | core, bugs, pbp, certrule | list_funcs, add_list_funcs || ControlStructures::ProhibitUnreachableCode | Don't write code after an unconditional C<die, exit, or next>. | PPI::Token::Word | 4 | core, bugs, certrec | || ControlStructures::ProhibitYadaOperator | Never use C<...> in production code. | PPI::Token::Operator | 4 | core, pbp, maintenance | || InputOutput::ProhibitBarewordFileHandles | Write C<open my $fh, q{<}, $filename;> instead of C<open FH, q{<}, $filename;>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || InputOutput::ProhibitExplicitStdin | Use "<>" or "<ARGV>" or a prompting module instead of "<STDIN>". | PPI::Token::QuoteLike::Readline | 4 | core, pbp, maintenance | || InputOutput::ProhibitInteractiveTest | Use prompt() instead of -t. | PPI::Token::Operator | 5 | core, pbp, bugs, certrule | || InputOutput::ProhibitOneArgSelect | Never write C<select($fh)>. | PPI::Token::Word | 4 | core, bugs, pbp, certrule | || InputOutput::ProhibitReadlineInForLoop | Write C<< while( $line = <> ){...} >> instead of C<< for(<>){...} >>. | PPI::Statement::Compound | 4 | core, bugs, pbp | || InputOutput::ProhibitTwoArgOpen | Write C<< open $fh, q{<}, $filename; >> instead of C<< open $fh, "<$filename"; >>. | PPI::Token::Word | 5 | core, pbp, bugs, security, certrule | || InputOutput::RequireBriefOpen | Close filehandles as soon as possible after opening them. | PPI::Token::Word | 4 | core, pbp, maintenance | lines || InputOutput::RequireEncodingWithUTF8Layer | Write C<< open $fh, q{<:encoding(UTF-8)}, $filename; >> instead of C<< open $fh, q{<:utf8}, $filename; >>. | PPI::Token::Word | 5 | core, bugs, security | || Modules::ProhibitAutomaticExportation | Export symbols via C<@EXPORT_OK> or C<%EXPORT_TAGS> instead of C<@EXPORT>. | PPI::Document | 4 | core, bugs | || Modules::ProhibitEvilModules | Ban modules that aren't blessed by your shop. | PPI::Statement::Include | 5 | core, bugs, certrule | modules, modules_file || Modules::ProhibitMultiplePackages | Put packages (especially subclasses) in separate files. | PPI::Document | 4 | core, bugs | || Modules::RequireBarewordIncludes | Write C<require Module> instead of C<require 'Module.pm'>. | PPI::Statement::Include | 5 | core, portability | || Modules::RequireEndWithOne | End each module with an explicitly C<1;> instead of some funky expression. | PPI::Document | 4 | core, bugs, pbp, certrule | || Modules::RequireExplicitPackage | Always make the C<package> explicit. | PPI::Document | 4 | core, bugs | exempt_scripts, allow_import_of || Modules::RequireFilenameMatchesPackage | Package declaration must match filename. | PPI::Document | 5 | core, bugs | || Objects::ProhibitIndirectSyntax | Prohibit indirect object call syntax. | PPI::Token::Word | 4 | core, pbp, maintenance, certrule | forbid || Subroutines::ProhibitBuiltinHomonyms | Don't declare your own C<open> function. | PPI::Statement::Sub | 4 | core, bugs, pbp, certrule | || Subroutines::ProhibitExplicitReturnUndef | Return failure with bare C<return> instead of C<return undef>. | PPI::Token::Word | 5 | core, pbp, bugs, certrec | || Subroutines::ProhibitNestedSubs | C<sub never { sub correct {} }>. | PPI::Statement::Sub | 5 | core, bugs | || Subroutines::ProhibitReturnSort | Behavior of C<sort> is not defined if called in scalar context. | PPI::Token::Word | 5 | core, bugs, certrule | || Subroutines::ProhibitSubroutinePrototypes | Don't write C<sub my_function (@@) {}>. | PPI::Statement::Sub | 5 | core, pbp, bugs, certrec | || Subroutines::RequireArgUnpacking | Always unpack C<@_> first. | PPI::Statement::Sub | 4 | core, pbp, maintenance | short_subroutine_statements, allow_subscripts, allow_delegation_to || Subroutines::RequireFinalReturn | End every path through a subroutine with an explicit C<return> statement. | PPI::Statement::Sub | 4 | core, bugs, pbp, certrec | terminal_funcs, terminal_methods || TestingAndDebugging::ProhibitNoStrict | Prohibit various flavors of C<no strict>. | PPI::Statement::Include | 5 | core, pbp, bugs, certrec | allow || TestingAndDebugging::ProhibitNoWarnings | Prohibit various flavors of C<no warnings>. | PPI::Statement::Include | 4 | core, bugs, pbp, certrec | allow, allow_with_category_restriction || TestingAndDebugging::ProhibitProlongedStrictureOverride | Don't turn off strict for large blocks of code. | PPI::Statement::Include | 4 | core, pbp, bugs, certrec | statements || TestingAndDebugging::RequireUseStrict | Always C<use strict>. | PPI::Document | 5 | core, pbp, bugs, certrule, certrec | equivalent_modules || TestingAndDebugging::RequireUseWarnings | Always C<use warnings>. | PPI::Document | 4 | core, pbp, bugs, certrule | equivalent_modules || ValuesAndExpressions::ProhibitCommaSeparatedStatements | Don't use the comma operator as a statement separator. | PPI::Statement | 4 | core, bugs, pbp, certrule | allow_last_statement_to_be_comma_separated_in_map_and_grep || ValuesAndExpressions::ProhibitConstantPragma | Don't C<< use constant FOO => 15 >>. | PPI::Statement::Include | 4 | core, bugs, pbp | || ValuesAndExpressions::ProhibitLeadingZeros | Write C<oct(755)> instead of C<0755>. | PPI::Token::Number::Octal | 5 | core, pbp, bugs, certrec | strict || ValuesAndExpressions::ProhibitMixedBooleanOperators | Write C< !$foo && $bar || $baz > instead of C< not $foo && $bar or $baz>. | PPI::Statement | 4 | core, bugs, pbp, certrec | || Variables::ProhibitAugmentedAssignmentInDeclaration | Do not write C< my $foo .= 'bar'; >. | PPI::Statement::Variable | 4 | core, bugs | || Variables::ProhibitConditionalDeclarations | Do not write C< my $foo = $bar if $baz; >. | PPI::Statement::Variable | 5 | core, bugs | || Variables::ProhibitEvilVariables | Ban variables that aren't blessed by your shop. | PPI::Token::Symbol | 5 | core, bugs | variables, variables_file || Variables::ProhibitFatCommaInDeclaration | Prohibit fat comma in declaration | PPI::Statement::Variable | 4 | core, bugs | || Variables::ProhibitMatchVars | Avoid C<$`>, C<$&>, C<$'> and their English equivalents. | PPI::Statement::Include | 4 | core, performance, pbp | || Variables::RequireLexicalLoopIterators | Write C<for my $element (@list) {...}> instead of C<for $element (@list) {...}>. | PPI::Statement::Compound | 5 | core, pbp, bugs, certrec | || Variables::RequireLocalizedPunctuationVars | Magic variables should be assigned as "local". | PPI::Token::Operator | 4 | core, pbp, bugs, certrec | allow || Variables::RequireNegativeIndices | Negative array index should be used. | PPI::Structure::Subscript | 4 | core, maintenance, pbp | |+---------------------------------------------------------+------------------------------------------------------------------------------------------------------------+---------------------------------+------------------+-------------------------------------+--------------------------------------------------------------------+=head1 HOMEPAGEPlease visit the project's homepage at L<https://metacpan.org/release/App-PerlCriticUtils>.=head1 SOURCESource repository is at L<https://github.com/perlancar/perl-App-PerlCriticUtils>.=head1 AUTHORperlancar <perlancar@cpan.org>=head1 CONTRIBUTINGTo contribute, you can send patches by email/via RT, or send pull requests onGitHub.Most of the time, you don't need to build the distribution yourself. You cansimply modify the code, then test via:% prove -lIf you want to build the distribution (e.g. to try to install it locally on yoursystem), you can install L<Dist::Zilla>,L<Dist::Zilla::PluginBundle::Author::PERLANCAR>,L<Pod::Weaver::PluginBundle::Author::PERLANCAR>, and sometimes one or two otherDist::Zilla- and/or Pod::Weaver plugins. Any additional steps required beyondthat are considered a bug and can be reported to me.=head1 COPYRIGHT AND LICENSEThis software is copyright (c) 2023, 2022, 2021, 2018, 2017 by perlancar <perlancar@cpan.org>.This is free software; you can redistribute it and/or modify it underthe same terms as the Perl 5 programming language system itself.=head1 BUGSPlease report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=App-PerlCriticUtils>When submitting a bug or request, please include a test-file or apatch to an existing test-file that illustrates the bug or desiredfeature.=cut