예제 #1
0
        private static ProjectSettings LoadOrCreate()
        {
            ProjectSettings settings;

            if (!File.Exists(Path))
            {
                settings = CreateNewSettingsFile();
            }
            else
            {
                settings = LoadInstance();

                if (settings == null)
                {
                    CSFileTools.DeleteFile(Path);
                    settings = CreateNewSettingsFile();
                }

                if (settings.version != Maintainer.Version)
                {
                    MigrateSettings(settings);
                    SearchResultsStorage.Clear();
                }
            }

            settings.hideFlags = HideFlags.HideAndDontSave;
            settings.version   = Maintainer.Version;

            return(settings);
        }
예제 #2
0
 private void DrawRecordCheckbox(CleanerRecord cleanerRecord)
 {
     EditorGUI.BeginChangeCheck();
     cleanerRecord.selected = EditorGUILayout.ToggleLeft(new GUIContent(""), cleanerRecord.selected, GUILayout.Width(20));
     if (EditorGUI.EndChangeCheck())
     {
         SearchResultsStorage.Save();
     }
 }
예제 #3
0
        protected override void DrawSearchBody()
        {
            //GUILayout.BeginHorizontal();
            if (GUILayout.Button("1. Find garbage!"))
            {
                startSearch = true;
            }

            if (GUILayout.Button("2. Clean selected items!"))
            {
                startClean = true;
            }
            //GUILayout.EndHorizontal();
            GUILayout.Space(10);

            if (records == null || records.Length == 0)
            {
                GUILayout.Label("No garbage");
            }
            else
            {
                ShowCollectionPages();

                GUILayout.Space(5);

                using (UIHelpers.Horizontal())
                {
                    if (GUILayout.Button("Select all"))
                    {
                        foreach (CleanerRecord record in records.OfType <CleanerRecord>())
                        {
                            record.selected = true;
                        }
                        SearchResultsStorage.Save();
                    }

                    if (GUILayout.Button("Select none"))
                    {
                        foreach (CleanerRecord record in records.OfType <CleanerRecord>())
                        {
                            record.selected = false;
                        }
                        SearchResultsStorage.Save();
                    }

                    if (GUILayout.Button("Clear results"))
                    {
                        records = null;
                        SearchResultsStorage.CleanerSearchResults = null;
                    }
                }

                using (UIHelpers.Horizontal())
                {
                    if (GUILayout.Button("Copy report to clipboard"))
                    {
                        EditorGUIUtility.systemCopyBuffer = ReportsBuilder.GenerateReport(ProjectCleaner.MODULE_NAME, records);
                        MaintainerWindow.ShowNotification("Report copied to clipboard!");
                    }
                    if (GUILayout.Button("Export report..."))
                    {
                        string filePath = EditorUtility.SaveFilePanel("Save " + ProjectCleaner.MODULE_NAME + " report", "", "MaintainerCleanerReport.txt", "txt");
                        if (!string.IsNullOrEmpty(filePath))
                        {
                            StreamWriter sr = File.CreateText(filePath);
                            sr.Write(ReportsBuilder.GenerateReport(ProjectCleaner.MODULE_NAME, records));
                            sr.Close();
                            MaintainerWindow.ShowNotification("Report saved!");
                        }
                    }
                }
            }
        }
예제 #4
0
 private void OnDisable()
 {
     MaintainerSettings.Save();
     SearchResultsStorage.Save();
 }
예제 #5
0
        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);
        }