X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;ds=sidebyside;f=Debbugs%2FStatus.pm;h=9d047a40b053a6867d4b10b24d0486c88e6c8a1e;hb=9e1812518c39ffaaa9000f08a4966323c58937ef;hp=73506611a26d585da976a31576b1b7a9008cda8c;hpb=13ec5025323d6fc900f601a6591d096afdb03549;p=debbugs.git

diff --git a/Debbugs/Status.pm b/Debbugs/Status.pm
index 7350661..9d047a4 100644
--- 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,8 @@ 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 uniq);
+use DateTime::Format::Pg;
 
 use Carp qw(croak);
 
@@ -164,33 +167,34 @@ 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};
     my $status;
     my $log;
     my $location;
+    my $report;
     if (not defined $param{summary}) {
 	 my $lref;
 	 ($lref,$location) = @param{qw(bug location)};
@@ -200,13 +204,16 @@ sub read_bug{
 	 }
 	 $status = getbugcomponent($lref, 'summary', $location);
 	 $log    = getbugcomponent($lref, 'log'    , $location);
+	 $report    = getbugcomponent($lref, 'report'    , $location);
 	 return undef unless defined $status;
 	 return undef if not -e $status;
     }
     else {
 	 $status = $param{summary};
 	 $log = $status;
+	 $report = $status;
 	 $log =~ s/\.summary$/.log/;
+	 $report =~ s/\.summary$/.report/;
 	 ($location) = $status =~ m/(db-h|db|archive)/;
          ($param{bug}) = $status =~ m/(\d+)\.summary$/;
     }
@@ -225,15 +232,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 +254,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 +262,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,18 +281,34 @@ 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"}});
     }
 
     my $status_modified = (stat($status))[9];
     # Add log last modified time
     $data{log_modified} = (stat($log))[9] // (stat("${log}.gz"))[9];
+    my $report_modified = (stat($report))[9] // $data{log_modified};
     $data{last_modified} = max($status_modified,$data{log_modified});
+    # if the date isn't set (ancient bug), use the smallest of any of the modified
+    if (not defined $data{date} or not length($data{date})) {
+        $data{date} = min($report_modified,$status_modified,$data{log_modified});
+    }
     $data{location} = $location;
     $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;
 }
 
@@ -303,20 +330,42 @@ our $ditch_empty = sub{
     return grep {length $_} map {split $splitter} @t;
 };
 
-my $ditch_empty_space = sub {return &{$ditch_empty}(' ',@_)};
+our $sort_and_unique = sub {
+    my @v;
+    my %u;
+    my $all_numeric = 1;
+    for my $v (@_) {
+        if ($all_numeric and $v =~ /\D/) {
+            $all_numeric = 0;
+        }
+        next if exists $u{$v};
+        $u{$v} = 1;
+        push @v, $v;
+    }
+    if ($all_numeric) {
+        return sort {$a <=> $b} @v;
+    } else {
+        return sort @v;
+    }
+};
+
+my $ditch_space_unique_and_sort = sub {return &{$sort_and_unique}(&{$ditch_empty}(' ',@_))};
 my %split_fields =
     (package        => \&splitpackages,
      affects        => \&splitpackages,
-     blocks         => $ditch_empty_space,
-     blockedby      => $ditch_empty_space,
+     # 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_space_unique_and_sort,
+     blockedby      => $ditch_space_unique_and_sort,
      # this isn't strictly correct, but we'll split both of them for
      # the time being until we ditch all use of keywords everywhere
      # from the code
-     keywords       => $ditch_empty_space,
-     tags           => $ditch_empty_space,
-     found_versions => $ditch_empty_space,
-     fixed_versions => $ditch_empty_space,
-     mergedwith     => $ditch_empty_space,
+     keywords       => $ditch_space_unique_and_sort,
+     tags           => $ditch_space_unique_and_sort,
+     found_versions => $ditch_space_unique_and_sort,
+     fixed_versions => $ditch_space_unique_and_sort,
+     mergedwith     => $ditch_space_unique_and_sort,
     );
 
 sub split_status_fields {
@@ -416,7 +465,6 @@ data.
 =cut
 
 sub lockreadbugmerge {
-     my ($bug_num,$location) = @_;
      my $data = lockreadbug(@_);
      if (not defined $data) {
 	  return (0,undef);
@@ -514,7 +562,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 +1227,43 @@ 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,
+				   },
+	 schema => {type => OBJECT,
+		    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;
 
@@ -1216,7 +1275,64 @@ sub get_bug_status {
 	  return \%status;
      }
      if (defined $param{status}) {
-	  %status = %{$param{status}};
+	 %status = %{$param{status}};
+     }
+     elsif (defined $param{schema}) {
+	 my $b = $param{schema}->resultset('Bug')->
+	     search_rs({'me.id' => $param{bug}},
+		      {prefetch => [{'bug_tags'=>'tag'},
+				    'severity',
+				   {'bug_binpackages'=> 'bin_pkg'},
+				   {'bug_srcpackages'=> 'src_pkg'},
+				   {'bug_user_tags'=>{'user_tag'=>'correspondent'}},
+				   {owner => 'correspondent_full_names'},
+				   {submitter => 'correspondent_full_names'},
+                                    'bug_merged_bugs',
+                                    'bug_mergeds_merged',
+                                    'bug_blocks_blocks',
+                                    'bug_blocks_bugs',
+                                   {'bug_vers' => ['src_pkg','src_ver']},
+				   ],
+		       '+columns' => [qw(subject log_modified creation last_modified)],
+		       collapse => 1,
+		       result_class => 'DBIx::Class::ResultClass::HashRefInflator',
+		      })->first();
+	 $status{keywords} =
+	     join(' ',map {$_->{tag}{tag}} @{$b->{bug_tags}});
+	 $status{tags} = $status{keywords};
+	 $status{subject} = $b->{subject};
+	 $status{bug_num} = $b->{id};
+	 $status{severity} = $b->{severity}{severity};
+	 $status{package} =
+	     join(' ',
+		  (map {$_->{bin_pkg}{pkg}} @{$b->{bug_binpackages}//[]}),
+		  (map {$_->{src_pkg}{pkg}} @{$b->{bug_srcpackages}//[]}));
+         $status{originator} = $b->{submitter_full};
+	 $status{log_modified} =
+	     DateTime::Format::Pg->parse_datetime($b->{log_modified})->epoch;
+	 $status{date} =
+	     DateTime::Format::Pg->parse_datetime($b->{creation})->epoch;
+	 $status{last_modified} =
+	     DateTime::Format::Pg->parse_datetime($b->{last_modified})->epoch;
+         $status{blocks} =
+             join(' ',
+                  uniq(sort(map {$_->{block}}
+                            @{$b->{bug_blocks_block}},
+                           )));
+         $status{blockedby} =
+             join(' ',
+                  uniq(sort(map {$_->{bug}}
+                            @{$b->{bug_blocks_bug}},
+                           )));
+         $status{mergedwith} =
+             join(' ',uniq(sort(map {$_->{bug},$_->{merged}}
+                                @{$b->{bug_merged_bugs}},
+                                @{$b->{bug_mergeds_merged}},
+                               )));
+         $status{fixed_versions} =
+             [map {$_->{found}?():$_->{ver_string}} @{$b->{bug_vers}}];
+         $status{found_versions} =
+             [map {$_->{found}?$_->{ver_string}:()} @{$b->{bug_vers}}];
      }
      else {
 	  my $location = getbuglocation($param{bug}, 'summary');
@@ -1238,6 +1354,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 '');