3 version - Perl extension for Version Objects
8 $version = version->new("12.2.1"); # must be quoted for Perl < 5.8.1
9 print $version; # 12.2.1
10 print $version->numify; # 12.002001
11 if ( $version gt "12.2" ) # true
13 $alphaver = version->new("1.02_03"); # must be quoted!
14 print $alphaver; # 1.02_030
15 print $alphaver->is_alpha(); # true
17 $ver = qv(1.2); # 1.2.0
18 $ver = qv("1.2"); # 1.2.0
20 $perlver = version->new(5.005_03); # must not be quoted!
21 print $perlver; # 5.005030
25 Overloaded version objects for all versions of Perl. This module
26 implements all of the features of version objects which will be part
27 of Perl 5.10.0 except automatic version object creation.
29 =head2 What IS a version
31 For the purposes of this module, a version "number" is a sequence of
32 positive integral values separated by decimal points and optionally a
33 single underscore. This corresponds to what Perl itself uses for a
34 version, as well as extending the "version as number" that is discussed
35 in the various editions of the Camel book.
37 There are actually two distinct ways to initialize versions:
41 =item * Numeric Versions
43 Any initial parameter which "looks like a number", see L<Numeric
44 Versions>. This also covers versions with a single decimal place and
45 a single embedded underscore, see L<Numeric Alpha Versions>, even though
46 these must be quoted to preserve the underscore formatting.
48 =item * Extended Versions
50 Any initial parameter which contains more than one decimal point
51 and an optional embedded underscore, see L<Extended Versions>.
55 Both of these methods will produce similar version objects, in that
56 the default stringification will yield the version L<Normal Form> only
59 $v = version->new(1.002); # 1.002, but compares like 1.2.0
60 $v = version->new(1.002003); # 1.002003
61 $v2 = version->new( "1.2.3"); # v1.2.3
62 $v3 = version->new( 1.2.3); # v1.2.3 for Perl >= 5.8.1
64 In specific, version numbers initialized as L<Numeric Versions> will
65 stringify in Numeric form. Version numbers initialized as L<Extended Versions>
66 will be stringified as L<Normal Form>.
68 Please see L<Quoting> for more details on how Perl will parse various
71 Any value passed to the new() operator will be parsed only so far as it
72 contains a numeric, decimal, or underscore character. So, for example:
74 $v1 = version->new("99 and 94/100 percent pure"); # $v1 == 99.0
75 $v2 = version->new("something"); # $v2 == "" and $v2->numify == 0
77 However, see L<New Operator> for one case where non-numeric text is
78 acceptable when initializing version objects.
80 =head2 What about v-strings?
82 Beginning with Perl 5.6.0, an alternate method to code arbitrary strings
83 of bytes was introduced, called v-strings. They were intended to be an
84 easy way to enter, for example, Unicode strings (which contain two bytes
85 per character). Some programs have used them to encode printer control
86 characters (e.g. CRLF). They were also intended to be used for $VERSION.
87 Their use has been problematic from the start and they will be phased out
88 beginning in Perl 5.10.0.
90 There are two ways to enter v-strings: a bare number with two or more
91 decimal places, or a bare number with one or more decimal places and a
92 leading 'v' character (also bare). For example:
94 $vs1 = 1.2.3; # encoded as \1\2\3
95 $vs2 = v1.2; # encoded as \1\2
97 The first of those two syntaxes is destined to be the default way to create
98 a version object in 5.10.0, whereas the second will issue a mandatory
99 deprecation warning beginning at the same time. In both cases, a v-string
100 encoded version will always be stringified in the version L<Normal Form>.
102 Consequently, the use of v-strings to initialize version objects with
103 this module is only possible with Perl 5.8.1 or better (which contain special
104 code to enable it). Their use is B<strongly> discouraged in all
105 circumstances (especially the leading 'v' style), since the meaning will
106 change depending on which Perl you are running. It is better to use
107 L<"Extended Versions"> to ensure the proper interpretation.
109 =head2 Numeric Versions
111 These correspond to historical versions of Perl itself prior to 5.6.0,
112 as well as all other modules which follow the Camel rules for the
113 $VERSION scalar. A numeric version is initialized with what looks like
114 a floating point number. Leading zeros B<are> significant and trailing
115 zeros are implied so that a minimum of three places is maintained
116 between subversions. What this means is that any subversion (digits
117 to the right of the decimal place) that contains less than three digits
118 will have trailing zeros added to make up the difference, but only for
119 purposes of comparison with other version objects. For example:
121 $v = version->new( 1.2); # prints 1.2, compares as 1.200.0
122 $v = version->new( 1.02); # prints 1.02, compares as 1.20.0
123 $v = version->new( 1.002); # prints 1.002, compares as 1.2.0
124 $v = version->new( 1.0023); # 1.2.300
125 $v = version->new( 1.00203); # 1.2.30
126 $v = version->new( 1.002_03); # 1.2.30 See "Quoting"
127 $v = version->new( 1.002003); # 1.2.3
129 All of the preceding examples except the second to last are true
130 whether or not the input value is quoted. The important feature is that
131 the input value contains only a single decimal.
133 IMPORTANT NOTE: If your numeric version contains more than 3 significant
134 digits after the decimal place, it will be split on each multiple of 3, so
135 1.0003 becomes 1.0.300, due to the need to remain compatible with Perl's
136 own 5.005_03 == 5.5.30 interpretation.
138 =head2 Extended Versions
140 These are the newest form of versions, and correspond to Perl's own
141 version style beginning with 5.6.0. Starting with Perl 5.10.0,
142 and most likely Perl 6, this is likely to be the preferred form. This
143 method requires that the input parameter be quoted, although Perl's after
144 5.9.0 can use bare numbers with multiple decimal places as a special form
147 Unlike L<Numeric Versions>, Extended Versions may have more than
148 a single decimal point, e.g. "5.6.1" (for all versions of Perl). If a
149 Extended Version has only one decimal place (and no embedded underscore),
150 it is interpreted exactly like a L<Numeric Version>.
154 $v = version->new( "1.002"); # 1.2
155 $v = version->new( "1.2.3"); # 1.2.3
156 $v = version->new("1.0003"); # 1.0.300
158 In addition to conventional versions, Extended Versions can be
159 used to create L<Alpha Versions>.
161 In general, Extended Versions permit the greatest amount of freedom
162 to specify a version, whereas Numeric Versions enforce a certain
163 uniformity. See also L<New Operator> for an additional method of
164 initializing version objects.
166 =head2 Numeric Alpha Versions
168 The one time that a numeric version must be quoted is when a alpha form is
169 used with an otherwise numeric version (i.e. a single decimal place). This
170 is commonly used for CPAN releases, where CPAN or CPANPLUS will ignore alpha
171 versions for automatic updating purposes. Since some developers have used
172 only two significant decimal places for their non-alpha releases, the
173 version object will automatically take that into account if the initializer
174 is quoted. For example Module::Example was released to CPAN with the
175 following sequence of $VERSION's:
177 # $VERSION Stringified
185 As you can see, the version object created from the values in the first
186 column may contain a trailing 0, but will otherwise be both mathematically
187 equivalent and sorts alpha-numerically as would be expected.
189 =head2 Object Methods
191 Overloading has been used with version objects to provide a natural
192 interface for their use. All mathematical operations are forbidden,
193 since they don't make any sense for base version objects.
199 Like all OO interfaces, the new() operator is used to initialize
200 version objects. One way to increment versions when programming is to
201 use the CVS variable $Revision, which is automatically incremented by
202 CVS every time the file is committed to the repository.
204 In order to facilitate this feature, the following
205 code can be employed:
207 $VERSION = version->new(qw$Revision: 2.7 $);
209 and the version object will be created as if the following code
212 $VERSION = version->new("v2.7");
214 In other words, the version will be automatically parsed out of the
215 string, and it will be quoted to preserve the meaning CVS normally
216 carries for versions. The CVS $Revision$ increments differently from
217 numeric versions (i.e. 1.10 follows 1.9), so it must be handled as if
218 it were a L<Extended Version>.
220 A new version object can be created as a copy of an existing version
221 object, either as a class method:
223 $v1 = version->new(12.3);
224 $v2 = version->new($v1);
226 or as an object method:
228 $v1 = version->new(12.3);
231 and in each case, $v1 and $v2 will be identical.
239 An alternate way to create a new version object is through the exported
240 qv() sub. This is not strictly like other q? operators (like qq, qw),
241 in that the only delimiters supported are parentheses (or spaces). It is
242 the best way to initialize a short version without triggering the floating
243 point interpretation. For example:
245 $v1 = qv(1.2); # 1.2.0
246 $v2 = qv("1.2"); # also 1.2.0
248 As you can see, either a bare number or a quoted string can be used, and
249 either will yield the same version number.
253 For the subsequent examples, the following three objects will be used:
255 $ver = version->new("1.2.3.4"); # see "Quoting" below
256 $alpha = version->new("1.2.3_4"); # see "Alpha versions" below
257 $nver = version->new(1.002); # see "Numeric Versions" above
263 For any version object which is initialized with multiple decimal
264 places (either quoted or if possible v-string), or initialized using
265 the L<qv()> operator, the stringified representation is returned in
266 a normalized or reduced form (no extraneous zeros), and with a leading 'v':
268 print $ver->normal; # prints as v1.2.3
269 print $ver->stringify; # ditto
271 print $nver->normal; # prints as v1.2.0
272 print $nver->stringify; # prints as 1.002, see "Stringification"
274 In order to preserve the meaning of the processed version, the
275 normalized representation will always contain at least three sub terms.
276 In other words, the following is guaranteed to always be true:
278 my $newver = version->new($ver->stringify);
279 if ($newver eq $ver ) # always true
288 Although all mathematical operations on version objects are forbidden
289 by default, it is possible to retrieve a number which roughly
290 corresponds to the version object through the use of the $obj->numify
291 method. For formatting purposes, when displaying a number which
292 corresponds a version object, all sub versions are assumed to have
293 three decimal places. So for example:
295 print $ver->numify; # prints 1.002003
296 print $nver->numify; # prints 1.002
298 Unlike the stringification operator, there is never any need to append
299 trailing zeros to preserve the correct version value.
305 =item * Stringification
307 In order to mirror as much as possible the existing behavior of ordinary
308 $VERSION scalars, the stringification operation will display differently,
309 depending on whether the version was initialized as a L<Numeric Version>
310 or L<Extended Version>.
312 What this means in practice is that if the normal CPAN and Camel rules are
313 followed ($VERSION is a floating point number with no more than 3 decimal
314 places), the stringified output will be exactly the same as the numified
315 output. There will be no visible difference, although the internal
316 representation will be different, and the L<Comparison operators> will
317 function using the internal coding.
319 If a version object is initialized using a L<Extended Version> form, or if
320 the number of significant decimal places exceed three, then the stringified
321 form will be the L<Normal Form>. The $obj->normal operation can always be
322 used to produce the L<Normal Form>, even if the version was originally a
325 print $ver->stringify; # prints v1.2.3
326 print $nver->stringify; # prints 1.002
332 =item * Comparison operators
334 Both cmp and <=> operators perform the same comparison between terms
335 (upgrading to a version object automatically). Perl automatically
336 generates all of the other comparison operators based on those two.
337 In addition to the obvious equalities listed below, appending a single
338 trailing 0 term does not change the value of a version for comparison
339 purposes. In other words "v1.2" and "1.2.0" will compare as identical.
341 For example, the following relations hold:
343 As Number As String Truth Value
344 --------- ------------ -----------
345 $ver > 1.0 $ver gt "1.0" true
346 $ver < 2.5 $ver lt true
347 $ver != 1.3 $ver ne "1.3" true
348 $ver == 1.2 $ver eq "1.2" false
349 $ver == 1.2.3 $ver eq "1.2.3" see discussion below
351 It is probably best to chose either the numeric notation or the string
352 notation and stick with it, to reduce confusion. Perl6 version objects
353 B<may> only support numeric comparisons. See also L<"Quoting">.
355 WARNING: Comparing version with unequal numbers of decimal places (whether
356 explicitly or implicitly initialized), may yield unexpected results at
357 first glance. For example, the following inequalities hold:
359 version->new(0.96) > version->new(0.95); # 0.960.0 > 0.950.0
360 version->new("0.96.1") < version->new(0.95); # 0.096.1 < 0.950.0
362 For this reason, it is best to use either exclusively L<Numeric Versions> or
363 L<Extended Versions> with multiple decimal places.
369 =item * Logical Operators
371 If you need to test whether a version object
372 has been initialized, you can simply test it directly:
374 $vobj = version->new($something);
375 if ( $vobj ) # true only if $something was non-blank
377 You can also test whether a version object is an L<Alpha version>, for
378 example to prevent the use of some feature not present in the main
381 $vobj = version->new("1.2_3"); # MUST QUOTE
383 if ( $vobj->is_alpha ) # True
389 Because of the nature of the Perl parsing and tokenizing routines,
390 certain initialization values B<must> be quoted in order to correctly
391 parse as the intended version, and additionally, some initial values
392 B<must not> be quoted to obtain the intended version.
394 Except for L<Alpha versions>, any version initialized with something
395 that looks like a number (a single decimal place) will be parsed in
396 the same way whether or not the term is quoted. In order to be
397 compatible with earlier Perl version styles, any use of versions of
398 the form 5.006001 will be translated as 5.6.1. In other words, a
399 version with a single decimal place will be parsed as implicitly
400 having three places between subversions.
402 The complicating factor is that in bare numbers (i.e. unquoted), the
403 underscore is a legal numeric character and is automatically stripped
404 by the Perl tokenizer before the version code is called. However, if
405 a number containing one or more decimals and an underscore is quoted, i.e.
406 not bare, that is considered a L<Alpha Version> and the underscore is
409 If you use a mathematic formula that resolves to a floating point number,
410 you are dependent on Perl's conversion routines to yield the version you
411 expect. You are pretty safe by dividing by a power of 10, for example,
412 but other operations are not likely to be what you intend. For example:
414 $VERSION = version->new((qw$Revision: 1.4)[1]/10);
415 print $VERSION; # yields 0.14
416 $V2 = version->new(100/9); # Integer overflow in decimal number
417 print $V2; # yields something like 11.111.111.100
419 Perl 5.8.1 and beyond will be able to automatically quote v-strings but
420 that is not possible in earlier versions of Perl. In other words:
422 $version = version->new("v2.5.4"); # legal in all versions of Perl
423 $newvers = version->new(v2.5.4); # legal only in Perl >= 5.8.1
426 =head2 Types of Versions Objects
428 There are two types of Version Objects:
432 =item * Ordinary versions
434 These are the versions that normal modules will use. Can contain as
435 many subversions as required. In particular, those using RCS/CVS can
438 $VERSION = version->new(qw$Revision: 2.7 $);
440 and the current RCS Revision for that file will be inserted
441 automatically. If the file has been moved to a branch, the Revision
442 will have three or more elements; otherwise, it will have only two.
443 This allows you to automatically increment your module version by
444 using the Revision number from the primary file in a distribution, see
445 L<ExtUtils::MakeMaker/"VERSION_FROM">.
447 =item * Alpha Versions
449 For module authors using CPAN, the convention has been to note
450 unstable releases with an underscore in the version string, see
451 L<CPAN>. Alpha releases will test as being newer than the more recent
452 stable release, and less than the next stable release. For example:
454 $alphaver = version->new("12.03_01"); # must be quoted
456 obeys the relationship
458 12.03 < $alphaver < 12.04
460 Alpha versions with a single decimal place will be treated exactly as if
461 they were L<Numeric Versions>, for parsing purposes. The stringification for
462 alpha versions with a single decimal place may seem surprising, since any
463 trailing zeros will visible. For example, the above $alphaver will print as
467 which is mathematically equivalent and ASCII sorts exactly the same as
468 without the trailing zeros.
470 Alpha versions with more than a single decimal place will be treated
471 exactly as if they were L<Extended Versions>, and will display without any
472 trailing (or leading) zeros, in the L<Version Normal> form. For example,
474 $newver = version->new("12.3.1_1");
475 print $newver; # v12.3.1_1
477 =head2 Replacement UNIVERSAL::VERSION
479 In addition to the version objects, this modules also replaces the core
480 UNIVERSAL::VERSION function with one that uses version objects for its
481 comparisons. The return from this operator is always the numified form,
482 and the warning message generated includes both the numified and normal
491 $VERSION = "1.3.5"; # works with all Perl's (since it is quoted)
496 print $Foo::VERSION; # prints 1.2
498 print $Bar::VERSION; # prints 1.003005
500 eval "use CGI 10"; # some far future release
501 print $@; # prints "CGI version 10 (10.0.0) required..."
503 IMPORTANT NOTE: This may mean that code which searches for a specific
504 string (to determine whether a given module is available) may need to be
507 The replacement UNIVERSAL::VERSION, when used as a function, like this:
509 print $module->VERSION;
511 will also exclusively return the numified form. Technically, the
512 $module->VERSION function returns a string (PV) that can be converted to a
513 number following the normal Perl rules, when used in a numeric context.
517 This module is specifically designed and tested to be easily subclassed.
518 In practice, you only need to override the methods you want to change, but
519 you have to take some care when overriding new() (since that is where all
520 of the parsing takes place). For example, this is a perfect acceptable
528 # perform any special input handling here
529 $obj = $self->SUPER::new($n);
530 # and/or add additional hash elements here
534 See also L<version::AlphaBeta> on CPAN for an alternate representation of
537 B<NOTE:> the L<qv> operator is not a class method and will not be inherited
538 in the same way as the other methods. L<qv> will always return an object of
539 type L<version> and not an object in the derived class. If you need to
540 have L<qv> return an object in your derived class, add something like this:
542 *::qv = sub { return bless version::qv(shift), __PACKAGE__ };
544 as seen in the test file F<t/02derived.t>.
548 qv - Extended Version initialization operator
552 John Peacock E<lt>jpeacock@cpan.orgE<gt>