I have been using this regular expression to parse *nix paths as part of a module.

my $rxParsePath = qr
   {(?x)               # Use extended regular expression syntax to
                       # allow comments and white space
      ^                # Anchor pattern to beginning of string
      (?=.)            # Zero-width look ahead assertion to ensure
                       # that there must be at least one character
                       # for the match to succeed
      (.*/)?           # A memory grouping (1st) for path, greedy
                       # match of any characters up to and including
                       # the rightmost slash (the path part) with a
                       # quantifier of '?' (0 or 1), i.e. there
                       # may or may not be a directory part
      (                # Open memory grouping (2nd) for file name
         (.*?)         # A memory grouping (3rd) for file name stub
                       # of a non-greedy match of any character
                       # without a quantifier since, if there is a
                       # file name part, at least some of it will
                       # form a stub otherwise it would be a dot-file
         (             # A memory grouping (4th) for file name 
                       # extension
            (?<=[^/])  # zero width look behind assertion such
                       # that following pattern will only succeed
                       # if preceded by any caracter other than
                       # a slash '/'
            \.[^.]+    # a literal dot '.' followed by one or more
                       # non-dots
         )?            # Close memory grouping (4th) with a quantifier
                       # of '?' (0 or 1), i.e. there may or may not
                       # be a file name extension part
      )?               # Close memory grouping (2nd) with a quantifier
                       # of '?' (0 or 1), i.e. there may or may not
                       # be a file name part
      $                # Anchor pattern to end of string
   };
[download]

Here is a short script using it, without extended syntax for brevity, to pull out the elements of a *nix path.

use strict;
use warnings;

my $rxParsePath = qr{^(?=.)(.*/)?((.*?)((?<=[^/])\.[^.]+)?)?$};

print <<EOT;
                Path      Directory      File Name File Stub Extension
EOT

print
   map { sprintf qq{%20s%15s%15s%10s%10s\n}, @$_ }
   map { [ $_, map { defined $_ ? $_ : q{} } m{$rxParsePath} ] }
   qw  { /etc/motd /var/adm/messages.1 .alias a.html ab.cd.txt /bin };
[download]

The results

                Path      Directory      File Name File Stub Extension
           /etc/motd          /etc/           motd      motd
 /var/adm/messages.1      /var/adm/     messages.1  messages        .1
              .alias                        .alias    .alias
              a.html                        a.html         a     .html
           ab.cd.txt                     ab.cd.txt     ab.cd      .txt
                /bin              /            bin       bin
[download]

I hope this will be useful.

Cheers,

JohnGG

Update: Corrected superfluous text from C&P error.