private void InsertCommit(VersionNode version) { // find commit hash for existing version string hash = VersionToCommit[version.Parent]; // create branch var branchname = GetBranchName(version); VersionConfig.GitRepo.MakeBranch(branchname, hash); // if this commit is the most recent for this branch, we can just commit right on top without insertion logic string tophash = VersionConfig.GitRepo.BranchHash(branchname); if (hash == tophash) { VersionConfig.GitRepo.Checkout(branchname); DoCommit(version); } else { Console.WriteLine($"Needs to insert into history for this one"); // make a branch that starts there and prepare to commit to it VersionConfig.GitRepo.CheckoutBranch("temp", hash); VersionConfig.GitRepo.MakeBranch(branchname); DoCommit(version); // insert Profiler.Start($"Rebasing"); VersionConfig.GitRepo.Rebase("temp", branchname); VersionConfig.GitRepo.Checkout(branchname); VersionConfig.GitRepo.DeleteBranch("temp"); Profiler.Stop(); // need to rescan since commit hashes change after a rebase LoadCommits(); } }
private void DoCommit(VersionNode version) { Profiler.Start($"Adding commit for {version.Version}"); // extract string workspace = Path.Combine(Path.GetTempPath(), "mc_version_history_workspace"); if (Directory.Exists(workspace)) { Directory.Delete(workspace, true); } Directory.CreateDirectory(workspace); Profiler.Run("Extracting", () => { version.Version.ExtractData(workspace, Config); }); Profiler.Run("Translating NBT Files", () => { TranslateNbtFiles(workspace); }); Profiler.Run($"Merging", () => { MergeWithWorkspace(VersionConfig.GitRepo.Folder, workspace); Directory.Delete(workspace, true); Util.RemoveEmptyFolders(VersionConfig.GitRepo.Folder); File.WriteAllText(Path.Combine(VersionConfig.GitRepo.Folder, "version.txt"), version.Version.Name); }); // commit Profiler.Start($"Running git commit"); VersionConfig.GitRepo.Commit(version.Version.Name, version.Version.ReleaseTime); string hash = VersionConfig.GitRepo.BranchHash("HEAD"); CommitToVersion.Add(hash, version); VersionToCommit.Add(version, hash); Profiler.Stop(); // git commit Profiler.Stop(); // top commit }
public static int Depth(this VersionNode node) { if (!node.Children.Any()) { return(1); } return(1 + node.Children.Max(x => Depth(x))); }
public static TreeNode GetAllTypeNode() { TypeDatapointTypeVersionNode nodeType = new TypeDatapointTypeVersionNode(); nodeType.Text = nodeType.KNXMainNumber + "." + nodeType.KNXSubNumber + " " + nodeType.Name; nodeType.Nodes.Add(VersionNode.GetTypeNode()); return(nodeType); }
public void TestSuccessor() { var first = new VersionNode(); var successor = first.GetSuccessor(); var anotherSuccessor = first.GetSuccessor(); Assert.IsTrue(first.CompareTo(successor) < 0); Assert.IsTrue(first.CompareTo(anotherSuccessor) < 0); Assert.IsTrue(anotherSuccessor.CompareTo(successor) < 0); }
public static Unit Set(string csprojPath, VersionNode node, string value) { var doc = ProjectLoader.Load(csprojPath); var versionNode = NodeFinder.GetVersionNode(doc, node); versionNode.IfSome(x => { x.InnerText = value; doc.Save(new Uri(doc.BaseURI).LocalPath); }); return(Unit.Default); }
private void InitialCommit(VersionNode version) { Profiler.Start("Initializing repo"); VersionConfig.GitRepo.Init(); if (Config.GitIgnoreContents != null) { File.WriteAllText(Path.Combine(VersionConfig.GitRepo.Folder, ".gitignore"), Config.GitIgnoreContents); } // create branch VersionConfig.GitRepo.CheckoutBranch(GetBranchName(version)); Profiler.Stop(); DoCommit(version); }
static VersionNode GetNode(byte[] data, int startPosition, out int nodeLength) { nodeLength = 0; VersionNode node = new VersionNode { cbNode = BitConverter.ToUInt16(data, startPosition + nodeLength), cbData = BitConverter.ToUInt16(data, startPosition + nodeLength + 2) }; nodeLength += 4; MemoryStream nameMs = new MemoryStream(); while (data[startPosition + nodeLength] > 0) { nameMs.WriteByte(data[startPosition + nodeLength]); nodeLength++; } node.szName = Encoding.ASCII.GetString(nameMs.ToArray()); nodeLength++; if (nodeLength % 4 > 0) { nodeLength += 4 - nodeLength % 4; } node.rgbData = new byte[node.cbData]; Array.Copy(data, startPosition + nodeLength, node.rgbData, 0, node.cbData); nodeLength += node.cbData; if (nodeLength % 4 > 0) { nodeLength += 4 - nodeLength % 4; } List <VersionNode> children = new List <VersionNode>(); while (nodeLength < node.cbNode) { children.Add(GetNode(data, startPosition + nodeLength, out int childLength)); nodeLength += childLength; } if (children.Count > 0) { node.children = children.ToArray(); } return(node); }
public void TestFromList() { VersionNode[] array = { new VersionNode(), new VersionNode(), new VersionNode(), new VersionNode(), new VersionNode() }; VersionNode.FromList(null, array, 0); for (int i = 0; i < array.Length; i++) { for (int j = i + 1; j < array.Length; j++) { Assert.Greater(array[j].CompareTo(array[i]), 0); } } }
void DecodeNode(VersionNode node, string parent, string grandparent) { if (node.szName == Consts.FixedFileInfoSig) { IntPtr infoPtr = Marshal.AllocHGlobal(node.cbData); Marshal.Copy(node.rgbData, 0, infoPtr, node.cbData); FixedFileInfo info = (FixedFileInfo)Marshal.PtrToStructure(infoPtr, typeof(FixedFileInfo)); Marshal.FreeHGlobal(infoPtr); FileVersion = $"{(info.dwFileVersionMS & 0xFFFF0000) >> 16}.{info.dwFileVersionMS & 0xFFFF:D2}.{(info.dwFileVersionLS & 0xFFFF0000) >> 16}.{info.dwFileVersionLS & 0xFFFF}"; ProductVersion = $"{(info.dwProductVersionMS & 0xFFFF0000) >> 16}.{info.dwProductVersionMS & 0xFFFF:D2}.{(info.dwProductVersionLS & 0xFFFF0000) >> 16}.{info.dwProductVersionLS & 0xFFFF}"; FileFlags = (VersionFileFlags)(info.dwFileFlags & info.dwFileFlagsMask); FileOs = (VersionFileOS)info.dwFileOS; FileType = (VersionFileType)info.dwFileType; FileSubtype = (VersionFileSubtype)info.dwFileSubtype; FileDate = DateTime.FromFileTime(info.dwFileDateMS * 0x100000000 + info.dwFileDateLS); } if (parent == Consts.StringFileInfo) { Dictionary <string, string> strings = new Dictionary <string, string>(); StringsByLanguage.Add(node.szName, strings); } if (grandparent == Consts.StringFileInfo) { if (StringsByLanguage.TryGetValue(parent, out Dictionary <string, string> strings)) { Encoding encoding; try { encoding = Encoding.GetEncoding(Convert.ToInt32(parent.Substring(4), 16)); } catch { encoding = Encoding.ASCII; } strings.Add(node.szName, encoding.GetString(node.rgbData)); } } if (node.children == null) { return; } foreach (VersionNode n in node.children) { DecodeNode(n, node.szName, parent); } }
/// <summary> /// Initializes a new instance of the <see cref="T:libexeinfo.NE.Version" /> class. /// </summary> /// <param name="data">Resource data.</param> /// <param name="resourceName">Resource name.</param> public Version(byte[] data, string resourceName = null) { if (data == null || data.Length < 5) { return; } Name = resourceName; StringsByLanguage = new Dictionary <string, Dictionary <string, string> >(); VersionNode root = GetNode(data, 0, out int rootLength); DecodeNode(root, null, null); }
private void Commit(VersionNode version) { if (VersionToCommit.ContainsKey(version)) { return; } if (version.Parent == null) { Console.WriteLine($"{version.Version.Name} is the first version in the history!"); InitialCommit(version); } else { Console.WriteLine($"Parent of {version.Version.Name} is {version.Parent.Version.Name}"); if (!VersionToCommit.ContainsKey(version.Parent)) { Console.WriteLine("Need to commit parent first"); Commit(version.Parent); } InsertCommit(version); } }
public static Option <XmlNode> GetVersionNode(XmlDocument document, VersionNode versionNode) { return(document.DocumentElement.SelectSingleNode(GetNodeStringMap()[versionNode])); }
public static Option <string> GetVersionNodeValue(string csprojPath, VersionNode versionNode) => GetReadOnlyVersionNode(csprojPath, versionNode).Select(x => x.InnerText);
private string GetBranchName(VersionNode version) => version.ReleaseName.Replace(' ', '-');
public static Option <XmlNode> GetReadOnlyVersionNode(string csprojPath, VersionNode versionNode) { var doc = ProjectLoader.Load(csprojPath); return(GetVersionNode(doc, versionNode)); }
public static IEnumerable <VersionNode> OrderedChildren(this VersionNode node) { return(node.Children.OrderBy(x => Depth(x))); }
static VersionNode GetNode(byte[] data, int startPosition, out int nodeLength) { nodeLength = 0; VersionNode node = new VersionNode { wLength = BitConverter.ToUInt16(data, startPosition + nodeLength), wValueLength = BitConverter.ToUInt16(data, startPosition + nodeLength + 2), wType = BitConverter.ToUInt16(data, startPosition + nodeLength + 4) }; nodeLength += 6; MemoryStream nameMs = new MemoryStream(); while (true) { if (data[startPosition + nodeLength] == 0 && data[startPosition + nodeLength + 1] == 0) { break; } nameMs.WriteByte(data[startPosition + nodeLength]); nameMs.WriteByte(data[startPosition + nodeLength + 1]); nodeLength += 2; } node.szName = Encoding.Unicode.GetString(nameMs.ToArray()); nodeLength += 2; if (nodeLength % 4 > 0) { nodeLength += 4 - nodeLength % 4; } int factor = node.wType == 1 ? 2 : 1; node.rgbData = new byte[node.wValueLength * factor]; Array.Copy(data, startPosition + nodeLength, node.rgbData, 0, node.rgbData.Length); nodeLength += node.rgbData.Length; if (nodeLength % 4 > 0) { nodeLength += 4 - nodeLength % 4; } string foo = Encoding.Unicode.GetString(node.rgbData); List <VersionNode> children = new List <VersionNode>(); while (nodeLength < node.wLength) { children.Add(GetNode(data, startPosition + nodeLength, out int childLength)); nodeLength += childLength; } if (children.Count > 0) { node.children = children.ToArray(); } return(node); }