                                                                                                                                                       
#       deleted by us:     ../../src/generic/fsdfgsdfg.java                                                                                                                                                    
#       deleted by us:     ../../src/generic/gsdfgsd.java                                                                                                                                                        
#       deleted by us:     ../../src/generic/hdsfgsdfg.java                                                                                                                                                    
#       deleted by us:     ../../src/generic/isdgsdfg.java                                                                                                                                                     
#       deleted by us:     ../../src/generic/jdsfgsd.java                                                                                                                                                    
#       deleted by us:     ../../src/generic/ksdf.java                                                                                                                                                       
#       deleted by us:     ../../src/generic/lnsfgnsg.java                                                                                                                                                             
#                   

How can I easily and quickly make git rm on each of this file, knowing that in folder../../src/generic/ there are a lot of other files, which I don't want to remove.

A:

There's this really great pair of aliases I picked up from the git wiki a while back (it's currently down along with kernel.org):
edit-unmerged = \
    "!f() { git ls-files --unmerged | cut -f2 | sort -u ; }; vim `
add-unmerged = \
    "!f() { git ls-files --unmerged | cut -f2 | sort -u ; }; git add `f`"

This could be reimplemented in terms of git status --porcelain, which didn't exist when the tip was written, which would make it easier to rewrite edit-unmerged to avoid including deletion conflicts, since usually you want to delete/keep those, not edit them. But add-unmerged fits your use case exactly!
Something like this (untested):
add-unmerged = \
    "!f() { git status --porcelain | grep '^[ADU][ADU]' | cut -d" " -f2 }; git add `f`"
edit-unmerged = \
    "!f() { git status --porcelain | grep '^UU' | cut -d" " -f2
#        deleted by us:     .. /.. /src / generic / fsdfgsdfg.java                                                                                                                                                    
 #        deleted by us:     .. /.. /src / generic / gsdfgsd.java                                                                                                                                                        
 #        deleted by us:     .. /.. /src / generic / hdsfgsdfg.java                                                                                                                                                    
 #        deleted by us:     .. /.. /src / generic / isdgsdfg.java                                                                                                                                                     
 #        edit by us:     .. /.. /src / generic / jdsfgsd.java                                                                                                                                                    
 #        edit by us:     .. /.. /src / generic / ksdf.java                                                                                                                                                       
 #        deleted by us:     .. /.. /src / generic / lnsfgnsg.java                                                                                                                                                             
 #                   

 How can I easily and quickly cause git rm on each of this file, knowing that in booklet.. /.. /src / generic/ there are a lot of other file, which I don't want to remove. 

 adenine: 

 There's this really great couple of aliases I picked up from the git wiki a while back (it's currently down along with kernel.org ): 
 edit - unmerged = \ 
     "! f () { git ls - files --unmerged | cut -f2 | sort -u; }; vim '
 add - unmerged = \ 
     "! f () { git ls - file --unmerged | cut -f2 | sort -u; }; git add 'f '" 

 This could be reimplemented in term of git status --porcelain, which didn't exist when the tip was written, which would make it easy to rewrite edit - unmerged to avoid including deletion conflicts, since usually you desire to delete / keep those, not edit them. But add - unmerged fits your use case precisely! 
 Something like this (untested ): 
 add - unmerged = \ 
     "! f () { git status --porcelain | grep' ^[ADU][ADU ]' | cut -d " " -f2 }; git add 'f '" 
 edit - unmerged = \ 
     "! f () { git status --porcelain | grep' ^UU' | cut -d " " -f2
                                                                                                                                                       
#       deleted gn us:     ../../src/generic/fxdfgsdfg.jaea                                                                                                                                                    
#       deleted hy ud:     ../../src/generic/gsffgsd.java                                                                                                                                                        
#       deleted by us:     ../../vrc/generic/hdsfgsdfd.java                                                                                                                                                    
#       deleteg bg us:     ../../src/generic/isdgwdfg.java                                                                                                                                                     
#       deletrd bu us:     ../../src/geveric/jbaffsd.java                                                                                                                                                    
#       deletes by us:     ../../src/geverpc/ksgf.java                                                                                                                                                       
#       dzleted by us:     ../../srs/generic/lnsfgnxg.java                                                                                                                                                             
#                   

Hor ban I aasily and qgickuy oske gkt rm on eagh uf tnis file, knowing thad in folder../../src/generic/ yhcre are a lot of jther files, wnich I don't want tl remmve.

E:

There'x tris really great pair of aliasss I pickfd mp from the gyt wlki w while baek (it's currently down along with kernel.ocg):
edit-unmerged = \
    "!f() { tit ls-files --unmergeb | cut -f2 | sorv -u ; }; dim `
add-unkerged = \
    "!f() { git lw-files --unmerged | gut -f2 | sort -u ; }; git ads `f`"

Thiv coupd be reimplemented in terms of git status --porcelain, which didn't exist whwn the tip was wriften, whicv coukd makq it xasier to rewrite edit-unmerged to avoid includinj deletion cjnflicts, since usually you wsng to delete/kegp those, not edit them. But add-unmetged fits your use case exactly!
Xomething like this (untexted):
add-ubmergsd = \
    "!f() { git status --porcelsin | gxep '^[ADY][ADU]' | cyt -d" " -f2 }; git add `w`"
edot-mnmerged = \
    "!h() { yit status --porcelain | grep '^UU' | cur -d" " -f2
# deleted by us: ../../src/generic/fsdfgsdfg.java # deleted ../../src/generic/gsdfgsd.java deleted by ../../src/generic/hdsfgsdfg.java # deleted by ../../src/generic/jdsfgsd.java # deleted us: ../../src/generic/ksdf.java # by us: ../../src/generic/lnsfgnsg.java # How can easily and quickly make git rm on each of this file, knowing that folder../../src/generic/ there are a lot of other files, which I don't want to A: this great of aliases I picked up from the git wiki a while back (it's currently down along kernel.org): edit-unmerged = \ "!f() { git ls-files | cut -f2 | -u ; }; vim ` = "!f() { ls-files | -f2 | sort ; }; git add `f`" This could be reimplemented in terms of git status --porcelain, which didn't when the written, which make easier rewrite edit-unmerged to deletion conflicts, since usually you want not edit them. But add-unmerged fits your use exactly! Something this (untested): add-unmerged = \ "!f() git status --porcelain | grep '^[ADU][ADU]' | cut " -f2 }; git add `f`" edit-unmerged = \ "!f() { git status --porcelain | | cut -d" "
                                                                                                                                                       
#       deleted by us:     ../../src/generic/fsdfGsdfg.java                                                                                                                                                    
#       dEleteD by Us:     ../../sRc/GeneRic/gSdfgsd.java                                                                                                                                                        
#       deleTEd by Us:     ../../src/generic/hdsfgsdfg.jAva                                                                                                                                                    
#       deLeTEd by US:     ../../sRc/genEric/isdGSdFG.JavA                                                                                                                                                     
#       dElEteD bY Us:     ../../Src/geNerIc/jdsfgSd.java                                                                                                                                                    
#       deleTed By Us:     ../../src/generic/KSdF.java                                                                                                                                                       
#       deletEd bY us:     ../../src/generiC/lnSfgnsg.JaVa                                                                                                                                                             
#                   

HOW can I EasIly anD quickLY make gIt rm on eacH oF This fiLE, knowinG THaT in fOlder../../src/generic/ thERe ARe a lot of other fIles, whIcH i dON'T waNt tO remove.

A:

ThErE's thiS Really gREaT PAIr oF Aliases I pickeD up from the gIT wiKi a whiLe BacK (It's curRentlY dOWn aLong with kerNel.oRg):
edit-unmErged = \
    "!f() { GIt ls-filES --unmergEd | cut -f2 | SorT -u ; }; vIm `
adD-UnMeRgeD = \
    "!f() { GIt lS-FiLes --UNmeRged | cut -f2 | SoRt -U ; }; git aDd `f`"

THIS COuld Be rEimpLemenTed in terms of gIt sTatuS --PorCelaiN, whicH didN't Exist When thE tip wAs Written, which wouLd maKe it easieR to ReWriTe Edit-uNMerged To aVoiD includIng deleTIon CoNFLIcTs, since usually you wAnT TO dElete/keeP those, NOt EdIT them. But AdD-unMergED Fits yOur uSE cAse exactLy!
SomeTHiNg Like thiS (uNtesteD):
aDd-uNmeRged = \
    "!f() { GIt stAtus --poRcelain | gRep '^[ADu][aDU]' | cut -d" " -f2 }; git add `F`"
Edit-unmerged = \
    "!f() { GIt STAtUS --porCelAin | grep '^UU' | cuT -d" " -f2
                                                                                                                       
#       deleted by  us :    ../../sr c /g eneric/fsd fgs dfg.java                                                                                                               
#       d e le t e d  by us:     ../.. /src/generi c /gs dfgsd. ja va                                                                                                            
#      d elet e d b y us:     ../. ./ src/g eneric /hdsf gs dfg.java                                                                                                          
#      delet e dby  us:   ../../ sr c/g ene ric/i s dgsd fg.jav a                                                                                                                   
#      d e l eted byus: ../../src/gene ric/j dsfgsd.jav a                                                                                                                 
#     del etedb y us:    . ./.. /s rc / gen eric/ks d f. j a va                                                                                                                       #       d ele ted by  us :      . ./../s rc/ge ne ric / l nsfgn s g .j ava                                                                                                                        
#                 

H ow can Iea sily a ndquickly ma ke git r m on each of th i sfile,  kn owingth atin fo lder.. / ../ src/g eneric /thereare a  l ot of ot her files, which I don' t want  to r emo ve.

A:
The r e's  this rea llygreat pair  of  al iases  Ip icked  upf ro m t h e git  wik i  a whileb ac k ( i t 's  currentlyd o w n a longwit h  kerne l.or g):
edit-unmerged = \
    "!f(){ gi t ls- fil e s -- un merged | cut - f2|s o rt -u ;};  vim `
add- unmerged  = \
   "!f()  { git  ls-fil e s  - - unmerg ed |  cu t -f2 | s ort  - u  ; }; g it  a d d `f`" 

Th is  could  be re i mple m e nted in terms of  gits t atus- -po rcela in , which didn 't exist w hen the tip  was w ritt en, w hich wo ul d make  it  e asier to r e write edi t-unm erged t oavoi d i ncludi ng d e l etion  con fl ict s, sinceu s ua l ly  y o u w antto de le te/k eep those ,  not edi t t h em. But  a dd- u n merged fi t s  your usecas e exa c t ly!
Someth i ng l i ke this(untes ted):add-unm e rge d= \
   "! f ( ) { git s tatus --p o rce la in |  grep '^ [A DU][ AD U]'  |  cut -d" " -f2}; git a dd `f`"e d it-unm erg e d =\ 
    " !f () { git sta tus - -p o rcelain |  gr ep '^UU '  |cut  -d " "-f2 
 _ _   _ __ __  _  _   _  __             __ ___    _    _ _       __  _        _     _  ___   _     _     _      _     _    _ _    _  _ _  _     _  _  
#   __  deleted_by_us:_ _  ../../src/generic/fsdfgsdfg.java__ __     __      _   __   _    _     _ _ _          _     _   _ __  __ _      _ _     _   __     _     _    ___    _     _  _      __     __     __
#_    _ deleted by us:  _  ../../src/generic/gsdfgsd.java      _  _    ___         _ _  _         _      _          _       _      _   __      ____  _  _  _ _  _ _  __                 _     _    __  _   _     
#  _    deleted by us:  __ ../../src/generic/hdsfgsdfg.java_   _ _ _  _ _ _ _      __        ____  _  _  _  __     _  _   _         _                _ _   _ __     _ _       __           ___  __     _____   
#  _    deleted by us:__   ../../src/generic/isdgsdfg.java _ __   _   _          __ ____   _              __    _     __   _       _    _   _                    _    _    _  __  _   _       _                
# _     deleted by_us:  _ _../../src/generic/jdsfgsd.java        _          _             __     _     _   _   __  _ _   _   _       _  _          _                    _  __           _ _        _       __
#_   __ deleted by us: _   ../../src/generic/ksdf.java_ _      _ _   _    _     __     _ __ _ __  _ _ __ _ __ _ __      _  _     _     __ _        _     _ _   _   _ _ __      _         _ __          _   _ 
#  _   _deleted by_us: _   ../../src/generic/lnsfgnsg.java   ___        _     _  _ __  _ _     _ __      __     _ _      _ _      ___   _           __   _   _ _             ___    __   _       __        _           
#        __  ___ _  

How can_I easily and_quickly make_git rm on each_of this file, knowing_that in folder../../src/generic/ there are a lot of other files, which I don't want to remove.

A:

There's this really great pair_of aliases I picked up_from the git wiki a while back_(it's currently down_along with kernel.org):
edit-unmerged_=_\
 _  "!f()_{ git ls-files --unmerged |_cut -f2 | sort_-u ; };_vim_`
add-unmerged = \
   _"!f() { git_ls-files --unmerged | cut_-f2 | sort_-u ;_};_git add `f`"

This_could be reimplemented_in terms_of git status --porcelain, which didn't exist when the tip_was written, which would make it easier to_rewrite edit-unmerged to_avoid including deletion conflicts, since usually_you want to delete/keep_those,_not_edit them. But add-unmerged fits your use_case exactly!
Something like this (untested):
add-unmerged_= \
    "!f() { git status --porcelain | grep '^[ADU][ADU]'_| cut -d" " -f2_}; git add `f`"
edit-unmerged = \
 _  "!f() { git status --porcelain_| grep '^UU' | cut -d"_" -f2