[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.3 and 1.5

version 1.3, 2010/01/06 19:54:56 version 1.5, 2010/01/09 05:00:21
Line 1 
Line 1 
 package Text::Todo;  package Text::Todo;
   
 # $RedRiver: Todo.pm,v 1.2 2009/07/10 22:26:14 andrew Exp $  # $RedRiver: Todo.pm,v 1.4 2010/01/06 20:07:16 andrew Exp $
   
 use warnings;  use warnings;
 use strict;  use strict;
Line 8 
Line 8 
   
 use Class::Std::Utils;  use Class::Std::Utils;
 use Text::Todo::Entry;  use Text::Todo::Entry;
   use File::Spec;
   
   use Data::Dumper;
   
 use version; our $VERSION = qv('0.0.1');  use version; our $VERSION = qv('0.0.1');
   
 {  {
   
     my %file_of;      my %path_of;
     my %list_of;      my %list_of;
   
     sub new {      sub new {
         my ( $class, $file ) = @_;          my ( $class, $options ) = @_;
   
         my $self = bless anon_scalar(), $class;          my $self = bless anon_scalar(), $class;
         my $ident = ident($self);          my $ident = ident($self);
   
         if ($file) { $self->load($file); }          $path_of{$ident} = {
               todo_dir    => undef,
               todo_file   => 'todo.txt',
               done_file   => undef,
               report_file => undef,
           };
   
           if ($options) {
               if ( ref $options eq 'HASH' ) {
                   foreach my $opt ( keys %{$options} ) {
                       if ( exists $path_of{$ident}{$opt} ) {
                           $self->_path_to( $opt, $options->{$opt} );
                       }
                       else {
                           carp "Invalid option [$opt]";
                       }
                   }
               }
               else {
                   if ( -d $options ) {
                       $self->_path_to( 'todo_dir', $options );
                   }
                   elsif ( $options =~ /\.txt$/ixms ) {
                       $self->_path_to( 'todo_file', $options );
                   }
                   else {
                       carp "Unknown options [$options]";
                   }
               }
           }
   
           my $file = $self->_path_to('todo_file');
           if ( defined $file && -e $file ) {
               $self->load();
           }
   
         return $self;          return $self;
     }      }
   
       sub _path_to {
           my ( $self, $type, $path ) = @_;
           my $ident = ident($self);
   
           if ( $type eq 'todo_dir' ) {
               if ($path) {
                   $path_of{$ident}{$type} = $path;
               }
               return $path_of{$ident}{$type};
           }
   
           if ($path) {
               my ( $volume, $directories, $file )
                   = File::Spec->splitpath($path);
               $path_of{$ident}{$type} = $file;
   
               if ($volume) {
                   $directories = File::Spec->catdir( $volume, $directories );
               }
   
               # XXX Should we save complete paths to each file, mebbe only if
               # the dirs are different?
               if ($directories) {
                   $path_of{$ident}{todo_dir} = $directories;
               }
           }
   
           if ( $type =~ /(todo|done|report)_file/xms ) {
               if ( my ( $pre, $post )
                   = $path_of{$ident}{$type} =~ /^(.*)$1(.*)\.txt$/ixms )
               {
                   foreach my $f qw( todo done report ) {
                       if ( !defined $path_of{$ident}{ $f . '_file' } ) {
                           $path_of{$ident}{ $f . '_file' }
                               = $pre . $f . $post . '.txt';
                       }
                   }
               }
           }
   
           if ( defined $path_of{$ident}{todo_dir} ) {
               return File::Spec->catfile( $path_of{$ident}{todo_dir},
                   $path_of{$ident}{$type} );
           }
   
           return;
       }
   
     sub file {      sub file {
         my ( $self, $file ) = @_;          my ( $self, $file ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
         if ($file) {          if ( defined $file && exists $path_of{$ident}{$file} ) {
             $file_of{$ident} = $file;              $file = $self->_path_to($file);
         }          }
           else {
               $file = $self->_path_to( 'todo_file', $file );
           }
   
         return $file_of{$ident};          return $file;
     }      }
   
     sub load {      sub load {
         my ( $self, $file ) = @_;          my ( $self, $file ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
         $file = $self->file($file) || croak 'load requires a filename';          $file = $self->file($file);
   
           if ( !defined $file ) {
               croak "todo file can't be found";
           }
   
           if ( !-e $file ) {
               carp "todo file [$file] does not exist";
               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;
Line 60 
Line 158 
         my ( $self, $file ) = @_;          my ( $self, $file ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
         $file = $self->file($file) || croak 'save requires a filename';          $file = $self->file($file);
           if ( !defined $file ) {
               croak "todo file can't be found";
           }
   
         open my $fh, '>', $file or croak "Couldn't open [$file]: $!";          open my $fh, '>', $file or croak "Couldn't open [$file]: $!";
         foreach my $e ( @{ $list_of{$ident} } ) {          foreach my $e ( @{ $list_of{$ident} } ) {
Line 77 
Line 178 
         my $ident = ident($self);          my $ident = ident($self);
         return if !$list_of{$ident};          return if !$list_of{$ident};
   
         return $list_of{$ident};          my @list = @{ $list_of{$ident} };
   
         #my $id = 1;          return wantarray ? @list : \@list;
         #my @l;  
         #foreach my $e ( @{ $list_of{$ident} } ) {  
         #    push @l, $e; #{ %{$e}, id => $id };  
         #    $id++;  
         #}  
         #  
         #my @list = sort { $a->priority cmp $b->priority }  
         #    grep { defined $_->priority } @l;  
         #  
         #push @list, grep { !defined $_->priority } @l;  
         #  
         #return \@list;  
     }      }
   
       sub listpri {
           my ($self) = @_;
   
           my @list = grep { $_->priority } $self->list;
   
           return wantarray ? @list : \@list;
       }
   
     sub add {      sub add {
         my ( $self, $entry ) = @_;          my ( $self, $entry ) = @_;
         my $ident = ident($self);          my $ident = ident($self);
   
           if ( !ref $entry ) {
               $entry = Text::Todo::Entry->new($entry);
           }
           elsif ( ref $entry ne 'Text::Todo::Entry' ) {
               croak(
                   'entry is a ' . ref($entry) . ' not a Text::Todo::Entry!' );
           }
   
           push @{ $list_of{$ident} }, $entry;
   
           return $entry;
       }
   
       sub del {
           my ( $self, $src ) = @_;
           my $ident = ident($self);
   
           my $id  = $self->_find_entry_id($src);
   
           my @list = $self->list;
           my $entry = splice( @list, $id, 1 );
           $list_of{$ident} = \@list;
   
           return $entry;
       }
   
       sub move {
           my ( $self, $entry, $dst ) = @_;
           my $ident = ident($self);
   
           my $src  = $self->_find_entry_id($entry);
           my @list = $self->list;
   
           splice( @list, $dst, 0, splice( @list, $src, 1 ) );
   
           $list_of{$ident} = \@list;
   
           return 1;
       }
   
       sub listproj {
           my ( $self, $entry, $dst ) = @_;
           my $ident = ident($self);
   
           my %available_projects;
           foreach my $e ($self->list) {
               foreach my $p ( $e->projects ) {
                   $available_projects{$p} = 1;
               }
           }
   
           my @projects = sort keys %available_projects;
   
           return wantarray ? @projects : \@projects;
       }
   
       sub archive  { carp "unsupported\n", return }
   
       sub addto    { carp "unsupported\n", return }
       sub listfile { carp "unsupported\n", return }
   
       sub _find_entry_id {
           my ( $self, $entry ) = @_;
           my $ident = ident($self);
   
         if ( ref $entry ) {          if ( ref $entry ) {
             if ( ref $entry ne 'Text::Todo::Entry' ) {              if ( ref $entry ne 'Text::Todo::Entry' ) {
                 croak(    'entry is a '                  croak(    'entry is a '
                         . ref($entry)                          . ref($entry)
                         . ' not a Text::Todo::Entry!' );                          . ' not a Text::Todo::Entry!' );
             }              }
   
               my @list = $self->list;
               foreach my $id ( 0 .. $#list ) {
                   if ( $list[$id] eq $entry ) {
                       return $id;
                   }
               }
         }          }
         else {          elsif ( $entry =~ /^\d+$/xms ) {
             $entry = Text::Todo::Entry->new($entry);              return $entry;
         }          }
   
         push @{ $list_of{$ident} }, $entry;          croak "Invalid entry [$entry]!";
   
         return $entry;  
     }      }
 }  }
   
Line 120 
Line 287 
   
 =head1 NAME  =head1 NAME
   
 Text::Todo - [One line description of module's purpose here]  Text::Todo - Perl interface to todo_txt files
   
   
 =head1 VERSION  
   
 This document describes Text::Todo version 0.0.1  
   
   
 =head1 SYNOPSIS  =head1 SYNOPSIS
   
     use Text::Todo;      use Text::Todo;
   
 =for author to fill in:  
     Brief code example(s) here showing commonest usage(s).  
     This section will be as far as many users bother reading  
     so make it as educational and exeplary as possible.  
   
   
 =head1 DESCRIPTION  =head1 DESCRIPTION
   
 =for author to fill in:  For more information see L<http://todotxt.com>
     Write a full description of the module and its features here.  
     Use subsections (=head2, =head3) as appropriate.  
   
   
 =head1 INTERFACE  =head1 INTERFACE
   
 =for author to fill in:  
     Write a separate section listing the public components of the modules  
     interface. These normally consist of either subroutines that may be  
     exported, or methods that may be called on objects belonging to the  
     classes provided by the module.  
   
 =head2 new  =head2 new
   
 =head2 load  =head2 load
Line 190 
Line 337 
   
 =head1 CONFIGURATION AND ENVIRONMENT  =head1 CONFIGURATION AND ENVIRONMENT
   
 =for author to fill in:  
     A full explanation of any configuration system(s) used by the  
     module, including the names and locations of any configuration  
     files, and the meaning of any environment variables or properties  
     that can be set. These descriptions must also include details of any  
     configuration language used.  
   
 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.
   
   
 =head1 DEPENDENCIES  =head1 DEPENDENCIES
   
 =for author to fill in:  =for author to fill in:
Line 213 
Line 355 
   
 =head1 INCOMPATIBILITIES  =head1 INCOMPATIBILITIES
   
 =for author to fill in:  
     A list of any modules that this module cannot be used in conjunction  
     with. This may be due to name conflicts in the interface, or  
     competition for system or program resources, or due to internal  
     limitations of Perl (for example, many modules that use source code  
     filters are mutually incompatible).  
   
 None reported.  None reported.
   
   
 =head1 BUGS AND LIMITATIONS  =head1 BUGS AND LIMITATIONS
   
 =for author to fill in:  
     A list of known problems with the module, together with some  
     indication Whether they are likely to be fixed in an upcoming  
     release. Also a list of restrictions on the features the module  
     does provide: data types that cannot be handled, performance issues  
     and the circumstances in which they may arise, practical  
     limitations on the size of data sets, special cases that are not  
     (yet) handled, etc.  
   
 No bugs have been reported.  No bugs have been reported.
   
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>