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

Diff for /todotxt/Text-Todo/lib/Text/Todo.pm between version 1.6 and 1.18

version 1.6, 2010/01/09 05:15:20 version 1.18, 2010/01/18 00:19:55
Line 1 
Line 1 
 package Text::Todo;  package Text::Todo;
   
 # $RedRiver: Todo.pm,v 1.5 2010/01/09 05:00:21 andrew Exp $  # $AFresh1: Todo.pm,v 1.17 2010/01/12 20:09:02 andrew Exp $
   
 use warnings;  use warnings;
 use strict;  use strict;
 use Carp;  use Carp;
   
 use Class::Std::Utils;  use Class::Std;
 use Text::Todo::Entry;  use Text::Todo::Entry;
 use File::Spec;  use File::Spec;
   
 use Data::Dumper;  
   
 use version; our $VERSION = qv('0.0.1');  use version; our $VERSION = qv('0.0.1');
   
 {  {
       my ( %path_of, %list_of, %loaded_of, ) : ATTR;
   
     my %path_of;      sub BUILD {
     my %list_of;          my ( $self, $ident, $options ) = @_;
   
     sub new {  
         my ( $class, $options ) = @_;  
   
         my $self = bless anon_scalar(), $class;  
         my $ident = ident($self);  
   
         $path_of{$ident} = {          $path_of{$ident} = {
             todo_dir    => undef,              todo_dir  => undef,
             todo_file   => 'todo.txt',              todo_file => 'todo.txt',
             done_file   => undef,              done_file => undef,
             report_file => undef,  
         };          };
   
         if ($options) {          if ($options) {
Line 39 
Line 31 
                         $self->_path_to( $opt, $options->{$opt} );                          $self->_path_to( $opt, $options->{$opt} );
                     }                      }
                     else {                      else {
                         carp "Invalid option [$opt]";  
                           #carp "Invalid option [$opt]";
                     }                      }
                 }                  }
             }              }
Line 130 
Line 123 
         my ( $self, $file ) = @_;          my ( $self, $file ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
           $loaded_of{$ident} = undef;
   
         $file = $self->file($file);          $file = $self->file($file);
   
           if ( $list_of{$ident} = $self->listfile($file) ) {
               $loaded_of{$ident} = $file;
               return 1;
           }
   
           return;
       }
   
       sub listfile {
           my ( $self, $file ) = @_;
   
           $file = $self->file($file);
   
         if ( !defined $file ) {          if ( !defined $file ) {
             croak q{todo file can't be found};              carp q{file can't be found};
               return;
         }          }
   
         if ( !-e $file ) {          if ( !-e $file ) {
             carp "todo file [$file] does not exist";              carp "file [$file] does not exist";
             return;              return;
         }          }
   
         my @list;          my @list;
         my $line = 1;  
         open my $fh, '<', $file or croak "Couldn't open [$file]: $!";          open my $fh, '<', $file or croak "Couldn't open [$file]: $!";
         while (<$fh>) {          while (<$fh>) {
             s/\r?\n$//xms;              s/\r?\n$//xms;
             push @list, Text::Todo::Entry->new($_);              push @list, Text::Todo::Entry->new({ text => $_ });
         }          }
         close $fh or croak "Couldn't close [$file]: $!";          close $fh or croak "Couldn't close [$file]: $!";
         $list_of{$ident} = \@list;  
   
         return 1;          return wantarray ? @list : \@list;
     }      }
   
     sub save {      sub save {
Line 170 
Line 177 
         }          }
         close $fh or croak "Couldn't close [$file]: $!";          close $fh or croak "Couldn't close [$file]: $!";
   
           $loaded_of{$ident} = $file;
   
         return 1;          return 1;
     }      }
   
Line 182 
Line 191 
     }      }
   
     sub listpri {      sub listpri {
         my ($self) = @_;          my ( $self, $pri ) = @_;
   
         my @list = grep { $_->priority } $self->list;          my @list;
           if ($pri) {
               $pri = uc $pri;
               if ( $pri !~ /^[A-Z]$/xms ) {
                   croak 'PRIORITY must a single letter from A to Z.';
               }
               @list = grep { defined $_->priority && $_->priority eq $pri }
                   $self->list;
           }
           else {
               @list = grep { $_->priority } $self->list;
           }
   
         return wantarray ? @list : \@list;          return wantarray ? @list : \@list;
     }      }
Line 194 
Line 214 
         my $ident = ident($self);          my $ident = ident($self);
   
         if ( !ref $entry ) {          if ( !ref $entry ) {
             $entry = Text::Todo::Entry->new($entry);              $entry = Text::Todo::Entry->new({ text => $entry });
         }          }
         elsif ( ref $entry ne 'Text::Todo::Entry' ) {          elsif ( ref $entry ne 'Text::Todo::Entry' ) {
             croak(              croak(
Line 234 
Line 254 
     }      }
   
     sub listproj {      sub listproj {
         my ( $self, $entry, $dst ) = @_;          my ($self) = @_;
           return $self->listtag('project');
       }
   
       sub listcon {
           my ($self) = @_;
           return $self->listtag('context');
       }
   
       sub listtag {
           my ( $self, $tag ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
         my %available_projects;          my $accessor = $tag . 's';
   
           my %available;
         foreach my $e ( $self->list ) {          foreach my $e ( $self->list ) {
             foreach my $p ( $e->projects ) {              foreach my $p ( $e->$accessor ) {
                 $available_projects{$p} = 1;                  $available{$p} = 1;
             }              }
         }          }
   
         my @projects = sort keys %available_projects;          my @tags = sort keys %available;
   
         return wantarray ? @projects : \@projects;          return wantarray ? @tags : \@tags;
     }      }
   
     sub archive  { carp "unsupported\n"; return }      sub archive {
     sub addto    { carp "unsupported\n"; return }          my ($self) = @_;
     sub listfile { carp "unsupported\n"; return }          my $ident = ident($self);
   
           if ( !defined $loaded_of{$ident}
               || $loaded_of{$ident} ne $self->file('todo_file') )
           {
               carp 'todo_file not loaded';
               return;
           }
   
           my $changed = 0;
       ENTRY: foreach my $e ( $self->list ) {
               if ( $e->done ) {
                   if ( $self->addto( 'done_file', $e ) && $self->del($e) ) {
                       $changed++;
                   }
                   else {
                       carp q{Couldn't archive entry [} . $e->text . ']';
                       last ENTRY;
                   }
               }
               elsif ( $e->text eq q{} ) {
                   if ( $self->del($e) ) {
                       $changed++;
                   }
                   else {
                       carp q{Couldn't delete blank entry};
                       last ENTRY;
                   }
               }
           }
   
           if ($changed) {
               $self->save;
           }
   
           return $changed;
       }
   
       sub addto {
           my ( $self, $file, $entry ) = @_;
           my $ident = ident($self);
   
           $file = $self->file($file);
           if ( !defined $file ) {
               croak q{file can't be found};
           }
   
           if ( ref $entry ) {
               if ( ref $entry eq 'Text::Todo::Entry' ) {
                   $entry = $entry->text;
               }
               else {
                   carp 'Unknown ref [' . ref($entry) . ']';
                   return;
               }
           }
   
           open my $fh, '>>', $file or croak "Couldn't open [$file]: $!";
           print {$fh} $entry, "\n"
               or croak "Couldn't print to [$file]: $!";
           close $fh or croak "Couldn't close [$file]: $!";
   
           if ( defined $loaded_of{$ident} && $file eq $loaded_of{$ident} ) {
               return $self->load($file);
           }
   
           return 1;
       }
   
     sub _find_entry_id {      sub _find_entry_id {
         my ( $self, $entry ) = @_;          my ( $self, $entry ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
Line 286 
Line 385 
   
 Text::Todo - Perl interface to todo_txt files  Text::Todo - Perl interface to todo_txt files
   
   
 =head1 VERSION  =head1 VERSION
   
 I will have to figure out how to include $VERSION in this somehow.  Since the $VERSION can't be automatically included,
   here is the RCS Id instead, you'll have to look up $VERSION.
   
 Perhaps RCS Id is good enough?  
   
     $Id$      $Id$
   
 =head1 SYNOPSIS  =head1 SYNOPSIS
   
     use Text::Todo;      use Text::Todo;
   
       my $todo = Text::Todo->new('todo/todo.txt');
   
       foreach my $e (sort { lc($_->text) cmp lc($e->text)} $todo->list) {
           print $e->text, "\n";
       }
   
   
 =head1 DESCRIPTION  =head1 DESCRIPTION
   
   This module is a basic interface to the todo.txt files as described by
   Lifehacker and extended by members of their community.
   
 For more information see L<http://todotxt.com>  For more information see L<http://todotxt.com>
   
   This module supports the 3 axes of an effective todo list.
   Priority, Project and Context.
   
   It does not support other notations or many of the more advanced features of
   the todo.sh like plugins.
   
   It should be extensible, but and hopefully will be before a 1.0 release.
   
   
 =head1 INTERFACE  =head1 INTERFACE
   
 =head2 new  =head2 BUILD
   
       new({
           [ todo_dir    => 'directory', ]
           [ todo_file   => 'filename in todo_dir', ]
           [ done_file   => 'filename in todo_dir', ]
           [ report_file => 'filename in todo_dir', ]
           });
   
   Allows you to set each item individually.  todo_file defaults to todo.txt.
   
       new({ todo_file => 'path/to/todo.txt');
   
   Automatically sets todo_dir to 'path/to', todo_file to 'todo.txt'
   
   If you what you set matches (.*)todo(.*).txt it will automatically set
   done_file to $1done$2.txt
   and
   report_file to $1report$2.txt.
   
   For example, new('todo/todo.shopping.txt') will set
   todo_dir to 'todo',
   todo_file to 'todo.shopping.txt',
   done_file to 'done.shopping.txt',
   and
   report_file to 'report.shopping.txt'.
   
   =head2 file
   
   Allows you to read the paths to the files in use.
   If as in the SYNOPSIS above you used $todo = new('todo/todo.txt').
   
       $todo_file = $todo->file('todo_file');
   
   then, $todo_file eq 'todo/todo.txt'
   
 =head2 load  =head2 load
   - Reads a list from a file into the current object.
   
   Allows you to load a different file into the object.
   
       $todo->load('done_file');
   
   This effects the other functions that act on the list.
   
 =head2 save  =head2 save
   - Writes the list to disk.
   
 =head2 file      $todo->save(['new/path/to/todo']);
   
   Either writes the current working file or the passed in argument
   that can be recognized by file().
   
   If you specify a filename it will save to that file and update the paths.
   Additional changes to the object work on that file.
   
 =head2 list  =head2 list
   - get the curently loaded list
   
       my @todo_list = $todo->list;
   
   In list context returns a list, it scalar context returns an array reference to the list.
   
   =head2 listpri
   - get the list items that are marked priority
   
   Like list, but only returns entries that have priority set.
   
       my @priority_list = $todo->listpri;
   
   Since this is so easy to write as:
   
       my @priority_list = grep { $_->priority } $todo->list;
   
   I think it may become depreciated unless there is demand.
   
   =head2 listtag
   
   Returns tags found in the list sorted by name.
   
   If there were projects +GarageSale and +Shopping then
   
       my @projects = $todo->listtag('project');
   
   is the same as
   
       @projects = ( 'GarageSale', 'Shopping' );
   
   =head2 listcon
   - Shortcut to listtag('context')
   
   =head2 listproj
   - Shortcut to listtag('project')
   
 =head2 add  =head2 add
   
 =head1 DIAGNOSTICS  Adds a new entry to the list.
   Can either be a Text::Todo::Entry object or plain text.
   
 =for author to fill in:      $todo->add('new todo entry');
     List every single error and warning message that the module can  
     generate (even the ones that will "never happen"), with a full  
     explanation of each problem, one or more likely causes, and any  
     suggested remedies.  
   
 =over  It then becomes $todo->list->[-1];
   
 =item C<< Error message here, perhaps with %s placeholders >>  =head2 del
   
 [Description of error here]  Remove an entry from the list, either the reference or by number.
   
 =item C<< Another error message here >>      $removed_entry = $todo->del($entry);
   
 [Description of error here]  $entry can either be an Text::Todo::Entry in the list or the index of the
   entry to delete.
   
 [Et cetera, et cetera]  Note that entries are 0 indexed (as expected in perl) not starting at line 1.
   
 =back  =head2 move
   
       $todo->move($entry, $new_pos);
   
   $entry can either be the number of the entry or the actual entry.
   $new_pos is the new position to put it.
   
   Note that entries are 0 indexed (as expected in perl) not starting at line 1.
   
   =head2 archive
   
       $todo->archive
   
   Iterates over the list and for each done entry,
   addto('done_file')
   and
   del($entry).
   If any were archived it will then
   save()
   and
   load().
   
   =head2 addto
   
       $todo->addto($file, $entry);
   
   Appends text to the file.
   $file can be anyting recognized by file().
   $entry can either be a Text::Todo::Entry or plain text.
   
   =head2 listfile
   
       @list = $todo->listfile($file);
   
   Read a file and returns a list like $todo->list but does not update the
   internal list that is being worked with.
   $file can be anyting recognized by file().
   
   
   =head1 DIAGNOSTICS
   
   Most methods return undef on failure.
   
   Some more important methods are fatal.
   
   
 =head1 CONFIGURATION AND ENVIRONMENT  =head1 CONFIGURATION AND ENVIRONMENT
   
 Text::Todo requires no configuration files or environment variables.  Text::Todo requires no configuration files or environment variables.
   
 Someday it should be able to read and use the todo.sh config file.  Someday it should be able to read and use the todo.sh config file.  This may
   possibly be better done in a client that would use this module.
   
   
 =head1 DEPENDENCIES  =head1 DEPENDENCIES
   
 =for author to fill in:  Class::Std
     A list of all the other modules that this module relies upon,  File::Spec
     including any restrictions on versions, and an indication whether  version
     the module is part of the standard Perl distribution, part of the  
     module's distribution, or must be installed separately. ]  
   
 None.  
   
   
 =head1 INCOMPATIBILITIES  =head1 INCOMPATIBILITIES
   
 None reported.  None reported.
Line 365 
Line 605 
 =head1 BUGS AND LIMITATIONS  =head1 BUGS AND LIMITATIONS
   
 No bugs have been reported.  No bugs have been reported.
   
   Limitations:
   
   Currently there isn't an easy way to print out line numbers with the entry.
   
 Please report any bugs or feature requests to  Please report any bugs or feature requests to
 C<bug-text-todo@rt.cpan.org>, or through the web interface at  C<bug-text-todo@rt.cpan.org>, or through the web interface at
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>