File Coverage

blib/lib/Text/Todo/Entry.pm

Criterion	Covered	Total	%
statement	128	133	96.2
branch	29	42	69.0
condition	9	12	75.0
subroutine	25	25	100.0
pod	12	12	100.0
total	203	224	90.6

package Text::Todo::Entry;

# $AFresh1: Entry.pm,v 1.30 2010/02/16 01:13:12 andrew Exp $

use warnings;
use strict;
use Carp;

use Class::Std::Utils;

use version; our $VERSION = qv('0.2.0');

{

    my @attr_refs = \(
        my %text_of,

        my %tags_of,
        my %priority_of,
        my %completion_status_of,
        my %known_tags_of,
    );

    # XXX Should the completion (x) be case sensitive?
    my $priority_completion_regex = qr{
        ^ \s*
        (?i:(x \s* [\d-]* ) \s*)?
        (?i:\( ([A-Z]) \)   \s*)?
    }xms;

    sub new {
        my ( $class, $options ) = @_;

        my $self = bless anon_scalar(), $class;
        my $ident = ident($self);

        $text_of{$ident} = q{};

        if ( !ref $options ) {
            $options = { text => $options };
        }
        elsif ( ref $options ne 'HASH' ) {
            croak 'Invalid parameter passed!';
        }

        my %tags = (
            context => q{@},
            project => q{+},
        );

        if ( exists $options->{tags} && ref $options->{tags} eq 'HASH' ) {
            %tags = ( %tags, %{ $options->{tags} } );
        }

        for my $tag ( keys %tags ) {
            $self->learn_tag( $tag, $tags{$tag} );
        }

        $self->replace( $options->{text} );

        return $self;
    }

    sub _parse_entry {
        my ($self) = @_;
        my $ident = ident($self);

        delete $tags_of{$ident};
        delete $completion_status_of{$ident};
        delete $priority_of{$ident};

        my $text       = $self->text       || q{};
        my $known_tags = $self->known_tags || {};

        foreach my $tag ( keys %{$known_tags} ) {
            next if !defined $known_tags->{$tag};
            next if !length $known_tags->{$tag};

            my $sigal = quotemeta $known_tags->{$tag};
            $tags_of{$ident}{$tag}
                = { map { $_ => q{} } $text =~ / (?:^|\s) $sigal (\S*)/gxms };
        }

        my ( $completed, $priority )
            = $text =~ / $priority_completion_regex /xms;

        $completion_status_of{$ident} = _clean_completed($completed);
        $priority_of{$ident}          = $priority;

        return 1;
    }

    sub _clean_completed {
        my ($completed) = @_;

        $completed ||= q{};
        $completed =~ s/^\s+|\s+$//gxms;

        if ( !$completed ) {
            return;
        }

        if ( $completed =~ s/(x)\s*//ixms ) {
            my $status = $1;
            if ($completed) {
                return $completed;
            }
            else {
                return $status;
            }
        }

        return;
    }

    sub replace {
        my ( $self, $text ) = @_;
        my $ident = ident($self);

        $text = defined $text ? $text : q{};

        $text_of{$ident} = $text;

        return $self->_parse_entry;
    }

    sub learn_tag {
        my ( $self, $tag, $sigal ) = @_;
        $known_tags_of{ ident $self}{$tag} = $sigal;

        ## no critic strict
        no strict 'refs';    # Violates use strict, but allows code generation
        ## use critic

        if ( !$self->can( $tag . 's' ) ) {
            *{ $tag . 's' } = sub {
                my ($self) = @_;
                return $self->_tags($tag);
            };
        }

        if ( !$self->can( 'in_' . $tag ) ) {
            *{ 'in_' . $tag } = sub {
                my ( $self, $item ) = @_;
                return $self->_is_in( $tag . 's', $item );
            };
        }

        return $self->_parse_entry;
    }

    sub _tags {
        my ( $self, $tag ) = @_;
        my $ident = ident($self);

        my @tags;
        if ( defined $tags_of{$ident}{$tag} ) {
            @tags = sort keys %{ $tags_of{$ident}{$tag} };
        }
        return wantarray ? @tags : \@tags;
    }

    sub _is_in {
        my ( $self, $tags, $item ) = @_;
        return if !defined $item;
        foreach ( $self->$tags ) {
            return 1 if $_ eq $item;
        }
        return 0;
    }

    sub pri {
        my ( $self, $new_pri ) = @_;
        my $ident = ident($self);

        if ( $new_pri !~ /^[a-zA-Z]?$/xms ) {
            croak "Invalid priority [$new_pri]";
        }

        $priority_of{$ident} = $new_pri;

        return $self->prepend();
    }

    sub prepend {
        my ( $self, $addition ) = @_;

        my $new = $self->text;
        my @new;

        $new =~ s/$priority_completion_regex//xms;

        if ( $self->done ) {
            if ( $self->done !~ /^x/ixms ) {
                push @new, 'x';
            }
            push @new, $self->done;
        }

        if ( $self->priority ) {
            push @new, '(' . $self->priority . ')';
        }

        if ( defined $addition && length $addition ) {
            push @new, $addition;
        }

        return $self->replace( join q{ }, @new, $new );
    }

    sub append {
        my ( $self, $addition ) = @_;
        return $self->replace( join q{ }, $self->text, $addition );
    }

    ## no critic 'homonym'
    sub do {    # This is what it is called in todo.sh
        ## use critic
        my ($self) = @_;
        my $ident = ident($self);

        if ( $self->done ) {
            return 1;
        }

        $completion_status_of{$ident} = sprintf "%04d-%02d-%02d",
            ( (localtime)[5] + 1900 ),
            ( (localtime)[4] + 1 ),
            ( (localtime)[3] );

        return $self->prepend();
    }

    sub done {
        my ($self) = @_;
        return $completion_status_of{ ident($self) };
    }
    sub known_tags { my ($self) = @_; return $known_tags_of{ ident($self) }; }
    sub priority   { my ($self) = @_; return $priority_of{ ident($self) }; }
    sub text       { my ($self) = @_; return $text_of{ ident($self) }; }
    sub depri      { my ($self) = @_; return $self->pri(q{}) }

    sub DESTROY {
        my ($self) = @_;
        my $ident = ident $self;
        foreach my $attr_ref (@attr_refs) {
            delete $attr_ref->{$ident};
        }
    }
}
1;    # Magic true value required at end of module
__END__