GetParentFile() public method

public GetParentFile ( ) : FilePath
return FilePath
コード例 #1
0
ファイル: FS_POSIX.cs プロジェクト: LunarLanding/ngit
		protected internal override FilePath DiscoverGitPrefix()
		{
			string path = SystemReader.GetInstance().Getenv("PATH");
			FilePath gitExe = SearchPath(path, "git");
			if (gitExe != null)
			{
				return gitExe.GetParentFile().GetParentFile();
			}
			if (SystemReader.GetInstance().IsMacOS())
			{
				// On MacOSX, PATH is shorter when Eclipse is launched from the
				// Finder than from a terminal. Therefore try to launch bash as a
				// login shell and search using that.
				//
				string w = ReadPipe(UserHome(), new string[] { "bash", "--login", "-c", "which git"
					 }, Encoding.Default.Name());
				//
				//
				if (w == null || w.Length == 0)
				{
					return null;
				}
				FilePath parentFile = new FilePath(w).GetParentFile();
				if (parentFile == null)
				{
					return null;
				}
				return parentFile.GetParentFile();
			}
			return null;
		}
コード例 #2
0
ファイル: PackLock.cs プロジェクト: LunarLanding/ngit
		/// <summary>Create a new lock for a pack file.</summary>
		/// <remarks>Create a new lock for a pack file.</remarks>
		/// <param name="packFile">location of the <code>pack-*.pack</code> file.</param>
		/// <param name="fs">the filesystem abstraction used by the repository.</param>
		public PackLock(FilePath packFile, FS fs)
		{
			FilePath p = packFile.GetParentFile();
			string n = packFile.GetName();
			keepFile = new FilePath(p, Sharpen.Runtime.Substring(n, 0, n.Length - 5) + ".keep"
				);
			this.fs = fs;
		}
コード例 #3
0
ファイル: OpenSshConfigTest.cs プロジェクト: JamesChan/ngit
 public override void SetUp()
 {
     base.SetUp();
     home = new FilePath(trash, "home");
     FileUtils.Mkdir(home);
     configFile = new FilePath(new FilePath(home, ".ssh"), Constants.CONFIG);
     FileUtils.Mkdir(configFile.GetParentFile());
     Runtime.SetProperty("user.name", "jex_junit");
     osc = new OpenSshConfig(home, configFile);
 }
コード例 #4
0
		/// <exception cref="System.IO.IOException"></exception>
		private FileObjectDatabase.AlternateHandle OpenAlternate(FilePath objdir)
		{
			FilePath parent = objdir.GetParentFile();
			if (RepositoryCache.FileKey.IsGitRepository(parent, fs))
			{
				RepositoryCache.FileKey key = RepositoryCache.FileKey.Exact(parent, fs);
				FileRepository db = (FileRepository)RepositoryCache.Open(key);
				return new FileObjectDatabase.AlternateRepository(db);
			}
			NGit.Storage.File.ObjectDirectory db_1 = new NGit.Storage.File.ObjectDirectory(config
				, objdir, null, fs);
			return new FileObjectDatabase.AlternateHandle(db_1);
		}
コード例 #5
0
ファイル: KnownHosts.cs プロジェクト: LunarLanding/ngit
		public override void Add(HostKey hostkey, UserInfo userinfo)
		{
			int type = hostkey.type;
			string host = hostkey.GetHost();
			byte[] key = hostkey.key;
			HostKey hk = null;
			lock (pool)
			{
				for (int i = 0; i < pool.Count; i++)
				{
					hk = (HostKey)(pool[i]);
					if (hk.IsMatched(host) && hk.type == type)
					{
					}
				}
			}
			hk = hostkey;
			pool.Add(hk);
			string bar = GetKnownHostsRepositoryID();
			if (bar != null)
			{
				bool foo = true;
				FilePath goo = new FilePath(bar);
				if (!goo.Exists())
				{
					foo = false;
					if (userinfo != null)
					{
						foo = userinfo.PromptYesNo(bar + " does not exist.\n" + "Are you sure you want to create it?"
							);
						goo = goo.GetParentFile();
						if (foo && goo != null && !goo.Exists())
						{
							foo = userinfo.PromptYesNo("The parent directory " + goo + " does not exist.\n" +
								 "Are you sure you want to create it?");
							if (foo)
							{
								if (!goo.Mkdirs())
								{
									userinfo.ShowMessage(goo + " has not been created.");
									foo = false;
								}
								else
								{
									userinfo.ShowMessage(goo + " has been succesfully created.\nPlease check its access permission."
										);
								}
							}
						}
						if (goo == null)
						{
							foo = false;
						}
					}
				}
				if (foo)
				{
					try
					{
						Sync(bar);
					}
					catch (Exception e)
					{
						System.Console.Error.WriteLine("sync known_hosts: " + e);
					}
				}
			}
		}
コード例 #6
0
ファイル: ReflogReaderTest.cs プロジェクト: LunarLanding/ngit
		/// <exception cref="System.IO.FileNotFoundException"></exception>
		/// <exception cref="System.IO.IOException"></exception>
		private void SetupReflog(string logName, byte[] data)
		{
			FilePath logfile = new FilePath(db.Directory, logName);
			if (!logfile.GetParentFile().Mkdirs() && !logfile.GetParentFile().IsDirectory())
			{
				throw new IOException("oops, cannot create the directory for the test reflog file"
					 + logfile);
			}
			FileOutputStream fileOutputStream = new FileOutputStream(logfile);
			try
			{
				fileOutputStream.Write(data);
			}
			finally
			{
				fileOutputStream.Close();
			}
		}
コード例 #7
0
ファイル: T0003_BasicTest.cs プロジェクト: JamesChan/ngit
 public virtual void Test000_openrepo_alternate_index_file_and_objdirs()
 {
     FilePath repo1Parent = new FilePath(trash.GetParentFile(), "r1");
     FilePath indexFile = new FilePath(trash, "idx");
     FilePath objDir = new FilePath(trash, "../obj");
     FilePath altObjDir = ((ObjectDirectory)db.ObjectDatabase).GetDirectory();
     Repository repo1initial = new FileRepository(new FilePath(repo1Parent, Constants.
         DOT_GIT));
     repo1initial.Create();
     repo1initial.Close();
     FilePath theDir = new FilePath(repo1Parent, Constants.DOT_GIT);
     FileRepository r = new FileRepositoryBuilder().SetGitDir(theDir).SetObjectDirectory
         (objDir).AddAlternateObjectDirectory(altObjDir).SetIndexFile(indexFile).Build();
     //
     //
     //
     //
     AssertEqualsPath(theDir, r.Directory);
     AssertEqualsPath(theDir.GetParentFile(), r.WorkTree);
     AssertEqualsPath(indexFile, r.GetIndexFile());
     AssertEqualsPath(objDir, ((ObjectDirectory)r.ObjectDatabase).GetDirectory());
     NUnit.Framework.Assert.IsNotNull(r.Open(ObjectId.FromString("6db9c2ebf75590eef973081736730a9ea169a0c4"
         )));
     // Must close or the default repo pack files created by this test gets
     // locked via the alternate object directories on Windows.
     r.Close();
 }
コード例 #8
0
		public virtual void RepositoryWithRootLevelSubmoduleRelativeRef()
		{
			ObjectId id = ObjectId.FromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
			string path = "sub";
			FilePath dotGit = new FilePath(db.WorkTree, path + FilePath.separatorChar + Constants
				.DOT_GIT);
			if (!dotGit.GetParentFile().Exists())
			{
				dotGit.GetParentFile().Mkdirs();
			}
			FilePath modulesGitDir = new FilePath(db.Directory, "modules" + FilePath.separatorChar
				 + path);
			new FileWriter(dotGit).Append("gitdir: " + "../" + Constants.DOT_GIT + "/modules/"
				 + path).Close();
			FileRepositoryBuilder builder = new FileRepositoryBuilder();
			builder.SetWorkTree(new FilePath(db.WorkTree, path));
			builder.Build().Create();
			DirCache cache = db.LockDirCache();
			DirCacheEditor editor = cache.Editor();
			editor.Add(new _PathEdit_203(id, path));
			editor.Commit();
			SubmoduleWalk gen = SubmoduleWalk.ForIndex(db);
			NUnit.Framework.Assert.IsTrue(gen.Next());
			NUnit.Framework.Assert.AreEqual(path, gen.GetPath());
			NUnit.Framework.Assert.AreEqual(id, gen.GetObjectId());
			NUnit.Framework.Assert.AreEqual(new FilePath(db.WorkTree, path), gen.GetDirectory
				());
			NUnit.Framework.Assert.IsNull(gen.GetConfigUpdate());
			NUnit.Framework.Assert.IsNull(gen.GetConfigUrl());
			NUnit.Framework.Assert.IsNull(gen.GetModulesPath());
			NUnit.Framework.Assert.IsNull(gen.GetModulesUpdate());
			NUnit.Framework.Assert.IsNull(gen.GetModulesUrl());
			Repository subRepo = gen.GetRepository();
			AddRepoToClose(subRepo);
			NUnit.Framework.Assert.IsNotNull(subRepo);
			NUnit.Framework.Assert.AreEqual(modulesGitDir, subRepo.Directory);
			NUnit.Framework.Assert.AreEqual(new FilePath(db.WorkTree, path), subRepo.WorkTree
				);
			NUnit.Framework.Assert.IsFalse(gen.Next());
		}
コード例 #9
0
ファイル: JGitTestUtil.cs プロジェクト: ArsenShnurkov/ngit
 /// <summary>Write a string as a UTF-8 file.</summary>
 /// <remarks>Write a string as a UTF-8 file.</remarks>
 /// <param name="f">
 /// file to write the string to. Caller is responsible for making
 /// sure it is in the trash directory or will otherwise be cleaned
 /// up at the end of the test. If the parent directory does not
 /// exist, the missing parent directories are automatically
 /// created.
 /// </param>
 /// <param name="body">content to write to the file.</param>
 /// <exception cref="System.IO.IOException">the file could not be written.</exception>
 public static void Write(FilePath f, string body)
 {
     FileUtils.Mkdirs(f.GetParentFile(), true);
     TextWriter w = new OutputStreamWriter(new FileOutputStream(f), "UTF-8");
     try
     {
         w.Write(body);
     }
     finally
     {
         w.Close();
     }
 }
コード例 #10
0
ファイル: DirCacheCheckout.cs プロジェクト: stinos/ngit
 /// <exception cref="NGit.Errors.CorruptObjectException"></exception>
 /// <exception cref="System.IO.IOException"></exception>
 /// <exception cref="NGit.Errors.MissingObjectException"></exception>
 /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
 /// <exception cref="NGit.Errors.CheckoutConflictException"></exception>
 /// <exception cref="NGit.Errors.IndexWriteException"></exception>
 private bool DoCheckout()
 {
     toBeDeleted.Clear();
     ObjectReader objectReader = repo.ObjectDatabase.NewReader();
     try
     {
         if (headCommitTree != null)
         {
             PreScanTwoTrees();
         }
         else
         {
             PrescanOneTree();
         }
         if (!conflicts.IsEmpty())
         {
             if (failOnConflict)
             {
                 throw new NGit.Errors.CheckoutConflictException(Sharpen.Collections.ToArray(conflicts
                     , new string[conflicts.Count]));
             }
             else
             {
                 CleanUpConflicts();
             }
         }
         // update our index
         builder.Finish();
         FilePath file = null;
         string last = string.Empty;
         // when deleting files process them in the opposite order as they have
         // been reported. This ensures the files are deleted before we delete
         // their parent folders
         for (int i = removed.Count - 1; i >= 0; i--)
         {
             string r = removed[i];
             file = new FilePath(repo.WorkTree, r);
             if (!file.Delete() && file.Exists())
             {
                 // The list of stuff to delete comes from the index
                 // which will only contain a directory if it is
                 // a submodule, in which case we shall not attempt
                 // to delete it. A submodule is not empty, so it
                 // is safe to check this after a failed delete.
                 if (!file.IsDirectory())
                 {
                     toBeDeleted.AddItem(r);
                 }
             }
             else
             {
                 if (!IsSamePrefix(r, last))
                 {
                     RemoveEmptyParents(new FilePath(repo.WorkTree, last));
                 }
                 last = r;
             }
         }
         if (file != null)
         {
             RemoveEmptyParents(file);
         }
         foreach (string path in updated.Keys)
         {
             // ... create/overwrite this file ...
             file = new FilePath(repo.WorkTree, path);
             if (!file.GetParentFile().Mkdirs())
             {
             }
             // ignore
             DirCacheEntry entry = dc.GetEntry(path);
             // submodules are handled with separate operations
             if (FileMode.GITLINK.Equals(entry.RawMode))
             {
                 continue;
             }
             CheckoutEntry(repo, file, entry, objectReader);
         }
         // commit the index builder - a new index is persisted
         if (!builder.Commit())
         {
             throw new IndexWriteException();
         }
     }
     finally
     {
         objectReader.Release();
     }
     return toBeDeleted.Count == 0;
 }
コード例 #11
0
ファイル: LockFile.cs プロジェクト: yayanyang/monodevelop
		/// <summary>Create a new lock for any file.</summary>
		/// <remarks>Create a new lock for any file.</remarks>
		/// <param name="f">the file that will be locked.</param>
		/// <param name="fs">
		/// the file system abstraction which will be necessary to perform
		/// certain file system operations.
		/// </param>
		public LockFile(FilePath f, FS fs)
		{
			@ref = f;
			lck = new FilePath(@ref.GetParentFile(), @ref.GetName() + SUFFIX);
			this.fs = fs;
		}
コード例 #12
0
		/// <summary>Execute this checkout</summary>
		/// <returns>
		/// <code>false</code> if this method could not delete all the files
		/// which should be deleted (e.g. because of of the files was
		/// locked). In this case
		/// <see cref="GetToBeDeleted()">GetToBeDeleted()</see>
		/// lists the files
		/// which should be tried to be deleted outside of this method.
		/// Although <code>false</code> is returned the checkout was
		/// successful and the working tree was updated for all other files.
		/// <code>true</code> is returned when no such problem occurred
		/// </returns>
		/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
		public virtual bool Checkout()
		{
			toBeDeleted.Clear();
			if (headCommitTree != null)
			{
				PreScanTwoTrees();
			}
			else
			{
				PrescanOneTree();
			}
			if (!conflicts.IsEmpty())
			{
				if (failOnConflict)
				{
					dc.Unlock();
					throw new CheckoutConflictException(Sharpen.Collections.ToArray(conflicts, new string
						[conflicts.Count]));
				}
				else
				{
					CleanUpConflicts();
				}
			}
			// update our index
			builder.Finish();
			FilePath file = null;
			string last = string.Empty;
			// when deleting files process them in the opposite order as they have
			// been reported. This ensures the files are deleted before we delete
			// their parent folders
			for (int i = removed.Count - 1; i >= 0; i--)
			{
				string r = removed[i];
				file = new FilePath(repo.WorkTree, r);
				if (!file.Delete() && file.Exists())
				{
					toBeDeleted.AddItem(r);
				}
				else
				{
					if (!IsSamePrefix(r, last))
					{
						RemoveEmptyParents(file);
					}
					last = r;
				}
			}
			if (file != null)
			{
				RemoveEmptyParents(file);
			}
			foreach (string path in updated.Keys)
			{
				// ... create/overwrite this file ...
				file = new FilePath(repo.WorkTree, path);
				file.GetParentFile().Mkdirs();
				file.CreateNewFile();
				DirCacheEntry entry = dc.GetEntry(path);
				CheckoutEntry(repo, file, entry);
			}
			// commit the index builder - a new index is persisted
			if (!builder.Commit())
			{
				dc.Unlock();
				throw new IndexWriteException();
			}
			return toBeDeleted.Count == 0;
		}
コード例 #13
0
ファイル: RefDirectoryRename.cs プロジェクト: sharwell/ngit
 private static bool Rename(FilePath src, FilePath dst)
 {
     if (src.RenameTo(dst))
     {
         return true;
     }
     FilePath dir = dst.GetParentFile();
     if ((dir.Exists() || !dir.Mkdirs()) && !dir.IsDirectory())
     {
         return false;
     }
     return src.RenameTo(dst);
 }
コード例 #14
0
ファイル: IndexPack.cs プロジェクト: nickname100/monodevelop
		/// <summary>Create a new pack indexer utility.</summary>
		/// <remarks>Create a new pack indexer utility.</remarks>
		/// <param name="db"></param>
		/// <param name="src">
		/// stream to read the pack data from. If the stream is buffered
		/// use
		/// <see cref="BUFFER_SIZE">BUFFER_SIZE</see>
		/// as the buffer size for the stream.
		/// </param>
		/// <param name="dstBase"></param>
		/// <exception cref="System.IO.IOException">the output packfile could not be created.
		/// 	</exception>
		public IndexPack(Repository db, InputStream src, FilePath dstBase)
		{
			repo = db;
			objectDatabase = db.ObjectDatabase.NewCachedDatabase();
			@in = src;
			inflater = new IndexPack.InflaterStream(this);
			readCurs = objectDatabase.NewReader();
			buf = new byte[BUFFER_SIZE];
			readBuffer = new byte[BUFFER_SIZE];
			objectDigest = Constants.NewMessageDigest();
			tempObjectId = new MutableObjectId();
			packDigest = Constants.NewMessageDigest();
			if (dstBase != null)
			{
				FilePath dir = dstBase.GetParentFile();
				string nam = dstBase.GetName();
				dstPack = new FilePath(dir, nam + ".pack");
				dstIdx = new FilePath(dir, nam + ".idx");
				packOut = new RandomAccessFile(dstPack, "rw");
				packOut.SetLength(0);
			}
			else
			{
				dstPack = null;
				dstIdx = null;
			}
		}
コード例 #15
0
		private void RemoveEmptyParents(FilePath f)
		{
			FilePath parentFile = f.GetParentFile();
			while (!parentFile.Equals(root))
			{
				if (parentFile.List().Length == 0)
				{
					parentFile.Delete();
				}
				else
				{
					break;
				}
				parentFile = parentFile.GetParentFile();
			}
		}
コード例 #16
0
		private void CheckConflictsWithFile(FilePath file)
		{
			if (file.IsDirectory())
			{
				AList<string> childFiles = ListFiles(file);
				Sharpen.Collections.AddAll(conflicts, childFiles);
			}
			else
			{
				FilePath parent = file.GetParentFile();
				while (!parent.Equals(root))
				{
					if (parent.IsDirectory())
					{
						break;
					}
					if (parent.IsFile())
					{
						conflicts.AddItem(Repository.StripWorkDir(root, parent));
						break;
					}
					parent = parent.GetParentFile();
				}
			}
		}
コード例 #17
0
ファイル: DirCacheCheckout.cs プロジェクト: stinos/ngit
 private void RemoveEmptyParents(FilePath f)
 {
     FilePath parentFile = f.GetParentFile();
     while (!parentFile.Equals(repo.WorkTree))
     {
         if (!parentFile.Delete())
         {
             break;
         }
         parentFile = parentFile.GetParentFile();
     }
 }
コード例 #18
0
ファイル: RepositoryCache.cs プロジェクト: LunarLanding/ngit
			/// <summary>Guess the proper path for a Git repository.</summary>
			/// <remarks>
			/// Guess the proper path for a Git repository.
			/// <p>
			/// The method performs some basic guessing to locate the repository.
			/// Searched paths are:
			/// <ol>
			/// <li>
			/// <code>directory</code>
			/// // assume exact match</li>
			/// <li>
			/// <code>directory</code>
			/// + "/.git" // assume working directory</li>
			/// <li>
			/// <code>directory</code>
			/// + ".git" // assume bare</li>
			/// </ol>
			/// </remarks>
			/// <param name="directory">location to guess from. Several permutations are tried.</param>
			/// <param name="fs">
			/// the file system abstraction which will be necessary to
			/// perform certain file system operations.
			/// </param>
			/// <returns>
			/// the actual directory location if a better match is found;
			/// null if there is no suitable match.
			/// </returns>
			public static FilePath Resolve(FilePath directory, FS fs)
			{
				if (IsGitRepository(directory, fs))
				{
					return directory;
				}
				if (IsGitRepository(new FilePath(directory, Constants.DOT_GIT), fs))
				{
					return new FilePath(directory, Constants.DOT_GIT);
				}
				string name = directory.GetName();
				FilePath parent = directory.GetParentFile();
				if (IsGitRepository(new FilePath(parent, name + Constants.DOT_GIT_EXT), fs))
				{
					return new FilePath(parent, name + Constants.DOT_GIT_EXT);
				}
				return null;
			}
コード例 #19
0
ファイル: DirCacheCheckout.cs プロジェクト: stinos/ngit
        /// <summary>
        /// Updates the file in the working tree with content and mode from an entry
        /// in the index.
        /// </summary>
        /// <remarks>
        /// Updates the file in the working tree with content and mode from an entry
        /// in the index. The new content is first written to a new temporary file in
        /// the same directory as the real file. Then that new file is renamed to the
        /// final filename.
        /// <p>
        /// TODO: this method works directly on File IO, we may need another
        /// abstraction (like WorkingTreeIterator). This way we could tell e.g.
        /// Eclipse that Files in the workspace got changed
        /// </p>
        /// </remarks>
        /// <param name="repo"></param>
        /// <param name="f">
        /// the file to be modified. The parent directory for this file
        /// has to exist already
        /// </param>
        /// <param name="entry">the entry containing new mode and content</param>
        /// <param name="or">object reader to use for checkout</param>
        /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
        public static void CheckoutEntry(Repository repo, FilePath f, DirCacheEntry entry
			, ObjectReader or)
        {
            ObjectLoader ol = or.Open(entry.GetObjectId());
            FilePath parentDir = f.GetParentFile();
            FilePath tmpFile = FilePath.CreateTempFile("._" + f.GetName(), null, parentDir);
            WorkingTreeOptions opt = repo.GetConfig().Get(WorkingTreeOptions.KEY);
            FileOutputStream rawChannel = new FileOutputStream(tmpFile);
            OutputStream channel;
            if (opt.GetAutoCRLF() == CoreConfig.AutoCRLF.TRUE)
            {
                channel = new AutoCRLFOutputStream(rawChannel);
            }
            else
            {
                channel = rawChannel;
            }
            try
            {
                ol.CopyTo(channel);
            }
            finally
            {
                channel.Close();
            }
            FS fs = repo.FileSystem;
            if (opt.IsFileMode() && fs.SupportsExecute())
            {
                if (FileMode.EXECUTABLE_FILE.Equals(entry.RawMode))
                {
                    if (!fs.CanExecute(tmpFile))
                    {
                        fs.SetExecute(tmpFile, true);
                    }
                }
                else
                {
                    if (fs.CanExecute(tmpFile))
                    {
                        fs.SetExecute(tmpFile, false);
                    }
                }
            }
            if (!tmpFile.RenameTo(f))
            {
                // tried to rename which failed. Let' delete the target file and try
                // again
                FileUtils.Delete(f);
                if (!tmpFile.RenameTo(f))
                {
                    throw new IOException(MessageFormat.Format(JGitText.Get().couldNotWriteFile, tmpFile
                        .GetPath(), f.GetPath()));
                }
            }
            entry.LastModified = f.LastModified();
            if (opt.GetAutoCRLF() != CoreConfig.AutoCRLF.FALSE)
            {
                entry.SetLength(f.Length());
            }
            else
            {
                // AutoCRLF wants on-disk-size
                entry.SetLength((int)ol.GetSize());
            }
        }
コード例 #20
0
ファイル: T0003_BasicTest.cs プロジェクト: JamesChan/ngit
 public virtual void Test000_openrepo_default_gitDirAndWorkTreeSet()
 {
     FilePath repo1Parent = new FilePath(trash.GetParentFile(), "r1");
     Repository repo1initial = new FileRepository(new FilePath(repo1Parent, Constants.
         DOT_GIT));
     repo1initial.Create();
     repo1initial.Close();
     FilePath theDir = new FilePath(repo1Parent, Constants.DOT_GIT);
     FileRepository r = new FileRepositoryBuilder().SetGitDir(theDir).SetWorkTree(repo1Parent
         .GetParentFile()).Build();
     AssertEqualsPath(theDir, r.Directory);
     AssertEqualsPath(repo1Parent.GetParentFile(), r.WorkTree);
     AssertEqualsPath(new FilePath(theDir, "index"), r.GetIndexFile());
     AssertEqualsPath(new FilePath(theDir, "objects"), ((ObjectDirectory)r.ObjectDatabase
         ).GetDirectory());
 }
コード例 #21
0
ファイル: FileUtilTest.cs プロジェクト: LunarLanding/ngit
		public virtual void TestDeleteRecursive()
		{
			FilePath f1 = new FilePath(trash, "test/test/a");
			FileUtils.Mkdirs(f1.GetParentFile());
			FileUtils.CreateNewFile(f1);
			FilePath f2 = new FilePath(trash, "test/test/b");
			FileUtils.CreateNewFile(f2);
			FilePath d = new FilePath(trash, "test");
			FileUtils.Delete(d, FileUtils.RECURSIVE);
			NUnit.Framework.Assert.IsFalse(d.Exists());
			try
			{
				FileUtils.Delete(d, FileUtils.RECURSIVE);
				NUnit.Framework.Assert.Fail("recursive deletion of non-existing directory must fail"
					);
			}
			catch (IOException)
			{
			}
			// expected
			try
			{
				FileUtils.Delete(d, FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
			}
			catch (IOException)
			{
				NUnit.Framework.Assert.Fail("recursive deletion of non-existing directory must not fail with option SKIP_MISSING"
					);
			}
		}
コード例 #22
0
ファイル: LockFile.cs プロジェクト: kenji-tan/ngit
 /// <summary>Get the lock file corresponding to the given file.</summary>
 /// <remarks>Get the lock file corresponding to the given file.</remarks>
 /// <param name="file"></param>
 /// <returns>lock file</returns>
 internal static FilePath GetLockFile(FilePath file)
 {
     return new FilePath(file.GetParentFile(), file.GetName() + SUFFIX);
 }
コード例 #23
0
ファイル: ResolveMerger.cs プロジェクト: stinos/ngit
 /// <exception cref="NGit.Errors.NoWorkTreeException"></exception>
 /// <exception cref="System.IO.IOException"></exception>
 private void Checkout()
 {
     ObjectReader r = db.ObjectDatabase.NewReader();
     try
     {
         foreach (KeyValuePair<string, DirCacheEntry> entry in toBeCheckedOut.EntrySet())
         {
             FilePath f = new FilePath(db.WorkTree, entry.Key);
             CreateDir(f.GetParentFile());
             DirCacheCheckout.CheckoutEntry(db, f, entry.Value, r);
             modifiedFiles.AddItem(entry.Key);
         }
         // Iterate in reverse so that "folder/file" is deleted before
         // "folder". Otherwise this could result in a failing path because
         // of a non-empty directory, for which delete() would fail.
         for (int i = toBeDeleted.Count - 1; i >= 0; i--)
         {
             string fileName = toBeDeleted[i];
             FilePath f = new FilePath(db.WorkTree, fileName);
             if (!f.Delete())
             {
                 failingPaths.Put(fileName, ResolveMerger.MergeFailureReason.COULD_NOT_DELETE);
             }
             modifiedFiles.AddItem(fileName);
         }
     }
     finally
     {
         r.Release();
     }
 }
コード例 #24
0
		/// <exception cref="NGit.Errors.NoWorkTreeException"></exception>
		/// <exception cref="System.IO.IOException"></exception>
		private void Checkout()
		{
			foreach (KeyValuePair<string, DirCacheEntry> entry in toBeCheckedOut.EntrySet())
			{
				FilePath f = new FilePath(db.WorkTree, entry.Key);
				if (entry.Value != null)
				{
					CreateDir(f.GetParentFile());
					DirCacheCheckout.CheckoutEntry(db, f, entry.Value);
				}
				else
				{
					if (!f.Delete())
					{
						failingPaths.Put(entry.Key, ResolveMerger.MergeFailureReason.COULD_NOT_DELETE);
					}
				}
				modifiedFiles.AddItem(entry.Key);
			}
		}
コード例 #25
0
ファイル: ResolveMerger.cs プロジェクト: stinos/ngit
 /// <summary>Writes merged file content to the working tree.</summary>
 /// <remarks>
 /// Writes merged file content to the working tree. In case
 /// <see cref="inCore">inCore</see>
 /// is set and we don't have a working tree the content is written to a
 /// temporary file
 /// </remarks>
 /// <param name="result">the result of the content merge</param>
 /// <returns>the file to which the merged content was written</returns>
 /// <exception cref="System.IO.FileNotFoundException">System.IO.FileNotFoundException
 /// 	</exception>
 /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
 private FilePath WriteMergedFile(MergeResult<RawText> result)
 {
     MergeFormatter fmt = new MergeFormatter();
     FilePath of = null;
     FileOutputStream fos;
     if (!inCore)
     {
         FilePath workTree = db.WorkTree;
         if (workTree == null)
         {
             // TODO: This should be handled by WorkingTreeIterators which
             // support write operations
             throw new NGit.Errors.NotSupportedException();
         }
         of = new FilePath(workTree, tw.PathString);
         FilePath parentFolder = of.GetParentFile();
         if (!parentFolder.Exists())
         {
             parentFolder.Mkdirs();
         }
         fos = new FileOutputStream(of);
         try
         {
             fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
                 );
         }
         finally
         {
             fos.Close();
         }
     }
     else
     {
         if (!result.ContainsConflicts())
         {
             // When working inCore, only trivial merges can be handled,
             // so we generate objects only in conflict free cases
             of = FilePath.CreateTempFile("merge_", "_temp", null);
             fos = new FileOutputStream(of);
             try
             {
                 fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
                     );
             }
             finally
             {
                 fos.Close();
             }
         }
     }
     return of;
 }