public void Custom()
{
string[] custom = new string[] { "*.foo", "a*b.test", "test.ego", "any*" };
IgnoredFiles.SetIngnoredFiles(custom);
string[] ignore = new string[]
{
".foo",
"file.foo",
"asdb.test",
"ab.test",
"AvB.test",
"test.ego",
"anymore",
"any",
"any.bar"
};
string[] pass = new string[] { "a.foo.bar", "bacb.test", "a.test", "atest.ego", "test.egomotion", "manymore", "many" };
foreach (var item in ignore)
{
Assert.IsTrue(IgnoredFiles.ShouldIgnore(item));
}
foreach (var item in pass)
{
Assert.IsFalse(IgnoredFiles.ShouldIgnore(item));
}
}
public void IgnoreDefaultFiles()
{
string[] ignoredFiles = new string[]
{
".git",
".svn",
".hg",
"file.meta",
".DS_Store",
"thumbs.db",
"Thumbs.db",
"file.bak",
".file~",
"file~",
"EgoXproject.dll",
"egoxproject.settings",
"egoxproject.configurations",
"change.egoxc"
};
foreach (var item in ignoredFiles)
{
Assert.IsTrue(IgnoredFiles.ShouldIgnore(item));
}
foreach (var item in ignoredFiles)
{
Assert.IsTrue(IgnoredFiles.ShouldIgnore(item.ToLower()));
}
foreach (var item in ignoredFiles)
{
Assert.IsTrue(IgnoredFiles.ShouldIgnore(item.ToUpper()));
}
}
public void Add([NotNull] FtpSummary other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
Deleted.AddRange(other.Deleted);
DeletedDirectories.AddRange(other.DeletedDirectories);
CreatedDirectories.AddRange(other.CreatedDirectories);
UpdatedFiles.AddRange(other.UpdatedFiles);
CreatedFiles.AddRange(other.CreatedFiles);
CreatedFiles = CreatedFiles.Except(UpdatedFiles).ToList();
IgnoredFiles.AddRange(other.IgnoredFiles);
IgnoredDirectories.AddRange(other.IgnoredDirectories);
}
public void Clear()
{
FileCheckedCount = 0;
NewFiles.Clear();
NewFilesForGroom.Clear();
ChangedFiles.Clear();
MissingFiles.Clear();
LastModifiedDateFiles.Clear();
ErrorFiles.Clear();
IgnoredFiles.Clear();
NewlyIgnoredFiles.Clear();
IgnoredFilesForGroom.Clear();
MovedFiles.Clear();
MovedFileOrder.Clear();
DuplicateFiles.Clear();
}
public void DontIngoreFiles()
{
//".git", ".svn", ".hg", ".meta", ".DS_Store", "thumbs.db", "Thumbs.db", "*.bak", ".*~", "*~";
string[] files = new string[]
{
"file.c",
"file.cpp",
"file",
"file.framework",
"lib.a",
".file",
"file.hg.c",
"file.meta.jpg",
"file.bak.png",
"file.git"
};
foreach (var item in files)
{
Assert.IsFalse(IgnoredFiles.ShouldIgnore(item));
}
}
public bool IsFileIgnored(string fileName)
{
return(IgnoredFiles.Any(fileName.EndsWith) || !Extensions.Any(fileName.EndsWith));
}
void DrawIgnoredFilesAndFolders()
{
EditorGUI.indentLevel++;
EditorGUILayout.LabelField(new GUIContent("Ignored Files and Folders", "File and folders that will be ignored when adding folders to change files"));
EditorGUI.indentLevel--;
EditorGUILayout.BeginVertical(_style.IndentedBox());
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Default Ignored Files", "These files are always ignored when adding folders"), GUILayout.ExpandWidth(false));
EditorGUILayout.LabelField(StringUtils.ArrayToString(IgnoredFiles.DefaultList), EditorStyles.wordWrappedLabel);
EditorGUILayout.EndHorizontal();
EditorGUILayout.LabelField(new GUIContent("Custom Ignored Files", "Add filenames and wildcards entries here to have them ignored when adding folders"), GUILayout.ExpandWidth(false));
EditorGUI.indentLevel++;
bool update = false;
int remove = -1;
for (int ii = 0; ii < _customIgnoredFiles.Count; ++ii)
{
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
_customIgnoredFiles[ii] = EditorGUILayout.TextField(_customIgnoredFiles[ii]);
if (EditorGUI.EndChangeCheck())
{
update = true;
}
EditorGUILayout.Space();
if (_style.MinusButton("Remove ignored file pattern"))
{
bool removeCheck = true;
if (!string.IsNullOrEmpty(_customIgnoredFiles[ii].Trim()))
{
removeCheck = EditorUtility.DisplayDialog("Remove ignored file pattern?", "Are you sure you want to remove \"" + _customIgnoredFiles[ii] + "\" from the ignore list?", "Remove", "Cancel");
}
if (removeCheck)
{
remove = ii;
}
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(2);
}
if (remove > -1)
{
IgnoredFiles.Remove(_customIgnoredFiles[remove]);
_customIgnoredFiles.RemoveAt(remove);
_settings.SetDirty();
_settings.Save();
}
if (update)
{
IgnoredFiles.SetIngnoredFiles(_customIgnoredFiles.ToArray());
_settings.SetDirty();
_settings.Save();
update = false;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Space();
if (_style.PlusButton("Add new ignored file pattern"))
{
_customIgnoredFiles.Add("");
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
GUILayout.Space(4);
EditorGUILayout.EndVertical();
}
protected void UpdateRecursive(
DirectoryInfo currentDirectoryInfo,
ManifestDirectoryInfo currentManfestDirInfo)
{
// Setup data for current directory
Dictionary <String, FileInfo> fileDict =
new Dictionary <string, FileInfo>();
Dictionary <String, DirectoryInfo> dirDict =
new Dictionary <string, DirectoryInfo>();
if (currentDirectoryInfo != null)
{
FileInfo[] fileList = null;
try
{
fileList = currentDirectoryInfo.GetFiles();
}
catch (Exception)
{
WriteLine(Manifest.MakeStandardPathString(
currentManfestDirInfo));
if (IgnoreFile(Manifest.MakeStandardPathString(
currentManfestDirInfo)) == true)
{
// This was implemented primarily to allow the user to
// silence the process of skipping over inaccessible
// system directories by ignoring them. For example,
// in some cases the "$RECYCLE BIN" under Windows
// is not accessible and will generate an error. The
// user can now add such directories to the ignore list
// and they will be silently ignored. The special
// message for showProgress alerts the user that the
// directory is actually being skipped altogether
// since it can't be accessed. The only significant
// implication of this is that the ignored files won't
// be enumerated and counted as being ignored.
if (ShowProgress)
{
WriteLine(
Manifest.MakeStandardPathString(currentManfestDirInfo) +
" [IGNORED DIRECTORY AND CANNOT ACCESS]");
}
}
else
{
ForceWriteLine("Could not access contents of: " +
currentDirectoryInfo.FullName);
}
return;
}
foreach (FileInfo nextFileInfo in fileList)
{
fileDict.Add(nextFileInfo.Name.Normalize(), nextFileInfo);
}
DirectoryInfo[] dirList =
currentDirectoryInfo.GetDirectories();
foreach (DirectoryInfo nextDirInfo in dirList)
{
dirDict.Add(nextDirInfo.Name.Normalize(), nextDirInfo);
}
}
// Clone in case we modify during iteration
List <ManifestFileInfo> fileListClone =
new List <ManifestFileInfo>(currentManfestDirInfo.Files.Values);
// Iterate through existing manifest entries
foreach (ManifestFileInfo nextManFileInfo in fileListClone)
{
if (ShowProgress)
{
Write(Manifest.MakeStandardPathString(nextManFileInfo));
}
if (fileDict.ContainsKey(nextManFileInfo.Name))
{
FileCheckedCount++;
FileInfo nextFileInfo = fileDict[nextManFileInfo.Name];
if (IgnoreFile(Manifest.MakeStandardPathString(nextManFileInfo)))
{
Write(" [NEWLY IGNORED]");
currentManfestDirInfo.Files.Remove(
nextManFileInfo.Name);
NewlyIgnoredFiles.Add(nextManFileInfo);
}
else if (nextFileInfo.Length != nextManFileInfo.FileLength &&
Update == false &&
AlwaysCheckHash == false)
{
// Don't compute hash if we aren't doing an update
Write(" [DIFFERENT]");
ChangedFiles.Add(nextManFileInfo);
}
else if (AlwaysCheckHash == true ||
MakeNewHash == true ||
nextManFileInfo.FileHash == null ||
Manifest.CompareManifestDateToFilesystemDate(nextFileInfo.LastWriteTimeUtc, nextManFileInfo.LastModifiedUtc) == false ||
nextFileInfo.Length != nextManFileInfo.FileLength)
{
FileHash checkHash = null;
Exception exception = null;
try
{
string hashType = Manifest.DefaultHashMethod;
if (nextManFileInfo.FileHash != null)
{
hashType = nextManFileInfo.FileHash.HashType;
}
checkHash = FileHash.ComputeHash(
nextFileInfo,
hashType);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
WriteLine(" [ERROR]");
WriteLine(exception.ToString());
ErrorFiles.Add(nextManFileInfo);
}
else
{
if (nextManFileInfo.FileHash == null)
{
Write(" [NULL HASH IN MANIFEST]");
ChangedFiles.Add(nextManFileInfo);
}
else if (checkHash.Equals(nextManFileInfo.FileHash) == false)
{
Write(" [DIFFERENT]");
ChangedFiles.Add(nextManFileInfo);
}
else
{
if (Manifest.CompareManifestDateToFilesystemDate(
nextFileInfo.LastWriteTimeUtc,
nextManFileInfo.LastModifiedUtc) == false)
{
Write(" [LAST MODIFIED DATE]");
LastModifiedDateFiles.Add(nextManFileInfo);
if (BackDate == true)
{
nextFileInfo.LastWriteTimeUtc =
nextManFileInfo.LastModifiedUtc;
}
}
}
}
FileHash newHash = checkHash;
if (MakeNewHash)
{
newHash = FileHash.ComputeHash(
nextFileInfo,
GetNewHashType(Manifest));
}
// Update hash and last modified date accordingly
nextManFileInfo.FileHash = newHash;
nextManFileInfo.LastModifiedUtc = nextFileInfo.LastWriteTimeUtc;
nextManFileInfo.FileLength = nextFileInfo.Length;
}
else
{
Write(" [SKIPPED]");
}
}
else
{
Write(" [MISSING]");
currentManfestDirInfo.Files.Remove(nextManFileInfo.Name);
MissingFiles.Add(nextManFileInfo);
}
WriteLine("");
}
// Clone in case we modify during iteration
List <ManifestDirectoryInfo> directoryListClone =
new List <ManifestDirectoryInfo>(
currentManfestDirInfo.Subdirectories.Values);
foreach (ManifestDirectoryInfo nextManDirInfo in
directoryListClone)
{
DirectoryInfo nextDirInfo = null;
if (dirDict.ContainsKey(nextManDirInfo.Name))
{
nextDirInfo = dirDict[nextManDirInfo.Name];
}
UpdateRecursive(
nextDirInfo,
nextManDirInfo);
if (nextManDirInfo.Empty)
{
currentManfestDirInfo.Subdirectories.Remove(
nextManDirInfo.Name);
}
}
// Look for new files
foreach (String nextFileName in fileDict.Keys)
{
FileInfo nextFileInfo = fileDict[nextFileName];
if (currentManfestDirInfo.Files.ContainsKey(
nextFileName) == false)
{
ManifestFileInfo newManFileInfo =
new ManifestFileInfo(
nextFileName,
currentManfestDirInfo);
Write(Manifest.MakeStandardPathString(newManFileInfo));
if (IgnoreFile(Manifest.MakeStandardPathString(newManFileInfo)))
{
IgnoredFiles.Add(newManFileInfo);
// Don't groom the manifest file!
if (Manifest.MakeNativePathString(newManFileInfo) !=
ManifestNativeFilePath)
{
IgnoredFilesForGroom.Add(nextFileInfo);
}
Write(" [IGNORED]");
}
else
{
FileCheckedCount++;
bool checkHash = false;
if (Update == true ||
AlwaysCheckHash == true ||
TrackMoves == true)
{
checkHash = true;
}
Exception exception = null;
if (checkHash)
{
try
{
newManFileInfo.FileHash =
FileHash.ComputeHash(
nextFileInfo,
GetNewHashType(Manifest));
}
catch (Exception ex)
{
exception = ex;
}
}
if (checkHash && newManFileInfo.FileHash == null)
{
ErrorFiles.Add(newManFileInfo);
WriteLine(" [ERROR]");
WriteLine(exception.ToString());
}
else
{
NewFiles.Add(newManFileInfo);
NewFilesForGroom.Add(nextFileInfo);
Write(" [NEW]");
}
newManFileInfo.FileLength =
nextFileInfo.Length;
newManFileInfo.LastModifiedUtc =
nextFileInfo.LastWriteTimeUtc;
newManFileInfo.RegisteredUtc =
DateTime.Now.ToUniversalTime();
currentManfestDirInfo.Files.Add(
nextFileName,
newManFileInfo);
}
WriteLine("");
}
}
// Recurse looking for new directories
foreach (String nextDirName in dirDict.Keys)
{
DirectoryInfo nextDirInfo = dirDict[nextDirName];
if (currentManfestDirInfo.Subdirectories.ContainsKey(
nextDirName) == false)
{
ManifestDirectoryInfo nextManDirInfo =
new ManifestDirectoryInfo(
nextDirName,
currentManfestDirInfo);
currentManfestDirInfo.Subdirectories.Add(
nextDirName,
nextManDirInfo);
UpdateRecursive(
nextDirInfo,
nextManDirInfo);
if (nextManDirInfo.Empty)
{
currentManfestDirInfo.Subdirectories.Remove(
nextDirName);
}
}
}
}
public static void WriteFilesToDatabase(DbFileContext ctx, Uri initialUri, DirectoryInfo root, int?id)
{
string virtualPath;
string dirName;
if (id == null)
{
virtualPath = "/";
dirName = null;
}
else
{
var currentUri = new Uri(root.FullName);
var tempRelative = initialUri.MakeRelativeUri(currentUri).ToString();
var iof = tempRelative.IndexOf('/');
virtualPath = tempRelative.Substring(iof);
dirName = root.Name;
}
foreach (var ignoredDirectory in IgnoredDirectories)
{
if (virtualPath.StartsWith(ignoredDirectory, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
var dbFile = new DbFile
{
IsDirectory = true,
Name = dirName,
VirtualPath = virtualPath,
ParentId = id
};
ctx.DbFiles.Add(dbFile);
ctx.SaveChanges();
foreach (var fi in root.EnumerateFiles())
{
bool ignore = IgnoredExtensions.Any(ignoredExtension => fi.Extension.StartsWith(ignoredExtension)) ||
IgnoredFiles.Any(x => x.Equals(fi.Name, StringComparison.OrdinalIgnoreCase));
if (ignore)
{
continue;
}
Console.WriteLine(fi.FullName);
var dbFileFolder = new DbFile
{
IsDirectory = false,
Name = Path.GetFileNameWithoutExtension(fi.Name),
Extension = fi.Extension,
VirtualPath = Path.Combine(virtualPath, fi.Name).Replace('\\', '/'),
ParentId = dbFile.Id,
};
if (IsTextFile(fi.Extension))
{
var text = File.ReadAllText(fi.FullName, Encoding.UTF8);
dbFileFolder.Texto = text;
}
else
{
var bytes = File.ReadAllBytes(fi.FullName);
dbFileFolder.Bytes = bytes;
dbFileFolder.IsBinary = true;
}
ctx.DbFiles.Add(dbFileFolder);
ctx.SaveChanges();
}
foreach (var di in root.EnumerateDirectories())
{
WriteFilesToDatabase(ctx, initialUri, di, dbFile.Id);
}
}
