Ian Jackson writes ("Re: Bug#910687: dgit: build-source and push-source 
disregard -wc"):
> I think in fact that this needs to be more general.  For example, with
> --clean=dpkg-source: if dpkg-source leaves untracked files, this
> should be detected.  I think this check should happen any time dgit
> builds a source package.

I made this table.  You'll need a wide window and a fixed-width font
and 8-column tabs.

In summary:

dgit used to always clean the tree.  But push-source and build-source
don't need to (when working in a playtree, ie without
--include-dirty), so don't.  I think we need to reintroduce some
variant of tree cleaning to those operations.

But I'm not really convinced that push-source and build-source ought
ever to run rules clean.  So I think we need a new interpretation of
clean modes: ie, the source builds should look at the clean mode and
do *something*: and that something will be to check that it doesn't
look like a git-add was forgotten.

And then I think we need a way to override this.  Given the special
nature of the various cases, I think that is going to be some new
clean modes which are varients of existing ones.

Ian.

/: = without --include-dirty
i: = with --include-dirty

                        ACTION ON BINARIES BUILD                                
ACTION ON SOURCE BUILD

                        ignored files           unignored files                 
ignored files                   unignored files

                                                                                
(These are gitignored files     (These are un-ignored files,    
                                                                                
 which could have resulted       maybe from a build (buggy      
                                                                                
 from a build without there      gitignore), or maybe           
                                                                                
 being any bug.)                 forgot to git add)             

                                                                                
quite possibly present          hopefully not present
                                                                                
                                often present in non-dgit pkgs

dpkg-source     }       (runs rules clean)      (runs rules clean)              
(used to run rules clean)       (used to run rules clean)
dpkg-source-d   }       /: disregarded          /: disregarded                  
do we want rules clean ?        do we want rules clean ?
                        i: used*                i: used*                        
without, makes check less good  without, makes check less good
                        (These are              (These are un-gitignored        
/: disregarded                  /: disregarded
                         gitignored files        files left by rules clean.     
i: used*                        i: used*
                         left by rules clean;    Either buggy clean or          
                         probably a bug but      forgot to git add.)            
                         not one we care about)                                 

                                                /: ** should trip **            
                                /: ** should trip **
 ** wddu ? **                                   ** want opt to disregard **     
                                ** want opt to disregard **
 aka --dpkg-source,untracked

git             }       deleted                 deleted                         
/: disregarded                  /: disregarded
git-ff          }                                                               
                                   would be fine to delete but
                                                                                
                                   ** better to trip ? **
                                                                                
                                ** want opt to disregard **

                                                                                
i: used*                        i: used*

check                   trips                   trips                           
/: disregarded                  /: disregarded
                                                                                
i: used*                        i: used*

                                                                                
both: ** should trip **         both: ** should trip **

 ** wci ? **                                                                    
** want opt to tolerate (only) ignored files **
 aka --clean=check,ignore

none                    /: disregarded          /: disregarded                  
/: disregarded                  /: disregarded
                        i: used*                i: used*                        
i: used*                        i: used*


* used means included in build source package, but will cause push failure

Reply via email to