verbose = %f:%l:%c:%p:%m\n color = 1 program-extensions = .PL .pl .t only = 1 severity = 2 # Use `List::MoreUtils::any' instead of `grep' in boolean context. [BuiltinFunctions::ProhibitBooleanGrep] # Map blocks should have a single statement. [-BuiltinFunctions::ProhibitComplexMappings] # Use 4-argument `substr' instead of writing `substr($foo, 2, 6) = $bar'. [BuiltinFunctions::ProhibitLvalueSubstr] # Forbid $b before $a in sort blocks. [BuiltinFunctions::ProhibitReverseSortBlock] # Use Time::HiRes instead of something like `select(undef, undef, undef, .05)'. [BuiltinFunctions::ProhibitSleepViaSelect] # Write `eval { my $foo; bar($foo) }' instead of `eval "my $foo; bar($foo);"'. [BuiltinFunctions::ProhibitStringyEval] # Write `split /-/, $string' instead of `split '-', $string'. [BuiltinFunctions::ProhibitStringySplit] # Write `eval { $foo->can($name) }' instead of `UNIVERSAL::can($foo, $name)'. [BuiltinFunctions::ProhibitUniversalCan] # Write `eval { $foo->isa($pkg) }' instead of `UNIVERSAL::isa($foo, $pkg)'. [BuiltinFunctions::ProhibitUniversalIsa] # this normally disables this policy! run with --severity 1 to get it severity = 1 # I'd really like to enable this, but it confuses Test::Deep::isa with # UNIVERSAL::isa # Don't pass $_ to built-in functions that assume it, or to most filetest operators. [BuiltinFunctions::ProhibitUselessTopic] # Don't use `grep' in void contexts. [BuiltinFunctions::ProhibitVoidGrep] # Don't use `map' in void contexts. # disabled because it gets confused with a map inside a hash constructor [-BuiltinFunctions::ProhibitVoidMap] # Write `grep { /$pattern/ } @list' instead of `grep /$pattern/, @list'. [BuiltinFunctions::RequireBlockGrep] # Write `map { /$pattern/ } @list' instead of `map /$pattern/, @list'. [BuiltinFunctions::RequireBlockMap] # Use `glob q{*}' instead of <*>. [BuiltinFunctions::RequireGlobFunction] # Sort blocks should have a single statement. [BuiltinFunctions::RequireSimpleSortBlock] # AUTOLOAD methods should be avoided. [ClassHierarchies::ProhibitAutoloading] # Employ `use base' instead of `@ISA'. [ClassHierarchies::ProhibitExplicitISA] # Write `bless {}, $class;' instead of just `bless {};'. [ClassHierarchies::ProhibitOneArgBless] # Use spaces instead of tabs. [CodeLayout::ProhibitHardTabs] allow_leading_tabs = 0 # Write `open $handle, $path' instead of `open($handle, $path)'. [CodeLayout::ProhibitParensWithBuiltins] # Write `qw(foo bar baz)' instead of `('foo', 'bar', 'baz')'. [CodeLayout::ProhibitQuotedWordLists] # Don't use whitespace at the end of lines. [CodeLayout::ProhibitTrailingWhitespace] # Use the same newline through the source. [CodeLayout::RequireConsistentNewlines] # Must run code through perltidy. [-CodeLayout::RequireTidyCode] # Put a comma at the end of every multi-line list declaration, including the last one. [CodeLayout::RequireTrailingCommas] # Write `for(0..20)' instead of `for($i=0; $i<=20; $i++)'. [ControlStructures::ProhibitCStyleForLoops] # Don't write long "if-elsif-elsif-elsif-elsif...else" chains. [ControlStructures::ProhibitCascadingIfElse] # Don't write deeply nested loops and conditionals. [ControlStructures::ProhibitDeepNests] max_nests = 5 # Don't use labels that are the same as the special block names. [ControlStructures::ProhibitLabelsWithSpecialBlockNames] # Don't modify `$_' in list functions. [ControlStructures::ProhibitMutatingListFunctions] # Don't use operators like `not', `!~', and `le' within `until' and `unless'. [-ControlStructures::ProhibitNegativeExpressionsInUnlessAndUntilConditions] # Write `if($condition){ do_something() }' instead of `do_something() if $condition'. [-ControlStructures::ProhibitPostfixControls] # Write `if(! $condition)' instead of `unless($condition)'. [-ControlStructures::ProhibitUnlessBlocks] # Don't write code after an unconditional `die, exit, or next'. [ControlStructures::ProhibitUnreachableCode] # Write `while(! $condition)' instead of `until($condition)'. [ControlStructures::ProhibitUntilBlocks] # Check your spelling. [-Documentation::PodSpelling] # The `=head1 NAME' section should match the package. [-Documentation::RequirePackageMatchesPodName] # All POD should be after `__END__'. [-Documentation::RequirePodAtEnd] # Provide text to display with your pod links. [-Documentation::RequirePodLinksIncludeText] # Organize your POD into the customary sections. [-Documentation::RequirePodSections] # Use functions from Carp instead of `warn' or `die'. [ErrorHandling::RequireCarping] # You can't depend upon the value of `$@'/`$EVAL_ERROR' to tell whether an `eval' failed. [ErrorHandling::RequireCheckingReturnValueOfEval] # Discourage stuff like `@files = `ls $directory`'. [InputOutput::ProhibitBacktickOperators] # Write `open my $fh, q{<}, $filename;' instead of `open FH, q{<}, $filename;'. [InputOutput::ProhibitBarewordFileHandles] severity = 2 # Use "<>" or "" or a prompting module instead of "". [InputOutput::ProhibitExplicitStdin] # Use prompt() instead of -t. [InputOutput::ProhibitInteractiveTest] # Use `local $/ = undef' or File::Slurp instead of joined readline. [InputOutput::ProhibitJoinedReadline] # Never write `select($fh)'. [InputOutput::ProhibitOneArgSelect] # Write `while( $line = <> ){...}' instead of `for(<>){...}'. [InputOutput::ProhibitReadlineInForLoop] # Write `open $fh, q{<}, $filename;' instead of `open $fh, "<$filename";'. [InputOutput::ProhibitTwoArgOpen] severity = 2 # Write `print {$FH} $foo, $bar;' instead of `print $FH $foo, $bar;'. [-InputOutput::RequireBracedFileHandleWithPrint] # Close filehandles as soon as possible after opening them. [-InputOutput::RequireBriefOpen] # Write `my $error = close $fh;' instead of `close $fh;'. [-InputOutput::RequireCheckedClose] # Write `my $error = open $fh, $mode, $filename;' instead of `open $fh, $mode, $filename;'. [-InputOutput::RequireCheckedOpen] # Return value of flagged function ignored. [-InputOutput::RequireCheckedSyscalls] # Write `open $fh, q{<:encoding(UTF-8)}, $filename;' instead of `open $fh, q{{<:utf8}, $filename;'. [InputOutput::RequireEncodingWithUTF8Layer] # Do not use `format'. [Miscellanea::ProhibitFormats] # Do not use `tie'. [Miscellanea::ProhibitTies] # Forbid a bare `## no critic' [Miscellanea::ProhibitUnrestrictedNoCritic] # Remove ineffective "## no critic" annotations. [Miscellanea::ProhibitUselessNoCritic] # Export symbols via `@EXPORT_OK' or `%EXPORT_TAGS' instead of `@EXPORT'. [Modules::ProhibitAutomaticExportation] # Avoid putting conditional logic around compile-time includes. [Modules::ProhibitConditionalUseStatements] # Minimize complexity in code that is outside of subroutines. [Modules::ProhibitExcessMainComplexity] max_mccabe = 20 # Put packages (especially subclasses) in separate files. [Modules::ProhibitMultiplePackages] severity = 2 # Write `require Module' instead of `require 'Module.pm''. [Modules::RequireBarewordIncludes] # End each module with an explicitly `1;' instead of some funky expression. [Modules::RequireEndWithOne] # Always make the `package' explicit. [Modules::RequireExplicitPackage] # Don't require programs to contain a package statement. exempt_scripts = 1 allow_import_of = utf8 strict warnings # Package declaration must match filename. [Modules::RequireFilenameMatchesPackage] # `use English' must be passed a `-no_match_vars' argument. [Modules::RequireNoMatchVarsWithUseEnglish] # Give every module a `$VERSION' number. [Modules::RequireVersionVar] # Distinguish different program components by case. [NamingConventions::Capitalization] # Don't use vague variable or subroutine names like 'last' or 'record'. [-NamingConventions::ProhibitAmbiguousNames] # Prohibit indirect object call syntax. [Objects::ProhibitIndirectSyntax] # Indirect method syntax is forbidden for these methods. # Values that are always included: new. # forbid = # postderef confuses this # Write `@{ $array_ref }' instead of `@$array_ref'. [-References::ProhibitDoubleSigils] # Capture variable used outside conditional. [RegularExpressions::ProhibitCaptureWithoutTest] # Names of ways to generate exceptions. # Values that are always included: confess, croak, die. # exception_source = # Split long regexps into smaller `qr//' chunks. [-RegularExpressions::ProhibitComplexRegexes] # Use named character classes instead of explicit character lists. [-RegularExpressions::ProhibitEnumeratedClasses] # Use character classes for literal meta-characters instead of escapes. [-RegularExpressions::ProhibitEscapedMetacharacters] # Use `eq' or hash instead of fixed-pattern regexps. [RegularExpressions::ProhibitFixedStringMatches] # Use `[abc]' instead of `a|b|c'. [RegularExpressions::ProhibitSingleCharAlternation] # Only use a capturing group if you plan to use the captured value. [RegularExpressions::ProhibitUnusedCapture] # Use only `//' or `{}' to delimit regexps. [RegularExpressions::ProhibitUnusualDelimiters] # In addition to allowing '{}', allow '()', '[]', and '{}'. #allow_all_brackets = 1 # Don't use $_ to match against regexes. [RegularExpressions::ProhibitUselessTopic] # Use `{' and `}' to delimit multi-line regexps. [RegularExpressions::RequireBracesForMultiline] # In addition to allowing '{}', allow '()', '[]', and '{}'. #allow_all_brackets = 1 # Always use the `/s' modifier with regular expressions. [-RegularExpressions::RequireDotMatchAnything] # Always use the `/x' modifier with regular expressions. [-RegularExpressions::RequireExtendedFormatting] # Always use the `/m' modifier with regular expressions. [-RegularExpressions::RequireLineBoundaryMatching] # Don't call functions with a leading ampersand sigil. [Subroutines::ProhibitAmpersandSigils] # Don't declare your own `open' function. [Subroutines::ProhibitBuiltinHomonyms] # Minimize complexity by factoring code into smaller subroutines. [Subroutines::ProhibitExcessComplexity] # Return failure with bare `return' instead of `return undef'. [-Subroutines::ProhibitExplicitReturnUndef] # Too many arguments. [Subroutines::ProhibitManyArgs] # `sub never { sub correct {} }'. [Subroutines::ProhibitNestedSubs] # Behavior of `sort' is not defined if called in scalar context. [Subroutines::ProhibitReturnSort] # we use signatures! # Don't write `sub my_function (@@) {}'. [-Subroutines::ProhibitSubroutinePrototypes] severity = 2 # Prevent unused private subroutines. [Subroutines::ProhibitUnusedPrivateSubroutines] private_name_regex = _(?!build_)\w+ # Prevent access to private subs in other packages. [Subroutines::ProtectPrivateSubs] # Always unpack `@_' first. [-Subroutines::RequireArgUnpacking] # End every path through a subroutine with an explicit `return' statement. [Subroutines::RequireFinalReturn] # this normally disables this policy! run with --severity 1 to get it severity = 1 # I'd really like to enable this, but we very often have # single-expression subs, and this policy would warn on every one of # them... maybe one day I'll patch the policy # Prohibit various flavors of `no strict'. [TestingAndDebugging::ProhibitNoStrict] # Prohibit various flavors of `no warnings'. [TestingAndDebugging::ProhibitNoWarnings] allow = uninitialized numeric redefine # Don't turn off strict for large blocks of code. [TestingAndDebugging::ProhibitProlongedStrictureOverride] # The maximum number of statements in a no strict block. statements = 10 # Tests should all have labels. [TestingAndDebugging::RequireTestLabels] # Always `use strict'. [TestingAndDebugging::RequireUseStrict] equivalent_modules = Sietima::Policy # Always `use warnings'. [TestingAndDebugging::RequireUseWarnings] equivalent_modules = Sietima::Policy # Don't use the comma operator as a statement separator. [ValuesAndExpressions::ProhibitCommaSeparatedStatements] # this normally disables this policy! run with --severity 1 to get it severity = 1 # I'd like to enable this, but it complains about arglists built with # ternary operators # Prohibit version values from outside the module. [ValuesAndExpressions::ProhibitComplexVersion] # Don't `use constant FOO => 15'. [ValuesAndExpressions::ProhibitConstantPragma] # Write `q{}' instead of `'''. [-ValuesAndExpressions::ProhibitEmptyQuotes] # Write `"\N{DELETE}"' instead of `"\x7F"', etc. [-ValuesAndExpressions::ProhibitEscapedCharacters] # Use concatenation or HEREDOCs instead of literal line breaks in strings. [ValuesAndExpressions::ProhibitImplicitNewlines] # Always use single quotes for literal strings. [ValuesAndExpressions::ProhibitInterpolationOfLiterals] # Write `oct(755)' instead of `0755'. [ValuesAndExpressions::ProhibitLeadingZeros] # Long chains of method calls indicate tightly coupled code. [-ValuesAndExpressions::ProhibitLongChainsOfMethodCalls] # Don't use values that don't explain themselves. [-ValuesAndExpressions::ProhibitMagicNumbers] # Don't mix numeric operators with string operands, or vice-versa. [ValuesAndExpressions::ProhibitMismatchedOperators] # Write ` !$foo && $bar || $baz ' instead of ` not $foo && $bar or $baz'. [ValuesAndExpressions::ProhibitMixedBooleanOperators] # Use `q{}' or `qq{}' instead of quotes for awkward-looking strings. [ValuesAndExpressions::ProhibitNoisyQuotes] # Don't use quotes (`'', `"', ``') as delimiters for the quote-like operators. [ValuesAndExpressions::ProhibitQuotesAsQuotelikeOperatorDelimiters] # Don't write ` print <<'__END__' '. [ValuesAndExpressions::ProhibitSpecialLiteralHeredocTerminator] # Don't use strings like `v1.4' or `1.4.5' when including other modules. [-ValuesAndExpressions::ProhibitVersionStrings] # Require $VERSION to be a constant rather than a computed value. [ValuesAndExpressions::RequireConstantVersion] # Warns that you might have used single quotes when you really wanted double-quotes. [-ValuesAndExpressions::RequireInterpolationOfMetachars] # Write ` 141_234_397.0145 ' instead of ` 141234397.0145 '. [-ValuesAndExpressions::RequireNumberSeparators] # Write ` print <<'THE_END' ' or ` print <<"THE_END" '. [ValuesAndExpressions::RequireQuotedHeredocTerminator] # Write ` <<'THE_END'; ' instead of ` <<'theEnd'; '. [ValuesAndExpressions::RequireUpperCaseHeredocTerminator] # Do not write ` my $foo .= 'bar'; '. [-Variables::ProhibitAugmentedAssignmentInDeclaration] # Do not write ` my $foo = $bar if $baz; '. [Variables::ProhibitConditionalDeclarations] # Use `my' instead of `local', except when you have to. [-Variables::ProhibitLocalVars] # Avoid `$`', `$&', `$'' and their English equivalents. [Variables::ProhibitMatchVars] # Eliminate globals declared with `our' or `use vars'. [Variables::ProhibitPackageVars] # Use double colon (::) to separate package name components instead of single quotes ('). [Variables::ProhibitPerl4PackageNames] # Write `$EVAL_ERROR' instead of `$@'. [-Variables::ProhibitPunctuationVars] # Do not reuse a variable name in a lexical scope [Variables::ProhibitReusedNames] # Don't ask for storage you don't need. [Variables::ProhibitUnusedVariables] # Prevent access to private vars in other packages. [Variables::ProtectPrivateVars] # Write `local $foo = $bar;' instead of just `local $foo;'. [-Variables::RequireInitializationForLocalVars] # Write `for my $element (@list) {...}' instead of `for $element (@list) {...}'. [Variables::RequireLexicalLoopIterators] # Magic variables should be assigned as "local". [Variables::RequireLocalizedPunctuationVars] allow = %ENV # Negative array index should be used. [Variables::RequireNegativeIndices]