445 lines
9.6 KiB
Perl
445 lines
9.6 KiB
Perl
package Git::IssueManager;
|
|
#ABSTRACT: Module for managing issues in a git branch within your repository
|
|
use Moose;
|
|
use Git::RepositoryHL;
|
|
use DateTime;
|
|
use DateTime::TimeZone;
|
|
use Data::Dumper;
|
|
|
|
our $VERSION = "0.1";
|
|
|
|
=attr repository
|
|
|
|
Git::Repository object on which to do the issue management
|
|
|
|
=cut
|
|
has 'repository' => (is =>'ro', isa => 'Git::RepositoryHL', required => 1);
|
|
|
|
|
|
=method ready
|
|
|
|
validates if everything is in place for issue management
|
|
|
|
=cut
|
|
sub ready
|
|
{
|
|
my $self = shift;
|
|
|
|
# return false if issue branch does not exist
|
|
return 0 unless $self->repository->hasBranch('heads/issues');
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
=method version
|
|
|
|
returns the version number of the issue system within the issue branch
|
|
|
|
=cut
|
|
sub version
|
|
{
|
|
my $self = shift;
|
|
|
|
return unless $self->ready();
|
|
|
|
my @tree = $self->repository->getTree("issues");
|
|
|
|
for my $t (@tree)
|
|
{
|
|
if ($t->{name} eq ".version")
|
|
{
|
|
my $version = $self->repository->getBlob($t->{ref});
|
|
chomp($version);
|
|
return $version;
|
|
}
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
=method tag
|
|
|
|
returns the issue tag to prepend in front of all issue ids
|
|
|
|
=cut
|
|
sub tag
|
|
{
|
|
my $self = shift;
|
|
|
|
return unless $self->ready();
|
|
|
|
my @tree = $self->repository->getTree("issues");
|
|
|
|
for my $t (@tree)
|
|
{
|
|
if ($t->{name} eq ".tag")
|
|
{
|
|
my $tag = $self->repository->getBlob($t->{ref});
|
|
chomp($tag);
|
|
return $tag;
|
|
}
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
=method init
|
|
|
|
initialize the repository for managing issues
|
|
|
|
=cut
|
|
sub init
|
|
{
|
|
my $self = shift;
|
|
my $issue_tag = shift;
|
|
|
|
return unless ! $self->ready();
|
|
|
|
die("no issue tag given") unless $issue_tag;
|
|
|
|
# create a version file in the issues branch, also creating the branch with this
|
|
my $filehash = $self->repository->createFileObject("0.1");
|
|
|
|
# add the version file to a git tree
|
|
my $t = {
|
|
mode => "100644",
|
|
type => "blob",
|
|
ref => $filehash,
|
|
path => ".version"
|
|
};
|
|
my @tree;
|
|
push(@tree,$t);
|
|
|
|
# create a tag file in the issues branch to identify the issue tag to prepend
|
|
$filehash = $self->repository->createFileObject($issue_tag);
|
|
my $t2 = {
|
|
mode => "100644",
|
|
type => "blob",
|
|
ref => $filehash,
|
|
path => ".tag"
|
|
};
|
|
push(@tree,$t2);
|
|
|
|
# create the tree
|
|
my $tree_hash=$self->repository->createTree(\@tree);
|
|
|
|
# commit the created tree
|
|
my $commit=$self->repository->createTreeCommit($tree_hash, "1", "initialized issue manager for this repository");
|
|
|
|
# now update/create the branch refs/heads/issues
|
|
|
|
$self->repository->updateRef("refs/heads/issues",$commit);
|
|
|
|
}
|
|
|
|
=method _recreate - internal method, do not call directly
|
|
|
|
method used to recreate the tree structure received by getTree to something like createTree can use
|
|
|
|
=cut
|
|
sub recreate
|
|
{
|
|
my $self = shift;
|
|
my $array = shift;
|
|
|
|
for my $a (@{$array})
|
|
{
|
|
$a->{path} = $a->{name};
|
|
}
|
|
}
|
|
|
|
=method add
|
|
|
|
add an issue to the repository
|
|
|
|
=cut
|
|
sub add
|
|
{
|
|
my $self = shift;
|
|
my $issue = shift;
|
|
die("IssueManager not initialized") unless $self->ready();
|
|
die("no Git::IssueManager::Issue object given") unless ref($issue) eq "Git::IssueManager::Issue";
|
|
|
|
my @root = $self->repository->getTree("issues");
|
|
my @open = $self->repository->getTree("issues","open/");
|
|
my @closed = $self->repository->getTree("issues","closed/");
|
|
my @assigned = $self->repository->getTree("issues","assigned/");
|
|
my @inprogress = $self->repository->getTree("issues","inprogress");
|
|
|
|
$self->recreate(\@open);
|
|
$self->recreate(\@closed);
|
|
$self->recreate(\@assigned);
|
|
$self->recreate(\@inprogress);
|
|
|
|
my $issues;
|
|
if ($issue->status eq "open")
|
|
{
|
|
$issues=\@open;
|
|
}
|
|
elsif ($issue->status eq "closed")
|
|
{
|
|
$issues=\@closed;
|
|
}
|
|
elsif ($issue->status eq "assigned")
|
|
{
|
|
$issues=\@assigned;
|
|
}
|
|
elsif ($issue->status eq "inprogress")
|
|
{
|
|
$issues=\@inprogress;
|
|
}
|
|
|
|
# check if issues already exist, only checks the subject !!!
|
|
for my $i (@{$issues})
|
|
{
|
|
if ($i->{name} eq $issue->subject)
|
|
{
|
|
die("issue already exist");
|
|
}
|
|
}
|
|
|
|
# append the issue to the tree
|
|
my $hash=$issue->createIssue($self->repository);
|
|
push (@{$issues},{
|
|
path => $issue->subject,
|
|
ref => $hash,
|
|
type => "tree",
|
|
mode => "040000"
|
|
});
|
|
|
|
# now recreate tree structure
|
|
my $openhash = $self->repository->createTree(\@open);
|
|
my $closedhash = $self->repository->createTree(\@closed);
|
|
my $assignedhash = $self->repository->createTree(\@assigned);
|
|
my $inprogresshash= $self->repository->createTree(\@inprogress);
|
|
|
|
my $openfound=0;
|
|
my $closedfound=0;
|
|
my $assignedfound=0;
|
|
my $inprogressfound=0;
|
|
# now recreate the root tree
|
|
for my $r (@root)
|
|
{
|
|
if ($r->{name} eq "open")
|
|
{
|
|
$r->{ref}=$openhash;
|
|
$openfound=1;
|
|
}
|
|
|
|
if ($r->{name} eq "closed")
|
|
{
|
|
$r->{ref}=$closedhash;
|
|
$closedfound=1;
|
|
}
|
|
|
|
if ($r->{name} eq "assigned")
|
|
{
|
|
$r->{ref}=$assignedhash;
|
|
$assignedfound=1;
|
|
}
|
|
|
|
if ($r->{name} eq "inprogess")
|
|
{
|
|
$r->{ref}=$inprogresshash;
|
|
$inprogressfound=1;
|
|
}
|
|
}
|
|
|
|
|
|
if (!$openfound && defined($openhash))
|
|
{
|
|
my $t = {
|
|
path => "open",
|
|
ref => $openhash,
|
|
type => "tree",
|
|
mode => "040000"
|
|
};
|
|
push(@root, $t);
|
|
}
|
|
|
|
if (!$closedfound && defined($closedhash))
|
|
{
|
|
my $t = {
|
|
path => "closed",
|
|
ref => $closedhash,
|
|
type => "tree",
|
|
mode => "040000"
|
|
};
|
|
push(@root, $t);
|
|
}
|
|
|
|
if (!$assignedfound && defined($assignedhash))
|
|
{
|
|
my $t = {
|
|
path => "assigned",
|
|
ref => $assignedhash,
|
|
type => "tree",
|
|
mode => "040000"
|
|
};
|
|
push(@root, $t);
|
|
}
|
|
|
|
if (!$inprogressfound && defined($inprogresshash))
|
|
{
|
|
my $t = {
|
|
path => "inprogress",
|
|
ref => $inprogresshash,
|
|
type => "tree",
|
|
mode => "040000"
|
|
};
|
|
push(@root, $t);
|
|
}
|
|
|
|
my $roothash = $self->repository->createTree(\@root);
|
|
|
|
# commit the issue
|
|
my $commit=$self->repository->createTreeCommit($roothash,$self->repository->getBranchRef("heads/issues") || "start", "ADD: " . $issue->subject);
|
|
|
|
#now update branch refs/heads/issues
|
|
$self->repository->updateRef("refs/heads/issues",$commit);
|
|
|
|
}
|
|
|
|
=method _to_issue - internal method, do not call directly
|
|
|
|
returns the issue converted from a tree hash entry
|
|
|
|
=cut
|
|
sub _to_issue
|
|
{
|
|
my $self = shift;
|
|
my $i = shift;
|
|
|
|
my $issue = Git::IssueManager::Issue->new(subject => $i->{name});
|
|
|
|
$issue->priority($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/priority")));
|
|
$issue->severity($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/severity")));
|
|
$issue->type($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/type")));
|
|
$issue->description($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/description")));
|
|
$issue->comment($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/comment")));
|
|
$issue->id($self->repository->getBlob($self->repository->getFileRef("issues",".tag")) . "-" . substr($i->{ref},0,8));
|
|
$issue->estimated_time($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/estimated")));
|
|
$issue->working_time($self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/working")));
|
|
|
|
my $worker = $self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/worker"));
|
|
if (defined($worker))
|
|
{
|
|
$worker=~/^(.*)<(.*)>$/;
|
|
$issue->worker($1 || "");
|
|
$issue->worker_email($2 || "");
|
|
}
|
|
|
|
my $taglist= $self->repository->getBlob($self->repository->getFileRef("issues",$i->{path}."/tags"));
|
|
if (defined($taglist) && length($taglist)>0)
|
|
{
|
|
my @tags=split /\n/,$taglist;
|
|
$issue->tags(\@tags);
|
|
}
|
|
|
|
my $tz=DateTime::TimeZone->new( name => 'local' );
|
|
my @commit = $self->repository->getFileLog("issues",$i->{path}."/subject",1);
|
|
$issue->creation_date(DateTime->from_epoch(epoch => $commit[0]->{date},time_zone=>$tz ));
|
|
$issue->author($commit[0]->{author}->{name});
|
|
$issue->author_email($commit[0]->{author}->{email});
|
|
|
|
@commit = $self->repository->getFileLog("issues",$i->{path},1);
|
|
$issue->last_change_date(DateTime->from_epoch(epoch => $commit[0]->{date},time_zone=>$tz ));
|
|
|
|
$issue->closed_date(DateTime->from_epoch(epoch => $commit[0]->{date},time_zone=>$tz ));
|
|
|
|
return $issue;
|
|
}
|
|
|
|
|
|
=method get
|
|
|
|
return the issue with the given id
|
|
|
|
=cut
|
|
sub get
|
|
{
|
|
my $self = shift;
|
|
my $id = shift;
|
|
|
|
die("no id given") unless defined($id);
|
|
|
|
$id=~/^[A-Z]+-(.*)$/;
|
|
my $hash=$1;
|
|
|
|
# first search for the id
|
|
my @open = $self->repository->getTree("issues","open/");
|
|
for my $i (@open)
|
|
{
|
|
if (substr($i->{ref},0,8) eq $hash)
|
|
{
|
|
return $self->_to_issue($i);
|
|
}
|
|
}
|
|
|
|
my @assigned = $self->repository->getTree("issues","assigned/");
|
|
for my $i (@assigned)
|
|
{
|
|
if (substr($i->{ref},0,8) eq $hash)
|
|
{
|
|
return $self->_to_issue($i);
|
|
}
|
|
}
|
|
|
|
my @inprogress = $self->repository->getTree("issues","inprogress");
|
|
for my $i (@inprogress)
|
|
{
|
|
if (substr($i->{ref},0,8) eq $hash)
|
|
{
|
|
return $self->_to_issue($i);
|
|
}
|
|
}
|
|
|
|
my @closed = $self->repository->getTree("issues","closed/");
|
|
for my $i (@closed)
|
|
{
|
|
if (substr($i->{ref},0,8) eq $hash)
|
|
{
|
|
return $self->_to_issue($i);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
=method list
|
|
|
|
list all issues of the repository
|
|
|
|
=cut
|
|
sub list
|
|
{
|
|
my $self = shift;
|
|
my $filter = shift;
|
|
my @issues =$self->repository->getTree("issues","open/");
|
|
my @ret;
|
|
|
|
if (!defined($filter) || $filter eq "open" )
|
|
{
|
|
@issues=$self->repository->getTree("issues","open/");
|
|
}
|
|
|
|
for my $i (@issues)
|
|
{
|
|
my $issue = $self->_to_issue($i);
|
|
|
|
push(@ret, $issue);
|
|
}
|
|
|
|
# now sort by creation date
|
|
@ret = sort {DateTime->compare($a->creation_date, $b->creation_date)} @ret;
|
|
|
|
return @ret;
|
|
}
|
|
|
|
|
|
1;
|