version 1.3, 2010/01/06 19:54:56 |
version 1.6, 2010/01/09 05:15:20 |
|
|
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.5 2010/01/09 05:00:21 andrew Exp $ |
|
|
use warnings; |
use warnings; |
use strict; |
use strict; |
|
|
|
|
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 q{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; |
|
|
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 q{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} } ) { |
|
|
sub list { |
sub list { |
my ($self) = @_; |
my ($self) = @_; |
my $ident = ident($self); |
my $ident = ident($self); |
|
|
return if !$list_of{$ident}; |
return if !$list_of{$ident}; |
|
return wantarray ? @{ $list_of{$ident} } : $list_of{$ident}; |
|
} |
|
|
return $list_of{$ident}; |
sub listpri { |
|
my ($self) = @_; |
|
|
#my $id = 1; |
my @list = grep { $_->priority } $self->list; |
#my @l; |
|
#foreach my $e ( @{ $list_of{$ident} } ) { |
return wantarray ? @list : \@list; |
# 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 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; |
|
} |
} |
} |
} |
|
|
|
|
|
|
=head1 NAME |
=head1 NAME |
|
|
Text::Todo - [One line description of module's purpose here] |
Text::Todo - Perl interface to todo_txt files |
|
|
|
|
=head1 VERSION |
=head1 VERSION |
|
|
This document describes Text::Todo version 0.0.1 |
I will have to figure out how to include $VERSION in this somehow. |
|
|
|
Perhaps RCS Id is good enough? |
|
|
|
$Id$ |
|
|
=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 |
|
|
|
|
=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: |
|
|
|
|
=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. |
|
|