विमडिफ: परिवर्तनों की कुल संख्या प्रदर्शित करना

Question

(g) vim में दो फ़ाइलों को अलग करते समय, क्या परिवर्तनों की कुल संख्या प्रदर्शित करना संभव है? मुझे लगता है कि यह गुना की संख्या को गिनने के बराबर है, लेकिन मुझे नहीं पता कि यह कैसे करना है।

आदर्श रूप से मुझे एक संदेश चाहिए जो "Change 1 of 12" जैसा कुछ कहता है जो अद्यतन होगा क्योंकि मैंने ]c के साथ परिवर्तनों के माध्यम से चक्रवात किया था।

मुझे अपने कार्यालय के कुछ सदस्यों को विम के चमत्कारों में परिवर्तित करने में बड़ी सफलता मिल रही है, लेकिन विमडिफ एक सतत बगबियर है।

Answer 1

यहां थोड़ा और परिष्कृत समाधान है। यह diff की गणना करने के लिए मेरे पिछले उत्तर के समान तकनीक का उपयोग करता है, लेकिन यह वैश्विक चर g:diff_hunks पर हस्ताक्षरित सूची में प्रत्येक हंक की पहली पंक्ति संग्रहीत करता है। फिर कर्सर के नीचे शिकारी की संख्या सूची में लाइन नंबर की स्थिति ढूंढकर पाई जा सकती है। यह भी ध्यान दें कि मैंने nocursorbind और noscrollbind सेट किया है और यह सुनिश्चित करने के लिए अंत में उन्हें रीसेट कर दिया है कि हम अलग-अलग विंडो में माउस स्क्रॉलिंग नहीं तोड़ते हैं। जब भी कोई अंतर बफर संशोधित किया गया है

function! UpdateDiffHunks() 
    setlocal nocursorbind 
    setlocal noscrollbind 
    let winview = winsaveview() 
    let pos = getpos(".") 
    sil exe 'normal! gg' 
    let moved = 1 
    let hunks = [] 
    while moved 
     let startl = line(".") 
     keepjumps sil exe 'normal! ]c' 
     let moved = line(".") - startl 
     if moved 
      call add(hunks,line(".")) 
     endif 
    endwhile 
    call winrestview(winview) 
    call setpos(".",pos) 
    setlocal cursorbind 
    setlocal scrollbind 
    let g:diff_hunks = hunks 
endfunction 

समारोह UpdateDiffHunks() अद्यतन किया जाना चाहिए, लेकिन मैं इसे पर्याप्त CursorMoved और BufEnter से मैप करने के लिए लगता है।

function! DiffCount() 
    if !exists("g:diff_hunks") 
     call UpdateDiffHunks() 
    endif 
    let n_hunks = 0 
    let curline = line(".") 
    for hunkline in g:diff_hunks 
     if curline < hunkline 
      break 
     endif 
     let n_hunks += 1 
    endfor 
    return n_hunks . '/' . len(g:diff_hunks) 
endfunction 

DiffCount() के उत्पादन statusline में इस्तेमाल किया जा सकता है, या एक आदेश से बंधा।

Answer 2

ठीक है, यहां सबसे अच्छा है कि मैं अपने साथ आ सकता हूं। यह फ़ंक्शन वर्तमान बफर के शीर्ष पर शुरू होता है और ]c गति का उपयोग करके यह ]c तक परिवर्तनों के माध्यम से अब तक कोई प्रभाव नहीं पड़ता है। यह परिवर्तनों की संख्या देता है (या 0 यदि कर्सर अगर यह एक diff बफर नहीं है)।

function! CountDiffs() 
    let winview = winsaveview() 
    let num_diffs = 0 
    if &diff 
     let pos = getpos(".") 
     keepj sil exe 'normal! G' 
     let lnum = 1 
     let moved = 1 
     while moved 
      let startl = line(".") 
      keepj sil exe 'normal! [c' 
      let moved = line(".") - startl 
      if moved 
       let num_diffs+=1 
      endif 
     endwhile 
     call winrestview(winview) 
     call setpos(".",pos) 
    endif 
    return num_diffs 
endfunction 

ऐसा लगता है कि ठीक है, और मेरी स्थिति रेखा में शामिल होने पर एक उल्लेखनीय प्रदर्शन हिट नहीं है।

वर्तमान परिवर्तन की "संख्या" ढूंढने के लिए, यहां एक ऐसा फ़ंक्शन है जो कर्सर की स्थिति से पहले परिवर्तनों की संख्या को गिनने के लिए पिछड़े [c गति का उपयोग करता है। लौटाया गया मूल्य बिल्कुल सही नहीं है ... मुझे लगता है कि शायद यह केवल एक नंबर लौटाएगा यदि कर्सर परिवर्तन की पहली पंक्ति के बजाय बदले गए पाठ के अंदर "भीतर" है।

function! CurrentDiff() 
    if &diff 
     let num_diff = 0 
     let winview = winsaveview() 
     let pos = getpos(".") 
     let moved = 1 
     while moved 
      let startl = line(".") 
      keepj sil exe 'normal! [c' 
      let moved = line(".") - startl 
      if moved 
       let num_diff+=1 
      endif 
     endwhile 
     call winrestview(winview) 
     call setpos(".",pos) 
     return num_diff 
    endif 
endfunction 

फिर से, ऐसा लगता है कि यह मेरी स्थिति रेखा में व्यवहार करता है और कर्सर के आंदोलन को प्रभावित नहीं करता है। संख्याएं ठीक से अपडेट होती हैं क्योंकि परिवर्तनों को बफर से भी कॉपी किया जाता है।

एक बार समस्याएं खत्म हो जाने के बाद मैं इसे विम वेबसाइट पर प्लगइन के रूप में अपलोड करने पर विचार कर सकता हूं।