Only search for the first Format-Version: and use it

[debbugs.git] / Debbugs / Status.pm

diff --git a/Debbugs/Status.pm b/Debbugs/Status.pm
index 73506611a26d585da976a31576b1b7a9008cda8c..2c6ce209e9c07dccbcde3335e0da25803c5dc544 100644 (file)
--- a/Debbugs/Status.pm
+++ b/Debbugs/Status.pm
@@ -33,8 +33,10 @@ status of a particular bug
 use warnings;
 use strict;
 
+use feature 'state';
+
 use vars qw($VERSION $DEBUG %EXPORT_TAGS @EXPORT_OK @EXPORT);
-use base qw(Exporter);
+use Exporter qw(import);
 
 use Params::Validate qw(validate_with :types);
 use Debbugs::Common qw(:util :lock :quit :misc);
@@ -49,7 +51,7 @@ use File::Copy qw(copy);
 use Encode qw(decode encode is_utf8);
 
 use Storable qw(dclone);
-use List::Util qw(min max);
+use List::AllUtils qw(min max);
 
 use Carp qw(croak);
 
@@ -164,27 +166,27 @@ sub read_bug{
     if (@_ == 1) {
         unshift @_, 'bug';
     }
+    state $spec =
+       {bug => {type => SCALAR,
+               optional => 1,
+               # something really stupid passes negative bugnumbers
+               regex    => qr/^-?\d+/,
+              },
+       location => {type => SCALAR|UNDEF,
+                    optional => 1,
+                   },
+       summary  => {type => SCALAR,
+                    optional => 1,
+                   },
+       lock     => {type => BOOLEAN,
+                    optional => 1,
+                   },
+       locks    => {type => HASHREF,
+                    optional => 1,
+                   },
+       };
     my %param = validate_with(params => \@_,
-                             spec   => {bug => {type => SCALAR,
-                                                optional => 1,
-                                                # something really
-                                                # stupid passes
-                                                # negative bugnumbers
-                                                regex    => qr/^-?\d+/,
-                                               },
-                                        location => {type => SCALAR|UNDEF,
-                                                     optional => 1,
-                                                    },
-                                        summary  => {type => SCALAR,
-                                                     optional => 1,
-                                                    },
-                                        lock     => {type => BOOLEAN,
-                                                     optional => 1,
-                                                    },
-                                        locks    => {type => HASHREF,
-                                                     optional => 1,
-                                                    },
-                                       },
+                             spec   => $spec,
                             );
     die "One of bug or summary must be passed to read_bug"
         if not exists $param{bug} and not exists $param{summary};
@@ -225,15 +227,19 @@ sub read_bug{
 
     my %data;
     my @lines;
-    my $version = 2;
+    my $version;
     local $_;
 
     while (<$status_fh>) {
         chomp;
         push @lines, $_;
-        $version = $1 if /^Format-Version: ([0-9]+)/i;
+       if (not defined $version and
+           /^Format-Version: ([0-9]+)/i
+          ) {
+           $version = $1;
+       }
     }
-
+    $version = 2 if not defined $version;
     # Version 3 is the latest format version currently supported.
     if ($version > 3) {
         warn "Unsupported status version '$version'";
@@ -243,7 +249,7 @@ sub read_bug{
         return undef;
     }
 
-    my %namemap = reverse %fields;
+    state $namemap = {reverse %fields};
     for my $line (@lines) {
         if ($line =~ /(\S+?): (.*)/) {
             my ($name, $value) = (lc $1, $2);
@@ -251,7 +257,7 @@ sub read_bug{
            # or \n in the fields of status. Kill them off here.
            # [Eventually, this should be superfluous.]
            $value =~ s/[\r\n]//g;
-           $data{$namemap{$name}} = $value if exists $namemap{$name};
+           $data{$namemap->{$name}} = $value if exists $namemap->{$name};
         }
     }
     for my $field (keys %fields) {
@@ -270,7 +276,7 @@ sub read_bug{
         # create the found/fixed hashes which indicate when a
         # particular version was marked found or marked fixed.
         @{$data{$field}}{@{$data{"${field}_versions"}}} =
-             (('') x (@{$data{"${field}_date"}} - @{$data{"${field}_versions"}}),
+             (('') x (@{$data{"${field}_versions"}} - @{$data{"${field}_date"}}),
               @{$data{"${field}_date"}});
     }
 
@@ -282,6 +288,17 @@ sub read_bug{
     $data{archived} = (defined($location) and ($location eq 'archive'))?1:0;
     $data{bug_num} = $param{bug};
 
+    # mergedwith occasionally is sorted badly. Fix it to always be sorted by <=>
+    # and not include this bug
+    if (defined $data{mergedwith} and
+       $data{mergedwith}) {
+       $data{mergedwith} =
+           join(' ',
+                grep { $_ != $data{bug_num}}
+                sort { $a <=> $b }
+                split / /, $data{mergedwith}
+               );
+    }
     return \%data;
 }
 
@@ -307,6 +324,9 @@ my $ditch_empty_space = sub {return &{$ditch_empty}(' ',@_)};
 my %split_fields =
     (package        => \&splitpackages,
      affects        => \&splitpackages,
+     # Ideally we won't have to split source, but because some consumers of
+     # get_bug_status cannot handle arrayref, we will split it here.
+     source         => \&splitpackages,
      blocks         => $ditch_empty_space,
      blockedby      => $ditch_empty_space,
      # this isn't strictly correct, but we'll split both of them for
@@ -416,7 +436,6 @@ data.
 =cut
 
 sub lockreadbugmerge {
-     my ($bug_num,$location) = @_;
      my $data = lockreadbug(@_);
      if (not defined $data) {
          return (0,undef);
@@ -514,7 +533,10 @@ sub lock_read_all_merged_bugs {
            # are all merged with eachother
         # We do a cmp sort instead of an <=> sort here, because that's
         # what merge does
-           my $expectmerge= join(' ',grep {$_ != $bug } sort @bugs);
+           my $expectmerge=
+               join(' ',grep {$_ != $bug }
+                    sort { $a <=> $b }
+                    @bugs);
            if ($newdata->{mergedwith} ne $expectmerge) {
                for (1..$locks) {
                    unfilelock(exists $param{locks}?$param{locks}:());
@@ -1176,35 +1198,40 @@ sub get_bug_status {
      if (@_ == 1) {
          unshift @_, 'bug';
      }
+     state $spec =
+       {bug       => {type => SCALAR,
+                      regex => qr/^\d+$/,
+                     },
+        status    => {type => HASHREF,
+                      optional => 1,
+                     },
+        bug_index => {type => OBJECT,
+                      optional => 1,
+                     },
+        version   => {type => SCALAR|ARRAYREF,
+                      optional => 1,
+                     },
+        dist       => {type => SCALAR|ARRAYREF,
+                       optional => 1,
+                      },
+        arch       => {type => SCALAR|ARRAYREF,
+                       optional => 1,
+                      },
+        bugusertags   => {type => HASHREF,
+                          optional => 1,
+                         },
+        sourceversions => {type => ARRAYREF,
+                           optional => 1,
+                          },
+        indicatesource => {type => BOOLEAN,
+                           default => 1,
+                          },
+        binary_to_source_cache => {type => HASHREF,
+                                   optional => 1,
+                                  },
+       };
      my %param = validate_with(params => \@_,
-                              spec   => {bug       => {type => SCALAR,
-                                                       regex => qr/^\d+$/,
-                                                      },
-                                         status    => {type => HASHREF,
-                                                       optional => 1,
-                                                      },
-                                         bug_index => {type => OBJECT,
-                                                       optional => 1,
-                                                      },
-                                         version   => {type => SCALAR|ARRAYREF,
-                                                       optional => 1,
-                                                      },
-                                         dist       => {type => SCALAR|ARRAYREF,
-                                                        optional => 1,
-                                                       },
-                                         arch       => {type => SCALAR|ARRAYREF,
-                                                        optional => 1,
-                                                       },
-                                         bugusertags   => {type => HASHREF,
-                                                           optional => 1,
-                                                          },
-                                         sourceversions => {type => ARRAYREF,
-                                                            optional => 1,
-                                                           },
-                                         indicatesource => {type => BOOLEAN,
-                                                            default => 1,
-                                                           },
-                                        },
+                              spec   => $spec,
                              );
      my %status;
 
@@ -1238,6 +1265,8 @@ sub get_bug_status {
 
      $status{source} = binary_to_source(binary=>[split /\s*,\s*/, $status{package}],
                                        source_only => 1,
+                                       exists $param{binary_to_source_cache}?
+                                       (cache =>$param{binary_to_source_cache}):(),
                                       );
 
      $status{"package"} = 'unknown' if ($status{"package"} eq '');