publicscripts/mvwrap/mvwrap

#!/usr/bin/perl -w

# $Id$

#
# Script to let an editor loose on a directory listing
# Much easier than doing 6000 moves by hand
# I think it's relatively safe now
# (C) 2001 Ward Wouts
#

use IO::File;
use File::Copy;
use POSIX qw(tmpnam);
use Getopt::Long;

&lock;

&cmdline;
unless (defined @source) { @source = &read_cur_dir; }

if (@pattern) {
	@target = @source;
	&pattern_edit;
} else {
	$temp_file = &open_temp;
	&edit($temp_file);
	&read_temp($temp_file);
}

&run_checks;

if ($paranoia) { # extra checks for a specified list of files
	&paranoia(\@source, \@target);
}

# if it's unsafe to move files directly, move the unsafe ones to a
# temporary file first
if (@unsafe = &check_safety(\@source, \@target)) {
	&safety_belt(\@unsafe, \@source);
}


&move_files(\@source, \@target);
&unlock;


########################################################
# sub routines from here on...
#

#Read current dir
sub read_cur_dir {
	my (@dir, $filename);
	opendir(DIRHANDLE, ".") or &cdie("couldn't open .: $!\n");
	while ( defined ($filename = readdir(DIRHANDLE)) ) {
		unless ($filename eq "." | $filename eq ".." | $filename eq ".mvwrap" ) {
			chomp ($filename);
			push @dir, $filename;
		}
	}
	closedir(DIRHANDLE);
	return sort @dir;
}

# call EDITOR or vi with filename
# edit($filename);
sub edit {
	my $filename = shift;
	@editor = (defined $ENV{EDITOR}  ? $ENV{EDITOR} : "vi", "$filename");
	if ($opt_e) { @editor = ($opt_e, "$filename") }
	system(@editor) == 0
		or &cdie("System @editor failed: $!");
}

# make tempfiles and install handler to remove them
sub open_temp {
	my $target;
	do { $target_name = tmpnam() }
		until $target = IO::File->new($target_name, O_RDWR|O_CREAT|O_EXCL);
	END { if ($opt_e) { unlink($target_name) or &cdie("Couldn't unlink $target_name: $!");} }
	foreach (@source) {
		print $target "$_\n";
	}
	close ($target);
	return $target_name;
}

sub read_temp {
	my $target_name = shift;
	open TARGET, $target_name or &cdie("Couldn't open tempfile: $target_name: $!");
	foreach (<TARGET>) {
		chomp;
		push @target, $_;
	}
	close TARGET;
}

# Moves files from the names in one array to the names in another array
# Must be called like:
# move_files(\@source, \@target)
sub move_files {
	my ($from, $to) = @_;
	my ($i, $source, $target);
	for ( $i=0; $i < scalar(@$from); $i++ ) {
		$source=$from->[$i];
		$target=$to->[$i];
		unless ( $source eq $target ) {
			if ($opt_v||$opt_n) {
				print "mv \"$source\" \"$target\"\n";
			}
			unless ($opt_n) {
				move("$source", "$target")
					or &cdie("move failed: $!");
			}
		}
	}
}

# read pattern file
sub read_pattern {
	open PAT, "< $opt_f" or &cdie("Couldn't open pattern file: $!\n");
	@pattern = <PAT>;
	close PAT;
}

# use patterns to change filenames
sub pattern_edit {
	my (@new_target, $pat);
	foreach $pat (@pattern) {
		@new_target=();
		foreach(@target) {
			eval $pat;
			push @new_target, $_;
		}
		@target = @new_target;
	}
}

sub run_checks {
	my $line;
	unless ( scalar(@source) == scalar(@target) ) {
		&cdie("Aborting. Source and target list don't have the same number of lines.\n");
	}
	
	foreach $line (@target) {
		if ( $line =~ m/^$/ ) {
			&cdie("Aborting. You can't move to empty names.\n");
		}
	}
	
	if ( &check_unique(@target) ) {
		&cdie("Aborting. You're trying to move multiple files to the same name.\n");
	}
}

# returns 0 if all entries in @target_list are unique. 1 if not.
sub check_unique (@){
	my @uniqu;
	my @target_list = @_;
	my %seen = ();
	@uniqu = grep { ! $seen{$_} ++ } @target_list;
	return (scalar(@uniqu) != scalar(@target))
}

# Compares one array of file names to another, making sure files
# can be moved safely without overwriting each other
# Must be called like:
# check_safety(\@source, \@target)
# Returns an array of unsafe line numbers
sub check_safety {
	my ($from, $to) = @_;
	my ($i, $j, @changed, @danger, @unique, %seen);
	my ($a, $b);
	my ($n, %to);
	# $n=0; %to = map { ($_, $n++) } @to;
	for ($i=0; $i < scalar(@$from); $i++){
		$a = $from->[$i];
		$b = $to->[$i];
		push @changed, $i if ($a ne $b);
	}
	foreach $i (@changed) {
		$a = $from->[$i];
		for ($j=0; $j < scalar(@$to); $j++){
			$b = $to->[$j];
			if (($a eq $b) && ($i != $j)) {
				push @danger, $i;
				push @danger, $j;
			}
		}
	}

	%seen = ();
	@unique = grep { ! $seen{$_} ++ } @danger;
	return @unique;
}

# generate random filename, which does not exist
sub rand_file {
	my $filename;
	my @chars=( "A" .. "Z", "a" .. "z", 0 .. 9);
	while ( -e ($filename = join("", @chars[ map { rand @chars } ( 1 .. 8 ) ]))) {}
	return $filename;
}

# Moves files to a random filename and updates the source array
# Must be called like:
# safety_belt(\@unsafe, \@source)
sub safety_belt {
	my ($unsafe, $source) = @_;
	my($filenr, $filename, $rand);
	foreach $filenr (@$unsafe) {
		$filename = $source->[$filenr];
		$rand = &rand_file;
		if ($opt_v||$opt_n) {
			print "mv \"$filename\" \"$rand\"\n";
		}
		unless ($opt_n) {
			move("$filename", "$rand")
				or &cdie("move failed: $!\n");
		}
		$source->[$filenr] = "$rand";
	}
}

# Extra safety checks when one's useing a specified list of files
# Must be called like:
# paranoia(\@unsafe, \@source)
sub paranoia {
	my ($source, $target) =@_;
	my $safe;
	foreach $ctarget (@$target) {
		$safe = 0;
		foreach $csource (@$source) {
			if ($ctarget eq $csource) { $safe = 1; }
		}
		if (! $safe && -e $ctarget) { &cdie("That would overwrite files\n"); }
	}
}

# lock, unlock and cdie are the only subs that should use die;
# all others should use &cdie. A handler for this would probably
# be nicer.

# place lockfile in dir, or exit if one exists.
sub lock {
	if ( -e ".mvwrap") {
		die "Another mvwrap process is active in this direcory\n"
	}
	else {
		open LOCK, "> .mvwrap" or die "Couldn't open .mvwrap for writing: $!\n";
		print LOCK $$;
		close LOCK;
	}
}

# clean up lockfile
sub unlock {
	if ( -e ".mvwrap" ) {
		unlink(".mvwrap") or die "Couldn't remove lock file: $!\n";
	}
}

# clean up lock & die
sub cdie {
	$message = shift;
	&unlock;
	die "$message";
}

# parse commandline
sub cmdline {
	%optctl = ();
	&GetOptions("e=s", "h", "p=s", \@pattern, "f=s", "v", "n");
	&GetOptions(\%optctl, "e");

	&help if $opt_h;
	if ($opt_f) { &read_pattern; }
	if (scalar(@ARGV)>0) {
		foreach (@ARGV) {
			push @source, "$_";
		}
		$paranoia = 1;
	}
}

# show help message
sub help {
	$opt_h = 1; # just get rid of that stupid message from -w
	print << "EOT";

This is a little script to make renaming large quantities of files easy.
It basically lets you edit the names in a directory with an editor
of your choice. By default this will be "vi", but it honors the EDITOR
environment variable. Which in turn can be overridden with the -e option.

$0 [options] [--] [files]

At the moment it takes the following options:
-h			this help message
-e <editor>		invoke with this editor; ignored if -f or -p is given
-p <pattern>		use a pattern to edit; ignored if -f is given
-f <file>		use a pattern file to edit
-v			verbose; shows file moves
-n			test; doesn't move, implies -v

EOT
&unlock;
exit;
}