This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Export and document is_lax and is_strict functions
[perl5.git] / lib / version.pod
CommitLineData
cb5772bb
RGS
1=head1 NAME
2
3version - Perl extension for Version Objects
4
5=head1 SYNOPSIS
6
692a467c 7 # Parsing version strings (decimal or dotted-decimal)
cb5772bb 8
692a467c
JP
9 use version 0.77; # get latest bug-fixes and API
10 $ver = version->parse($string)
cb5772bb 11
692a467c 12 # Declaring a dotted-decimal $VERSION (keep on one line!)
cb5772bb 13
692a467c
JP
14 use version 0.77; our $VERSION = version->declare("v1.2.3"); # formal
15 use version 0.77; our $VERSION = qv("v1.2.3"); # shorthand
16 use version 0.77; our $VERSION = qv("v1.2_3"); # alpha
317f7c8a 17
692a467c 18 # Declaring an old-style decimal $VERSION (use quotes!)
317f7c8a 19
692a467c
JP
20 use version 0.77; our $VERSION = version->parse("1.0203"); # formal
21 use version 0.77; our $VERSION = version->parse("1.02_03"); # alpha
317f7c8a 22
692a467c 23 # Comparing mixed version styles (decimals, dotted-decimals, objects)
317f7c8a 24
692a467c
JP
25 if ( version->parse($v1) == version->parse($v2) ) {
26 # do stuff
27 }
317f7c8a 28
692a467c 29 # Sorting mixed version styles
317f7c8a 30
692a467c 31 @ordered = sort { version->parse($a) <=> version->parse($b) } @list;
317f7c8a 32
692a467c 33=head1 DESCRIPTION
317f7c8a 34
692a467c
JP
35Version objects were added to Perl in 5.10. This module implements version
36objects for older version of Perl and provides the version object API for all
37versions of Perl. All previous releases before 0.74 are deprecated and should
38not be used due to incompatible API changes. Version 0.77 introduces the new
39'parse' and 'declare' methods to standardize usage. You are strongly urged to
61a0cb1c 40set 0.77 as a minimum in your code, e.g.
317f7c8a 41
692a467c 42 use version 0.77; # even for Perl v.5.10.0
cb5772bb 43
692a467c 44=head1 TYPES OF VERSION OBJECTS
cb5772bb 45
692a467c
JP
46There are two different types of version objects, corresponding to the two
47different styles of versions in use:
cb5772bb 48
692a467c 49=over 2
cb5772bb 50
692a467c 51=item Decimal Versions
cb5772bb 52
692a467c
JP
53The classic floating-point number $VERSION. The advantage to this style is
54that you don't need to do anything special, just type a number (without
55quotes) into your source file.
cb5772bb 56
692a467c 57=item Dotted Decimal Versions
cb5772bb 58
692a467c
JP
59The more modern form of version assignment, with 3 (or potentially more)
60integers seperated by decimal points (e.g. v1.2.3). This is the form that
61a0cb1c 61Perl itself has used since 5.6.0 was released. The leading "v" is now
692a467c
JP
62strongly recommended for clarity, and will throw a warning in a future
63release if omitted.
cb5772bb
RGS
64
65=back
66
692a467c 67See L<VERSION OBJECT DETAILS> for further information.
cb5772bb 68
692a467c 69=head1 DECLARING VERSIONS
43eaf59d 70
692a467c
JP
71If you have a module that uses a decimal $VERSION (floating point), and you
72do not intend to ever change that, this module is not for you. There is
73nothing that version.pm gains you over a simple $VERSION assignment:
cb5772bb 74
692a467c 75 our $VERSION = 1.02;
cb5772bb 76
61a0cb1c 77Since Perl v5.10.0 includes the version.pm comparison logic anyways,
692a467c 78you don't need to do anything at all.
cb5772bb 79
692a467c 80=head2 How to convert a module from decimal to dotted-decimal
cb5772bb 81
692a467c
JP
82If you have used a decimal $VERSION in the past and wish to switch to a
83dotted-decimal $VERSION, then you need to make a one-time conversion to
61a0cb1c 84the new format.
cb5772bb 85
692a467c
JP
86B<Important Note>: you must ensure that your new $VERSION is numerically
87greater than your current decimal $VERSION; this is not always obvious. First,
88convert your old decimal version (e.g. 1.02) to a normalized dotted-decimal
89form:
cb5772bb 90
692a467c
JP
91 $ perl -Mversion -e 'print version->parse("1.02")->normal'
92 v1.20.0
cb5772bb 93
692a467c 94Then increment any of the dotted-decimal components (v1.20.1 or v1.21.0).
cb5772bb 95
692a467c 96=head2 How to C<declare()> a dotted-decimal version
cb5772bb 97
692a467c 98 use version 0.77; our $VERSION = version->declare("v1.2.3");
cb5772bb 99
692a467c
JP
100The C<declare()> method always creates dotted-decimal version objects. When
101used in a module, you B<must> put it on the same line as "use version" to
102ensure that $VERSION is read correctly by PAUSE and installer tools. You
103should also add 'version' to the 'configure_requires' section of your
104module metadata file. See instructions in L<ExtUtils::MakeMaker> or
105L<Module::Build> for details.
cb5772bb 106
692a467c
JP
107B<Important Note>: Even if you pass in what looks like a decimal number
108("1.2"), a dotted-decimal will be created ("v1.200.0"). To avoid confusion
109or unintentional errors on older Perls, follow these guidelines:
cb5772bb 110
692a467c 111=over 2
cb5772bb 112
692a467c 113=item *
cb5772bb 114
692a467c 115Always use a dotted-decimal with (at least) three components
92dcf8ce 116
692a467c 117=item *
92dcf8ce 118
692a467c 119Always use a leading-v
92dcf8ce 120
692a467c 121=item *
92dcf8ce 122
692a467c 123Always quote the version
92dcf8ce 124
cb5772bb
RGS
125=back
126
692a467c
JP
127If you really insist on using version.pm with an ordinary decimal version,
128use C<parse()> instead of declare. See the L<PARSING AND COMPARING VERSIONS>
129for details.
cb5772bb 130
692a467c
JP
131See also L<VERSION OBJECT DETAILS> for more on version number conversion,
132quoting, calculated version numbers and declaring developer or "alpha" version
133numbers.
cb5772bb 134
692a467c 135=head1 PARSING AND COMPARING VERSIONS
cb5772bb 136
692a467c
JP
137If you need to compare version numbers, but can't be sure whether they are
138expressed as numbers, strings, v-strings or version objects, then you can
139use version.pm to parse them all into objects for comparison.
cb5772bb 140
692a467c 141=head2 How to C<parse()> a version
cb5772bb 142
692a467c
JP
143The C<parse()> method takes in anything that might be a version and returns
144a corresponding version object, doing any necessary conversion along the way.
cb5772bb 145
692a467c 146=over 2
cb5772bb 147
692a467c 148=item *
cb5772bb 149
692a467c
JP
150Dotted-decimal: bare v-strings (v1.2.3) and strings with more than one
151decimal point and a leading 'v' ("v1.2.3"); NOTE you can technically use a
152v-string or strings with a leading-v and only one decimal point (v1.2 or
153"v1.2"), but you will confuse both yourself and others.
cb5772bb 154
692a467c 155=item *
cb5772bb 156
692a467c 157Decimal: regular decimal numbers (literal or in a string)
cb5772bb
RGS
158
159=back
160
692a467c 161Some examples:
cb5772bb 162
692a467c
JP
163 $variable version->parse($variable)
164 --------- -------------------------
165 1.23 v1.230.0
166 "1.23" v1.230.0
167 v1.23 v1.23.0
168 "v1.23" v1.23.0
169 "1.2.3" v1.2.3
170 "v1.2.3" v1.2.3
cb5772bb 171
692a467c 172See L<VERSION OBJECT DETAILS> for more on version number conversion.
cb5772bb 173
61a0cb1c
JP
174=head2 How to check for a version
175
176If you do not want to actually create a full blown version object, but
177would still like to verify that a given string meets the criteria to
178be parsed as a version, there are now regular expressions included with
179the version module and there are two helper functions that can be
180employed directly:
181
182=over 2
183
184=item C<is_strict()>
185
186If you want to limit youself to a much more narrow definition of what
187a version string constitutes, you can use this function, which limits
188legal version strings to the following list:
189
190=over 2
191
192=item v1.234.5
193
194For dotted-decimal versions, requires a leading 'v', three sub-versions
195of no more than three digits. A leading 0 (zero) before the first
196sub-version (in the above example, '1') is also prohibited.
197
198=item 2.3456
199
200For standard decimal version, requires an integer portion (no leading
2010), a decimal, and one or more digits to the right of the decimal
202
203=back
204
205=item C<is_lax()>
206
207=over 2
208
209=item v1.2
210=item 1.2345.6
211=item 1.23_4
212
213With the lax criteria, all of the above styles are acceptable for
214dotted-decimal formats. The leading 'v' is optional if two or more
215decimals appear. If only a single decimal is included, then the leading
216'v' is required to trigger the dotted-decimal parsing. A leading zero
217is permitted, though not recommended except when quoted, because of the
218risk that Perl will treat the number as octal. A trailing underscore
219plus one or more digits denotes an alpha or development release
220(and must be quoted to be parsed properly).
221
222=item 1.2345
223=item 1.2345_01
224
225For decimal versions, the lax form is nearly identical to the strict
226form except that the alpha form is allowed and a leading zero is
227permitted. Just like the lax dotted-decimal version, quoting the
228values is required for alpha/development forms to be parsed correctly.
229
230=back
231
232See L<version::Internal> for details of the regular expressions used,
233as well as how to use the regular expressions in your own code.
234
235=back
236
692a467c 237=head2 How to compare version objects
cb5772bb 238
692a467c
JP
239Version objects overload the C<cmp> and C<< E<lt>=E<gt> >> operators. Perl
240automatically generates all of the other comparison operators based on those
241two so all the normal logical comparisons will work.
cb5772bb 242
692a467c
JP
243 if ( version->parse($v1) == version->parse($v2) ) {
244 # do stuff
245 }
219bf418 246
692a467c
JP
247If a version object is compared against a non-version object, the non-object
248term will be converted to a version object using C<parse()>. This may give
219bf418
RGS
249surprising results:
250
692a467c
JP
251 $v1 = version->parse("v0.95.0");
252 $bool = $v1 < 0.96; # FALSE since 0.96 is v0.960.0
219bf418 253
692a467c 254Always comparing to a version object will help avoid surprises:
cb5772bb 255
692a467c 256 $bool = $v1 < version->parse("v0.96.0"); # TRUE
cb5772bb 257
692a467c 258=head1 VERSION OBJECT DETAILS
cb5772bb 259
692a467c 260=head2 Equivalence between Decimal and Dotted-Decimal Versions
cb5772bb 261
692a467c
JP
262When Perl 5.6.0 was released, the decision was made to provide a
263transformation between the old-style decimal versions and new-style
264dotted-decimal versions:
cb5772bb 265
692a467c
JP
266 5.6.0 == 5.006000
267 5.005_04 == 5.5.40
cb5772bb 268
692a467c
JP
269The floating point number is taken and split first on the single decimal
270place, then each group of three digits to the right of the decimal makes up
271the next digit, and so on until the number of significant digits is exhausted,
272B<plus> enough trailing zeros to reach the next multiple of three.
cb5772bb 273
692a467c
JP
274This was the method that version.pm adopted as well. Some examples may be
275helpful:
cb5772bb 276
692a467c
JP
277 equivalent
278 decimal zero-padded dotted-decimal
279 ------- ----------- --------------
280 1.2 1.200 v1.200.0
281 1.02 1.020 v1.20.0
282 1.002 1.002 v1.2.0
283 1.0023 1.002300 v1.2.300
284 1.00203 1.002030 v1.2.30
285 1.002003 1.002003 v1.2.3
cb5772bb 286
692a467c 287=head2 Quoting rules
cb5772bb
RGS
288
289Because of the nature of the Perl parsing and tokenizing routines,
290certain initialization values B<must> be quoted in order to correctly
692a467c
JP
291parse as the intended version, especially when using the L<declare> or
292L<qv> methods. While you do not have to quote decimal numbers when
293creating version objects, it is always safe to quote B<all> initial values
294when using version.pm methods, as this will ensure that what you type is
295what is used.
296
297Additionally, if you quote your initializer, then the quoted value that goes
298B<in> will be be exactly what comes B<out> when your $VERSION is printed
299(stringified). If you do not quote your value, Perl's normal numeric handling
300comes into play and you may not get back what you were expecting.
cb5772bb
RGS
301
302If you use a mathematic formula that resolves to a floating point number,
303you are dependent on Perl's conversion routines to yield the version you
304expect. You are pretty safe by dividing by a power of 10, for example,
305but other operations are not likely to be what you intend. For example:
306
307 $VERSION = version->new((qw$Revision: 1.4)[1]/10);
308 print $VERSION; # yields 0.14
309 $V2 = version->new(100/9); # Integer overflow in decimal number
310 print $V2; # yields something like 11.111.111.100
311
692a467c 312Perl 5.8.1 and beyond are able to automatically quote v-strings but
cb5772bb
RGS
313that is not possible in earlier versions of Perl. In other words:
314
315 $version = version->new("v2.5.4"); # legal in all versions of Perl
316 $newvers = version->new(v2.5.4); # legal only in Perl >= 5.8.1
317
43eaf59d
SP
318=head2 What about v-strings?
319
43eaf59d 320There are two ways to enter v-strings: a bare number with two or more
61a0cb1c 321decimal points, or a bare number with one or more decimal points and a
43eaf59d
SP
322leading 'v' character (also bare). For example:
323
324 $vs1 = 1.2.3; # encoded as \1\2\3
61a0cb1c 325 $vs2 = v1.2; # encoded as \1\2
43eaf59d 326
f34c6aaf 327However, the use of bare v-strings to initialize version objects is
692a467c
JP
328B<strongly> discouraged in all circumstances. Also, bare
329v-strings are not completely supported in any version of Perl prior to
3305.8.1.
f34c6aaf 331
61a0cb1c 332If you insist on using bare v-strings with Perl > 5.6.0, be aware of the
f34c6aaf 333following limitations:
43eaf59d 334
61a0cb1c 3351) For Perl releases 5.6.0 through 5.8.0, the v-string code merely guesses,
f34c6aaf
JP
336based on some characteristics of v-strings. You B<must> use a three part
337version, e.g. 1.2.3 or v1.2.3 in order for this heuristic to be successful.
338
3392) For Perl releases 5.8.1 and later, v-strings have changed in the Perl
340core to be magical, which means that the version.pm code can automatically
341determine whether the v-string encoding was used.
cb5772bb 342
8cb289bd
RGS
3433) In all cases, a version created using v-strings will have a stringified
344form that has a leading 'v' character, for the simple reason that sometimes
345it is impossible to tell whether one was present initially.
346
692a467c 347=head2 Alpha versions
cb5772bb 348
692a467c
JP
349For module authors using CPAN, the convention has been to note unstable
350releases with an underscore in the version string. (See L<CPAN>.) version.pm
351follows this convention and alpha releases will test as being newer than the
352more recent stable release, and less than the next stable release. For
353dotted-decimal versions, only the last element may be separated by an
354underscore:
cb5772bb 355
692a467c
JP
356 # Declaring
357 use version 0.77; our $VERSION = version->declare("v1.2_3");
cb5772bb 358
692a467c
JP
359 # Parsing
360 $v1 = version->parse("v1.2_3");
361 $v1 = version->parse("1.002_003");
cb5772bb 362
692a467c 363=head1 OBJECT METHODS
cb5772bb 364
692a467c 365=head2 is_alpha()
cb5772bb 366
692a467c 367True if and only if the version object was created with a underscore, e.g.
cb5772bb 368
692a467c
JP
369 version->parse('1.002_03')->is_alpha; # TRUE
370 version->declare('1.2.3_4')->is_alpha; # TRUE
cb5772bb 371
692a467c 372=head2 is_qv()
cb5772bb 373
692a467c 374True only if the version object is a dotted-decimal version, e.g.
cb5772bb 375
692a467c
JP
376 version->parse('v1.2.0')->is_qv; # TRUE
377 version->declare('v1.2')->is_qv; # TRUE
378 qv('1.2')->is_qv; # TRUE
379 version->parse('1.2')->is_qv; # FALSE
cb5772bb 380
692a467c 381=head2 normal()
cb5772bb 382
692a467c
JP
383Returns a string with a standard 'normalized' dotted-decimal form with a
384leading-v and at least 3 components.
cb5772bb 385
692a467c
JP
386 version->declare('v1.2')->normal; # v1.2.0
387 version->parse('1.2')->normal; # v1.200.0
8cb289bd 388
692a467c 389=head2 numify()
8cb289bd 390
692a467c
JP
391Returns a value representing the object in a pure decimal form without
392trailing zeroes.
cb5772bb 393
692a467c
JP
394 version->declare('v1.2')->numify; # 1.002
395 version->parse('1.2')->numify; # 1.2
cb5772bb 396
692a467c 397=head2 stringify()
cb5772bb 398
692a467c
JP
399Returns a string that is as close to the original representation as possible.
400If the original representation was a numeric literal, it will be returned the
401way perl would normally represent it in a string. This method is used whenever
402a version object is interpolated into a string.
cb5772bb 403
692a467c
JP
404 version->declare('v1.2')->stringify; # v1.2
405 version->parse('1.200')->stringify; # 1.200
406 version->parse(1.02_30)->stringify; # 1.023
cb5772bb 407
692a467c 408=head1 EXPORTED FUNCTIONS
cb5772bb 409
692a467c 410=head2 qv()
cb5772bb 411
692a467c
JP
412This function is no longer recommended for use, but is maintained for
413compatibility with existing code. If you do not want to have it exported
414to your namespace, use this form:
cb5772bb 415
692a467c 416 use version 0.77 ();
cb5772bb
RGS
417
418=head1 AUTHOR
419
420John Peacock E<lt>jpeacock@cpan.orgE<gt>
421
422=head1 SEE ALSO
423
692a467c
JP
424L<version::Internal>.
425
cb5772bb
RGS
426L<perl>.
427
428=cut