[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.25 and 1.28

version 1.25, 2010/01/20 21:53:01 version 1.28, 2010/02/14 00:50:56
Line 1 
Line 1 
 package Text::Todo::Entry;  package Text::Todo::Entry;
   
 # $AFresh1: Entry.pm,v 1.24 2010/01/19 18:53:36 andrew Exp $  # $AFresh1: Entry.pm,v 1.27 2010/02/13 23:06:34 andrew Exp $
   
 use warnings;  use warnings;
 use strict;  use strict;
Line 8 
Line 8 
   
 use Class::Std::Utils;  use Class::Std::Utils;
   
 use version; our $VERSION = qv('0.1.0');  use version; our $VERSION = qv('0.1.1');
   
 {  {
   
Line 34 
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 41 
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} } ) {              foreach my $k ( keys %{ $options->{tags} } ) {
                 $known_tags_of{$ident}{$k} = $options->{tags}->{$k};                  $tags{$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 78 
Line 63 
         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 123 
Line 115 
         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 ) = @_;
         foreach ($self->$tags) {          return if !defined $item;
           foreach ( $self->$tags ) {
             return 1 if $_ eq $item;              return 1 if $_ eq $item;
         }          }
         return 0;          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 161 
Line 184 
         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 219 
Line 235 
   
     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 317 
Line 335 
   
 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 328 
Line 346 
   
     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 352 
Line 370 
     }      }
   
 =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.25  
changed lines
  Added in v.1.28
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>