VCI::Abstract::Committable - Anything that can be committed to a repository.

package VCI::Abstract::Committable;
use Moose::Role;
use VCI::Util;

with 'VCI::Abstract::ProjectItem';

has 'history'        => (is => 'ro', isa => 'VCI::Abstract::History', lazy_build => 1);

has 'first_revision' => (is => 'ro', does => 'VCI::Abstract::Committable',
                         lazy_build => 1);
                                          
has 'last_revision'  => (is => 'ro', does => 'VCI::Abstract::Committable',
                         lazy_build => 1);

has 'revision'   => (is => 'ro', lazy_build => 1, predicate => '_has_revision');
has 'revno'      => (is => 'ro', lazy_build => 1);
# All of this crazy init_arg stuff means "coerce lazily, because it's
# slow to make thousands of DateTime and Path::Abstract::Underload objects."
has 'time'       => (is => 'ro', isa => 'VCI::Type::DateTime', coerce => 1,
                     lazy => 1,
                     default => sub { shift->_time }, init_arg => '__time');
has '_time'      => (is => 'ro', isa => 'Defined', init_arg => 'time',
                     lazy_build => 1, builder => '_build_time');
has 'path'       => (is => 'ro', isa => 'VCI::Type::Path', coerce => 1,
                     lazy => 1,
                     default => sub { shift->_path }, init_arg => '__path');
has '_path'      => (is => 'ro', isa => 'Defined', required => 1,
                     init_arg => 'path');
has 'name'       => (is => 'ro', isa => 'Str', lazy => 1,
                     default => sub { shift->path->last });

has 'parent'     => (is => 'ro', does => 'VCI::Abstract::Committable',
                     lazy_build => 1);

# Unfortunately Moose is a little dumb about Roles sometimes, and requires
# our *abstract* classes to implement these, instead of our subclasses. So
# we can't really require them.
# requires 'build_revision', 'build_time';

sub _build_first_revision {
    my $self = shift;
    my $commit = $self->history->commits->[0];
    return $self->_me_from($commit);
}

sub _build_last_revision {
    my $self = shift;
    my $commit = $self->history->commits->[-1];
    return $self->_me_from($commit);
}

sub _build_revno {
    my $self = shift;
    my $commit = $self->project->get_commit(revision => $self->revision);
    return $commit->revno;
}

sub _me_from {
    my ($self, $commit) = @_;
    my @item = grep {$_->path->stringify eq $self->path->stringify
                     # This assures we don't get a Directory if we're a File.
                     && $_->isa(blessed $self)}
                    @{$commit->contents};
    warn("More than one item in the contents of commit "
         . $commit->revision . " with path " . $self->path)
        if scalar @item > 1;
    return $item[0];
}

sub _build_history {
    my $self = shift;
    
    my $current_path = $self->path->stringify;
    my @commits;
    # We go backwards in time to catch renames.
    foreach my $commit (reverse @{ $self->project->history->commits }) {
        my $in_contents = grep {$_->path->stringify eq $current_path}
                               @{$commit->contents};
        push(@commits, $commit) if $in_contents;
        # XXX Need to also track our history through copies.
        if (exists $commit->moved->{$current_path}) {
            $current_path = $commit->moved->{$current_path}->path->stringify;
        }
    }
    
    return $self->history_class->new(
        commits => [reverse @commits],
        project => $self->project,
    );
}

sub _build_parent {
    my $self = shift;
    my $path = $self->path;
    return undef if $path->is_empty;

    my $parent_path = $self->path->parent;
    return $self->project->get_path(path => $parent_path);
}

#######################
# Implementor Helpers #
#######################

sub _no_time_without_revision {
    my $self = shift;
    if (defined $self->{time} && !defined $self->{revision}) {
        confess("You cannot build a Committable that has its time"
                . " defined but not its revision");
    }
}

1;

__END__