rename files using regex.

[djbiv]

Ok, this is 'stolen' from the 'Perl Cookbook', and I would bet most veteran Monks will probably find this trivial but I enjoy it, and wanted to share it anyways.
whoops won't run with strict; (Oddly enough the example in the perl cookbook isn't using strict!), so I updated the code declaring $op and $was...

#!/usr/bin/perl -w
#
# rename - larry's filename fixer
# small script from the "perl cookbook"
#
# examples:     % rename 's/\.orig$//' *.orig
#         % rename 'tr/A-Z/a-Z/ unless /^Make/' *
#         % rename '$_ .= "bad"' *.f
#         % rename 'print "$_: "; s/foo/bar/ if <STDIN> =~ /^y/i' *
#         % find /tmp -name '*~' -print | rename 's/^(.+)~$/.#$1/'
use strict;

my $op = shift or die "Usage: rename expr [files]\n";
chomp(@ARGV = <STDIN>) unless @ARGV;    
for (@ARGV) {                                         
   my $was = $_;   
   eval $op;
   die $@ if $@;
   rename($was,$_) unless $was eq $_;               
}

[jeffa]

Looks cool to me. The only recommendation i have sounds trivial at first, but if you get into the habit of using POD for your documentation now, you won't regret it. Here is some POD for your script, just append this to the end and modify to suite your needs:

__END__

=head1 NAME

rename - larry's filename fixer

=head1 SYNOPSIS

  % rename 's/\.orig$//' *.orig
  % rename 'tr/A-Z/a-Z/ unless /^Make/' *
  % rename '$_ .= "bad"' *.f
  % rename 'print "$_: "; s/foo/bar/ if <STDIN> =~ /^y/i' *
  % find /tmp -name '*~' -print | rename 's/^(.+)~$/.#$1/'

=head1 DESCRIPTION

B<rename> is small script inspired from the "perl cookbook" 
that allows you to pass it a regular expression and 
filenames to apply that regex to. This is available online 
at http://www.perlmonks.org/index.pl?node=277174

=head1 AUTHOR

djbiv

Now you just type perldoc rename and voila! Instant documentation. This even works if the script is not in your current directory as long it is in a directory that is in your PATH. Check out POD in 5 minutes for more on POD, and definitely take a gander at The Dynamic Duo --or-- Holy Getopt::Long, Pod::UsageMan!. Very useful stuff. :)

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

[bsb]

I tried using rename to clean up file names but my expression outgrew the command line (not to mention the difficulty of escaping everything). I ended up hacking /usr/bin/rename.

Here it is, for what it's worth:

#!/usr/bin/perl -s
# bsb hacked version of /usr/bin/rename
use strict;
use vars qw($q $n $t);
use Convert::Translit;
# Quiet, do Nothing, Test
$q=$q; $n=$n; $t=$t;
my $trans = Convert::Translit->new('Latin1' => 'ascii');

if ($t) {
    $n=1;
    @ARGV = <DATA>;
}
if (!@ARGV) {
    print "reading filenames from STDIN\n" unless $q;
    @ARGV = <STDIN>;
    chop(@ARGV);
}


for (@ARGV) {
    my $was = $_;

    $_ = $trans->transliterate($_);
    $_=lc;
    s/&/ and /g;
    s/\+/ plus /g;
    s/'//g;
    y/()~/---/s;
    print if $t;
    s/(?:(\.)|(-)|[\W_])+/$1||$2||'_'/ge;
    s/^[._-]//;
    s/[._-]$//;

    die $@ if $@;
    if( $was eq $_ )        { }     # ignore quietly
    elsif( -e $_ )      { warn  "$was not renamed: $_ already exists\n
+"; }
    elsif($n || rename($was,$_)) { print "$was renamed as $_\n" unless
+ $q; }
    else            { warn  "Can't rename $was $_: $!\n"; }
}

Brad

[parv]

Thanks bsb for pointing out the Convert::Translit::transliterate(). Now, only if the first locale could be guessed given some text...

[Abigail-II]

Why would it have to use strict? Larry's well known rename program predates Perl5, so I wouldn't expect it to use strict. Besides, the code is Larry's, and AFAIK, Larry hardly ever uses strict. And neither does Damian for that matter. (Conspiricy?)

There's little value in adding 'use strict' to old programs. Strictness is mostly a development aid.

Abigail

[dragonchild]

Strictness is mostly a development aid.

I'm going to disagree with that statement. Strictness is both a development aid and a debugging aid. For example, I am attempting to maintain some crappy code that is in production that was originally written by C programmers who don't understand references. By adding strict, I can detect and fail on attempts to use non-references as references. While testing should catch these, it won't catch them all.

Personally, I feel that if you're maintaining and updating an old program, it should be made strict. (Preferably, I'd add warnings to it, as well, but that's truly a personal preference. I'm anal. *grins*)

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

[djbiv]

good notes! I enjoyed your comment, and didn't even think about the snippet pre-dating strict;

[bsb]

A GUI rename (example_overview0.gif), no kidding.

[Aristotle]

That's a good example of why literature is written in text, and only first graders at most "read" picture books.

Makeshifts last the longest.