If you break a condition like that over multiple lines (and for a complicated or long condition I recommend it) put the operators at the front of the lines so they don't get "lost" at the back:

if (  $args =~ /\-rs(\s+)(\S+)/
   || $args =~ /\-p(\s+)(\S+)/
   || $args =~ /\-P(\s+)(\S+)/
   )
[download]

Actually, I like that better.
As I remember, a senior Monk yelled at me once when I posted something like that. But yes this is the way that I would do it in my code. I didn't want to get into an argument that detracts from the main point.
Update: As I remember the argument against this was like "injecting spacing like that is bad because it is manually done and IDE's don't do it that way". BS. The compiler doesn't give a darn about spaces. Whitespace is added to help the humans. If it helps the humans, it is a good idea.

I agree with your and GrandFather's leftist leaning when it comes to formatting complex logical expressions, but I think it's tangential to the main point made by haukex here: the statements
    if     (    condition  ) {} else {code }
    unless (    condition  )         {code }
    if     ( ! (condition) )         {code }
are all exactly equivalent, so the condition expression within them does not need to change at all.

---

Give a man a fish:  <%-{-{-{-<

Also you can waste one line of code for making first conditional to have the same line-format as others:

if( not 0
   || $args =~ /\-rs(\s+)(\S+)/x
#  || $args =~ /\-? (\s+)(\S+)/x
   || $args =~ /\-p (\s+)(\S+)/x
   || $args =~ /\-P (\s+)(\S+)/x
   ){ ... }
[download]

...or equivalently inside regex:

if( $args !~ / (*FAIL)
   | \-rs(\s+)(\S+) 
#  | \-? (\s+)(\S+)
   | \-P (\s+)(\S+)
   | \-p (\s+)(\S+)
   /x ){ ... }
[download]

edit: not equivalently, because there are 8 capturing groups instead of 2 :)

Of course regex can be simplyfied as AnomalousMonk have shown here Re: regex return true instead of false.

if( $args !~ / (*FAIL)
   | \-rs(\s+)(\S+) 
#  | \-? (\s+)(\S+)
   | \-P (\s+)(\S+)
   | \-p (\s+)(\S+)
   /x ){ ... }
[download]

I don't understand the purpose of the  (*FAIL) operator (see Special Backtracking Control Verbs in perlre in Perl versions 5.10+ (update: see also Backtracking control verbs in perlretut - but that's not actually as extensive as the discussion in perlre)) in the quoted regex. At any position in the  | alternation,  (*FAIL) will simply force the RE to try the next alternation; if it's at the last position, all the preceding pattern matches would have failed and the alternation would fail anyway without (*FAIL).

c:\@Work\Perl\monks>perl -wMstrict -le
"use 5.010;
 ;;
 for my $s (qw(XXX ppp)) {
   print qq{for '$s' string};
   if ($s !~ m{ (*F) | p | q }xms) { print '  with (*F): no match, !~ 
+true' }
   if ($s !~ m{   Z  | p | q }xms) { print '  with Z:    no match, !~ 
+true' }
   if ($s !~ m{        p | q }xms) { print '  no (*F):   no match, !~ 
+true' }
   print '  -------';
   }
"
for 'XXX' string
  with (*F): no match, !~ true
  with Z:    no match, !~ true
  no (*F):   no match, !~ true
  -------
for 'ppp' string
  -------
[download]

Note that for all these variations, for string 'XXX' there is never a match (!~ is always true); string 'ppp' always matches (!~ always false).

... not equivalently, because there are 8 capturing groups instead of 2 ...

If you're using  (*FAIL) you must be using Perl version 5.10+, so you also have the  (?|pattern) "branch reset" operator (see Extended Patterns in perlre). This allows you to go back to having two capture groups again!

Update: Changed example code slightly to better reflect discussion.

---

Give a man a fish:  <%-{-{-{-<