URI

File::Basename

Win32

index,rindex,substr,length,split,tr

use strict;
use warnings;
use Win32;

die unless $^O =~ /Win32/i;

my $copyme = 'C:/Apache/www-root/images';
my $here = 'C:/Apache/www-root/images/bgs';

$copyme = Win32::GetFullPathName($copyme);
$here = Win32::GetFullPathName($here);

# index STR, SUBSTR

if( (index($copyme,$here) != -1) or (index($here,$copyme) != -1) ) {
   die "a horrible death";
}

# Win32::GetShortPathName and Win32::GetLongPathName
# may also be of interest (for use with open)
[download]

 

______crazyinsomniac_____________________________ Of all the things I've lost, I miss my mind the most. perl -e "$q=$_;map({chr unpack qq;H*;,$_}split(q;;,q*H*));print;$q/$q;"

#!/usr/bin/perl -w
use strict;
use File::Find;
use Tree::DAG_Node;
my $count =0;
my $rootname="/home/perl/"; # or your favourite dir
my $dirname= "testtree";

my $root = new Tree::DAG_Node;
$root->name($dirname);

my $node = $root;
find(\&{ sub {
     if (-d "$File::Find::dir/$_"){
         my $dir = $File::Find::dir;
         $dir .= "/$_" if $count++;
         $dir =~ s/^$rootname//;
         my $ancestor = $node;
         while ($ancestor) {
              my $name = $ancestor->name;
              if ((length($dir) > length($name)) && $dir =~ /^$name/) 
+{
                  my $nnode = new Tree::DAG_Node;
                  $ancestor->add_daughter($nnode);
                  $nnode->name($dir);
                  $node = $nnode;
                  last;
              }
              $ancestor = $ancestor->mother;
         }
     }
   }
}, "$rootname$dirname");

sub is_below {
    my $node = shift;
    my $dir = shift;
    return scalar grep {$dir eq $_->name} $node->ancestors;
}

sub is_above {
    my $node = shift;
    my $dir = shift;
    return scalar grep {$dir eq $_->name}
        $node->self_and_descendants;
}

sub find_node {
    my $node = shift;
    my $dir = shift;
    my ($descendant) = grep {$dir eq $_->name}
        $node->self_and_descendants;
    return $descendant;
}

my $source = "testtree/a/k";
my $dest = "testtree/a";

my $n = find_node($root,$source) or die "can't find dir\n";

if (is_below($n,$dest)) {
    print "[$source] is below [$dest]\n";
}
elsif (is_above($n,$dest)) {
    print "[$source] is above [$dest]\n";
}

print "\nthe tree\n\n";
print $root->dump_names,"\n";

print "the same, fancier\n";
print map "$_\n", @{$root->draw_ascii_tree};
__END__
output:

[testtree/a/k] is below [testtree/a]

the tree

'testtree'
  'testtree/b'
    'testtree/b/y'
    'testtree/b/x'
  'testtree/a'
    'testtree/a/k'
      'testtree/a/k/m'
      'testtree/a/k/l'
    'testtree/a/j'

the same, fancier
(simplified, for posting purposes)
                        |
                   <testtree>
           /-----------------------\
           |                       |
          <b>                     <a>
      /---------\              /-------\
      |         |              |       |
    <b/y>     <b/x>          <a/k>    <a/j>
                          /--------\
                          |        |
                       <a/k/m>   <a/k/l>
[download]

 _  _ _  _  
(_|| | |(_|><
 _|   

Hmmm, interesting problem. Please never use real paths in CGI input - that's asking for trouble. Please never use "$foo", because that's (in a way) equal to saying "" . $foo . "". Just use the scalar you want directly: $foo. (Note: except for when a subroutine usually modifies data, but you only want the returned value - using interpolation is a very nice way to cheat in those circumstances.)

As for your problem, you could split the directory names on \ and then compare the two arrays, or use one of the directory names as a regex (\Q!) for the other. Windows doesn't have symlinks and such, so I think a simple minded approach like that might just work.

U28geW91IGNhbiBhbGwgcm90MTMgY
W5kIHBhY2soKS4gQnV0IGRvIHlvdS
ByZWNvZ25pc2UgQmFzZTY0IHdoZW4
geW91IHNlZSBpdD8gIC0tIEp1ZXJk

Windows doesn't have symlinks and such

Time to recheck the documentation. NT has supported symlinks since at least NT5/W2k. :-)

Yves / DeMerphq
--
When to use Prototypes?
Advanced Sorting - GRT - Guttman Rosler Transform

Not for nothing, but it's NTFS that supports hard (not symbolic) links, not NT/2K/XP, per se.

1. NT's own CLI (CMD.EXE) doesn't even support them directly.
2. You need a separate console mode program (ln.exe, from the POSIX subsystem -- or MKS Toolkit, Cygwin, U/WIN, et al) to create links.
3. The standard Windows Explorer is not even (apparently) link aware.

I think Juerd's point was true if you assume typical Windows users (i.e., not everyone knows how to create multiple links to a file).

How about building a directory tree at run time and assigning values for each level of the tree.

You'd then compare $input{'directory'} and $input{'copy_to'} and branch accordingly.

Having provided that interesting bit of theory, I'm not really sure how you'd go about doing it.. :-)

1. what if you first search for the filenames in one step and prepare the copy-commands file by file, and then i a second step execute the copy-commands?

2. Otherwise:

if ($dir1 !~ /^\Q$dir2/){
  print "$dir1 is no subdir of $dir2\n";
}
[download]

Best regards,
perl -le "s==*F=e=>y~\*martinF~stronat~=>s~[^\w]~~g=>chop,print"

Update: Okay, I tried crazyinsomniac's code again, and it worked for the most part, but it still left valid directories out of the options, so I went back with strat's code with a small modification. Here is the code I use now:

my $root_path = "C:/Apache/www-root";
my $count = 0;
my $dir = "";
my @dirs

find(\&{ sub {
     if (-d "$File::Find::dir/$_"){
          if (++$count == 1) {
               push @dirs, $File::Find::dir;
          } else {
               push @dirs, $File::Find::dir . "/" . $_;
          }
     }

   }
}, "$root_path");

foreach $dir (@dirs) {

     my $tmp_dir = $input{'file' . $i};
     my $tmp_dir =~ s/(.*)\/(.*)/$1/;

     if ($test_this_directory !~ /^\Q$full_file_path/ && $dir ne $tmp_
+dir) {
          #valid directory - add it to cpoy options
     }
}
[download]