C# GitIndex.write方法代码示例

        public void testReadTree()
        {
            // Prepare tree
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("[email protected]", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "[email protected]")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            index.write();

            ObjectId id = index.writeTree();
            Console.WriteLine("wrote id " + id);
            Assert.AreEqual("0036d433dc4f10ec47b61abc3ec5033c78d34f84", id.Name);
            var index2 = new GitIndex(db);

            index2.ReadTree(db.MapTree(ObjectId.FromString("0036d433dc4f10ec47b61abc3ec5033c78d34f84")));
            IList<GitIndex.Entry> members = index2.Members;
            Assert.AreEqual(3, members.Count);
            Assert.AreEqual("a.b", members[0].Name);
            Assert.AreEqual("a/b", members[1].Name);
            Assert.AreEqual("[email protected]", members[2].Name);
            Assert.AreEqual(3, members.Count);

            var indexr = new GitIndex(db);
            indexr.Read();
            IList<GitIndex.Entry> membersr = indexr.Members;
            Assert.AreEqual(3, membersr.Count);
            Assert.AreEqual("a.b", membersr[0].Name);
            Assert.AreEqual("a/b", membersr[1].Name);
            Assert.AreEqual("[email protected]", membersr[2].Name);
            Assert.AreEqual(3, membersr.Count);

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testReadTree2()
        {
            // Prepare a larger tree to test some odd cases in tree writing
            var index = new GitIndex(db);
            FileInfo f1 = writeTrashFile("a/a/a/a", "data:a/a/a/a");
            FileInfo f2 = writeTrashFile("a/c/c", "data:a/c/c");
            FileInfo f3 = writeTrashFile("a/b", "data:a/b");
            FileInfo f4 = writeTrashFile("[email protected]", "data:a:b");
            FileInfo f5 = writeTrashFile("a/d", "data:a/d");
            FileInfo f6 = writeTrashFile("a.b", "data:a.b");
            index.add(trash, f1);
            index.add(trash, f2);
            index.add(trash, f3);
            index.add(trash, f4);
            index.add(trash, f5);
            index.add(trash, f6);
            index.write();
            ObjectId id = index.writeTree();
            Console.WriteLine("wrote id " + id);
            Assert.AreEqual("5e0bf0aad57706894c15fdf0681c9bc7343274fc", id.Name);
            var index2 = new GitIndex(db);

            index2.ReadTree(db.MapTree(ObjectId.FromString("5e0bf0aad57706894c15fdf0681c9bc7343274fc")));
            IList<GitIndex.Entry> members = index2.Members;
            Assert.AreEqual(6, members.Count);
            Assert.AreEqual("a.b", members[0].Name);
            Assert.AreEqual("a/a/a/a", members[1].Name);
            Assert.AreEqual("a/b", members[2].Name);
            Assert.AreEqual("a/c/c", members[3].Name);
            Assert.AreEqual("a/d", members[4].Name);
            Assert.AreEqual("[email protected]", members[5].Name);

            // reread and test
            var indexr = new GitIndex(db);
            indexr.Read();
            IList<GitIndex.Entry> membersr = indexr.Members;
            Assert.AreEqual(6, membersr.Count);
            Assert.AreEqual("a.b", membersr[0].Name);
            Assert.AreEqual("a/a/a/a", membersr[1].Name);
            Assert.AreEqual("a/b", membersr[2].Name);
            Assert.AreEqual("a/c/c", membersr[3].Name);
            Assert.AreEqual("a/d", membersr[4].Name);
            Assert.AreEqual("[email protected]", membersr[5].Name);
        }

        public void testCreateSimpleSortTestIndex()
        {
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("[email protected]", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "[email protected]")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            index.write();

            Assert.AreEqual("a/b", index.GetEntry("a/b").Name);
            Assert.AreEqual("[email protected]", index.GetEntry("[email protected]").Name);
            Assert.AreEqual("a.b", index.GetEntry("a.b").Name);
            Assert.IsNull(index.GetEntry("a*b"));

            // Repeat test for re-Read index
            var indexr = new GitIndex(db);
            indexr.Read();
            Assert.AreEqual("a/b", indexr.GetEntry("a/b").Name);
            Assert.AreEqual("[email protected]", indexr.GetEntry("[email protected]").Name);
            Assert.AreEqual("a.b", indexr.GetEntry("a.b").Name);
            Assert.IsNull(indexr.GetEntry("a*b"));

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testDelete()
        {
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("[email protected]", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "[email protected]")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            index.write();
            index.writeTree();
            index.remove(trash, new FileInfo(Path.Combine(trash.FullName, "[email protected]")));
            index.write();
            Assert.AreEqual("a.b", index.Members[0].Name);
            Assert.AreEqual("a/b", index.Members[1].Name);

            var indexr = new GitIndex(db);
            indexr.Read();
            Assert.AreEqual("a.b", indexr.Members[0].Name);
            Assert.AreEqual("a/b", indexr.Members[1].Name);

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testCheckout()
        {
            // Prepare tree, remote it and checkout
            var index = new GitIndex(db);
            FileInfo aslashb = writeTrashFile("a/b", "data:a/b");
            FileInfo acolonb = writeTrashFile("[email protected]", "data:a:b");
            FileInfo adotb = writeTrashFile("a.b", "data:a.b");
            index.add(trash, aslashb);
            index.add(trash, acolonb);
            index.add(trash, adotb);
            index.write();
            index.writeTree();
            Delete(aslashb);
            Delete(acolonb);
            Delete(adotb);
            Delete(Directory.GetParent(aslashb.FullName));

            var index2 = new GitIndex(db);
            Assert.AreEqual(0, index2.Members.Count);

            index2.ReadTree(db.MapTree(ObjectId.FromString("0036d433dc4f10ec47b61abc3ec5033c78d34f84")));

            index2.checkout(trash);
            Assert.AreEqual("data:a/b", Content(aslashb));
            Assert.AreEqual("data:a:b", Content(acolonb));
            Assert.AreEqual("data:a.b", Content(adotb));

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testCreateEmptyIndex()
        {
            var index = new GitIndex(db);
            index.write();
            // native git doesn't like an empty index
            // Assert.AreEqual(0,System(trash,"git status"));

            var indexr = new GitIndex(db);
            indexr.Read();
            Assert.AreEqual(0, indexr.Members.Count);
        }

        private void doCheckout(GitSharp.Core.Ref branch)
        {
            if (branch == null)
                throw new ArgumentNullException("branch", "Cannot checkout; no HEAD advertised by remote");

            if (!Constants.HEAD.Equals(branch.Name))
                GitRepository.WriteSymref(Constants.HEAD, branch.Name);
            GitSharp.Core.Commit commit = GitRepository.MapCommit(branch.ObjectId);
            RefUpdate u = GitRepository.UpdateRef(Constants.HEAD);
            u.NewObjectId = commit.CommitId;
            u.ForceUpdate();
            GitIndex index = new GitIndex(GitRepository);
            GitSharp.Core.Tree tree = commit.TreeEntry;
            WorkDirCheckout co = new WorkDirCheckout(GitRepository, GitRepository.WorkingDirectory, index, tree);
            co.checkout();
            index.write();
        }

        public void testCheckout()
        {
            // Prepare tree, remote it and checkout
            var index = new GitIndex(db);
            FileInfo aslashb = writeTrashFile("a/b", "data:a/b");
            FileInfo acolonb = writeTrashFile("a:b", "data:a:b");
            FileInfo adotb = writeTrashFile("a.b", "data:a.b");
            index.add(trash, aslashb);
            index.add(trash, acolonb);
            index.add(trash, adotb);
            index.write();
            index.writeTree();
            Delete(aslashb);
            Delete(acolonb);
            Delete(adotb);
            Delete(Directory.GetParent(aslashb.FullName));

            var index2 = new GitIndex(db);
            Assert.AreEqual(0, index2.Members.Length);

            index2.ReadTree(db.MapTree(ObjectId.FromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));

            index2.checkout(trash);
            Assert.AreEqual("data:a/b", Content(aslashb));
            Assert.AreEqual("data:a:b", Content(acolonb));
            Assert.AreEqual("data:a.b", Content(adotb));

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testUpdateExistingMsysgitIndex()
        {
            var index_path = Path.Combine(trash.FullName + "/.git", "index");
            new FileInfo("Resources/index_originating_from_msysgit").CopyTo(index_path);

            var index = new GitIndex(db);
            index.Read();
            var a = writeTrashFile("a.txt", "Data:a");
            index.add(trash, a);
            index.write();
            index.Read();

            byte[] content = File.ReadAllBytes(index_path);

            Assert.AreEqual(352, content.Length);
        }

		protected override void Run ()
		{
			var cloneDialog = new CloneRepositoryDialog ();
			cloneDialog.Run ();
			cloneDialog.Destroy ();
			
			var repositoryPath = cloneDialog.RepositoryPath;
			URIish source = new URIish (repositoryPath);
			var originName = cloneDialog.OriginName;
			var destination = cloneDialog.WorkingDirectory;
			var workingDirectory = Path.Combine (destination, Constants.DOT_GIT);
			
			if (string.IsNullOrEmpty (originName))
				originName = Constants.DEFAULT_REMOTE_NAME;
			
			var rep = new GitSharp.Core.Repository (new DirectoryInfo (workingDirectory));
			rep.Create ();
			rep.Config.setBoolean ("core", null, "bare", false);
			rep.Config.save ();
			
			var rc = new RemoteConfig (rep.Config, originName);
			rc.AddURI (source);
			rc.AddFetchRefSpec (new RefSpec ().SetForce (true).SetSourceDestination (
					Constants.R_HEADS + "*", 
					Constants.R_REMOTES + originName + "/*"));
			rc.Update (rep.Config);
			rep.Config.save ();
			
			Transport tn = Transport.open (rep, originName);
			FetchResult fetchResult = null;
			try 
			{
				fetchResult = tn.fetch (new NullProgressMonitor (), null);
			} 
			catch 
			{
				tn.Dispose ();
			}
			
			GitSharp.Core.Ref branch = null;
			if (fetchResult != null) 
			{
				var headId = fetchResult.GetAdvertisedRef (Constants.HEAD);
				var availableRefs = new List<GitSharp.Core.Ref> ();
				
				foreach (GitSharp.Core.Ref r in fetchResult.AdvertisedRefs) 
				{
					var n = r.Name;
					if (!n.StartsWith (Constants.R_HEADS))
						continue;
					
					availableRefs.Add (r);
					if (headId == null || branch != null)
						continue;
					
					if (r.ObjectId.Equals (headId.ObjectId))
						branch = r;
				}
				
				availableRefs.Sort (RefComparator.INSTANCE);
				
				if (headId != null && branch == null)
					branch = headId;
			}
			
			if (branch != null) 
			{
				if (!Constants.HEAD.Equals (branch.Name)) 
				{
					//rep. (Constants.HEAD, branch.Name);
					GitSharp.Core.Commit commit = rep.MapCommit (branch.ObjectId);
					RefUpdate update = rep.UpdateRef (Constants.HEAD);
					update.NewObjectId = commit.CommitId;
					update.forceUpdate ();
					
					var index = new GitIndex (rep);
					var tree = commit.TreeEntry;
					WorkDirCheckout co = new WorkDirCheckout (rep, rep.WorkingDirectory, index, tree);
					co.checkout ();
					index.write ();
				}
			} 
			else 
			{
				MessageService.ShowError ("Cannot clone: no HEAD advertised by remote.");
			}
			
			MessageService.ShowMessage(string.Format("Finished cloning {0} to {1}", 
					repositoryPath, 
					destination));
		}

        public void testWriteTree()
        {
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("a:b", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a:b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            index.write();

            ObjectId id = index.writeTree();
            Assert.AreEqual("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.Name);

            writeTrashFile("a/b", "data:a/b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testReadTree2()
        {
            // Prepare a larger tree to test some odd cases in tree writing
            var index = new GitIndex(db);
            FileInfo f1 = writeTrashFile("a/a/a/a", "data:a/a/a/a");
            FileInfo f2 = writeTrashFile("a/c/c", "data:a/c/c");
            FileInfo f3 = writeTrashFile("a/b", "data:a/b");
            FileInfo f4 = writeTrashFile("a:b", "data:a:b");
            FileInfo f5 = writeTrashFile("a/d", "data:a/d");
            FileInfo f6 = writeTrashFile("a.b", "data:a.b");
            index.add(trash, f1);
            index.add(trash, f2);
            index.add(trash, f3);
            index.add(trash, f4);
            index.add(trash, f5);
            index.add(trash, f6);
            index.write();
            ObjectId id = index.writeTree();
            Console.WriteLine("wrote id " + id);
            Assert.AreEqual("ba78e065e2c261d4f7b8f42107588051e87e18e9", id.Name);
            var index2 = new GitIndex(db);

            index2.ReadTree(db.MapTree(ObjectId.FromString("ba78e065e2c261d4f7b8f42107588051e87e18e9")));
            GitIndex.Entry[] members = index2.Members;
            Assert.AreEqual(6, members.Length);
            Assert.AreEqual("a.b", members[0].Name);
            Assert.AreEqual("a/a/a/a", members[1].Name);
            Assert.AreEqual("a/b", members[2].Name);
            Assert.AreEqual("a/c/c", members[3].Name);
            Assert.AreEqual("a/d", members[4].Name);
            Assert.AreEqual("a:b", members[5].Name);

            // reread and test
            var indexr = new GitIndex(db);
            indexr.Read();
            GitIndex.Entry[] membersr = indexr.Members;
            Assert.AreEqual(6, membersr.Length);
            Assert.AreEqual("a.b", membersr[0].Name);
            Assert.AreEqual("a/a/a/a", membersr[1].Name);
            Assert.AreEqual("a/b", membersr[2].Name);
            Assert.AreEqual("a/c/c", membersr[3].Name);
            Assert.AreEqual("a/d", membersr[4].Name);
            Assert.AreEqual("a:b", membersr[5].Name);
        }

        public void testReadTree()
        {
            // Prepare tree
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("a:b", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a:b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            index.write();

            ObjectId id = index.writeTree();
            Console.WriteLine("wrote id " + id);
            Assert.AreEqual("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.Name);
            var index2 = new GitIndex(db);

            index2.ReadTree(db.MapTree(ObjectId.FromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));
            GitIndex.Entry[] members = index2.Members;
            Assert.AreEqual(3, members.Length);
            Assert.AreEqual("a.b", members[0].Name);
            Assert.AreEqual("a/b", members[1].Name);
            Assert.AreEqual("a:b", members[2].Name);
            Assert.AreEqual(3, members.Length);

            var indexr = new GitIndex(db);
            indexr.Read();
            GitIndex.Entry[] membersr = indexr.Members;
            Assert.AreEqual(3, membersr.Length);
            Assert.AreEqual("a.b", membersr[0].Name);
            Assert.AreEqual("a/b", membersr[1].Name);
            Assert.AreEqual("a:b", membersr[2].Name);
            Assert.AreEqual(3, membersr.Length);

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        public void testUpdateSimpleSortTestIndex()
        {
            var index = new GitIndex(db);
            writeTrashFile("a/b", "data:a/b");
            writeTrashFile("[email protected]", "data:a:b");
            writeTrashFile("a.b", "data:a.b");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "[email protected]")));
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a.b")));
            writeTrashFile("a/b", "data:a/b modified");
            index.add(trash, new FileInfo(Path.Combine(trash.FullName, "a/b")));
            index.write();

            if (CanRunGitStatus)
            {
                Assert.AreEqual(0, System(trash, "git status"));
            }
        }

        private void doCheckout(GitSharp.Core.Ref branch)
        {
            if (branch == null)
                throw new ArgumentNullException("branch", "Cannot checkout; no HEAD advertised by remote");
            var repo = Repository._internal_repo;

            if (!Constants.HEAD.Equals(branch.getName()))
            {
                RefUpdate u1 = repo.UpdateRef(Constants.HEAD);
                u1.disableRefLog();
                u1.link(branch.getName());
            }

            GitSharp.Core.Commit commit = repo.MapCommit(branch.ObjectId);
            RefUpdate u = repo.UpdateRef(Constants.HEAD);
            u.NewObjectId = commit.CommitId;
            u.forceUpdate();
            GitIndex index = new GitIndex(repo);
            GitSharp.Core.Tree tree = commit.TreeEntry;
            WorkDirCheckout co = new WorkDirCheckout(repo, repo.WorkingDirectory, index, tree);
            co.checkout();
            index.write();
        }