perl::critic::policy::subroutines::prohibitexcesscomplexity(3pm) [debian man page]

Perl::Critic::Policy::Subroutines::ProhibitExcessComplexUser3Contributed Perl DocuPerl::Critic::Policy::Subroutines::ProhibitExcessComplexity(3pm)

NAME

       Perl::Critic::Policy::Subroutines::ProhibitExcessComplexity - Minimize complexity by factoring code into smaller subroutines.

AFFILIATION

       This Policy is part of the core Perl::Critic distribution.

DESCRIPTION

       All else being equal, complicated code is more error-prone and more expensive to maintain than simpler code.  The first step towards
       managing complexity is to establish formal complexity metrics.  One such metric is the McCabe score, which describes the number of possible
       paths through a subroutine.  This Policy approximates the McCabe score by summing the number of conditional statements and operators within
       a subroutine.  Research has shown that a McCabe score higher than 20 is a sign of high-risk, potentially untestable code.  See
       <http://en.wikipedia.org/wiki/Cyclomatic_complexity> for some discussion about the McCabe number and other complexity metrics.

       The usual prescription for reducing complexity is to refactor code into smaller subroutines.  Mark Dominus book "Higher Order Perl" also
       describes callbacks, recursion, memoization, iterators, and other techniques that help create simple and extensible Perl code.

CONFIGURATION

       The maximum acceptable McCabe can be set with the "max_mccabe" configuration item.  Any subroutine with a McCabe score higher than this
       number will generate a policy violation.  The default is 20.  An example section for a .perlcriticrc:

	 [Subroutines::ProhibitExcessComplexity]
	 max_mccabe = 30

NOTES

	 "Everything should be made as simple as possible, but no simpler."

							 -- Albert Einstein

       Complexity is subjective, but formal complexity metrics are still incredibly valuable.  Every problem has an inherent level of complexity,
       so it is not necessarily optimal to minimize the McCabe number.	So don't get offended if your code triggers this Policy.  Just consider if
       there might be a simpler way to get the job done.

AUTHOR

       Jeffrey Ryan Thalhammer <jeff@imaginative-software.com>

COPYRIGHT

       Copyright (c) 2005-2011 Imaginative Software Systems.  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 v5.14.2							    2012-06-07	  Perl::Critic::Policy::Subroutines::ProhibitExcessComplexity(3pm)

Perl::Critic::Policy::Subroutines::ProhibitUnusedPrivateUseroContributed PerPerl::Critic::Policy::Subroutines::ProhibitUnusedPrivateSubroutines(3)

NAME

       Perl::Critic::Policy::Subroutines::ProhibitUnusedPrivateSubroutines - Prevent unused private subroutines.

AFFILIATION

       This Policy is part of the core Perl::Critic distribution.

DESCRIPTION

       By convention Perl authors (like authors in many other languages) indicate private methods and variables by inserting a leading underscore
       before the identifier.  This policy catches such subroutines which are not used in the file which declares them.

       This module defines a 'use' of a subroutine as a subroutine or method call to it (other than from inside the subroutine itself), a
       reference to it (i.e.  "my $foo = &_foo"), a "goto" to it outside the subroutine itself (i.e.  "goto &_foo"), or the use of the
       subroutine's name as an even-numbered argument to "use overload".

CONFIGURATION

       You can define what a private subroutine name looks like by specifying a regular expression for the "private_name_regex" option in your
       .perlcriticrc:

	   [Subroutines::ProhibitUnusedPrivateSubroutines]
	   private_name_regex = _(?!_)w+

       The above example is a way of saying that subroutines that start with a double underscore are not considered to be private.  (Perl::Critic,
       in its implementation, uses leading double underscores to indicate a distribution-private subroutine -- one that is allowed to be invoked
       by other Perl::Critic modules, but not by anything outside of Perl::Critic.)

       You can configure additional subroutines to accept by specifying them in a space-delimited list to the "allow" option:

	   [Subroutines::ProhibitUnusedPrivateSubroutines]
	   allow = _bar _baz

       These are added to the default list of exemptions from this policy. So the above allows "sub _bar {}" and "sub _baz {}", even if they are
       not referred to in the module that defines them.

HISTORY

       This policy is derived from Perl::Critic::Policy::Subroutines::ProtectPrivateSubs, which looks at the other side of the problem.

BUGS

       Does not forbid "sub Foo::_foo{}" because it does not know (and can not assume) what is in the "Foo" package.

SEE ALSO

       Perl::Critic::Policy::Subroutines::ProtectPrivateSubs.

AUTHOR

       Chris Dolan <cdolan@cpan.org>

COPYRIGHT

       Copyright (c) 2009-2011 Thomas R. Wyant, III.

       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 v5.16.3							    2014-06-Perl::Critic::Policy::Subroutines::ProhibitUnusedPrivateSubroutines(3)