Well, I'm glad that I got right what you wanted. =) Now, to explain the substitution...

my $str = "/One/Two/Three";

# Start with the whole thing in the array.  You could
# start with @paths = () if you'd rather not include
# the current directory/path/category/whatever.
my @paths = ($str);

while(   # Spreading this out so I can comment it...

$str =~ s[
 ^             # Match from the start of the string...
  (            # Save this in $1
   /           # The first /
   .+          # Followed by one or more <anything>'s
               #  (including /'s!!), all the way up to
               #  the last / (see below)
  )            # Don't save anything else in $1
  /            # The very last / in the string.  This
               #  is what causes the above .+ to stop
               #  before the end of the string.
  [^/]*        # We want an optional word after
               #  the last / but NOT /'s (otherwise
               #  it wouldn't be the last one, would it?)
 $             # Make sure don't stop before the end
               #  of what's left of the string.

][$1]x # Replace it all with $1, which contains
       # everything up to (but not including)
       # the last /.  Note the x option, let's us
       # include comments and space it out.
) {
    # Push the current version of $str onto the list.
    # It's whatever we have left after chopping off
    # the last word and it's /.
    push @paths, $str;
}
[download]

You're right. That's not a very pretty substitution. :-) If I can think of a cleaner way of doing it, I'll post it. Hope that helps.

bbfu
Seasons don't fear The Reaper.
Nor do the wind, the sun, and the rain.
We can be like they are.

my $str = "/One/Two/Three";
my @paths = ($str);

while ($paths[-1] =~ tr#/#/# > 1) {
    push @paths, substr($paths[-1], 0, rindex($paths[-1], '/'));
}

print "$_\n" for @paths;
[download]

All these things are in the documentation that comes with perl, you just have to put them together.

Damn you. I was going to post that. :-P

Yeah, I wouldn't have used the s/// if I'd remembered rindex. You'll have to forgive me, I was tired last night (yay 12 hours of overtime...).

Anyway, here's my version of the substr/rindex version. It uses the same algorithm as my regexp version (ie, it's still destructive to $str) and is a little cleaner than yours (but not much):

# MAKE SURE $str IS A _COPY_ OF YOUR DATA!!!
my $str = "/One/Two/Three";

my @paths = ();

while($str) {
    # If you don't want @push to include the current
    # cat (ie, "/One/Two/Three"), put this line after
    # the substr.  But then you'll have as the last
    # element an empty string.  Put a "last unless($str);"
    # between the substr and the push to avoid that.
    push @paths, $str;

    # Save everything from the begining of the string
    # up to, but not including, the last /.
    $str = substr($str, 0, rindex($str, '/'));
}

print "$_\n" for @paths;
[download]

This prints:

/One/Two/Three
/One/Two
/One
[download]

bbfu
Seasons don't fear The Reaper.
Nor do the wind, the sun, and the rain.
We can be like they are.