क्या संशोधन संख्याओं को मैन्युअल रूप से बदलना/पुन: व्यवस्थित करना संभव है (बशर्ते टोपोलॉजी वही रहती है)?

Question

Mercurial में, संशोधन संख्या स्थानीय क्लोन विशिष्ट हैं, और उन्हें एक परिवर्तन आईडी के मुकाबले अधिक उपयोगकर्ता के अनुकूल तरीके से एक विशिष्ट परिवर्तन को इंगित करने की सुविधा के रूप में प्रदान किया जाता है।

हालांकि टाइमलाइन ग्राफ प्रदर्शित करते समय, TortoiseHG संशोधन संख्या द्वारा ऑर्डर करेगा। अगर कुछ लड़के अक्सर ऐसा नहीं करते हैं, तो आप आसन्न संशोधन संख्याओं के साथ एक साथ अपने सभी काम करेंगे, और यह ग्राफ के पूरे बिंदु को गड़बड़ कर देगा। दो लेखकों, एक दूसरे के काम को मर्ज करने में, वहाँ विकास के दो लाइनें हैं:

यह ग्राफ अधिक व्यावहारिक होगा

इसलिए, यह संभव है संशोधन संख्याओं को मैन्युअल रूप से पुन: व्यवस्थित करने के लिए (जब तक the topological order of changesets अभी भी नई संख्याओं के साथ संगत है?

धन्यवाद।

Answer 1

अपने भंडार को पुन: व्यवस्थित करना संभव है (यही contrib/shrink-revlog.py करता है)। लेकिन इस मामले में यह अधिक कठिन और जटिल लगता है।

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

Answer 2

जैसा कि अन्य कह रहे हैं, यह संभव है, लेकिन शायद काम के लायक नहीं है, क्योंकि यह आपके क्लोन (और आपके क्लोन के किसी भी क्लोन) के लिए स्थानीय होगा। यह ऐसा कुछ नहीं है जिसे आप पहले रिमोट रिपोजिटरी w/o को सबकुछ हटा सकते हैं, और यहां तक ​​कि यदि आपने ऐसा किया है, तो उन लोगों को जो स्थानीय रिमोट रिपोजिटरी से क्लोन थे, उन्हें खींचने पर "कोई बदलाव नहीं" दिखाई देगा।

यह कहा गया है कि, यदि आप कोशिश करना चाहते हैं तो आपको hg pull -r REV कमांड की एक श्रृंखला को नए क्लोन में उपयोग करने की आवश्यकता है। कुछ इस तरह:

hg init my_reordered_clone 
cd my_reordered_clone 
hg pull -r d84b1 ../un_reordered_clone 
hg pull -r 6d269 ../un_reordered_clone 
hg pull -r bb9e4 ../un_reordered_clone 

जाहिर है कि बहुत ज्यादा काम सौंदर्य प्रयोजनों के लिए लायक हो, लेकिन अवधारणा है कि जब आप -r साथ खींच आपको लगता है कि changeset और अपने पूर्वजों के सभी मिलता है, तो आप अपने करते हैं उन बिंदुओं पर खींचता है जहां अज्ञात शाखाएं एक समय में विलय हो जाती हैं, आप विकास की उस पंक्ति से केवल अतिरिक्त परिवर्तनों को खींचेंगे।

Answer 3

मेरे पास एक समान उपयोग केस है: मैं इस प्रश्न पर आया क्योंकि मैंने एक ही समय में विभिन्न शाखाओं से परिवर्तनों का एक गुच्छा धक्का दिया, और वे तिथि तक क्रमबद्ध नहीं हुए। अब मेरे पास कम संख्या वाले माता-पिता के साथ कुछ विलय हैं जो वास्तव में पुराने नहीं हैं; उन्हें देखने के लिए लॉग को ऊपर और नीचे स्क्रॉल करना एक दर्द है। मैंने @ Ry4an के उत्तर में सुझाए गए दृष्टिकोण का पालन किया - यह वास्तव में काफी सरल है, यदि आप अपने इच्छित परिवर्तन आदेश की भविष्यवाणी (यानी, गणना) कर सकते हैं।

यदि आपका वर्कफ़्लो केवल शाखा प्रमुखों को विलय करता है, तो आप तिथि के अनुसार revsets को सॉर्ट करके वांछित संशोधन आदेश प्राप्त कर सकते हैं। यह आपको निम्न आदेश के साथ कर सकते हैं:

hg log -r 'sort(0:tip, date)' --template '{rev}\n' 

फिर आप रिपोजिटरी क्लोन और कालानुक्रमिक क्रम में एक के बाद संशोधन एक खींचने के लिए अपने पसंदीदा पटकथा भाषा में एक पाश का उपयोग कर सकते हैं।,

hg clone -r 0 messy-repo sorted-repo 
cd sorted-repo 
for REV in `hg log -R ../messy-repo -r 'sort(1:tip, date)' --template '{rev}\n'` 
do 
    hg pull ../messy-repo -r $REV 
done 

मैं ध्यान दें (इससे पहले कि कोई और करता है :-)) है कि इस भंडार का भंडारण आकार में वृद्धि होगी चाहिए की वजह से: बल्कि शुरू से एक भंडार init से, मैं इस तरह से यह कर समाप्त हो गया जिस तरह से डेल्टा गणना की जाती है। मुझे कोई फर्क नहीं पड़ता।

Answer 4

नीचे इतिहास पुनर्क्रमित के साथ अपने रेपो कॉपी करने के लिए एक csscript

आदेश का उपयोग ग्राफ चौड़ाई संकीर्ण करने के लिए एक कार्यान्वयन है

cs-script\cscs.exe HgSortMergeChangesets.cs fromRepo toNewRepo 

फ़ाइल "HgSortMergeChangesets.cs" निम्नलिखित सामग्री है:

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.IO; 
using System.Linq; 

class Program 
{ 
    static int Main(string[] args) 
    { 
     if (args.Length != 2) 
     { 
      Console.WriteLine("usage: SortHgRepo <fromRepo> <toRepo>"); 
      return -1; 
     } 

     var fromRepo = new DirectoryInfo(args[0]); 
     var toRepo = new DirectoryInfo(args[1]); 


     int errorCode = VerifyParameters(toRepo, fromRepo); 
     if (errorCode != 0) 
     { 
      return errorCode; 
     } 

     var revsOutput = ExecCmdReturnStdOut("hg.exe", "log -r \"sort(merge(),date)\" -T \"{rev} {date|date}\\n\"", fromRepo.FullName, Console.WriteLine); 

     var mergeChangesets = ParseChangesetLog(revsOutput) 
      .ToList(); 

     ExecCmdReturnStdOut("hg.exe", string.Format("clone -U -r 0 . \"{0}\"", toRepo.FullName), fromRepo.FullName, Console.WriteLine); 

     foreach (var changeset in mergeChangesets) 
     { 
      ExecCmdReturnStdOut("hg.exe", string.Format("pull \"{1}\" -r {0}", changeset.ChangesetId, fromRepo.FullName), toRepo.FullName, Console.WriteLine); 
     } 

     ExecCmdReturnStdOut("hg.exe", string.Format("pull \"{0}\"", fromRepo.FullName), toRepo.FullName, Console.WriteLine); 

     return 0; 

    } 

    private static int VerifyParameters(DirectoryInfo toRepo, DirectoryInfo fromRepo) 
    { 
     if (toRepo.Exists) 
     { 
      Console.WriteLine("The destination repo already exists: {0}", toRepo); 
      { 
       return -2; 
      } 
     } 


     if (!fromRepo.Exists) 
     { 
      Console.WriteLine("The source repo does not exists: {0}", fromRepo); 
      { 
       return -3; 
      } 
     } 

     // make sure the source dir is a repo 
     try 
     { 
      var identity = ExecCmdReturnStdOut("hg.exe", "identify", fromRepo.FullName, Console.WriteLine); 
      Console.WriteLine(identity); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine(e.Message); 
      Console.WriteLine("The source directory, {0}, does not look like an Hg repo.", fromRepo); 
      return -4; 
     } 
     return 0; 
    } 


    private static IEnumerable<Changeset> ParseChangesetLog(string revsOutput) 
    { 
     using (var r = new StringReader(revsOutput)) 
     { 
      string line; 
      while ((line = r.ReadLine()) != null) 
      { 
       var spacePos = line.IndexOf(' '); 
       yield return new Changeset 
       { 
        ChangesetId = int.Parse(line.Substring(0, spacePos)), 
        DateStr = line.Substring(spacePos + 1) 
       }; 
      } 
     } 
    } 

    class Changeset 
    { 
     public int ChangesetId; 
     public string DateStr; 
     public DateTime Date { get { return DateTime.ParseExact(DateStr, "ddd MMM dd H:mm:ss yyyy zzz", null); } } 
    } 



    public static string ExecCmdReturnStdOut(string program, string args, string workingDir, Action<string> writeline) 
    { 

     writeline(String.Format("Executing: \"{0}\" {1} in {2}", program, args, workingDir)); 

     using (var proc = new Process()) 
     { 

      proc.StartInfo.Arguments = args; 
      proc.StartInfo.CreateNoWindow = false; 
      proc.StartInfo.FileName = program; 
      proc.StartInfo.WorkingDirectory = workingDir; 
      proc.StartInfo.RedirectStandardError = false; 
      proc.StartInfo.RedirectStandardOutput = true; 
      proc.StartInfo.UseShellExecute = false; 

      proc.Start(); 

      var output = proc.StandardOutput.ReadToEnd(); 

      proc.WaitForExit(); 

      if (proc.ExitCode != 0) 
      { 
       throw new Exception(string.Format("error code {0} returned when running command {1} in dir {2}", proc.ExitCode, "\"" + program + "\" " + args, workingDir)); 
      } 

      return output; 
     } 
    } 


} 

Answer 5

@alexis करने और @ Ry4an

श्रेय 10

मुझे तारीख के अनुसार आदेश दिया गया एक नया क्लोन बनाने का यह कामकाज पता है, और यह काम करता है, हालांकि यह बड़े भंडारों के लिए धीमा हो सकता है। यह इस बात पर निर्भर करता है कि आप इसे परेशानी के लायक मानते हैं या नहीं।

आज, मैं एक विंडोज पीसी पर खींच रहा था और यह मुझे पकड़ा, इसलिए मैं इसे जल्दी से स्वचालित करना चाहता था। तो यहाँ विंडोज कमांड प्रॉम्प्ट के लिए एक पुनर्लेखन है:

hg clone -r 0 messy-repo sorted-repo 
cd sorted-repo 
for /f "usebackq tokens=*" %r in (`hg log -R ../messy-repo -r "sort(1:tip, date)" --template "{rev}\n"`) do @echo %r && @hg pull ../messy-repo -r %r 

नोटिस: प्रतिशत चिह्न सीधे कमांड प्रॉम्प्ट पर यह इनपुट के लिए अगर यह एक बैच स्क्रिप्ट फ़ाइल के भीतर चला जाता है दोगुनी जाना चाहिए, अन्यथा एक प्रतिशत।

पीडी: विंडोज शीघ्र के लिए backquote के लिए माइकल बर को भी श्रेय: windows subcommand evaluation