Login
Officially bless Const::Fast.
authorElliot Shank <perl@galumph.com>
Sat, 13 Nov 2010 21:11:06 +0000 (21:11 +0000)
committerElliot Shank <perl@galumph.com>
Sat, 13 Nov 2010 21:11:06 +0000 (21:11 +0000)
Changes
lib/Perl/Critic/Policy/ValuesAndExpressions/ProhibitMagicNumbers.pm
t/ValuesAndExpressions/ProhibitMagicNumbers.run

diff --git a/Changes b/Changes
index 6284d76..a2d5dc9 100644 (file)
--- a/Changes
+++ b/Changes
@@ -20,12 +20,6 @@ Next release whenever it is
       which was introduced in 5.13.2.
     * ControlStructures::ProhibitPostfixControls now looks for "when".  It is
       treated in the same way as "if".
-    * Subroutines::ProhibitUnusedPrivateSubroutines now looks inside
-      regular expressions.
-    * ValuesAndExpressions::ProhibitMismatchedOperators didn't handle file
-      test operators properly.  Patch by H.Merijn Brand.  RT #58751
-    * Variables::ProhibitUnusedVariables now looks inside regular
-      expressions.
     * Documentation::RequirePodSections now honors '## no critic'
       annotation anywhere before the '__END__', '__DATA__', or first
       '=head1', whichever comes first.  The line number of the offending
@@ -36,9 +30,16 @@ Next release whenever it is
     * RegularExpressions::ProhibitUnusedCapture now takes account of the
       use of capture variables in the replacement portion of
       s/.../.../e.
+    * Subroutines::ProhibitUnusedPrivateSubroutines now looks inside
+      regular expressions.
+    * ValuesAndExpressions::ProhibitMagicNumbers now supports Const::Fast.
     * ValuesAndExpressions::ProhibitMagicNumbers now has a
       constant_creator_subroutines parameter to allow the user to
       configure the names of subroutines that create constants. RT #62562.
+    * ValuesAndExpressions::ProhibitMismatchedOperators didn't handle file
+      test operators properly.  Patch by H.Merijn Brand.  RT #58751
+    * Variables::ProhibitUnusedVariables now looks inside regular
+      expressions.
     * ValuesAndExpressions::RequireInterpolationOfMetachars now detects
       and complains about "\b" and "\l" as documented in perlop, and
       "\1" through "\7", which are not documented there, but were found
index f623e3f..a1c7c91 100644 (file)
@@ -24,7 +24,7 @@ our $VERSION = '1.110';
 Readonly::Scalar my $EXPL =>
     q{Unnamed numeric literals make code less maintainable};
 Readonly::Scalar my $USE_READONLY_OR_CONSTANT =>
-    ' Use the Readonly module or the "constant" pragma instead';
+    ' Use the Readonly or Const::Fast module or the "constant" pragma instead';
 Readonly::Scalar my $TYPE_NOT_ALLOWED_SUFFIX =>
     ") are not allowed.$USE_READONLY_OR_CONSTANT";
 
@@ -80,9 +80,12 @@ sub supported_parameters {
             name            => 'constant_creator_subroutines',
             description     => q{Names of subroutines that create constants},
             behavior        => 'string list',
-            list_always_present_values => [ qw{
+            list_always_present_values => [
+                qw<
                     Readonly Readonly::Scalar Readonly::Array Readonly::Hash
-                } ],
+                    const
+                >,
+            ],
         },
     );
 }
@@ -223,7 +226,8 @@ sub violates {
     }
 
     return if _element_is_in_an_include_readonly_or_version_statement(
-        $self, $elem );
+        $self, $elem,
+    );
     return if _element_is_in_a_plan_statement($elem);
     return if _element_is_in_a_constant_subroutine($elem);
 
@@ -430,9 +434,9 @@ code without any explanation; e.g.  C<$bank_account_balance *=
 number came from.  Since you don't understand the significance of the
 number, you don't understand the code.
 
-In general, numeric literals other than C<0> or C<1> in should not be
-used.  Use the L<constant|constant> pragma or the L<Readonly|Readonly>
-module to give a descriptive name to the number.
+In general, numeric literals other than C<0> or C<1> in should not be used.
+Use the L<constant|constant> pragma or the L<Readonly|Readonly> or
+L<Const::Fast|Const::Fast> modules to give a descriptive name to the number.
 
 There are, of course, exceptions to when this rule should be applied.
 One good example is positioning of objects in some container like
@@ -465,36 +469,36 @@ There is a special exemption for accessing the last element of an
 array, i.e. C<$x[-1]>.
 
 
-    $x = 0;                                   #ok
-    $x = 0.0;                                 #ok
-    $x = 1;                                   #ok
-    $x = 1.0;                                 #ok
-    $x = 1.5;                                 #not ok
-    $x = 0b0                                  #not ok
-    $x = 0b1                                  #not ok
-    $x = 0x00                                 #not ok
-    $x = 0x01                                 #not ok
-    $x = 000                                  #not ok
-    $x = 001                                  #not ok
-    $x = 0e1                                  #not ok
-    $x = 1e1                                  #not ok
+    $x = 0;                                   # ok
+    $x = 0.0;                                 # ok
+    $x = 1;                                   # ok
+    $x = 1.0;                                 # ok
+    $x = 1.5;                                 # not ok
+    $x = 0b0                                  # not ok
+    $x = 0b1                                  # not ok
+    $x = 0x00                                 # not ok
+    $x = 0x01                                 # not ok
+    $x = 000                                  # not ok
+    $x = 001                                  # not ok
+    $x = 0e1                                  # not ok
+    $x = 1e1                                  # not ok
 
-    $frobnication_factor = 42;                #not ok
-    use constant FROBNICATION_FACTOR => 42;   #ok
+    $frobnication_factor = 42;                # not ok
+    use constant FROBNICATION_FACTOR => 42;   # ok
 
 
-    use 5.6.1;                                #ok
-    use Test::More plan => 57;                #ok
-    plan tests => 39;                         #ok
-    our $VERSION = 0.22;                      #ok
+    use 5.6.1;                                # ok
+    use Test::More plan => 57;                # ok
+    plan tests => 39;                         # ok
+    our $VERSION = 0.22;                      # ok
 
 
-    $x = $y[-1]                               #ok
-    $x = $y[-2]                               #not ok
+    $x = $y[-1]                               # ok
+    $x = $y[-2]                               # not ok
 
 
 
-    foreach my $solid (1..5) {                #not ok
+    foreach my $solid (1..5) {                # not ok
         ...
     }
 
@@ -510,8 +514,8 @@ array, i.e. C<$x[-1]>.
 
 =head1 CONFIGURATION
 
-This policy has three options: C<allowed_values>, C<allowed_types>, and
-C<allow_to_the_right_of_a_fat_comma>.
+This policy has four options: C<allowed_values>, C<allowed_types>,
+C<allow_to_the_right_of_a_fat_comma>, and C<constant_creator_subroutines>.
 
 
 =head2 C<allowed_values>
@@ -616,27 +620,28 @@ default, this value is I<true>.
 =head2 C<constant_creator_subroutines>
 
 This parameter allows you to specify the names of subroutines that create
-constants, in addition to C<Readonly> and friends. For example, if you use
-C<Const::Fast> to create constants, you could add something like the following
-to your F<.perlcriticrc>:
+constants, in addition to C<Readonly>, C<Const::Fast>, and friends.  For
+example, if you use a custom C<Const::Fast>-like module that supports a
+C<create_constant> subroutine to create constants, you could add something
+like the following to your F<.perlcriticrc>:
 
     [ValuesAndExpressions::ProhibitMagicNumbers]
-    constant_creator_subroutines = const
+    constant_creator_subroutines = create_constant
 
 If you have more than one name to add, separate them by whitespace.
 
-The subroutine name should appear exactly as it is in your code. For example,
-if your code uses C<Const::Fast>, but sometimes does not import the C<const>
-subroutine, you would need to configure this policy as
+The subroutine name should appear exactly as it is in your code.  For example,
+if your code does not import the creating subroutine
+subroutine, you would need to configure this policy as something like
 
     [ValuesAndExpressions::ProhibitMagicNumbers]
-    constant_creator_subroutines = const Const::Fast::const
+    constant_creator_subroutines = create_constant Constant::Create::create_constant
 
 
 =head1 BUGS
 
 There is currently no way to permit version numbers in regular code,
-even if you include them in the allowed_types.  Some may actually
+even if you include them in the C<allowed_types>.  Some may actually
 consider this a feature.
 
 
index 8e03844..126d46c 100644 (file)
@@ -168,6 +168,15 @@ use Readonly;
 
 Readonly::Hash1 %frobnication_factors => ( quhh => 290 );
 
+## name Const::Fast works even if allow_to_the_right_of_a_fat_comma is not set.
+## failures 0
+## parms { allow_to_the_right_of_a_fat_comma => 0 }
+## cut
+
+use Const::Fast;
+
+const my $frobnication_factor => 57;
+
 ## name Constant subroutines containing just a number are allowed.
 ## failures 0
 ## cut