1 package Module::Metadata::Version;
4 # stolen from Module::Build::Version - this is perl licensed code,
10 eval "use version $VERSION";
11 if ($@) { # can't locate version files, use our own
13 # Avoid redefined warnings if an old version.pm was available
14 delete $version::{$_} foreach keys %version::;
16 # first we get the stub version module
19 s/(\$VERSION)\s=\s\d+/\$VERSION = 0/;
24 # and now get the current version::vpp code
27 s/(\$VERSION)\s=\s\d+/\$VERSION = 0/;
32 # but we eval them in reverse order since version depends on
33 # version::vpp to already exist
34 eval $vpp; die $@ if $@;
35 $INC{'version/vpp.pm'} = 'inside Module::Metadata::Version';
36 eval $version; die $@ if $@;
37 $INC{'version.pm'} = 'inside Module::Metadata::Version';
40 # now we can safely subclass version, installed or not
46 # stub version module to make everything else happy
52 use vars qw(@ISA $VERSION $CLASS *declare *qv);
58 push @ISA, "version::vpp";
60 *version::qv = \&version::vpp::qv;
61 *version::declare = \&version::vpp::declare;
62 *version::_VERSION = \&version::vpp::_VERSION;
63 if ($] > 5.009001 && $] <= 5.010000) {
65 *{'version::stringify'} = \*version::vpp::stringify;
66 *{'version::(""'} = \*version::vpp::stringify;
67 *{'version::new'} = \*version::vpp::new;
70 # Preloaded methods go here.
75 # Set up any derived class
76 unless ($class eq 'version') {
78 *{$class.'::declare'} = \&version::declare;
79 *{$class.'::qv'} = \&version::qv;
83 if (@_) { # any remaining terms are arguments
84 map { $args{$_} = 1 } @_
86 else { # no parameters at all on use line
90 'UNIVERSAL::VERSION' => 1,
94 my $callpkg = caller();
96 if (exists($args{declare})) {
97 *{$callpkg."::declare"} =
98 sub {return $class->declare(shift) }
99 unless defined(&{$callpkg.'::declare'});
102 if (exists($args{qv})) {
104 sub {return $class->qv(shift) }
105 unless defined(&{"$callpkg\::qv"});
108 if (exists($args{'UNIVERSAL::VERSION'})) {
110 *UNIVERSAL::VERSION = \&version::_VERSION;
113 if (exists($args{'VERSION'})) {
114 *{$callpkg."::VERSION"} = \&version::_VERSION;
120 # replace everything from here to the end with the current version/vpp.pm
121 package version::vpp;
124 use POSIX qw/locale_h/;
126 use vars qw ($VERSION @ISA @REGEXS);
128 $VERSION = eval $VERSION;
131 ^v? # optional leading 'v'
132 (\d*) # major revision not required
133 \. # requires at least one decimal
143 'nomethod' => \&vnoop,
146 my $VERSION_MAX = 0x7FFFFFFF;
152 sub enabled {return $^W;}
159 my ($class, $value) = @_;
160 my $self = bless ({}, ref ($class) || $class);
162 if ( ref($value) && eval('$value->isa("version")') ) {
163 # Can copy the elements directly
164 $self->{version} = [ @{$value->{version} } ];
165 $self->{qv} = 1 if $value->{qv};
166 $self->{alpha} = 1 if $value->{alpha};
167 $self->{original} = ''.$value->{original};
171 my $currlocale = setlocale(LC_ALL);
173 # if the current locale uses commas for decimal points, we
174 # just replace commas with decimal places, rather than changing
176 if ( localeconv()->{decimal_point} eq ',' ) {
180 if ( not defined $value or $value =~ /^undef$/ ) {
181 # RT #19517 - special case for undef comparison
182 # or someone forgot to pass a value
183 push @{$self->{version}}, 0;
184 $self->{original} = "0";
188 if ( $#_ == 2 ) { # must be CVS-style
192 $value = _un_vstring($value);
194 # exponential notation
195 if ( $value =~ /\d+.?\d*e[-+]?\d+/ ) {
196 $value = sprintf("%.9f",$value);
197 $value =~ s/(0+)$//; # trim trailing zeros
200 # This is not very efficient, but it is morally equivalent
201 # to the XS code (as that is the reference implementation).
202 # See vutil/vutil.c for details
208 my ($start, $last, $pos, $s);
211 while ( substr($value,$s,1) =~ /\s/ ) { # leading whitespace is OK
215 if (substr($value,$s,1) eq 'v') {
217 $qv = 1; # force quoted version processing
220 $start = $last = $pos = $s;
222 # pre-scan the input string to check for decimals/underbars
223 while ( substr($value,$pos,1) =~ /[._\d,]/ ) {
224 if ( substr($value,$pos,1) eq '.' ) {
226 Carp::croak("Invalid version format ".
227 "(underscores before decimal)");
232 elsif ( substr($value,$pos,1) eq '_' ) {
235 Carp::croak("Invalid version format ".
236 "(multiple underscores)");
239 $width = $pos - $last - 1; # natural width of sub-version
241 elsif ( substr($value,$pos,1) eq ','
242 and substr($value,$pos+1,1) =~ /[0-9]/ ) {
243 # looks like an unhandled locale
250 if ( $alpha && !$saw_period ) {
252 Carp::croak("Invalid version format ".
253 "(alpha without decimal)");
256 if ( $alpha && $saw_period && $width == 0 ) {
258 Carp::croak("Invalid version format ".
259 "(misplaced _ in number)");
262 if ( $saw_period > 1 ) {
263 $qv = 1; # force quoted version processing
277 if ( !$qv && $width < 3 ) {
278 $self->{width} = $width;
281 while ( substr($value,$pos,1) =~ /\d/ ) {
285 if ( substr($value,$pos,1) !~ /[a-z]/ ) { ### FIX THIS ###
292 # this is atoi() that delimits on underscores
297 # the following if() will only be true after the decimal
298 # point of a version originally created with a bare
299 # floating point number, i.e. not quoted in any way
300 if ( !$qv && $s > $start && $saw_period == 1 ) {
302 while ( $s < $end ) {
304 $rev += substr($value,$s,1) * $mult;
306 if ( abs($orev) > abs($rev)
307 || abs($rev) > abs($VERSION_MAX) ) {
308 if ( warnings::enabled("overflow") ) {
310 Carp::carp("Integer overflow in version");
316 if ( substr($value,$s,1) eq '_' ) {
322 while (--$end >= $s) {
324 $rev += substr($value,$end,1) * $mult;
326 if ( abs($orev) > abs($rev)
327 || abs($rev) > abs($VERSION_MAX) ) {
328 if ( warnings::enabled("overflow") ) {
330 Carp::carp("Integer overflow in version");
340 push @{$self->{version}}, $rev;
341 if ( substr($value,$pos,1) eq '.'
342 && substr($value,$pos+1,1) =~ /\d/ ) {
345 elsif ( substr($value,$pos,1) eq '_'
346 && substr($value,$pos+1,1) =~ /\d/ ) {
349 elsif ( substr($value,$pos,1) eq ','
350 && substr($value,$pos+1,1) =~ /\d/ ) {
353 elsif ( substr($value,$pos,1) =~ /\d/ ) {
361 while ( substr($value,$pos,1) =~ /\d/ ) {
367 while (substr($value,$pos,1) =~ /[\d_]/ && $digits < 3) {
368 if ( substr($value,$pos,1) ne '_' ) {
376 if ( $qv ) { # quoted versions always get at least three terms
377 my $len = scalar @{$self->{version}};
380 push @{$self->{version}}, 0;
384 if ( substr($value,$pos) ) { # any remaining text
385 if ( warnings::enabled("misc") ) {
387 Carp::carp("Version string '$value' contains invalid data; ".
388 "ignoring: '".substr($value,$pos)."'");
392 # cache the original value for use when stringification
395 $self->{original} = 'v.Inf';
398 $self->{original} = substr($value,0,$pos);
409 unless (_verify($self)) {
411 Carp::croak("Invalid version object");
413 my $width = $self->{width} || 3;
414 my $alpha = $self->{alpha} || "";
415 my $len = $#{$self->{version}};
416 my $digit = $self->{version}[0];
417 my $string = sprintf("%d.", $digit );
419 for ( my $i = 1 ; $i < $len ; $i++ ) {
420 $digit = $self->{version}[$i];
422 my $denom = 10**(3-$width);
423 my $quot = int($digit/$denom);
424 my $rem = $digit - ($quot * $denom);
425 $string .= sprintf("%0".$width."d_%d", $quot, $rem);
428 $string .= sprintf("%03d", $digit);
433 $digit = $self->{version}[$len];
434 if ( $alpha && $width == 3 ) {
437 $string .= sprintf("%0".$width."d", $digit);
441 $string .= sprintf("000");
450 unless (_verify($self)) {
452 Carp::croak("Invalid version object");
454 my $alpha = $self->{alpha} || "";
455 my $len = $#{$self->{version}};
456 my $digit = $self->{version}[0];
457 my $string = sprintf("v%d", $digit );
459 for ( my $i = 1 ; $i < $len ; $i++ ) {
460 $digit = $self->{version}[$i];
461 $string .= sprintf(".%d", $digit);
465 $digit = $self->{version}[$len];
467 $string .= sprintf("_%0d", $digit);
470 $string .= sprintf(".%0d", $digit);
475 for ( $len = 2 - $len; $len != 0; $len-- ) {
476 $string .= sprintf(".%0d", 0);
486 unless (_verify($self)) {
488 Carp::croak("Invalid version object");
490 return exists $self->{original}
500 my ($left,$right,$swap) = @_;
501 my $class = ref($left);
502 unless ( UNIVERSAL::isa($right, $class) ) {
503 $right = $class->new($right);
507 ($left, $right) = ($right, $left);
509 unless (_verify($left)) {
511 Carp::croak("Invalid version object");
513 unless (_verify($right)) {
515 Carp::croak("Invalid version object");
517 my $l = $#{$left->{version}};
518 my $r = $#{$right->{version}};
519 my $m = $l < $r ? $l : $r;
520 my $lalpha = $left->is_alpha;
521 my $ralpha = $right->is_alpha;
524 while ( $i <= $m && $retval == 0 ) {
525 $retval = $left->{version}[$i] <=> $right->{version}[$i];
529 # tiebreaker for alpha with identical terms
532 && $left->{version}[$m] == $right->{version}[$m]
533 && ( $lalpha || $ralpha ) ) {
535 if ( $lalpha && !$ralpha ) {
538 elsif ( $ralpha && !$lalpha) {
543 # possible match except for trailing 0's
544 if ( $retval == 0 && $l != $r ) {
546 while ( $i <= $r && $retval == 0 ) {
547 if ( $right->{version}[$i] != 0 ) {
548 $retval = -1; # not a match after all
554 while ( $i <= $l && $retval == 0 ) {
555 if ( $left->{version}[$i] != 0 ) {
556 $retval = +1; # not a match after all
568 return vcmp($self,$self->new("0"),1);
573 Carp::croak("operation not supported with version object");
578 return (exists $self->{alpha});
583 my $class = 'version';
585 $class = ref($value) || $value;
589 $value = _un_vstring($value);
590 $value = 'v'.$value unless $value =~ /(^v|\d+\.\d+\.\d)/;
591 my $version = $class->new($value);
599 return (exists $self->{qv});
606 && eval { exists $self->{version} }
607 && ref($self->{version}) eq 'ARRAY'
619 if ( $] >= 5.006_000 && length($value) >= 3 && $value !~ /[._]/ ) {
620 my $tvalue = sprintf("v%vd",$value);
621 if ( $tvalue =~ /^v\d+\.\d+\.\d+$/ ) {
630 my ($obj, $req) = @_;
631 my $class = ref($obj) || $obj;
634 if ( exists $INC{"$class.pm"} and not %{"$class\::"} and $] >= 5.008) {
635 # file but no package
637 Carp::croak( "$class defines neither package nor VERSION"
638 ."--version check failed");
641 my $version = eval "\$$class\::VERSION";
642 if ( defined $version ) {
643 local $^W if $] <= 5.008;
644 $version = version::vpp->new($version);
647 if ( defined $req ) {
648 unless ( defined $version ) {
651 ? "$class version $req required--this is only version "
652 : "$class does not define \$$class\::VERSION"
653 ."--version check failed";
655 if ( $ENV{VERSION_DEBUG} ) {
663 $req = version::vpp->new($req);
665 if ( $req > $version ) {
669 sprintf ("%s version %s required--".
670 "this is only version %s", $class,
671 $req->normal, $version->normal)
676 sprintf ("%s version %s required--".
677 "this is only version %s", $class,
678 $req->stringify, $version->stringify)
684 return defined $version ? $version->stringify : undef;
687 1; #this line is important and will help the module return a true value