Term::ProgressBar may be of interest.

The "twirling baton" is another simple progress indicator that may be more suited to large jobs with indeterminate ends. Here's a simple implementation that I wrote years ago, long before even finding this site:

BEGIN {
  my @chars=('-','\\','|','/','-','\\','|','/');
  my $step=0;
  sub baton_start { $step=0 ; goto &baton_step }
  sub baton_step { print STDERR $chars[$step++],"\b";
                  $step=0 if $step >=8 }
  sub baton_end { print STDERR "\b "; }
}
[download]

I have used this in many one-off scripts and I generally just copy and paste it when needed, since it is so simple.

Not on windows you havent :) \r\r\r\r\r\r\r\r\r\r\r\r

You are correct about that; none of my personal stuff has been on Windows for over a decade now. Come to think of it, none of the "heavy lifting" at $WORK has been on Windows either.

I presume the builtin Windows excuse for a terminal emulator does not properly handle ASCII backspace and overwrite? Have you tried rxvt or other ports of X11-native terminal emulators that actually work? There is even a MinGW X server if I recall correctly, so you could use xterm on Windows. :)

Out of curiosity, how will you know the file count ahead of time so that you can present a meaningful progress bar?

Hi there. Its not important; and just another distraction waiting for the system to work out initial state. Thats why I simply printed a contiguous series of dots - the user knows each dot is file progress (also I add a directory print each time one of those is deleted).

Fair enough, so you need a sort of "I'm still doing something" row of dots that emerges as work progresses.

It's a little unfortunate how File::Copy::Recursive implements recursion in dircopy. I mean it works great, but it's hard to hook into. However, the dircopy subroutine calls fcopy which is easier to wrap. So this seems to work as I had hoped:

#!/usr/bin/env perl

use strict;
use warnings;
use File::Copy::Recursive qw(dircopy);
use Hook::WrapSub qw(wrap_subs);
use IO::Handle;

sub after_dircopy {
    print '.';
    STDOUT->flush;
}

wrap_subs sub {},
          'File::Copy::Recursive::fcopy',
          \&after_dircopy;

dircopy('/tmp/test1', '/tmp/test2');
print "\n";
[download]

I'm wrapping the fcopy function, which dircopy calls by adding a sub that fires off after each fcopy call. The wrapper prints a dot and flushes STDOUT.

One warning: This depends on an implementation detail of dircopy. There are no guarantees the module's author couldn't change how dircopy works, rendering this broken.




Dave