Re: Re: Useful addition to Perl?

[hardburn]

Personally, I think it should be named simply 'R.pm', since its primary use is directly on the command line:

perl -MR -ne 'print if _____'

I would normally say that one-letter modules are a bad thing, but the special-purpose use of this one makes it an exception, IMHO.

[etcshadow]

Actually, I started this, myself, a while ago... only (in order to avoid certain baddnesses of blowing up @ARGV to impossibly stupidly large proportions) it went a little more like this:

package r;
use strict;
use File::Spec;

tie @ARGV, 'r::Tie::RecursiveARGVArray', @ARGV;

sub import {
}


package r::Tie::RecursiveARGVArray;
use Tie::Array;
use base 'Tie::StdArray';

sub TIEARRAY {
    my ($classname,@init) = @_;
    bless [@init], $classname;
}

sub FETCH {
    # magic here to explode directory contents if -d
}

# etc

So that @ARGV didn't actually get enormous... it just added items to the front as while (<>) { implicitly unshift'd stuff off it.

You can tell by the way that it starts that, actually,

perl -mr -e ...

was sufficient (who's got time for the shift key, anyway?). Too bad I never finished... coulda been a neat CPAN contribution... oh, well. Maybe someday, if no one runs off from reading these posts and implements it before I have time to finish it.

[etcshadow]

OK... I bothered to finish it. Or at least get it to a working state (I don't really like just grepping out the "." and ".." directories... it feels so non-portable (even though I know it's cool on windows and *nix)).

package r;
use strict;

tie @ARGV, 'r::Tie::RecursiveARGVArray', @ARGV;

sub import { }

package r::Tie::RecursiveARGVArray;
use Tie::Array;
use base 'Tie::Array';
use File::Spec;

sub TIEARRAY {
        my ($classname,@init) = @_;
        bless [@init], $classname;
}

sub FETCH {
        my ($self, $index) = @_;
        $self->_ReplaceDirs($index,$index);
        $self->[$index];
}

sub FETCHSIZE {
        my ($self) = @_;
        scalar @$self;
}

sub STORE {
        my ($self, $index, $value) = @_;
        $self->[$index] = $value;
}

sub STORESIZE {
        my ($self, $count) = @_;
        $#$self = $count - 1;
}

sub SPLICE {
        my ($self,$offset,$length,@list) = @_;
        $self->_ReplaceDirs($offset,$offset+$length-1);
        splice(@$self,$offset,$length,@list);
}

sub POP {
        my ($self,$item) = @_;
        $self->_ReplaceDirs(-1,-1);
        pop(@$self);
}

sub _ReplaceDirs {
        my ($self, $fromindex, $toindex) = @_;

        # as long as the index range contains directories, substitute 
+the directory contents
        my $recursionguard = 0;
        while (my @indices = grep { -d $self->[$_] } ($fromindex..$toi
+ndex) and $recursionguard++ < 10000) {
                my $index = $indices[0];

                opendir DIR, $self->[$index] or do {
                        warn "Cannot traverse directory $self->[$index
+]: $!\n";
                        splice(@$self, $index, 1, ()); # remove the ba
+d-apple
                        next;
                };
                my @contents = readdir DIR or do {
                        warn "Cannot read directory $self->[$index]: $
+!\n";
                        splice(@$self, $index, 1, ()); # remove the ba
+d-apple
                        closedir DIR or warn "Cannot close directory $
+self->[$index] (weird): $!\n";
                        next;
                };
                closedir DIR or warn "Cannot close directory $self->[$
+index] (weird): $!\n";

                # if there is any portable way to do this... I'd like 
+to hear it!
                @contents = grep !/^\.{1,2}$/, @contents;

                # convert directory contents to paths by prepending th
+e directory.
                # even be super nice about using catfile or catdir, ap
+propriately
                @contents = map {
                        my $asfile = File::Spec->catfile( $self->[$ind
+ex], $_ );
                        -f $asfile ? $asfile : File::Spec->catdir( $se
+lf->[$index], $_ );
                } @contents;

                # replace directory with its contents
                splice(@$self, $index, 1, @contents);
        }
}

1;

complete with example use:

[me@host]$ cat `find d* -type f` | wc -l  
  58040
[me@host]$ perl -mr -lne '$x++; END{print $x}' d*
58040
[me@host]$

I guess now I should pod this up and make it my first contribution to cpan :-D

[demerphq]

I think the only problem with all of this is that you arent using it as a wrapper to File::Find. Youve got a good idea here, but hand rolling a directory traversal is not in my opinion smart. Also the way that you do it worries me a touch. Its an interesting implementation of a depth first traveral, but surely its quite inefficient? Arent you repeatedly doing file system checks over the same objects?

I think you should rewrite this as an alternate interface to File::Find. Which would get you better portability and whole host of hooks and options to add. Overall its a good idea though. And I go with calling it something long and giving it a flexible import() interface. For instance:

use File::Find::ARGV filter=>sub { /\.txt/i };
while (<>){
...
}

Anyway, its an interesting idea. ++ to you.

[BrowserUk]

Why use (open|read|close)dir and then have to concern yourself with removing '.' & '..' and use File::Spec->catfile/catdir to fix up the pathnames, when glob would take care of (most?) of that for you?

[tsee]

You really should because I'd be the first to download the module since I've been writing one-liners using File::Find far too often. As you all know, File::Find's interface sucks...

If you need any support with packaging the module correctly for CPAN, feel free to contact me via email and I'll try to help.

Steffen