This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
34bdacddf7919dc11f9753857ca76c2f6a2ec395
[perl5.git] / lib / version.pod
1 =head1 NAME
2
3 version - Perl extension for Version Objects
4
5 =head1 SYNOPSIS
6
7   use version;
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
12
13   $alphaver = version->new("1.02_03"); # must be quoted!
14   print $alphaver;              # 1.02_030
15   print $alphaver->is_alpha();  # true
16   
17   $ver = qv(1.2);               # 1.2.0
18   $ver = qv("1.2");             # 1.2.0
19
20   $perlver = version->new(5.005_03); # must not be quoted!
21   print $perlver;               # 5.005030
22
23 =head1 DESCRIPTION
24
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.
28
29 =head2 What IS a version
30
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.
36
37 There are actually two distinct ways to initialize versions:
38
39 =over 4
40
41 =item * Numeric Versions
42
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.
47
48 =item * Extended Versions
49
50 Any initial parameter which contains more than one decimal point
51 and an optional embedded underscore, see L<Extended Versions>.
52
53 =back
54
55 Both of these methods will produce similar version objects, in that
56 the default stringification will yield the version L<Normal Form> only 
57 if required:
58
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
63
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>.
67
68 Please see L<Quoting> for more details on how Perl will parse various
69 input values.
70
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:
73
74   $v1 = version->new("99 and 94/100 percent pure"); # $v1 == 99.0
75   $v2 = version->new("something"); # $v2 == "" and $v2->numify == 0
76
77 However, see L<New Operator> for one case where non-numeric text is
78 acceptable when initializing version objects.
79
80 =head2 What about v-strings?
81
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.
89
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:
93
94   $vs1 = 1.2.3; # encoded as \1\2\3
95   $vs2 = v1.2;  # encoded as \1\2 
96
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>.
101
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.
108
109 =head2 Numeric Versions
110
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:
120
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
128
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.
132
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.
137
138 =head2 Extended Versions
139
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
145 of quoting.
146
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>.  
151
152 So, for example:
153
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
157
158 In addition to conventional versions, Extended Versions can be
159 used to create L<Alpha Versions>.
160
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.
165
166 =head2 Numeric Alpha Versions
167
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:
176
177   # $VERSION    Stringified
178   0.01          0.010
179   0.02          0.020
180   0.02_01       0.02_0100
181   0.02_02       0.02_0200
182   0.03          0.030
183   etc.
184
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.
188
189 =head2 Object Methods
190
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.
194
195 =over 4
196
197 =item * New Operator
198
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.
203
204 In order to facilitate this feature, the following
205 code can be employed:
206
207   $VERSION = version->new(qw$Revision: 2.7 $);
208
209 and the version object will be created as if the following code
210 were used:
211
212   $VERSION = version->new("v2.7");
213
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>.
219
220 A new version object can be created as a copy of an existing version
221 object, either as a class method:
222
223   $v1 = version->new(12.3);
224   $v2 = version->new($v1);
225
226 or as an object method:
227
228   $v1 = version->new(12.3);
229   $v2 = $v1->new();
230
231 and in each case, $v1 and $v2 will be identical.
232
233 =back
234
235 =over 4
236
237 =item * qv()
238
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:
244
245   $v1 = qv(1.2);         # 1.2.0
246   $v2 = qv("1.2");       # also 1.2.0
247
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.
250
251 =back
252
253 For the subsequent examples, the following three objects will be used:
254
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
258
259 =over 4
260
261 =item * Normal Form
262
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':
267
268   print $ver->normal;         # prints as v1.2.3
269   print $ver->stringify;      # ditto
270   print $ver;                 # ditto
271   print $nver->normal;        # prints as v1.2.0
272   print $nver->stringify;     # prints as 1.002, see "Stringification" 
273
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:
277
278   my $newver = version->new($ver->stringify);
279   if ($newver eq $ver ) # always true
280     {...}
281
282 =back
283
284 =over 4
285
286 =item * Numification
287
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:
294
295   print $ver->numify;         # prints 1.002003
296   print $nver->numify;        # prints 1.002
297
298 Unlike the stringification operator, there is never any need to append
299 trailing zeros to preserve the correct version value.
300
301 =back
302
303 =over 4
304
305 =item * Stringification
306
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>.
311
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.
318
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
323 L<Numeric Version>.
324
325   print $ver->stringify;    # prints v1.2.3
326   print $nver->stringify;   # prints 1.002
327
328 =back
329
330 =over 4
331
332 =item * Comparison operators
333
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.
340
341 For example, the following relations hold:
342
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
350
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">.
354
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:
358
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
361
362 For this reason, it is best to use either exclusively L<Numeric Versions> or
363 L<Extended Versions> with multiple decimal places.
364
365 =back
366
367 =over 4
368
369 =item * Logical Operators 
370
371 If you need to test whether a version object
372 has been initialized, you can simply test it directly:
373
374   $vobj = version->new($something);
375   if ( $vobj )   # true only if $something was non-blank
376
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
379 release:
380
381   $vobj = version->new("1.2_3"); # MUST QUOTE
382   ...later...
383   if ( $vobj->is_alpha )       # True
384
385 =back
386
387 =head2 Quoting
388
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.
393
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.
401
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
407 significant.
408
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:
413
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
418
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:
421
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
424
425
426 =head2 Types of Versions Objects
427
428 There are two types of Version Objects:
429
430 =over 4
431
432 =item * Ordinary versions
433
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
436 use the following:
437
438   $VERSION = version->new(qw$Revision: 2.7 $);
439
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">.
446
447 =item * Alpha Versions
448
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:
453
454   $alphaver = version->new("12.03_01"); # must be quoted
455
456 obeys the relationship
457
458   12.03 < $alphaver < 12.04
459
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
464
465   12.03_0100
466
467 which is mathematically equivalent and ASCII sorts exactly the same as
468 without the trailing zeros.
469
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,
473
474   $newver = version->new("12.3.1_1");
475   print $newver; # v12.3.1_1
476
477 =head2 Replacement UNIVERSAL::VERSION
478
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
483 forms (for clarity).
484
485 For example:
486
487   package Foo;
488   $VERSION = 1.2;
489
490   package Bar;
491   $VERSION = "1.3.5"; # works with all Perl's (since it is quoted)
492
493   package main;
494   use version;
495
496   print $Foo::VERSION; # prints 1.2
497
498   print $Bar::VERSION; # prints 1.003005
499
500   eval "use CGI 10"; # some far future release
501   print $@; # prints "CGI version 10 (10.0.0) required..."
502
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
505 changed.
506
507 The replacement UNIVERSAL::VERSION, when used as a function, like this:
508
509   print $module->VERSION;
510
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.
514
515 =head1 SUBCLASSING
516
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
521 derived class:
522
523   package myversion;
524   use base version;
525   sub new { 
526       my($self,$n)=@_;
527       my $obj;
528       # perform any special input handling here
529       $obj = $self->SUPER::new($n);
530       # and/or add additional hash elements here
531       return $obj;
532   }
533
534 See also L<version::AlphaBeta> on CPAN for an alternate representation of
535 version strings.
536
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:
541
542   *::qv = sub { return bless version::qv(shift), __PACKAGE__ };
543
544 as seen in the test file F<t/02derived.t>.
545
546 =head1 EXPORT
547
548 qv - Extended Version initialization operator
549
550 =head1 AUTHOR
551
552 John Peacock E<lt>jpeacock@cpan.orgE<gt>
553
554 =head1 SEE ALSO
555
556 L<perl>.
557
558 =cut