public void testObjectMovedWithinPack() { // Create an object and pack it. // Core.Repository eden = createBareRepository(); RevObject o1 = WriteBlob(eden, "o1"); FileInfo[] out1 = Pack(eden, o1); Assert.AreEqual(o1.Name, Parse(o1).Name); // Force close the old pack. // WhackCache(); // Now overwrite the old pack in place. This method of creating a // different pack under the same file name is partially broken. We // should also have a different file name because the list of objects // within the pack has been modified. // RevObject o2 = WriteBlob(eden, "o2"); var pw = new PackWriter(eden, NullProgressMonitor.Instance); pw.addObject(o2); pw.addObject(o1); Write(out1, pw); // Try the old name, then the new name. The old name should cause the // pack to reload when it opens and the index and pack mismatch. // Assert.AreEqual(o1.Name, Parse(o1).Name); Assert.AreEqual(o2.Name, Parse(o2).Name); }
public void testObjectMovedToNewPack1() { // Create an object and pack it. Then remove that pack and put the // object into a different pack file, with some other object. We // still should be able to access the objects. // Core.Repository eden = createBareRepository(); RevObject o1 = WriteBlob(eden, "o1"); FileInfo[] out1 = Pack(eden, o1); Assert.AreEqual(o1.Name, Parse(o1).Name); RevObject o2 = WriteBlob(eden, "o2"); Pack(eden, o2, o1); // Force close, and then delete, the old pack. // WhackCache(); Delete(out1); // Now here is the interesting thing. Will git figure the new // object exists in the new pack, and not the old one. // Assert.AreEqual(o2.Name, Parse(o2).Name); Assert.AreEqual(o1.Name, Parse(o1).Name); }
public override void setUp() { base.setUp(); db = createWorkRepository(); trash = db.WorkingDirectory; }
public void Check_entries_of_msysgit_index() { using (var repo = new Core.Repository(db.Directory)) { var index_path = Path.Combine(repo.Directory.FullName, "index"); new FileInfo("Resources/index_originating_from_msysgit").CopyTo(index_path); var index = repo.Index; index.RereadIfNecessary(); var paths = new[] { "New Folder/New Ruby Program.rb", "for henon.txt", "test.cmd", }; var dict = index.Members.ToDictionary(entry => entry.Name); Assert.AreEqual(3, dict.Count); foreach (var path in paths) { Assert.IsTrue(dict.ContainsKey(path)); } } }
public override void setUp() { base.setUp(); db = createWorkRepository(); trash = db.WorkingDirectory; string[] packs = { "pack-34be9032ac282b11fa9babdc2b2a93ca996c9c2f", "pack-df2982f284bbabb6bdb59ee3fcc6eb0983e20371", "pack-9fb5b411fe6dfa89cc2e6b89d2bd8e5de02b5745", "pack-546ff360fe3488adb20860ce3436a2d6373d2796", "pack-cbdeda40019ae0e6e789088ea0f51f164f489d14", "pack-e6d07037cbcf13376308a0a995d1fa48f8f76aaa", "pack-3280af9c07ee18a87705ef50b0cc4cd20266cf12" }; var packDir = new DirectoryInfo(db.ObjectsDirectory + "/pack"); foreach (var packname in packs) { new FileInfo("Resources/" + Core.Transport.IndexPack.GetPackFileName(packname)).CopyTo(packDir + "/" + Core.Transport.IndexPack.GetPackFileName(packname), true); new FileInfo("Resources/" + Core.Transport.IndexPack.GetIndexFileName(packname)).CopyTo(packDir + "/" + Core.Transport.IndexPack.GetIndexFileName(packname), true); } new FileInfo("Resources/packed-refs").CopyTo(db.Directory.FullName + "/packed-refs", true); }
public void testCacheOpen() { RepositoryCache.FileKey loc = RepositoryCache.FileKey.exact(db.Directory); Core.Repository d2 = RepositoryCache.open(loc); Assert.AreNotSame(db, d2); Assert.AreSame(d2, RepositoryCache.open(RepositoryCache.FileKey.exact(loc.getFile()))); d2.Close(); d2.Close(); }
public void test007_Open() { using (Core.Repository db2 = new Core.Repository(db.Directory)) { Assert.AreEqual(db.Directory, db2.Directory); Assert.AreEqual(db.ObjectsDirectory.FullName, db2.ObjectsDirectory.FullName); Assert.AreNotSame(db.Config, db2.Config); } }
public void testObjectInNewPack() { // Create a new object in a new pack, and test that it is present. // Core.Repository eden = createBareRepository(); RevObject o1 = WriteBlob(eden, "o1"); Pack(eden, o1); Assert.AreEqual(o1.Name, Parse(o1).Name); }
ObjectId Resolve(string s) { Core.Repository repo = Git.DefaultRepository; ObjectId r = repo.Resolve(s); if (r == null) { throw die("Not a revision: " + s); } return(r); }
/** * Creates a new empty repository. * * @param bare * true to create a bare repository; false to make a repository * within its working directory * @return the newly created repository, opened for access * @throws IOException * the repository could not be created in the temporary area */ private Core.Repository createRepository(bool bare) { String uniqueId = GetType().Name + Guid.NewGuid().ToString(); String gitdirName = "test" + uniqueId + (bare ? "" : "/") + Constants.DOT_GIT; DirectoryInfo gitdir = new DirectoryInfo(Path.Combine(trash.FullName, gitdirName)); Core.Repository db = new Core.Repository(gitdir); Assert.IsFalse(gitdir.Exists); db.Create(); toClose.Add(db); return(db); }
private FetchResult fetchFromBundle(Core.Repository newRepo, byte[] bundle) { var uri = new URIish("in-memory://"); var @in = new MemoryStream(bundle); var rs = new RefSpec("refs/heads/*:refs/heads/*"); var refs = new List <RefSpec> { rs }; var transportBundleStream = new TransportBundleStream(newRepo, uri, @in); _transportBundleStreams.Add(transportBundleStream); return(transportBundleStream.fetch(NullProgressMonitor.Instance, refs)); }
public void test002_WriteEmptyTree() { // One of our test packs contains the empty tree object. If the pack is // open when we Create it we won't write the object file out as a loose // object (as it already exists in the pack). // Core.Repository newdb = createBareRepository(); var t = new Core.Tree(newdb); t.Accept(new WriteTree(trash, newdb), TreeEntry.MODIFIED_ONLY); Assert.AreEqual("4b825dc642cb6eb9a060e54bf8d69288fbee4904", t.Id.Name); var o = new FileInfo(newdb.Directory + "/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904"); Assert.IsTrue(o.IsFile(), "Exists " + o); Assert.IsTrue(o.IsReadOnly, "Read-only " + o); }
public void CanAddAFileToAMSysGitIndexWhereAFileIsAlreadyWaitingToBeCommitted() { //setup of .git directory var resource = new DirectoryInfo(Path.Combine(Path.Combine(Environment.CurrentDirectory, "Resources"), "CorruptIndex")); var tempRepository = new DirectoryInfo(Path.Combine(trash.FullName, "CorruptIndex" + Path.GetRandomFileName())); CopyDirectory(resource.FullName, tempRepository.FullName); var repositoryPath = new DirectoryInfo(Path.Combine(tempRepository.FullName, Constants.DOT_GIT)); Directory.Move(repositoryPath.FullName + "ted", repositoryPath.FullName); using (var repository = new Core.Repository(repositoryPath)) { GitIndex index = repository.Index; Assert.IsNotNull(index); writeTrashFile(Path.Combine(repository.WorkingDirectory.FullName, "c.txt"), "c"); var tree = repository.MapTree(repository.Head.ObjectId); index.add(repository.WorkingDirectory, new FileInfo(Path.Combine(repository.WorkingDirectory.FullName, "c.txt"))); var diff = new IndexDiff(tree, index); diff.Diff(); index.write(); Assert.AreEqual(2, diff.Added.Count); Assert.IsFalse(diff.Added.Contains("a.txt"), "Should not contain a.txt because it is already committed."); Assert.IsTrue(diff.Added.Contains("b.txt"), "Should contain b.txt since it was added by msysgit, but not committed"); Assert.IsTrue(diff.Added.Contains("c.txt"), "Should contain c.txt since it was added by this test, but not committed"); Assert.AreEqual(0, diff.Changed.Count); Assert.AreEqual(0, diff.Modified.Count); Assert.AreEqual(0, diff.Removed.Count); } }
private FileInfo[] Pack(Core.Repository src, params RevObject[] list) { var pw = new PackWriter(src, NullProgressMonitor.Instance); foreach (RevObject o in list) { pw.addObject(o); } ObjectId name = pw.computeName(); FileInfo packFile = FullPackFileName(name); FileInfo idxFile = FullIndexFileName(name); var files = new[] { packFile, idxFile }; Write(files, pw); return(files); }
public void CanReadMsysgitIndex() { //setup of .git directory var resource = new DirectoryInfo(Path.Combine(Path.Combine(Environment.CurrentDirectory, "Resources"), "OneFileRepository")); var tempRepository = new DirectoryInfo(Path.Combine(trash.FullName, "OneFileRepository" + Path.GetRandomFileName())); CopyDirectory(resource.FullName, tempRepository.FullName); var repositoryPath = new DirectoryInfo(Path.Combine(tempRepository.FullName, Constants.DOT_GIT)); Directory.Move(repositoryPath.FullName + "ted", repositoryPath.FullName); using (var repository = new Core.Repository(repositoryPath)) { GitIndex index = repository.Index; Assert.IsNotNull(index); List <GitIndex.Entry> entries = index.Members.ToList(); Assert.AreEqual(1, entries.Count); GitIndex.Entry entry = entries[0]; Assert.AreEqual("dummy.txt", entry.Name); Core.Ref headRef = repository.Head; Assert.AreEqual("refs/heads/master", headRef.Target.Name); Assert.AreEqual("f3ca78a01f1baa4eaddcc349c97dcab95a379981", headRef.ObjectId.Name); object obj = repository.MapObject(headRef.ObjectId, headRef.Name); #pragma warning disable 0612 Assert.IsInstanceOfType(typeof(Core.Commit), obj); // [henon] IsInstanceOfType is obsolete #pragma warning restore 0612 var commit = (Core.Commit)obj; Assert.AreEqual("f3ca78a01f1baa4eaddcc349c97dcab95a379981", commit.CommitId.Name); Assert.AreEqual(commit.Committer, commit.Author); Assert.AreEqual("nulltoken <*****@*****.**> 1255117188 +0200", commit.Committer.ToExternalString()); Assert.AreEqual(0, commit.ParentIds.Length); } }
public void testWrite0() { // Create a tiny bundle, (well one of) the first commits only byte[] bundle = makeBundle("refs/heads/firstcommit", "42e4e7c5e507e113ebbb7801b16b52cf867b7ce1", null); // Then we clone a new repo from that bundle and do a simple test. This // makes sure // we could Read the bundle we created. Core.Repository newRepo = createBareRepository(); FetchResult fetchResult = fetchFromBundle(newRepo, bundle); Core.Ref advertisedRef = fetchResult.GetAdvertisedRef("refs/heads/firstcommit"); // We expect firstcommit to appear by id Assert.AreEqual("42e4e7c5e507e113ebbb7801b16b52cf867b7ce1", advertisedRef.ObjectId.Name); // ..and by name as the bundle created a new ref Assert.AreEqual("42e4e7c5e507e113ebbb7801b16b52cf867b7ce1", newRepo.Resolve(("refs/heads/firstcommit")).Name); }
public void CanReadMsysgitIndex() { //setup of .git directory var resource = new DirectoryInfo(Path.Combine(Path.Combine(Environment.CurrentDirectory, "Resources"), "OneFileRepository")); var tempRepository = new DirectoryInfo(Path.Combine(trash.FullName, "OneFileRepository" + Path.GetRandomFileName())); CopyDirectory(resource.FullName, tempRepository.FullName); var repositoryPath = new DirectoryInfo(Path.Combine(tempRepository.FullName, Constants.DOT_GIT)); Directory.Move(repositoryPath.FullName + "ted", repositoryPath.FullName); using (var repository = new Core.Repository(repositoryPath)) { GitIndex index = repository.Index; Assert.IsNotNull(index); List<GitIndex.Entry> entries = index.Members.ToList(); Assert.AreEqual(1, entries.Count); GitIndex.Entry entry = entries[0]; Assert.AreEqual("dummy.txt", entry.Name); Core.Ref headRef = repository.Head; Assert.AreEqual("refs/heads/master", headRef.Target.Name); Assert.AreEqual("f3ca78a01f1baa4eaddcc349c97dcab95a379981", headRef.ObjectId.Name); object obj = repository.MapObject(headRef.ObjectId, headRef.Name); #pragma warning disable 0612 Assert.IsInstanceOfType(typeof (Core.Commit), obj); // [henon] IsInstanceOfType is obsolete #pragma warning restore 0612 var commit = (Core.Commit) obj; Assert.AreEqual("f3ca78a01f1baa4eaddcc349c97dcab95a379981", commit.CommitId.Name); Assert.AreEqual(commit.Committer, commit.Author); Assert.AreEqual("nulltoken <*****@*****.**> 1255117188 +0200", commit.Committer.ToExternalString()); Assert.AreEqual(0, commit.ParentIds.Length); } }
public void testWrite1() { // Create a small bundle, an early commit byte[] bundle = makeBundle("refs/heads/aa", db.Resolve("a").Name, null); // Then we clone a new repo from that bundle and do a simple test. This // makes sure // we could Read the bundle we created. Core.Repository newRepo = createBareRepository(); FetchResult fetchResult = fetchFromBundle(newRepo, bundle); Core.Ref advertisedRef = fetchResult.GetAdvertisedRef("refs/heads/aa"); Assert.AreEqual(db.Resolve("a").Name, advertisedRef.ObjectId.Name); Assert.AreEqual(db.Resolve("a").Name, newRepo.Resolve("refs/heads/aa").Name); Assert.IsNull(newRepo.Resolve("refs/heads/a")); // Next an incremental bundle bundle = makeBundle( "refs/heads/cc", db.Resolve("c").Name, new GitSharp.Core.RevWalk.RevWalk(db).parseCommit(db.Resolve("a").ToObjectId())); fetchResult = fetchFromBundle(newRepo, bundle); advertisedRef = fetchResult.GetAdvertisedRef("refs/heads/cc"); Assert.AreEqual(db.Resolve("c").Name, advertisedRef.ObjectId.Name); Assert.AreEqual(db.Resolve("c").Name, newRepo.Resolve("refs/heads/cc").Name); Assert.IsNull(newRepo.Resolve("refs/heads/c")); Assert.IsNull(newRepo.Resolve("refs/heads/a")); // still unknown try { // Check that we actually needed the first bundle Core.Repository newRepo2 = createBareRepository(); fetchResult = fetchFromBundle(newRepo2, bundle); Assert.Fail("We should not be able to fetch from bundle with prerequisites that are not fulfilled"); } catch (MissingBundlePrerequisiteException e) { Assert.IsTrue(e.Message.IndexOf(db.Resolve("refs/heads/a").Name) >= 0); } }
public void testObjectMovedToNewPack2() { // Create an object and pack it. Then remove that pack and put the // object into a different pack file, with some other object. We // still should be able to access the objects. // Core.Repository eden = createBareRepository(); RevObject o1 = WriteBlob(eden, "o1"); FileInfo[] out1 = Pack(eden, o1); Assert.AreEqual(o1.Name, Parse(o1).Name); ObjectLoader load1 = db.OpenBlob(o1); Assert.IsNotNull(load1); RevObject o2 = WriteBlob(eden, "o2"); Pack(eden, o2, o1); // Force close, and then delete, the old pack. // WhackCache(); Delete(out1); // Now here is the interesting thing... can the loader we made // earlier still resolve the object, even though its underlying // pack is gone, but the object still exists. // ObjectLoader load2 = db.OpenBlob(o1); Assert.IsNotNull(load2); Assert.AreNotSame(load1, load2); byte[] data2 = load2.CachedBytes; byte[] data1 = load1.CachedBytes; Assert.IsNotNull(data2); Assert.IsNotNull(data1); Assert.AreNotSame(data1, data2); // cache should be per-pack, not per object Assert.IsTrue(data1.SequenceEqual(data2)); Assert.AreEqual(load2.Type, load1.Type); }
public void testBareFileKey() { Core.Repository bare = createBareRepository(); DirectoryInfo gitdir = bare.Directory; DirectoryInfo parent = gitdir.Parent; Assert.IsNotNull(parent); string name = gitdir.Name; Assert.IsTrue(name.EndsWith(Constants.DOT_GIT_EXT)); name = name.Slice(0, name.Length - 4); Assert.AreEqual(gitdir, RepositoryCache.FileKey.exact(gitdir).getFile()); Assert.AreEqual(gitdir, RepositoryCache.FileKey.lenient(gitdir).getFile()); // Test was "fixed" because DirectoryInfo.Equals() compares two different references Assert.AreEqual(gitdir.FullName, RepositoryCache.FileKey.lenient(new DirectoryInfo(Path.Combine(parent.FullName, name))).getFile().FullName); }
private RevObject WriteBlob(Core.Repository repo, string data) { var revWalk = new GitSharp.Core.RevWalk.RevWalk(repo); byte[] bytes = Constants.encode(data); var ow = new ObjectWriter(repo); ObjectId id = ow.WriteBlob(bytes); try { Parse(id); Assert.Fail("Object " + id.Name + " should not exist in test repository"); } catch (MissingObjectException) { // Ok } return(revWalk.lookupBlob(id)); }
public void testCacheRegisterOpen() { DirectoryInfo dir = db.Directory; RepositoryCache.register(db); using (Core.Repository exact = RepositoryCache.open(RepositoryCache.FileKey.exact(dir))) { Assert.AreSame(db, exact); } Assert.IsTrue(dir.Name.EndsWith(Constants.DOT_GIT_EXT)); Assert.AreEqual(Constants.DOT_GIT, dir.Name); DirectoryInfo parent = dir.Parent; using (Core.Repository lenient = RepositoryCache.open(RepositoryCache.FileKey.lenient(parent))) { Assert.AreSame(db, lenient); } RepositoryCache.close(db); }
public void testFileKeyOpenNew() { Core.Repository n = createBareRepository(); DirectoryInfo gitdir = n.Directory; n.Close(); recursiveDelete(gitdir); Assert.IsFalse(gitdir.Exists); var e = AssertHelper.Throws <RepositoryNotFoundException>(() => new RepositoryCache.FileKey(gitdir).open(true)); Assert.AreEqual("repository not found: " + gitdir, e.Message); using (Core.Repository o = new RepositoryCache.FileKey(gitdir).open(false)) { Assert.IsNotNull(o); Assert.AreEqual(gitdir.FullName, o.Directory.FullName); Assert.IsFalse(gitdir.Exists); } }
public void testRenameBranchAlsoInPack() { ObjectId rb = db.Resolve("refs/heads/b"); ObjectId rb2 = db.Resolve("refs/heads/b~1"); Assert.AreEqual(Core.Ref.Storage.Packed, db.getRef("refs/heads/b").StorageFormat); RefUpdate updateRef = db.UpdateRef("refs/heads/b"); updateRef.NewObjectId = rb2; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.Forced, update, "internal check new ref is loose"); Assert.AreEqual(Core.Ref.Storage.LoosePacked, db.getRef("refs/heads/b") .StorageFormat); RefLogWriter.WriteReflog(db, rb, rb, "Just a message", "refs/heads/b"); Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists, "no log on old branch"); RefRename renameRef = db.RenameRef("refs/heads/b", "refs/heads/new/name"); RefUpdate.RefUpdateResult result = renameRef.Rename(); Assert.AreEqual(RefUpdate.RefUpdateResult.Renamed, result); Assert.AreEqual(rb2, db.Resolve("refs/heads/new/name")); Assert.IsNull(db.Resolve("refs/heads/b")); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader( "new/name").getLastEntry().getComment()); Assert.AreEqual(3, db.ReflogReader("refs/heads/new/name").getReverseEntries().Count); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader("refs/heads/new/name").getReverseEntries()[0].getComment()); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); // make sure b's log file is gone too. Assert.IsFalse(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists); // Create new Repository instance, to reread caches and make sure our // assumptions are persistent. using (Core.Repository ndb = new Core.Repository(db.Directory)) { Assert.AreEqual(rb2, ndb.Resolve("refs/heads/new/name")); Assert.IsNull(ndb.Resolve("refs/heads/b")); } }
/** * Run a hook script in the repository, returning the exit status. * * @param db * repository the script should see in GIT_DIR environment * @param hook * path of the hook script to execute, must be executable file * type on this platform * @param args * arguments to pass to the hook script * @return exit status code of the invoked hook * @throws IOException * the hook could not be executed * @throws InterruptedException * the caller was interrupted before the hook completed */ protected int runHook(Core.Repository db, FileInfo hook, params string[] args) { String[] argv = new String[1 + args.Length]; argv[0] = hook.FullName; System.Array.Copy(args, 0, argv, 1, args.Length); IDictionary <String, String> env = cloneEnv(); env.put("GIT_DIR", db.Directory.FullName); putPersonIdent(env, "AUTHOR", author); putPersonIdent(env, "COMMITTER", committer); DirectoryInfo cwd = db.WorkingDirectory; throw new NotImplementedException("Not ported yet."); //Process p = Runtime.getRuntime().exec(argv, toEnvArray(env), cwd); //p.getOutputStream().close(); //p.getErrorStream().close(); //p.getInputStream().close(); //return p.waitFor(); }
public void testRenameBranchAlsoInPack() { ObjectId rb = db.Resolve("refs/heads/b"); ObjectId rb2 = db.Resolve("refs/heads/b~1"); Assert.AreEqual(Ref.Storage.Packed, db.getRef("refs/heads/b").StorageFormat); RefUpdate updateRef = db.UpdateRef("refs/heads/b"); updateRef.NewObjectId = rb2; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.Update(); Assert.AreEqual(RefUpdate.RefUpdateResult.Forced, update, "internal check new ref is loose"); Assert.AreEqual(Ref.Storage.LoosePacked, db.getRef("refs/heads/b") .StorageFormat); RefLogWriter.WriteReflog(db, rb, rb, "Just a message", "refs/heads/b"); Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists, "no log on old branch"); RefRename renameRef = db.RenameRef("refs/heads/b", "refs/heads/new/name"); RefUpdate.RefUpdateResult result = renameRef.Rename(); Assert.AreEqual(RefUpdate.RefUpdateResult.Renamed, result); Assert.AreEqual(rb2, db.Resolve("refs/heads/new/name")); Assert.IsNull(db.Resolve("refs/heads/b")); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader( "new/name").getLastEntry().getComment()); Assert.AreEqual(3, db.ReflogReader("refs/heads/new/name").getReverseEntries().Count); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader("refs/heads/new/name").getReverseEntries()[0].getComment()); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); // make sure b's log file is gone too. Assert.IsFalse(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists); // Create new Repository instance, to reread caches and make sure our // assumptions are persistent. Core.Repository ndb = new Core.Repository(db.Directory); Assert.AreEqual(rb2, ndb.Resolve("refs/heads/new/name")); Assert.IsNull(ndb.Resolve("refs/heads/b")); }
/** * Creates a new empty repository. * * @param bare * true to create a bare repository; false to make a repository * within its working directory * @return the newly created repository, opened for access * @throws IOException * the repository could not be created in the temporary area */ private Core.Repository createRepository(bool bare) { String uniqueId = GetType().Name + Guid.NewGuid().ToString(); String gitdirName = "test" + uniqueId + (bare ? "" : "/") + ".git"; DirectoryInfo gitdir = new DirectoryInfo(Path.Combine(trash.FullName, gitdirName)); Core.Repository db = new Core.Repository(gitdir); Assert.IsFalse(gitdir.Exists); db.Create(); toClose.Add(db); return db; }
/// <summary> /// Do it. /// </summary> public override void Execute() { if (Source.Length <= 0) { throw new ArgumentException("fatal: You must specify a repository to clone."); } if (Directory != null && GitDirectory != null) { throw new ArgumentException("conflicting usage of --git-dir and arguments"); } var source = new URIish(Source); if (Directory == null) { try { Directory = source.getHumanishName(); } catch (InvalidOperationException e) { throw new ArgumentException("cannot guess local name from " + source, e); } } if (GitDirectory == null) { GitDirectory = Path.Combine(Directory, Constants.DOT_GIT); } if (Mirror) Bare = true; if (Bare) { if (OriginName != null) throw new ArgumentException("Bare+Origin", "--bare and --origin " + OriginName + " options are incompatible."); NoCheckout = true; } if (OriginName == null) OriginName = Constants.DEFAULT_REMOTE_NAME; if (System.IO.Directory.Exists(Directory) && System.IO.Directory.GetFileSystemEntries(Directory).Length != 0) { throw new InvalidOperationException(string.Format("destination path '{0}' already exists and is not an empty directory.", new DirectoryInfo(Directory).FullName)); } var repo = new Core.Repository(new DirectoryInfo(GitDirectory)); repo.Create(Bare); repo.Config.setBoolean("core", null, "bare", Bare); repo.Config.save(); Repository = new Repository(repo); if (!Quiet) { OutputStream.WriteLine("Initialized empty Git repository in " + repo.Directory.FullName); OutputStream.Flush(); } saveRemote(source); FetchResult r; try { r = runFetch(); } catch (NoRemoteRepositoryException) { Repository.Dispose(); throw; } GitSharp.Core.Ref branch = guessHEAD(r); if (!NoCheckout) doCheckout(branch); }
/// <summary> /// Execute the command line /// </summary> /// <param name="argv"></param> private static void execute(string[] argv) { if (argv.Count() == 0) { ShowHelp(); } else if (!argv[0].StartsWith("--") && !argv[0].StartsWith("-")) { CommandCatalog catalog = new CommandCatalog(); CommandRef subcommand = catalog.Get(argv[0]); string gitdir = null; if (subcommand != null) { TextBuiltin cmd = subcommand.Create(); List<String> args = argv.ToList(); GitSharp.Core.Repository repo = null; try { for (int x = 0; x < args.Count; x++) { if (args[x].IndexOf("--git-dir=") > -1) { if (args[x].Length > 10) { gitdir = args[x].Substring(11); args.RemoveAt(x); break; } } } } catch (ArgumentException) { if (Git.DefaultOutputStream != null) { Git.DefaultOutputStream.WriteLine("error: can't find git directory"); Git.DefaultOutputStream.Flush(); } Exit(1); } if (cmd.RequiresRepository) { if (gitdir == null) gitdir = Commands.AbstractCommand.FindGitDirectory(null, true, false); repo = new Core.Repository(new DirectoryInfo(gitdir)); cmd.Init(repo, gitdir); } else cmd.Init(null, gitdir); try { // Remove the subcommand from the command line args.RemoveAt(0); cmd.Execute(args.ToArray()); } finally { if (Git.DefaultOutputStream != null) Git.DefaultOutputStream.Flush(); if (repo != null) repo.Close(); } } else { // List all available commands starting with argv[0] if the command // specified does not exist. // If no commands exist starting with argv[0], show the help screen. if (!ShowCommandMatches(argv[0])) ShowHelp(); } } else { // If the first argument in the command line is an option (denoted by starting with - or --), // no subcommand has been specified in the command line. try { arguments = options.Parse(argv); } catch (OptionException err) { if (arguments.Count > 0) { Console.Error.WriteLine("fatal: " + err.Message); Exit(1); } } } Exit(0); }
public override AbstractTreeIterator createSubtreeIterator(Core.Repository repo) { return(null); }
/// <summary> /// Do it. /// </summary> public override void Execute() { if (Source.Length <= 0) { throw new ArgumentException("fatal: You must specify a repository to clone."); } if (Directory != null && GitDirectory != null) { throw new ArgumentException("conflicting usage of --git-dir and arguments"); } var source = new URIish(Source); if (Directory == null) { try { Directory = source.getHumanishName(); } catch (InvalidOperationException e) { throw new ArgumentException("cannot guess local name from " + source, e); } } if (GitDirectory == null) { GitDirectory = Path.Combine(Directory, Constants.DOT_GIT); } if (Mirror) { Bare = true; } if (Bare) { if (OriginName != null) { throw new ArgumentException("Bare+Origin", "--bare and --origin " + OriginName + " options are incompatible."); } NoCheckout = true; } if (OriginName == null) { OriginName = Constants.DEFAULT_REMOTE_NAME; } if (System.IO.Directory.Exists(Directory) && System.IO.Directory.GetFileSystemEntries(Directory).Length != 0) { throw new InvalidOperationException(string.Format("destination path '{0}' already exists and is not an empty directory.", new DirectoryInfo(Directory).FullName)); } var repo = new Core.Repository(new DirectoryInfo(GitDirectory)); repo.Create(Bare); repo.Config.setBoolean("core", null, "bare", Bare); repo.Config.save(); Repository = new Repository(repo); if (!Quiet) { OutputStream.WriteLine("Initialized empty Git repository in " + repo.Directory.FullName); OutputStream.Flush(); } saveRemote(source); FetchResult r; try { r = runFetch(); } catch (NoRemoteRepositoryException) { Repository.Dispose(); throw; } GitSharp.Core.Ref branch = guessHEAD(r); if (!NoCheckout) { doCheckout(branch); } }
public void Check_entries_of_msysgit_index() { using (var repo = new Core.Repository(db.Directory)) { var index_path = Path.Combine(repo.Directory.FullName, "index"); new FileInfo("Resources/index_originating_from_msysgit").CopyTo(index_path); var index = repo.Index; index.RereadIfNecessary(); var paths = new[] { "New Folder/New Ruby Program.rb", "for henon.txt", "test.cmd", }; var dict = index.Members.ToDictionary(entry => entry.Name); Assert.AreEqual(3, dict.Count); foreach (var path in paths) Assert.IsTrue(dict.ContainsKey(path)); } }
public MockTransport(Core.Repository local, URIish uri, List <Core.Ref> advertisedRefs) : base(local, uri) { advertised = advertisedRefs; }