$data =~ s/\s+/ /g;
$data =~ s/  +//g;
# remove leading and trailing blanks
$data =~ s/^\s+//;
$data =~ s/\s+$//;
[download]

Greatly appreciate your commenting.

What you do here is first to substitute any whitespace characters by blanks, then all blanks by nothing and then you look for blank at the beginning and the end of your data. As your RegEx to validate input is $data =~ /^(-\@\w. +)$/, I would guess that you might have wanted to leave the second RegEx out.

The second RegEx contains two spaces (not one), so what it does is remove extra spaces but one to nothing.

The second RegEx contains two spaces (not one), so what it does is remove extra spaces but one to nothing.

Huh? If I understand your statement, then you might not understand the process...

  $data =~ s/\s+/ /g;
  # Remove extra spaces to nothing
  $data =~ s/  +//g;
[download]

Regardless of what sort of whitespace is contained in $data, your first regex eliminates all cases where two or more whitespace characters are adjacent -- it changes every string of one or more whitespace to a single space -- which means there will be nothing left for your second regex to apply to, so the second one is not needed.

(And if you were to apply the second regex to a string that happened to contain two or more consecutive spaces -- i.e. where the first regex had not been applied -- it would delete all the spaces in that sequence, not leaving any behind.)

As for the rest, I second the earlier suggestions to look at established modules for this sort of thing, especially if you expect there will be an increasing need for it.

Also, just as a matter of style, it's often nicer to have the shorter, simpler, and/or more primary conditions fully handled first, and deeper, more complicated ones later. In general, this allows for simpler code, with less nesting of "if ... else ..." conditions; eg:

$length = length( $data );
if ( ! $length ) { # empty string
   if ( $obligatory ) {
      bail_out( "Obligatory field not filled in" );
   } else {
      return;
   }
}
if ( $data =~ /([^-\@\w. ])/) {
   bail_out( "Bad character: $1 -- Only alphanumerics and -@. allowed"
+ );
}
if ( $numeric and $data =~ /[^\d]/ ) {
   bail_out( "Non-numeric character(s) in numeric field" );
}
if ( $min and $length < $min ) {
   bail_out( "too short" );
}
if ( $max and $length > $max ) {
   bail_out( "too long" );
}
return $data;
[download]

I haven't tested it, but I think that covers everything you posted. Instead of being a long block of nested logic, it's a set of simple, discrete checks, arranged in such a way that the later ones only need to be checked if the earlier ones pass. Note that the case of $min==$max does not need special treatment, and the checks for acceptable character content and for digits involve seeing if any unacceptable characters are present.

(Is it possible that negative and/or decimal-fraction numbers should be allowed in some numeric fields? If so, that condition should be:  $data =~ /[^\d.-]/)

(update: fixed the code slightly, to give a better error message in the character-class check. Did some rewording.)

I'm seeking your opinion on whether the coding practice I adopt is a sound one and if not, how should I change it.

Pet peeve: $ should not be used in regexs unless you really want to allow a trailing "\n"; probably not the case here.

Could you explain your pet peeve further?   I'm not sure what you are thinking about.

  $s = "8b\n";
  printf "  %smatch\n", ($s=~/^\d*$/) ? '' : 'no ';
    no match
  printf "  %smatch\n", ($s=~/^\d*/)  ? '' : 'no ';
    match

Without the '$' the checking is, um, untrustworthy.

Use \z to match the end of the string.

$ should not be used in regexs unless you really want to allow a trailing "\n"; probably not the case here.

Well, since all whitespace has been normalized to single space (and leading and trailing whitespace has been removed), $ works as well as anything else here.

On the contrary, since it is impossible for there to be a trailing \n here, using $ instead of \z is misleading and wrong. It's just as incorrect as needlessly ending an unanchored regex with .*.