File Coverage

blib/lib/App/TimelogTxt.pm

Criterion	Covered	Total	%
statement	38	230	16.5
branch	1	60	1.6
condition	0	32	0.0
subroutine	13	44	29.5
pod	16	16	100.0
total	68	382	17.8

package App::TimelogTxt;

use warnings;
use strict;
use 5.010;

use autodie;
use App::CmdDispatch;
use Getopt::Long qw(:config posix_default);
use App::TimelogTxt::Utils;
use App::TimelogTxt::Day;
use App::TimelogTxt::File;
use App::TimelogTxt::Event;

our $VERSION = '0.22';

# Initial configuration information.
my %config = (
    editor => '',
    dir    => '',
    defcmd => '',
);

my $config_file =  _normalize_path( '~/.timelogrc' );

# Dispatch table for commands
my %commands = (
    'start' => {
        code     => \&start_event,
        clue     => 'start {event description}',
        abstract => 'Start timing a new event.',
        help     => 'Stop the current event and start timing a new event.',
    },
    App::TimelogTxt::Utils::STOP_CMD() => {
        code => sub { my $app = shift; log_event( $app, App::TimelogTxt::Utils::STOP_CMD() ); },
        clue => App::TimelogTxt::Utils::STOP_CMD(),
        abstract => 'Stop timing the current event.',
        help     => 'Stop timing the current event.',
    },
    'init' => {
        code     => \&init_timelog,
        clue     => 'init [directory]',
        abstract => 'Create the timelog directory and configuration.',
        help     => 'Create the directory and configuration file used by timelog
if they do not already exist.',
    },
    'push' => {
        code     => \&push_event,
        clue     => 'push {event description}',
        abstract => 'Save the current event and start timing new.',
        help     => 'Save the current event on stack and start timing new event.',
    },
    'pop' => {
        code     => \&pop_event,
        clue     => 'pop',
        abstract => 'Return to last pushed event.',
        help     => 'Stop last event and restart top event on stack.',
    },
    'drop' => {
        code     => \&drop_event,
        clue     => 'drop [all|{n}]',
        abstract => 'Drop items from stack.',
        help     => 'Drop one or more events from top of event stack, or all
if argument supplied.',
    },
    'ls' => {
        code     => \&list_events,
        clue     => 'ls [date]',
        abstract => 'List events.',
        help     => 'List events for the specified day. Default to today.',
    },
    'lsproj' => {
        code     => \&list_projects,
        clue     => 'lsproj',
        abstract => 'List known projects.',
        help     => 'List known projects.',
    },
    'lstk' => {
        code     => \&list_stack,
        clue     => 'lstk',
        abstract => 'Display items on the stack.',
        help     => 'Display items on the stack.',
    },
    'edit' => {
        code     => \&edit_logfile,
        clue     => 'edit',
        abstract => 'Edit the timelog file.',
        help     => 'Open the timelog file in the current editor',
    },
    'report' => {
        code     => \&daily_report,
        clue     => 'report [date [end date]] [project regexes]',
        abstract => 'Task report.',
        help     => 'Display a report for the specified days and projects.',
    },
    'summary' => {
        code     => \&daily_summary,
        clue     => 'summary [date [end date]] [project regexes]',
        abstract => 'Short summary report.',
        help     => q{Display a summary of the appropriate days' projects.},
    },
    'hours' => {
        code     => \&report_hours,
        clue     => 'hours [date [end date]] [project regexes]',
        abstract => 'Hours report.',
        help     => q{Display the hours worked for each of the appropriate days
and projects.},
    },
    'curr' => {
        code     => \¤t_event,
        clue     => 'curr',
        abstract => 'Display current event.',
        help     => q{Display the current event (if any) and the time since the
event started.},
    },
);

# Sub class of App::CmdDispatch that initializes configuration information
# specific to this program. It also provides access to that configuration.
{
    package Timelog::CmdDispatch;
    use base 'App::CmdDispatch';

    sub new
    {
        my $self = App::CmdDispatch::new( @_ );
        $self->init();
        $self->{_timelog_out_fh} = \*STDOUT;
        return $self;
    }

    sub _logfile   { return $_[0]->get_config()->{'logfile'}; }
    sub _stackfile { return $_[0]->get_config()->{'stackfile'}; }
    sub _out_fh    { return $_[0]->{_timelog_out_fh}; }

    # Support injection of an output filehandle for testing.
    sub _set_out_fh { return $_[0]->{_timelog_out_fh} = $_[1]; }

    sub init
    {
        my ($self) = @_;
        my $config = $self->get_config();

        $config->{editor} ||= $config{editor} || $ENV{'VISUAL'} || $ENV{'EDITOR'} || 'vim';
        $config->{dir}    ||= $config{dir} || App::TimelogTxt::_normalize_path( '~/timelog' );
        $config->{defcmd} ||= $config{defcmd} || App::TimelogTxt::Utils::STOP_CMD();
        $config->{dir} = App::TimelogTxt::_normalize_path( $config->{'dir'} );
        foreach my $d ( [qw/logfile timelog.txt/], [qw/stackfile stack.txt/] )
        {
            $config->{ $d->[0] } = "$config->{'dir'}/$d->[1]";
        }
        return;
    }

}

sub run
{
    GetOptions(
        "dir=s"    => \$config{'dir'},
        "editor=s" => \$config{'editor'},
        "conf=s"   => \$config_file,
    );

    my $options = {
        config           => (-f $config_file ? $config_file : undef),
        default_commands => 'help shell',
        'help:post_hint' =>
            "\nwhere [date] is an optional string specifying a date of the form YYYY-MM-DD
or a day name: yesterday, today, or sunday .. saturday and [project regexes]
is a list of strings of regular expressions matching project names.\n",
        'help:post_help' =>
            "\nwhere [date] is an optional string specifying a date of the form YYYY-MM-DD
or a day name: yesterday, today, or sunday .. saturday and [project regexes]
is a list of strings of regular expressions matching project names.\n",
    };
    my $app = Timelog::CmdDispatch->new( \%commands, $options );

    # Handle default command if none specified
    @ARGV = split / /, $app->get_config()->{'defcmd'} unless @ARGV;

    $app->run( @ARGV );

    return;
}

# Command handlers

sub init_timelog
{
    my ($app, $dir) = @_;
    require File::Path;
    my $config = $app->get_config();
    $dir //= $config->{'dir'};
    $dir = _normalize_path( $dir );
    File::Path::mkpath( $dir ) unless -d $dir;
    unless( -f $config_file )
    {
        open my $fh, '>', $config_file;
        # don't supply the editor value, default to the environment
        print {$fh} <<"EOF";
dir=$dir
defcmd=$config->{defcmd}

[alias]
EOF
    }
    print "timelog initialized\n";
    return;
}

sub log_event
{
    my $app    = shift;
    my $task = "@_";
    if( App::TimelogTxt::Utils::is_stop_cmd( $task ) || App::TimelogTxt::Utils::has_project( $task ) )
    {
        open my $fh, '>>', $app->_logfile;
        my $event = App::TimelogTxt::Event->new( $task, time );
        print {$fh} $event->to_string, "\n";
    }
    else
    {
        die "Event has no project.\n";
    }
    return;
}

sub edit_logfile
{
    my ( $app ) = @_;
    system $app->get_config()->{'editor'}, $app->_logfile;
    return;
}

sub list_events
{
    my ( $app, $day ) = @_;
    my $stamp = App::TimelogTxt::Utils::day_stamp( $day );

    _each_logline( $app, sub { print if 0 == index $_, $stamp; } );
    return;
}

sub list_projects
{
    my ( $app ) = @_;
    my %projects;
    _each_logline(
        $app,
        sub {
            my ( @projs ) = m/\+(\S+)/g;
            @projects{@projs} = ( 1 ) x @projs if @projs;
        }
    );
    print "$_\n" foreach sort keys %projects;
    return;
}

sub daily_report
{
    my ( $app, @filters ) = @_;

    my $summaries = extract_day_tasks( $app, @filters );

    foreach my $summary ( @{$summaries} )
    {
        $summary->print_day_detail( $app->_out_fh );
    }
    return;
}

sub daily_summary
{
    my ( $app, @filters ) = @_;

    my $summaries = extract_day_tasks( $app, @filters );

    foreach my $summary ( @{$summaries} )
    {
        $summary->print_day_summary( $app->_out_fh );
    }
    return;
}

sub report_hours
{
    my ( $app, @filters ) = @_;

    my $summaries = extract_day_tasks( $app, @filters );

    foreach my $summary ( @{$summaries} )
    {
        $summary->print_hours( $app->_out_fh );
    }
    return;
}

sub start_event
{
    my ( $app, @event ) = @_;
    log_event( $app, @event );
    return;
}

sub push_event
{
    my ( $app, @event ) = @_;
    my $stack = _stack( $app );
    $stack->push( _get_last_event( $app ) );
    log_event( $app, @event );
    return;
}

sub pop_event
{
    my ( $app ) = @_;
    return unless -f $app->_stackfile;
    my $stack = _stack( $app );
    my $event = $stack->pop;
    die "Event stack is empty.\n" unless $event;
    log_event( $app, $event );
    return;
}

sub drop_event
{
    my ( $app, $arg ) = @_;
    return unless -f $app->_stackfile;
    my $stack = _stack( $app );
    $stack->drop( $arg );
    return;
}

sub list_stack
{
    my ($app) = @_;
    return unless -f $app->_stackfile;
    my $stack = _stack( $app );
    $stack->list( $app->_out_fh );
    return;
}

sub current_event
{
    my ($app) = @_;
    my $fh = $app->_out_fh;

    my $event = _get_last_full_event( $app );
    if( $event->is_stop )
    {
        print {$fh} "Not in event.\n";
        return;
    }

    # Use day summary object to get duration and to report.
    my $summary = App::TimelogTxt::Day->new( $event->stamp );
    $summary->start_task( $event );
    $summary->update_dur( $event, time );

    print {$fh} $event->to_string, "\nDuration: ";
    $summary->print_duration( $fh );

    return;
}

# Extract the daily events from the timelog.txt file and generate the list of Day
# objects that encapsulates them.

sub extract_day_tasks
{
    my ( $app, @args ) = @_;

    my ($stamp, $estamp, $pstamp, @filters) = _process_extraction_args( @args );
    my ( $summary, $last, @summaries );
    my $prev_stamp = '';

    open my $fh, '<', $app->_logfile;
    my $file = App::TimelogTxt::File->new( $fh, $pstamp, $estamp );

    while( defined( my $line = $file->readline ) )
    {
        my $event;
        eval {
            $event = App::TimelogTxt::Event->new_from_line( $line );
        } or next;
        if( $prev_stamp ne $event->stamp )
        {
            my $new_stamp = $event->stamp;
            my $new_summary = App::TimelogTxt::Day->new( $new_stamp );
            if( $summary and !$summary->is_complete() )
            {
                $summary->close_day( $last );
                # Need to build a new last item beginning at midnight for the
                # Previous event.
                my $start = $summary->day_end()+1;
                $last = App::TimelogTxt::Event->new( $last->task(), $start );
                $new_summary->start_task( $last );
            }
            $summary = $new_summary;
            push @summaries, $summary;
            $prev_stamp = $new_stamp;
        }
        $summary->update_dur( $last, $event->epoch );
        $summary->start_task( $event );
        $last = ($event->is_stop() ? undef : $event );
    }

    # If the first summary is the day before we were supposed to report,
    #   drop it.
    shift @summaries if @summaries && $summaries[0]->date_stamp() eq $pstamp;

    return [] unless $summary;
    my $end_time;
    if( $summary->is_complete() )
    {
        $summary->update_dur( $last, $end_time );
    }
    else
    {
        my $datestamp = $summary->date_stamp() || $stamp;
        if( App::TimelogTxt::Utils::is_today( $datestamp ) )
        {
            $end_time = time;
            $summary->update_dur( $last, $end_time );
        }
        else
        {
            $summary->close_day( $last );
            $end_time = App::TimelogTxt::Utils::stamp_to_localtime( $datestamp );
        }
    }

    return if $summary->is_empty;

    return _filter_summaries( \@filters, \@summaries );
}

sub _filter_summaries
{
    my ( $filters, $summaries ) = @_;

    return $summaries unless @{$filters};

    my $filter = join( '|', map { "(?:$_)" } @{$filters} );
    my $filter_re = qr/$filter/;
    return [
        grep { $_->has_tasks }
        map { $_->day_filtered_by_project( $filter_re ) }
        @{$summaries}
    ];
}

sub _process_extraction_args
{
    my ($day, @args) = @_;

    # First argument is always the day
    my $stamp = App::TimelogTxt::Utils::day_stamp( $day );
    die "No day provided.\n" unless defined $stamp;
    my $eday = shift @args;
    my $estamp = App::TimelogTxt::Utils::day_end( $eday ? App::TimelogTxt::Utils::day_stamp( $eday ) : $stamp );
    if( !defined $estamp )
    {
        $estamp = App::TimelogTxt::Utils::day_end( $stamp );
        unshift @args, $eday if $eday;
    }

    # I need to start one day before to deal with the possibility that first
    #   task was held over midnight.
    my $pstamp = App::TimelogTxt::Utils::prev_stamp( $stamp );

    return ($stamp, $estamp, $pstamp, @args);
}

# Utility functions

# Find user's home directory
sub _home
{
    return $ENV{HOME} if defined $ENV{HOME};
    if( $^O eq 'MSWin32' )
    {
        return "$ENV{HOMEDRIVE}$ENV{HOMEPATH}" if defined $ENV{HOMEPATH};
        return $ENV{USERPROFILE} if defined $ENV{USERPROFILE};
    }
    return '/';
}

# Resolve ~ notation and convert to an absolute path.
sub _normalize_path
{
    my ($path) = @_;

    my $home = _home();
    $path =~ s/~/$home/;

    return $path;
}

sub _each_logline
{
    my ( $app, $code ) = @_;
    open my $fh, '<', $app->_logfile;
    $code->() while( <$fh> );
    return;
}

sub _stack
{
    my ($app) = @_;
    require App::TimelogTxt::Stack;
    return App::TimelogTxt::Stack->new( $app->_stackfile );
}

sub _get_last_full_event
{
    my ( $app ) = @_;
    my $event_line;
    _each_logline( $app, sub { $event_line = $_; } );
    return App::TimelogTxt::Event->new_from_line( $event_line );
}

sub _get_last_event
{
    my $event = _get_last_full_event( @_ );

    return $event->task;
}

1;
__END__