internal override bool MatchesFilter(FilterItem newFilter)
{
var filters = new[] { newFilter };
switch (newFilter.kind)
{
case FilterKind.Path:
case FilterKind.Directory:
case FilterKind.FileName:
case FilterKind.Extension:
return(!string.IsNullOrEmpty(Path) && CSFilterTools.IsValueMatchesAnyFilterOfKind(Path, filters, newFilter.kind));
case FilterKind.Type:
{
return(!string.IsNullOrEmpty(componentName) && CSFilterTools.IsValueMatchesAnyFilterOfKind(componentName, filters, newFilter.kind));
}
case FilterKind.NotSet:
return(false);
default:
Debug.LogWarning(Maintainer.LogPrefix + "Unknown filter kind: " + newFilter.kind);
return(false);
}
}
private static void MigrateFromPre_1_4_1_0(ProjectSettings settings)
{
if (!CSFilterTools.IsValueMatchesAnyFilterOfKind("dummy.asmdef",
settings.projectCleanerSettings.pathIgnoresFilters, FilterKind.Extension))
{
ArrayUtility.Add(ref settings.projectCleanerSettings.pathIgnoresFilters,
FilterItem.Create(".asmdef", FilterKind.Extension));
}
}
private void DrawMoreButton(AssetRecord assetRecord)
{
if (UIHelpers.RecordButton(assetRecord, "Shows menu with additional actions for this record.", CSIcons.More))
{
var menu = new GenericMenu();
if (!string.IsNullOrEmpty(assetRecord.path))
{
menu.AddItem(new GUIContent("Ignore/Full Path"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilter(assetRecord.assetDatabasePath, MaintainerSettings.Cleaner.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(assetRecord.assetDatabasePath, FilterKind.Path);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + assetRecord.assetDatabasePath);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
var dir = Directory.GetParent(assetRecord.assetDatabasePath);
if (!CSPathTools.IsAssetsRootPath(dir.FullName))
{
menu.AddItem(new GUIContent("Ignore/Parent Folder"), false, () =>
{
var dirPath = CSPathTools.EnforceSlashes(dir.ToString());
if (!CSFilterTools.IsValueMatchesAnyFilter(dirPath, MaintainerSettings.Cleaner.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(dirPath, FilterKind.Directory);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + dirPath);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
var extension = Path.GetExtension(assetRecord.path);
if (!string.IsNullOrEmpty(extension))
{
menu.AddItem(new GUIContent("Ignore/\"" + extension + "\" Extension"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilterOfKind(extension, MaintainerSettings.Cleaner.pathIgnoresFilters, FilterKind.Extension))
{
var newFilter = FilterItem.Create(extension, FilterKind.Extension, true);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + extension);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
}
menu.ShowAsContext();
}
}
private static void MigrateFromPre_1_5_1(ProjectSettings settings)
{
if (settings.projectCleanerSettings.pathIgnoresFilters != null &&
settings.projectCleanerSettings.pathIgnoresFilters.Length > 0)
{
var defaultFilters = ProjectCleanerSettings.GetDefaultFilters();
var mandatoryFilters = settings.projectCleanerSettings.MandatoryFilters;
var modificationsLog = new StringBuilder();
for (var i = settings.projectCleanerSettings.pathIgnoresFilters.Length - 1; i >= 0; i--)
{
var pathIgnoresFilter = settings.projectCleanerSettings.pathIgnoresFilters[i];
if (pathIgnoresFilter.ignoreCase)
{
continue;
}
var isMandatory = false;
if (CSFilterTools.IsValueMatchesAnyFilterOfKind(pathIgnoresFilter.value, mandatoryFilters,
pathIgnoresFilter.kind))
{
isMandatory = true;
}
else
{
switch (pathIgnoresFilter.kind)
{
case FilterKind.Extension:
var extension = pathIgnoresFilter.value.ToLowerInvariant();
if (extension == ".dll" ||
extension == ".asmdef" ||
extension == ".mdb" ||
extension == ".xml" ||
extension == ".rsp")
{
isMandatory = true;
}
break;
case FilterKind.FileName:
var value = pathIgnoresFilter.value.ToLowerInvariant();
if (value == "readme" ||
value == "manual")
{
isMandatory = true;
}
break;
}
}
if (isMandatory)
{
modificationsLog.Append("Removing Project Cleaner filter '")
.Append(pathIgnoresFilter.value)
.AppendLine("': built-in mandatory filter covers it now.");
ArrayUtility.RemoveAt(ref settings.projectCleanerSettings.pathIgnoresFilters, i);
continue;
}
if (CSFilterTools.IsValueMatchesAnyFilterOfKind(pathIgnoresFilter.value, defaultFilters,
pathIgnoresFilter.kind))
{
modificationsLog.Append("Changing default Project Cleaner filter '")
.Append(pathIgnoresFilter.value)
.AppendLine("': ignore case setting to 'true' for better accuracy.");
pathIgnoresFilter.ignoreCase = true;
}
}
if (modificationsLog.Length > 0)
{
modificationsLog.Insert(0, "Maintainer settings updated, read below for details\n");
Debug.Log(Maintainer.LogPrefix + modificationsLog);
}
}
}
/////////////////////////////////////////////////////////////////////////
// Game Object's Components Processing
/////////////////////////////////////////////////////////////////////////
public static void ProcessComponent(Component component, int orderIndex)
{
#if !UNITY_2019_1_OR_NEWER
if (missingComponentDetector.CheckAndRecordNullComponent(component))
{
return;
}
#else
if (component == null)
{
return;
}
#endif
if ((component.hideFlags & HideFlags.HideInInspector) != 0)
{
return;
}
if (!MaintainerSettings.Issues.touchDisabledComponents)
{
if (EditorUtility.GetObjectEnabled(component) == 0)
{
return;
}
}
var componentType = component.GetType();
var componentName = componentType.Name;
if (MaintainerSettings.Issues.componentIgnoresFilters != null &&
MaintainerSettings.Issues.componentIgnoresFilters.Length > 0)
{
if (CSFilterTools.IsValueMatchesAnyFilterOfKind(componentName, MaintainerSettings.Issues.componentIgnoresFilters, FilterKind.Type))
{
return;
}
}
duplicateComponentDetector.ProcessComponent(component, componentType);
var shouldCheckPropertiesForDuplicate = duplicateComponentDetector.IsPropertiesHashCalculationRequired();
if (shouldCheckPropertiesForDuplicate)
{
// skipping duplicate search for non-standard components with invisible properties
var baseType = componentType.BaseType;
if (baseType != null)
{
if (baseType.Name == "MegaModifier")
{
shouldCheckPropertiesForDuplicate = false;
duplicateComponentDetector.SkipComponent();
}
}
}
var shouldTraverseProperties = missingReferenceDetector.Enabled || shouldCheckPropertiesForDuplicate;
if (shouldTraverseProperties)
{
var initialInfo = new SerializedObjectTraverseInfo(component);
CSTraverseTools.TraverseObjectProperties(initialInfo, (info, property) =>
{
if (property.type == "UnityEvent")
{
missingReferenceDetector.TryDetectUnityEventIssues(currentLocation, currentAsset.Path,
currentGameObject, componentType, componentName, orderIndex, property);
info.skipCurrentTree = true;
return;
}
missingReferenceDetector.TryDetectIssue(currentLocation, currentAsset.Path, currentGameObject, componentType, componentName, orderIndex, property);
if (shouldCheckPropertiesForDuplicate)
{
duplicateComponentDetector.ProcessProperty(property);
}
});
}
if (shouldCheckPropertiesForDuplicate)
{
duplicateComponentDetector.TryDetectIssue(currentLocation, currentAsset.Path, currentGameObject, componentType, componentName, orderIndex);
}
if (component is Terrain)
{
inconsistentTerrainDataDetector.ProcessTerrainComponent((Terrain)component, componentType, componentName, orderIndex);
}
else if (component is TerrainCollider)
{
inconsistentTerrainDataDetector.ProcessTerrainColliderComponent((TerrainCollider)component);
}
//Debug.Log("ProcessComponent: " + target.name + ":" + component);
}
private static MaintainerSettings LoadOrCreate()
{
MaintainerSettings settings;
if (!File.Exists(Path))
{
settings = CreateNewSettingsFile();
}
else
{
settings = LoadInstance();
if (settings == null)
{
CSFileTools.DeleteFile(Path);
settings = CreateNewSettingsFile();
}
if (settings.version != Maintainer.Version)
{
if (string.IsNullOrEmpty(settings.version))
{
MigrateAllIgnores(settings.issuesFinderSettings.pathIgnores, ref settings.issuesFinderSettings.pathIgnoresFilters, FilterKind.Path);
settings.issuesFinderSettings.pathIgnores = null;
MigrateAllIgnores(settings.issuesFinderSettings.componentIgnores, ref settings.issuesFinderSettings.componentIgnoresFilters, FilterKind.Type);
settings.issuesFinderSettings.componentIgnores = null;
MigrateAllIgnores(settings.issuesFinderSettings.pathIncludes, ref settings.issuesFinderSettings.pathIncludesFilters, FilterKind.Path);
settings.issuesFinderSettings.pathIncludes = null;
MigrateAllIgnores(settings.issuesFinderSettings.sceneIncludes, ref settings.issuesFinderSettings.sceneIncludesFilters, FilterKind.Path);
settings.issuesFinderSettings.sceneIncludes = null;
MigrateAllIgnores(settings.projectCleanerSettings.pathIgnores, ref settings.projectCleanerSettings.pathIgnoresFilters, FilterKind.Path);
settings.projectCleanerSettings.pathIgnores = null;
MigrateAllIgnores(settings.projectCleanerSettings.sceneIgnores, ref settings.projectCleanerSettings.sceneIgnoresFilters, FilterKind.Path);
settings.projectCleanerSettings.sceneIgnores = null;
settings.projectCleanerSettings.AddDefaultFilters();
}
if (new Version(settings.version) < new Version("1.4.1.0"))
{
if (!CSFilterTools.IsValueMatchesAnyFilterOfKind("dummy.asmdef", settings.projectCleanerSettings.pathIgnoresFilters, FilterKind.Extension))
{
ArrayUtility.Add(ref settings.projectCleanerSettings.pathIgnoresFilters, FilterItem.Create(".asmdef", FilterKind.Extension));
}
}
if (new Version(settings.version) < new Version("1.5.1"))
{
if (settings.projectCleanerSettings.pathIgnoresFilters != null &&
settings.projectCleanerSettings.pathIgnoresFilters.Length > 0)
{
var defaultFilters = settings.projectCleanerSettings.GetDefaultFilters();
var mandatoryFilters = settings.projectCleanerSettings.MandatoryFilters;
var modificationsLog = new StringBuilder();
for (var i = settings.projectCleanerSettings.pathIgnoresFilters.Length - 1; i >= 0; i--)
{
var pathIgnoresFilter = settings.projectCleanerSettings.pathIgnoresFilters[i];
if (pathIgnoresFilter.ignoreCase)
{
continue;
}
var isMandatory = false;
if (CSFilterTools.IsValueMatchesAnyFilterOfKind(pathIgnoresFilter.value, mandatoryFilters, pathIgnoresFilter.kind))
{
isMandatory = true;
}
else
{
switch (pathIgnoresFilter.kind)
{
case FilterKind.Extension:
var extension = pathIgnoresFilter.value.ToLowerInvariant();
if (extension == ".dll" ||
extension == ".asmdef" ||
extension == ".mdb" ||
extension == ".xml" ||
extension == ".rsp")
{
isMandatory = true;
}
break;
case FilterKind.FileName:
var value = pathIgnoresFilter.value.ToLowerInvariant();
if (value == "readme" ||
value == "manual")
{
isMandatory = true;
}
break;
}
}
if (isMandatory)
{
modificationsLog.Append("Removing Project Cleaner filter '")
.Append(pathIgnoresFilter.value)
.AppendLine("': built-in mandatory filter covers it now.");
ArrayUtility.RemoveAt(ref settings.projectCleanerSettings.pathIgnoresFilters, i);
continue;
}
if (CSFilterTools.IsValueMatchesAnyFilterOfKind(pathIgnoresFilter.value, defaultFilters, pathIgnoresFilter.kind))
{
modificationsLog.Append("Changing default Project Cleaner filter '")
.Append(pathIgnoresFilter.value)
.AppendLine("': ignore case setting to 'true' for better accuracy.");
pathIgnoresFilter.ignoreCase = true;
}
}
if (modificationsLog.Length > 0)
{
modificationsLog.Insert(0, "Maintainer settings updated, read below for details\n");
Debug.Log(Maintainer.LogPrefix + modificationsLog);
}
}
}
SearchResultsStorage.Clear();
//AssetsMap.Delete();
}
}
settings.hideFlags = HideFlags.HideAndDontSave;
settings.version = Maintainer.Version;
return(settings);
}
