t: ensure failure if field gets fed an invalid regexp value

[barcat.git] / barcat
diff --git a/barcat b/barcat

index cc3f607a990787bdb985d9735aeb7a23079c45a3..0316b64460300a7e5ffb3dc73b4c696fe20024c2 100755 (executable)
--- a/barcat
+++ b/barcat
@@ -39,8 +39,9 @@ GetOptions(\%opt,
         'limit|L:s' => sub {
                 my ($optname, $optval) = @_;
                 $optval ||= 0;
+               $optval =~ /\A-[0-9]+\z/ and $optval .= '-';  # tail shorthand
                 ($opt{hidemin}, $opt{hidemax}) =
-               $optval =~ m/\A (?: ([0-9]+)? - )? ([0-9]+)? \z/ or die(
+               $optval =~ m/\A (?: (-? [0-9]+)? - )? ([0-9]+)? \z/ or die(
                         "Value \"$optval\" invalid for option limit",
                         " (range expected)\n"
                 );
@@ -205,13 +206,24 @@ sub color {
  
  sub show_lines {
  
-state $nr = $opt{hidemin};
-@lines or return;
+state $nr =
+       $opt{hidemin} < 0 ? @lines + $opt{hidemin} + 1 :
+       $opt{hidemin};
  @lines > $nr or return;
  
+my $limit = $#lines;
+if (defined $opt{hidemax}) {
+       if ($opt{hidemin} and $opt{hidemin} < 0) {
+               $limit -= $opt{hidemax} - 1;
+       }
+       else {
+               $limit = $opt{hidemax} - 1;
+       }
+}
+
  @order = sort { $b <=> $a } @order unless tied @order;
  my $maxval = $opt{maxval} // (
-       $opt{hidemax} ? max grep { length } @values[0 .. $opt{hidemax} - 1] :
+       $opt{hidemax} ? max grep { length } @values[$nr .. $limit] :
         $order[0]
  ) // 0;
  my $minval = $opt{minval} // min $order[-1] // (), 0;
@@ -274,8 +286,7 @@ say(
         color(0),
  ) if $opt{header};
  
-while ($nr <= $#lines) {
-       $nr >= $opt{hidemax} and last if defined $opt{hidemax};
+while ($nr <= $limit) {
         my $val = $values[$nr];
         my $rel = length $val && $range && ($val - $minval) / $range;
         my $color = !length $val || !$opt{palette} ? undef :
@@ -316,9 +327,15 @@ say $opt{palette} ? color(0) : '' if $opt{spark};
  
  sub show_stat {
         if ($opt{hidemin} or $opt{hidemax}) {
-               printf '%.8g of ', $opt{'sum-format'}->(sum(grep { length }
-                       @values[$opt{hidemin} .. ($opt{hidemax} || @lines) - 1]
-               ) // 0);
+               my $linemin = $opt{hidemin};
+               my $linemax = ($opt{hidemax} || @lines) - 1;
+               if ($linemin < 0) {
+                       $linemin += @lines;
+                       $linemax = @lines - $linemax;
+               }
+               printf '%.8g of ', $opt{'sum-format'}->(
+                       sum(grep {length} @values[$linemin .. $linemax]) // 0
+               );
         }
         if (@order) {
                 my $total = sum @order;
@@ -326,9 +343,9 @@ sub show_stat {
                 printf ' in %d values', scalar @order;
                 printf ' over %d lines', scalar @lines if @order != @lines;
                 printf(' (%s min, %s avg, %s max)',
-                       color(31) . $order[-1] . color(0),
-                       color(36) . $opt{'calc-format'}->($total / @order) . color(0),
-                       color(32) . $order[0] . color(0),
+                       color(31) . ($opt{'value-format'} || sub {$_[0]})->($order[-1]) . color(0),
+                       color(36) . ($opt{'value-format'} || $opt{'calc-format'})->($total / @order) . color(0),
+                       color(32) . ($opt{'value-format'} || sub {$_[0]})->($order[0]) . color(0),
                 );
         }
         say '';
@@ -422,9 +439,13 @@ unless C<--length=0>.
  Prepend a dash (i.e. make negative) to enforce padding
  regardless of encountered contents.
  
-=item -L, --limit[=(<count> | <start>-[<end>])]
+=item -L, --limit[=(<count> | -<last> | <start>-[<end>])]
  
  Stop output after a number of lines.
+A single value indicates the last line number (like C<head>),
+or first line counting from the bottom if negative (like C<tail>).
+A specific range can be given by two values.
+
  All input is still counted and analyzed for statistics,
  but disregarded for padding and bar size.