version 1.20, 2010/01/12 20:09:02 |
version 1.30, 2010/02/16 01:13:12 |
|
|
package Text::Todo::Entry; |
package Text::Todo::Entry; |
|
|
# $AFresh1: Entry.pm,v 1.19 2010/01/11 19:52:06 andrew Exp $ |
# $AFresh1: Entry.pm,v 1.29 2010/02/14 06:08:07 andrew Exp $ |
|
|
use warnings; |
use warnings; |
use strict; |
use strict; |
use Carp; |
use Carp; |
|
|
use Class::Std::Utils; |
use Class::Std::Utils; |
use List::Util qw/ first /; |
|
|
|
use version; our $VERSION = qv('0.0.1'); |
use version; our $VERSION = qv('0.2.0'); |
|
|
{ |
{ |
my %text_of; |
|
|
|
my %tags_of; |
my @attr_refs = \( |
my %priority_of; |
my %text_of, |
my %completion_status_of; |
|
my %known_tags_of; |
|
|
|
|
my %tags_of, |
|
my %priority_of, |
|
my %completion_status_of, |
|
my %known_tags_of, |
|
); |
|
|
# XXX Should the completion (x) be case sensitive? |
# XXX Should the completion (x) be case sensitive? |
my $priority_completion_regex = qr{ |
my $priority_completion_regex = qr{ |
^ \s* |
^ \s* |
|
|
my $self = bless anon_scalar(), $class; |
my $self = bless anon_scalar(), $class; |
my $ident = ident($self); |
my $ident = ident($self); |
|
|
|
$text_of{$ident} = q{}; |
|
|
if ( !ref $options ) { |
if ( !ref $options ) { |
$options = { text => $options }; |
$options = { text => $options }; |
} |
} |
|
|
croak 'Invalid parameter passed!'; |
croak 'Invalid parameter passed!'; |
} |
} |
|
|
$known_tags_of{$ident} = { |
my %tags = ( |
context => q{@}, |
context => q{@}, |
project => q{+}, |
project => q{+}, |
}; |
); |
|
|
if ( exists $options->{tags} && ref $options->{tags} eq 'HASH' ) { |
if ( exists $options->{tags} && ref $options->{tags} eq 'HASH' ) { |
foreach my $k ( keys %{ $options->{tags} } ) { |
%tags = ( %tags, %{ $options->{tags} } ); |
$known_tags_of{$ident}{$k} = $options->{tags}->{$k}; |
|
} |
|
} |
} |
|
|
for my $tag ( keys %{ $known_tags_of{$ident} } ) { |
for my $tag ( keys %tags ) { |
## no critic strict |
$self->learn_tag( $tag, $tags{$tag} ); |
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 ); |
|
}; |
|
} |
|
} |
} |
|
|
$self->replace( $options->{text} ); |
$self->replace( $options->{text} ); |
|
|
return $self; |
return $self; |
} |
} |
|
|
sub replace { |
sub _parse_entry { |
my ( $self, $text ) = @_; |
my ($self) = @_; |
my $ident = ident($self); |
my $ident = ident($self); |
|
|
$text = defined $text ? $text : q{}; |
delete $tags_of{$ident}; |
|
delete $completion_status_of{$ident}; |
|
delete $priority_of{$ident}; |
|
|
$text_of{$ident} = $text; |
my $text = $self->text || q{}; |
|
my $known_tags = $self->known_tags || {}; |
|
|
foreach my $tag ( keys %{ $known_tags_of{$ident} } ) { |
foreach my $tag ( keys %{$known_tags} ) { |
my $symbol = quotemeta $known_tags_of{$ident}{$tag}; |
next if !defined $known_tags->{$tag}; |
$tags_of{$ident}{$tag} = { map { $_ => q{} } |
next if !length $known_tags->{$tag}; |
$text =~ / (?:^|\s) $symbol (\S*)/gxms }; |
|
|
my $sigal = quotemeta $known_tags->{$tag}; |
|
$tags_of{$ident}{$tag} |
|
= { map { $_ => q{} } $text =~ / (?:^|\s) $sigal (\S*)/gxms }; |
} |
} |
|
|
my ( $completed, $priority ) |
my ( $completed, $priority ) |
= $text =~ / $priority_completion_regex /xms; |
= $text =~ / $priority_completion_regex /xms; |
|
|
|
|
return; |
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 { |
sub _tags { |
my ( $self, $tag ) = @_; |
my ( $self, $tag ) = @_; |
my $ident = ident($self); |
my $ident = ident($self); |
|
|
my @tags = sort keys %{ $tags_of{$ident}{$tag} }; |
my @tags; |
|
if ( defined $tags_of{$ident}{$tag} ) { |
|
@tags = sort keys %{ $tags_of{$ident}{$tag} }; |
|
} |
return wantarray ? @tags : \@tags; |
return wantarray ? @tags : \@tags; |
} |
} |
|
|
sub _is_in { |
sub _is_in { |
my ( $self, $tags, $item ) = @_; |
my ( $self, $tags, $item ) = @_; |
return defined first { $_ eq $item } $self->$tags; |
return if !defined $item; |
|
foreach ( $self->$tags ) { |
|
return 1 if $_ eq $item; |
|
} |
|
return 0; |
} |
} |
|
|
sub text { |
|
my ($self) = @_; |
|
my $ident = ident($self); |
|
|
|
return $text_of{$ident}; |
|
} |
|
|
|
sub depri { my ($self) = @_; return $self->pri(q{}) } |
|
|
|
sub pri { |
sub pri { |
my ( $self, $new_pri ) = @_; |
my ( $self, $new_pri ) = @_; |
my $ident = ident($self); |
my $ident = ident($self); |
|
|
return $self->prepend(); |
return $self->prepend(); |
} |
} |
|
|
sub priority { |
|
my ( $self, $new_pri ) = @_; |
|
my $ident = ident($self); |
|
|
|
return $priority_of{$ident}; |
|
} |
|
|
|
sub prepend { |
sub prepend { |
my ( $self, $addition ) = @_; |
my ( $self, $addition ) = @_; |
|
|
|
|
|
|
sub done { |
sub done { |
my ($self) = @_; |
my ($self) = @_; |
my $ident = ident($self); |
return $completion_status_of{ ident($self) }; |
|
|
return $completion_status_of{$ident}; |
|
} |
} |
|
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 |
1; # Magic true value required at end of module |
__END__ |
__END__ |
|
|
|
|
Each tag type generates two accessor functions {tag}s and in_{tag}. |
Each tag type generates two accessor functions {tag}s and in_{tag}. |
|
|
Current tags are context (@) and project (+). |
Default tags are context (@) and project (+). |
|
|
When creating a new object you can pass in new tags to recognize. |
When creating a new object you can pass in new tags to recognize. |
|
|
|
|
|
|
my @due_dates = $entry->due_dates; |
my @due_dates = $entry->due_dates; |
|
|
then @due_dates eq ( '2011-01-01' ); |
then @due_dates is ( '2011-01-01' ); |
|
|
and you could also: |
and you could also: |
|
|
|
|
} |
} |
|
|
=back |
=back |
|
|
|
=head2 learn_tag($tag, $sigal) |
|
|
|
$entry->learn_tag('due_date', 'DUE:'); |
|
|
|
Teaches the entry about an additional tag, same as passing a tags argument to |
|
new(). See tags() |
|
|
|
You can simulate forgetting a tag by setting the sigal to undef or an empty |
|
string. |
|
|
|
=head2 known_tags |
|
|
|
$known_tags = $entry->known_tags; |
|
|
|
$known_tags by default would be: |
|
|
|
{ context => '@', |
|
project => '+', |
|
} |
|
|
|
|
=head3 context |
=head3 context |
|
|