view release on metacpan or  search on metacpan

lib/Dist/Zilla/Plugin/Subversion/NextVersion.pm  view on Meta::CPAN

use strict;
use warnings;
package Dist::Zilla::Plugin::Subversion::NextVersion;
# ABSTRACT: provide a version number by bumping the last SVN release tag

use Dist::Zilla 4 ();
use version;
use Version::Next;

use Moose;
use Moose::Util::TypeConstraints;
use SVN::Client;
use Try::Tiny;

with 'Dist::Zilla::Role::VersionProvider';
with 'Dist::Zilla::Role::BeforeRelease';

has 'svn' => (
	is => 'ro',
	isa => 'SVN::Client',
	lazy => 1,
	default => sub {
		my $self = shift;
		SVN::Client->new();
	},
);

use constant _CoercedRegexp => do {
    my $tc = subtype as 'RegexpRef';
    coerce $tc, from 'Str', via { qr/$_/ };
    $tc;
};

has 'tag_folder' => (
	is => 'ro', isa => 'Str',
	default => sub {
		my $self = shift;
		return( '^/'.$self->zilla->name.'/tags/' );
	},
);

has version_regexp  => ( is => 'ro', isa=> _CoercedRegexp, coerce => 1,
                         default => sub { qr/^(.+)$/ } );

has first_version  => ( is => 'ro', isa=>'Str', default => '0.001' );

has 'all_versions' => (
	is => 'ro', isa => 'ArrayRef[version]', lazy => 1,
	default => sub {
		my $self = shift;
		my $regex = $self->version_regexp;
		my $listing = $self->svn->ls($self->tag_folder, 'HEAD', 0);
		my @versions = keys %$listing;
		@versions = sort map { /$regex/ ? try { version->parse("$1") } : () } @versions;
		return( \@versions );
	},
);

has 'max_version' => (
	is => 'ro', isa => 'version', lazy => 1,
	default => sub {
		my $self = shift;
		if( ! @{$self->all_versions} ) {
			die('could not obtain max_version from empty version list!');
		}
		return( $self->all_versions->[-1] );
	},
);

has 'next_version' => (
	is => 'ro', isa => 'Str', lazy => 1,
	default => sub {
		my $self = shift;
		return( Version::Next::next_version($self->max_version->stringify) );
	},
);

sub provide_version {
	my ($self) = @_;

	# override (or maybe needed to initialize)
	if( exists $ENV{V} ) {
		$self->log("using version ".$ENV{V}.' from environment');
		return $ENV{V};
	}

	my $max_version = $self->max_version;
	my $next_version = $self->next_version;

	$self->log("bumping version from $max_version to $next_version");

	return "$next_version";
}

sub before_release {
	my $self = shift;
	my $version = version->parse( $self->zilla->version );

	if( grep { $_ == $version } @{$self->all_versions} ) {
		$self->log_fatal("version $version has already been tagged")
	}
}

1;

__END__

=pod