[BACK]Return to Entry.pm CVS log [TXT][DIR] Up to [local] / todotxt / Text-Todo / lib / Text / Todo

Diff for /todotxt/Text-Todo/lib/Text/Todo/Entry.pm between version 1.24 and 1.30

version 1.24, 2010/01/19 18:53:36 version 1.30, 2010/02/16 01:13:12
Line 1 
Line 1 
 package Text::Todo::Entry;  package Text::Todo::Entry;
   
 # $AFresh1: Entry.pm,v 1.23 2010/01/18 03:04:48 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.1.0');  use version; our $VERSION = qv('0.2.0');
   
 {  {
   
Line 35 
Line 34 
         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 };
         }          }
Line 42 
Line 43 
             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} );
Line 79 
Line 61 
         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;
   
Line 124 
Line 113 
         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);
Line 159 
Line 182 
         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 ) = @_;
   
Line 217 
Line 233 
   
     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 {      sub DESTROY {
         my ($self) = @_;          my ($self) = @_;
Line 315 
Line 333 
   
 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.
   
Line 326 
Line 344 
   
     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:
   
Line 350 
Line 368 
     }      }
   
 =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
   
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.30
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>