use File::Find;
use Data::Dumper;

my $files = {};
find(sub {wanted($files);}, "c:/perl58");
print Dumper($files);

sub wanted {
    if (($_ ne ".") && ($_ ne "..")) {
        insert(shift);
    }
}

sub insert {
    my @elements = split("/", $File::Find::name);
    my $parent = shift;
    my $index;
    foreach ($index = 0; $index <= $#elements; $index ++) {
        if (($index == $#elements) && (-f $_)) {
            $parent->{$elements[$index]} = $File::Find::name;
        } else {
            if (!defined($parent->{$elements[$index]})) {
                $parent->{$elements[$index]} = {};
            }
            $parent = $parent->{$elements[$index]};
        }
    }
}
[download]

++pg for headspin value ! This code does run on linux , a small mod to &wanted to make it symlink safe(r)

if (($_ ne ".") && ($_ ne "..") && (! -l $_)) {
[download]


However when the hash is unrolled, the first key is null, and keys are generated all the way down to the actual search base.

eg: running this script on  /usr/local/html/users/me
returns
VAR1='' => { 
    'usr'=> { 
        'local' => {
             'html' => {
                'me' => {
etc,etc. Before the real search begins.
[download]

So to accomodate for that we can change the assignment to @elements

@elements = split("/" , substr($File::Find::name, length($ARGV[0])));
[download]

Obviously that shift @ARGV had to be replaced with $ARGV[0] , which might be better done assigning to a (heaven forefend) global.

'b'x2 || ! 'b'x2

use warnings;
use strict;
use Data::Dumper;

my $urlbase = 'http://proxy/cgi-bin/getobj.pl?';

sub recurse
{
        my ($basedir, $dir) = @_;

        $dir = $basedir unless (defined($dir));
        $dir = "$dir/" unless ($dir =~ m#/$#);

        my $base = substr($dir, length($basedir));
        my %tree;

        opendir(DIR , $dir);
        foreach my $path (readdir(DIR))
        {
                next if ($path =~ /^\.\.?/);    # . & ..
                my $dirpath = "$dir$path";

                if (-f $dirpath)
                {
                        $tree{$path} = "$urlbase$base$path";
                }
                elsif (-d $dirpath && !-l $dirpath)
                {
                        $tree{$path} = recurse($basedir, $dirpath);
                }
        }
        closedir(DIR);

        return \%tree;
}

my ($path)  = @ARGV;

unless (defined($path))
{
        print "Usage: $0 path\n";
        exit(0);
}

print Dumper recurse ($path);
[download]

To append the '/' when required with a regex :-

$dir=~s#(?<!/)$#/#;
[download]

Also I would suggest :-

next if ($path =~ /^\.\.?$/);
[download]

So that '.filename' file/directories are not ignored if you want to map these too.

Hope it helps
UnderMine

Argh! non skinny substitution delimiters :). Lemme see if I understand though.

s#(?<!/)$#/#;

means... if the character / is NOT occuring as the last char in the string, substitute a / for the match, BUT since this is a zero width match ?< then presumably "/" replaces "" at the end of the string?.

Not being a regex guru, and knowing that (at least for me), you're only as good as your best reference!! , I used the Perl In a Nutshell regex reference to unwrap this. However, the only mention of ! , is as the !~ operator, or in situations like (?<!=...) or (?!...) , being hesitant to use code before I understand it, am I even close?

evil groan I don't want to map .anything (should have been clearer in the 1st post) , I like the .invisibility - and shall not shirk it!

Anyone know how to contact paco? This looks to be just what he needs.