public static void AddDirectory(this ZipArchive archive, string sourceDir)
{
DirectoryInfo directoryInfo = new DirectoryInfo(sourceDir);
sourceDir = directoryInfo.FullName;
foreach (FileSystemInfo entry in directoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
{
string relativePath = entry.FullName.Substring(sourceDir.Length, entry.FullName.Length - sourceDir.Length);
relativePath = relativePath.TrimStart(new char[]
{
Path.DirectorySeparatorChar,
Path.AltDirectorySeparatorChar
});
if (entry is FileInfo)
{
archive.AddFile(entry.FullName, relativePath);
}
else
{
DirectoryInfo subDirInfo = entry as DirectoryInfo;
if (subDirInfo != null && !subDirInfo.EnumerateFileSystemInfos().Any())
{
archive.CreateEntry(relativePath + Path.DirectorySeparatorChar);
}
}
}
}
internal static void AddFileWithCheck(this IFileSystem fileSystem, string path, Func<Stream> streamFactory)
{
using (Stream stream = streamFactory())
{
fileSystem.AddFile(path, stream);
}
}
internal static void AddFile(this IFileSystem fileSystem, string path, Action<Stream> write)
{
using (var stream = new MemoryStream()) {
write(stream);
stream.Seek(0, SeekOrigin.Begin);
fileSystem.AddFile(path, stream);
}
}
public static MockFileSystem WithFiles(this MockFileSystem mockFileSystem, params string[] paths)
{
foreach (var path in paths)
{
mockFileSystem.AddFile(mockFileSystem.Path.Combine(mockFileSystem.Directory.GetCurrentDirectory(), path), new MockFileData(""));
}
return mockFileSystem;
}
public static System.Tuple<Bam.Core.Module, Bam.Core.Module> GenerateSource(
this C.CObjectFileCollection collection)
{
// generate source file
var generatedSourceFile = Bam.Core.Module.Create<GeneratedSourceModule>(collection);
// compile the generated source file
var objFile = collection.AddFile(generatedSourceFile);
// return both generated source, and the compiled object file
return new System.Tuple<Bam.Core.Module, Bam.Core.Module>(generatedSourceFile, objFile);
}
internal static void AddFileWithCheck(this IFileSystem fileSystem, string path, Func<Stream> streamFactory)
{
// Don't overwrite file if it exists if force wasn't set to true
if (fileSystem.FileExists(path)) {
fileSystem.Logger.Log(MessageLevel.Warning, NuGetResources.Warning_FileAlreadyExists, path);
}
else {
using (Stream stream = streamFactory()) {
fileSystem.AddFile(path, stream);
}
}
}
/// <summary>
/// Добавляет директорию в указанную коллекцию кассеты. Возвращает добавленные в базу данных элементы
/// </summary>
/// <param name="dir"></param>
/// <param name="collectionId"></param>
/// <returns>Возвращает добавленные в базу данных элементы</returns>
public static IEnumerable<XElement> AddDirectory(this Cassette cassette, DirectoryInfo dir, string collectionId)
{
List<XElement> addedElements = new List<XElement>();
var dname = dir.FullName;
var shortname = dir.Name;
// TODO: Надо учесть русские имена и с пробелами
var newcoll_id = "collection_" + cassette.Name + "_" + dname;
// Поищу, нет ли такой коллекции в базе данных
var collection_found =
cassette.db.Elements(ONames.TagCollection)
.FirstOrDefault((XElement e) =>
{
var xabout = e.Attribute(ONames.rdfabout);
return (xabout != null && xabout.Value == newcoll_id);
});
if(collection_found != null) { }
else
{
// Создам коллекцию
XElement coll =
new XElement(ONames.TagCollection,
new XAttribute(ONames.rdfabout, newcoll_id),
new XElement(ONames.TagName, shortname));
cassette.db.Add(coll);
addedElements.Add(coll);
// Присоединим коллекцию к вышестоящей
XElement collmem =
new XElement(ONames.TagCollectionmember,
new XAttribute(ONames.rdfabout, "cm_" + newcoll_id),
new XElement(ONames.TagCollectionitem,
new XAttribute(ONames.rdfresource, newcoll_id)),
new XElement(ONames.TagIncollection,
new XAttribute(ONames.rdfresource, collectionId)));
cassette.db.Add(collmem);
addedElements.Add(collmem);
cassette.Changed = true;
}
// Обработаем файлы и директории
foreach(var f in dir.GetFiles())
{
if(f.Name == "Thumbs.db") { }
else addedElements.AddRange(cassette.AddFile(f, newcoll_id));
}
foreach(var d in dir.GetDirectories())
addedElements.AddRange(cassette.AddDirectory(d, newcoll_id));
return addedElements;
}
public static System.Tuple<Bam.Core.Module, Bam.Core.Module> Rcc(
this C.Cxx.ObjectFileCollection collection,
QRCFile qrcFile)
{
// rcc the .qrc file to generate the source file
var rccSourceFile = Bam.Core.Module.Create<RccGeneratedSource>(collection);
// compile the generated source file
var objFile = collection.AddFile(rccSourceFile);
// set the source file AFTER the source has been chained into the object file
// so that the encapsulating module can be determined
rccSourceFile.SourceHeader = qrcFile;
// return both rcc'd source, and the compiled object file
return new System.Tuple<Bam.Core.Module, Bam.Core.Module>(rccSourceFile, objFile);
}
public static System.Tuple<Bam.Core.Module, Bam.Core.Module> MocHeader(
this C.Cxx.ObjectFileCollection collection,
C.HeaderFile header)
{
// moc the header file to generate the source file
var mocSourceFile = Bam.Core.Module.Create<MocGeneratedSource>(collection);
// compile the generated source file
var objFile = collection.AddFile(mocSourceFile);
// set the source header AFTER the source has been chained into the object file
// so that the encapsulating module can be determined
mocSourceFile.SourceHeader = header;
// return both moc'd source, and the compiled object file
return new System.Tuple<Bam.Core.Module, Bam.Core.Module>(mocSourceFile, objFile);
}
/// <summary>
/// Creates a .refresh file in bin directory of the IProjectSystem that points to the assembly being installed.
/// This works around issues in DTE's AddReference method when dealing with GACed binaries.
/// </summary>
/// <param name="projectSystem">The project system the assembly is being referenced by.</param>
/// <param name="assemblyPath">The relative path to the assembly being added</param>
internal static void CreateRefreshFile(this IProjectSystem projectSystem, string assemblyPath)
{
string referenceName = Path.GetFileName(assemblyPath);
string refreshFilePath = Path.Combine("bin", referenceName + ".refresh");
if (!projectSystem.FileExists(refreshFilePath))
{
string projectPath = PathUtility.EnsureTrailingSlash(projectSystem.Root);
string relativeAssemblyPath = PathUtility.GetRelativePath(projectPath, assemblyPath);
try
{
using (var stream = relativeAssemblyPath.AsStream())
{
projectSystem.AddFile(refreshFilePath, stream);
}
}
catch (UnauthorizedAccessException exception)
{
// log IO permission error
ExceptionHelper.WriteToActivityLog(exception);
}
}
}
public static void AddDirectory(this ZipArchive zipArchive, DirectoryInfoBase directory, string directoryNameInArchive)
{
bool any = false;
foreach (var info in directory.GetFileSystemInfos())
{
any = true;
var subDirectoryInfo = info as DirectoryInfoBase;
if (subDirectoryInfo != null)
{
string childName = Path.Combine(directoryNameInArchive, subDirectoryInfo.Name);
zipArchive.AddDirectory(subDirectoryInfo, childName);
}
else
{
zipArchive.AddFile((FileInfoBase)info, directoryNameInArchive);
}
}
if (!any)
{
// If the directory did not have any files or folders, add a entry for it
zipArchive.CreateEntry(EnsureTrailingSlash(directoryNameInArchive));
}
}
internal static void AddFileWithCheck(this IFileSystem fileSystem, string path, Action<Stream> write)
{
if (fileSystem.FileExists(path))
{
fileSystem.Logger.Log(MessageLevel.Warning, NuGetResources.Warning_FileAlreadyExists, path);
}
else
{
fileSystem.AddFile(path, write);
}
}
internal static void AddFileWithCheck(this IFileSystem fileSystem, string path, Action<Stream> write)
{
fileSystem.AddFile(path, write);
}
/// <summary>
/// Adds a File to a Zip file archive.
/// </summary>
/// <remarks>
///
/// <para>
/// This call collects metadata for the named file in the filesystem,
/// including the file attributes and the timestamp, and inserts that metadata
/// into the resulting ZipEntry. Only when the application calls Save() on
/// the <c>ZipFile</c>, does DotNetZip read the file from the filesystem and
/// then write the content to the zip file archive.
/// </para>
///
/// <para>
/// This method will throw an exception if an entry with the same name already
/// exists in the <c>ZipFile</c>.
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to the
/// <c>ZipEntry</c> added.
/// </para>
///
/// </remarks>
///
/// <example>
/// <para>
/// In this example, three files are added to a Zip archive. The ReadMe.txt
/// file will be placed in the root of the archive. The .png file will be
/// placed in a folder within the zip called photos\personal. The pdf file
/// will be included into a folder within the zip called Desktop.
/// </para>
/// <code>
/// try
/// {
/// using (ZipFile zip = new ZipFile())
/// {
/// zip.AddFile("c:\\photos\\personal\\7440-N49th.png");
/// zip.AddFile("c:\\Desktop\\2008-Regional-Sales-Report.pdf");
/// zip.AddFile("ReadMe.txt");
///
/// zip.Save("Package.zip");
/// }
/// }
/// catch (System.Exception ex1)
/// {
/// System.Console.Error.WriteLine("exception: " + ex1);
/// }
/// </code>
///
/// <code lang="VB">
/// Try
/// Using zip As ZipFile = New ZipFile
/// zip.AddFile("c:\photos\personal\7440-N49th.png")
/// zip.AddFile("c:\Desktop\2008-Regional-Sales-Report.pdf")
/// zip.AddFile("ReadMe.txt")
/// zip.Save("Package.zip")
/// End Using
/// Catch ex1 As Exception
/// Console.Error.WriteLine("exception: {0}", ex1.ToString)
/// End Try
/// </code>
/// </example>
///
/// <overloads>This method has two overloads.</overloads>
///
/// <seealso cref="Ionic.Zip.ZipFile.AddItem(string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.UpdateFile(string)"/>
///
/// <param name="fileName">
/// The name of the file to add. It should refer to a file in the filesystem.
/// The name of the file may be a relative path or a fully-qualified path.
/// </param>
/// <returns>The <c>ZipEntry</c> corresponding to the File added.</returns>
public static ZipEntry AddFile(this ZipFile zipFile, string fileName)
{
return zipFile.AddFile(fileName, null);
}
public static DBFile AddFile (this DBWork me, DB db, string path, string filename, bool hidden, string compressed_mime)
{
DBFile result = db.Upload (path, Path.GetExtension (filename), hidden, compressed_mime);
me.AddFile (db, result, filename, hidden);
return result;
}
public static MockFileSystem WithEmptyGitIgnore(this MockFileSystem mockFileSystem)
{
mockFileSystem.AddFile(@"C:\.gitignore", new MockFileData(""));
return mockFileSystem;
}
/// <summary>
/// Adds a set of files to the <c>ZipFile</c>, using the specified directory
/// path in the archive, and preserving the full directory structure in the
/// filenames.
/// </summary>
///
/// <remarks>
///
/// <para>
/// Think of the <paramref name="directoryPathInArchive"/> as a "root" or
/// base directory used in the archive for the files that get added. when
/// <paramref name="preserveDirHierarchy"/> is true, the hierarchy of files
/// found in the filesystem will be placed, with the hierarchy intact,
/// starting at that root in the archive. When <c>preserveDirHierarchy</c>
/// is false, the path hierarchy of files is flattned, and the flattened
/// set of files gets placed in the root within the archive as specified in
/// <c>directoryPathInArchive</c>.
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to each
/// ZipEntry added.
/// </para>
///
/// </remarks>
///
/// <param name="fileNames">
/// The names of the files to add. Each string should refer to a file in the
/// filesystem. The name of the file may be a relative path or a
/// fully-qualified path.
/// </param>
///
/// <param name="directoryPathInArchive">
/// Specifies a directory path to use as a prefix for each entry name.
/// This path may, or may not, correspond to a real directory in the current
/// filesystem. If the files within the zip are later extracted, this is the
/// path used for the extracted file. Passing <c>null</c> (<c>Nothing</c> in
/// VB) will use the path on each of the <c>fileNames</c>, if any. Passing
/// the empty string ("") will insert the item at the root path within the
/// archive.
/// </param>
///
/// <param name="preserveDirHierarchy">
/// whether the entries in the zip archive will reflect the directory
/// hierarchy that is present in the various filenames. For example, if
/// <paramref name="fileNames"/> includes two paths,
/// \Animalia\Chordata\Mammalia\Info.txt and
/// \Plantae\Magnoliophyta\Dicotyledon\Info.txt, then calling this method
/// with <paramref name="preserveDirHierarchy"/> = <c>false</c> will
/// result in an exception because of a duplicate entry name, while
/// calling this method with <paramref name="preserveDirHierarchy"/> =
/// <c>true</c> will result in the full direcory paths being included in
/// the entries added to the ZipFile.
/// </param>
/// <seealso cref="Ionic.Zip.ZipFile.AddSelectedFiles(String, String)" />
public static void AddFiles(this ZipFile zipFile, System.Collections.Generic.IEnumerable<String> fileNames, String directoryPathInArchive, bool preserveDirHierarchy)
{
if (fileNames == null)
throw new ArgumentNullException("fileNames");
zipFile.SetAddOperationCanceled(false);
zipFile.SetInAddAll(true);
try
{
zipFile.OnAddStarted();
if (preserveDirHierarchy)
{
foreach (var f in fileNames)
{
if (zipFile.IsAddOperationCanceled()) break;
if (directoryPathInArchive != null)
{
//string s = SharedUtilities.NormalizePath(Path.Combine(directoryPathInArchive, Path.GetDirectoryName(f)));
string s = ZipEntryInternal.NormalizePath(Path.Combine(directoryPathInArchive, Path.GetDirectoryName(f)));
zipFile.AddFile(f, s);
}
else
zipFile.AddFile(f, null);
}
}
else
{
foreach (var f in fileNames)
{
if (zipFile.IsAddOperationCanceled()) break;
zipFile.AddFile(f, directoryPathInArchive);
}
}
if (!zipFile.IsAddOperationCanceled())
zipFile.OnAddCompleted();
}
finally
{
zipFile.SetInAddAll(false);
}
}
/// <summary>
/// Adds an item, either a file or a directory, to a zip file archive,
/// explicitly specifying the directory path to be used in the archive.
/// </summary>
///
/// <remarks>
/// <para>
/// If adding a directory, the add is recursive on all files and
/// subdirectories contained within it.
/// </para>
/// <para>
/// The name of the item may be a relative path or a fully-qualified path.
/// The item added by this call to the <c>ZipFile</c> is not read from the
/// disk nor written to the zip file archive until the application calls
/// Save() on the <c>ZipFile</c>.
/// </para>
///
/// <para>
/// This version of the method allows the caller to explicitly specify the
/// directory path to be used in the archive, which would override the
/// "natural" path of the filesystem file.
/// </para>
///
/// <para>
/// Encryption will be used on the file data if the <c>Password</c> has
/// been set on the <c>ZipFile</c> object, prior to calling this method.
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to the
/// <c>ZipEntry</c> added.
/// </para>
///
/// </remarks>
///
/// <exception cref="System.IO.FileNotFoundException">
/// Thrown if the file or directory passed in does not exist.
/// </exception>
///
/// <param name="fileOrDirectoryName">the name of the file or directory to add.
/// </param>
///
/// <param name="directoryPathInArchive">
/// The name of the directory path to use within the zip archive. This path
/// need not refer to an extant directory in the current filesystem. If the
/// files within the zip are later extracted, this is the path used for the
/// extracted file. Passing <c>null</c> (<c>Nothing</c> in VB) will use the
/// path on the fileOrDirectoryName. Passing the empty string ("") will
/// insert the item at the root path within the archive.
/// </param>
///
/// <seealso cref="Ionic.Zip.ZipFile.AddFile(string, string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.AddDirectory(string, string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string, string)"/>
///
/// <example>
/// This example shows how to zip up a set of files into a flat hierarchy,
/// regardless of where in the filesystem the files originated. The resulting
/// zip archive will contain a toplevel directory named "flat", which itself
/// will contain files Readme.txt, MyProposal.docx, and Image1.jpg. A
/// subdirectory under "flat" called SupportFiles will contain all the files
/// in the "c:\SupportFiles" directory on disk.
///
/// <code>
/// String[] itemnames= {
/// "c:\\fixedContent\\Readme.txt",
/// "MyProposal.docx",
/// "c:\\SupportFiles", // a directory
/// "images\\Image1.jpg"
/// };
///
/// try
/// {
/// using (ZipFile zip = new ZipFile())
/// {
/// for (int i = 1; i < itemnames.Length; i++)
/// {
/// // will add Files or Dirs, recurses and flattens subdirectories
/// zip.AddItem(itemnames[i],"flat");
/// }
/// zip.Save(ZipToCreate);
/// }
/// }
/// catch (System.Exception ex1)
/// {
/// System.Console.Error.WriteLine("exception: {0}", ex1);
/// }
/// </code>
///
/// <code lang="VB">
/// Dim itemnames As String() = _
/// New String() { "c:\fixedContent\Readme.txt", _
/// "MyProposal.docx", _
/// "SupportFiles", _
/// "images\Image1.jpg" }
/// Try
/// Using zip As New ZipFile
/// Dim i As Integer
/// For i = 1 To itemnames.Length - 1
/// ' will add Files or Dirs, recursing and flattening subdirectories.
/// zip.AddItem(itemnames(i), "flat")
/// Next i
/// zip.Save(ZipToCreate)
/// End Using
/// Catch ex1 As Exception
/// Console.Error.WriteLine("exception: {0}", ex1.ToString())
/// End Try
/// </code>
/// </example>
/// <returns>The <c>ZipEntry</c> added.</returns>
public static ZipEntry AddItem(this ZipFile zipFile, String fileOrDirectoryName, String directoryPathInArchive)
{
string fullPath = GetFullPath(fileOrDirectoryName);
if (FileSystem.Current.GetFileFromPathAsync(fullPath).ExecuteSync() != null)
return zipFile.AddFile(fileOrDirectoryName, directoryPathInArchive);
if (FileSystem.Current.GetFolderFromPathAsync(fullPath).ExecuteSync() != null)
return zipFile.AddDirectory(fileOrDirectoryName, directoryPathInArchive);
throw new FileNotFoundException(String.Format("That file or directory ({0}) does not exist!",
fileOrDirectoryName));
}
/// <summary>
/// Adds or Updates a File in a Zip file archive.
/// </summary>
///
/// <remarks>
/// <para>
/// This method adds a file to a zip archive, or, if the file already exists
/// in the zip archive, this method Updates the content of that given filename
/// in the zip archive.
/// </para>
///
/// <para>
/// This version of the method allows the caller to explicitly specify the
/// directory path to be used in the archive. The entry to be added or
/// updated is found by using the specified directory path, combined with the
/// basename of the specified filename.
/// </para>
///
/// <para>
/// Upon success, there is no way for the application to learn if the file was
/// added versus updated.
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to the
/// <c>ZipEntry</c> added.
/// </para>
/// </remarks>
///
/// <seealso cref="Ionic.Zip.ZipFile.AddFile(string,string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.UpdateDirectory(string,string)"/>
/// <seealso cref="Ionic.Zip.ZipFile.UpdateItem(string,string)"/>
///
/// <param name="fileName">
/// The name of the file to add or update. It should refer to a file in the
/// filesystem. The name of the file may be a relative path or a
/// fully-qualified path.
/// </param>
///
/// <param name="directoryPathInArchive">
/// Specifies a directory path to use to override any path in the
/// <c>fileName</c>. This path may, or may not, correspond to a real
/// directory in the current filesystem. If the files within the zip are
/// later extracted, this is the path used for the extracted file. Passing
/// <c>null</c> (<c>Nothing</c> in VB) will use the path on the
/// <c>fileName</c>, if any. Passing the empty string ("") will insert the
/// item at the root path within the archive.
/// </param>
///
/// <returns>
/// The <c>ZipEntry</c> corresponding to the File that was added or updated.
/// </returns>
public static ZipEntry UpdateFile(this ZipFile zipFile, string fileName, String directoryPathInArchive)
{
// ideally this would all be transactional!
var key = ZipEntryInternal.NameInArchive(fileName, directoryPathInArchive);
if (zipFile[key] != null)
zipFile.RemoveEntry(key);
return zipFile.AddFile(fileName, directoryPathInArchive);
}
public static IEnumerable<XElement> AddNewRdf(this Cassette cassette, string owner)
{
string dbid = cassette.Name + "_" + owner + "_" + DateTime.Now.Ticks.ToString();
XElement emptyRdfDoc = Cassette.RDFdb(dbid,
new XAttribute(ONames.AttOwner, owner),
new XAttribute(ONames.AttPrefix, dbid + "_"),
new XAttribute(ONames.AttCounter, "1001"));
string filepath = cassette.Dir.FullName + "/" + dbid + ".fog";
emptyRdfDoc.Save(filepath);
var seq = cassette.AddFile(new FileInfo(filepath), cassette.CollectionId).ToList();
// Надо добавить владельца в iisstore документа и хорошо бы проставить uri (это надо делать в файле)
XElement rdfdoc = seq.First(xe => xe.Name == ONames.TagDocument);
XElement iisstore = rdfdoc.Element(ONames.TagIisstore);
iisstore.Add(new XAttribute(ONames.AttOwner, owner));
File.Delete(filepath);
return seq;
}
/// <summary>
/// Adds a group of files to this load procedure
/// </summary>
/// <param name="proc"></param>
/// <param name="files"></param>
public static void AddFiles(this IBaseLoadProcedure proc, IEnumerable<string> files)
{
Check.NotNull(proc, "proc"); //NOXLATE
Check.NotNull(files, "files"); //NOXLATE
foreach (var f in files)
{
proc.AddFile(f);
}
}
public static ZipArchiveEntry AddFile(this ZipArchive archive, string sourceFile)
{
return archive.AddFile(sourceFile, Path.GetFileName(sourceFile));
}
public static MockFileSystem WithGitIgnoreContaining(this MockFileSystem mockFileSystem, string contents)
{
mockFileSystem.AddFile(@"C:\.gitignore", new MockFileData(contents));
return mockFileSystem;
}
public static void CopyFile(this IFileSystem fs, string path, string newPath)
{
fs.AddFile(newPath, fs.OpenFile(path));
}
public static MockFileSystem WithFile(this MockFileSystem mockFileSystem, string path)
{
mockFileSystem.AddFile(mockFileSystem.Path.Combine(mockFileSystem.Directory.GetCurrentDirectory(), path), new MockFileData(""));
return mockFileSystem;
}
public static void AddFile(this ZipArchive zipArchive, string filePath, string directoryNameInArchive = "")
{
var fileInfo = new FileInfoWrapper(new FileInfo(filePath));
zipArchive.AddFile(fileInfo, directoryNameInArchive);
}
internal static ZipEntry AddOrUpdateDirectoryImpl(this ZipFile zipFile, string directoryName, string rootDirectoryPathInArchive, AddOrUpdateAction action, bool recurse, int level)
{
string fullPath = GetFullPath(directoryName);
if (zipFile.StatusMessageTextWriter != null)
zipFile.StatusMessageTextWriter.WriteLine("{0} {1}...",
(action == AddOrUpdateAction.AddOnly) ? "adding" : "Adding or updating",
directoryName);
if (level == 0)
{
zipFile.SetAddOperationCanceled(false);
zipFile.OnAddStarted();
}
// workitem 13371
if (zipFile.IsAddOperationCanceled())
return null;
string dirForEntries = rootDirectoryPathInArchive;
ZipEntry baseDir = null;
if (level > 0)
{
int f = directoryName.Length;
for (int i = level; i > 0; i--)
f = directoryName.LastIndexOfAny("/\\".ToCharArray(), f - 1, f - 1);
dirForEntries = directoryName.Substring(f + 1);
dirForEntries = Path.Combine(rootDirectoryPathInArchive, dirForEntries);
}
// if not top level, or if the root is non-empty, then explicitly add the directory
if (level > 0 || rootDirectoryPathInArchive != "")
{
// add the directory only if it does not exist.
// It's not an error if it already exists.
dirForEntries = ZipEntryInternal.NameInArchive(dirForEntries) + '/';
if (!zipFile.EntryFileNames.Contains(dirForEntries))
{
baseDir = zipFile.AddDirectoryByName(dirForEntries);
}
}
if (!zipFile.IsAddOperationCanceled())
{
IFile fileCheck = FileSystem.Current.GetFileFromPathAsync(fullPath).ExecuteSync();
if (fileCheck != null)
{
throw new IOException(string.Format("That path ({0}) is a file, not a directory!", directoryName));
}
IFolder folder = FileSystem.Current.GetFolderFromPathAsync(fullPath).ExecuteSync();
if (folder == null)
{
throw new FileNotFoundException(string.Format("That folder ({0}) does not exist!", directoryName));
}
IList<IFile> files = folder.GetFilesAsync().ExecuteSync();
if (recurse)
{
// add the files:
foreach (IFile file in files)
{
if (zipFile.IsAddOperationCanceled()) break;
if (action == AddOrUpdateAction.AddOnly)
zipFile.AddFile(file.Path, dirForEntries);
else
zipFile.UpdateFile(file.Path, dirForEntries);
}
if (!zipFile.IsAddOperationCanceled())
{
// add the subdirectories:
IList<IFolder> dirs = folder.GetFoldersAsync().ExecuteSync();
foreach (IFolder dir in dirs)
{
zipFile.AddOrUpdateDirectoryImpl(dir.Path, rootDirectoryPathInArchive, action, recurse, level + 1);
}
}
}
}
if (level == 0)
zipFile.OnAddCompleted();
return baseDir;
}
