feat: Allowed usage of non-serialized types when creating generic UnityEngine Objects and removed the possibility to choose custom namespace name and scripts path when generating concrete types from generic scriptable objects

SolidAlloy · SolidAlloy · commit b66a7e5d46c8 · 2020-12-11T15:30:27.000+02:00
diff --git a/Editor/AssetCreation/AssetCreatorHelper.cs b/Editor/AssetCreation/AssetCreatorHelper.cs
@@ -15,16 +15,12 @@ internal class AssetCreatorHelper
     {
         private readonly Type _genericType;
         private readonly Type[] _argumentTypes;
-        private readonly string _scriptsPath;
-        private readonly string _namespaceName;
         private readonly string _fileName;
 
-        public AssetCreatorHelper(Type genericType, Type[] argumentTypes, string namespaceName, string scriptsPath, string fileName)
+        public AssetCreatorHelper(Type genericType, Type[] argumentTypes, string fileName)
         {
             _genericType = genericType;
             _argumentTypes = argumentTypes;
-            _namespaceName = namespaceName;
-            _scriptsPath = scriptsPath;
             _fileName = fileName;
         }
 
@@ -46,7 +42,7 @@ public void CreateAsset()
                 return;
             }
 
-            GenericObjectsPersistentStorage.SaveForAssemblyReload(genericTypeWithArgs, _namespaceName, _scriptsPath, _fileName);
+            GenericObjectsPersistentStorage.SaveForAssemblyReload(genericTypeWithArgs, _fileName);
             string className = GetUniqueClassName();
             CreateScript(className);
         }
@@ -95,7 +91,7 @@ private void CreateScript(string className)
         {
 #if UNITY_EDITOR_WIN
             const string longPathPrefix = @"\\?\";
-            string fullAssetPath = $"{longPathPrefix}{Application.dataPath}/{_scriptsPath}/{className}.cs";
+            string fullAssetPath = $"{longPathPrefix}{Application.dataPath}/{Config.ScriptsPath}/{className}.cs";
 
             if (fullAssetPath.Length > 260 + longPathPrefix.Length)
             {
@@ -108,15 +104,15 @@ private void CreateScript(string className)
 
             string scriptContent = GetScriptContent(className);
 
-            AssetDatabaseHelper.MakeSureFolderExists(_scriptsPath);
+            AssetDatabaseHelper.MakeSureFolderExists(Config.ScriptsPath);
             File.WriteAllText(fullAssetPath, scriptContent);
             AssetDatabase.Refresh();
         }
 
         private string GetScriptContent(string className)
         {
             string genericTypeWithBrackets = CreatorUtil.GetFullNameWithBrackets(_genericType, _argumentTypes);
-            return $"namespace {_namespaceName} {{ public class {className} : {genericTypeWithBrackets} {{ }} }}";
+            return $"namespace {Config.NamespaceName} {{ public class {className} : {genericTypeWithBrackets} {{ }} }}";
         }
 
         private void CreateAssetInteractively()
diff --git a/Editor/AssetCreation/GenericBehaviourCreator.cs b/Editor/AssetCreation/GenericBehaviourCreator.cs
@@ -105,7 +105,7 @@ private static string GetUniqueClassName(Type genericTypeWithoutArgs, Type[] gen
         public static string GetPathToGeneratedFile(Type genericTypeWithoutArgs, Type[] genericArgs)
         {
             string fileName = genericTypeWithoutArgs.FullName.MakeClassFriendly();
-            string fileDir = $"Assets/{Config.DefaultScriptsPath}";
+            string fileDir = $"Assets/{Config.ScriptsPath}";
             return $"{fileDir}/{fileName}.cs";
         }
 
diff --git a/Editor/AssetCreation/GenericSOCreator.cs b/Editor/AssetCreation/GenericSOCreator.cs
@@ -23,19 +23,16 @@ public class GenericSOCreator
         /// <param name="scriptsPath">Path to a folder where auto-generated non-generic types must be kept.</param>
         /// <param name="fileName">Name for an asset.</param>
         protected static void CreateAsset(
-            Type genericType, string namespaceName, string scriptsPath, string fileName)
+            Type genericType, string fileName)
         {
-            namespaceName = ValidateNamespaceName(namespaceName);
-            scriptsPath = ValidateScriptsPath(scriptsPath);
-
             genericType = TypeHelper.MakeGenericTypeDefinition(genericType);
             var constraints = genericType.GetGenericArguments()
                 .Select(type => type.GetGenericParameterConstraints())
                 .ToArray();
 
             TypeSelectionWindow.Create(constraints, paramTypes =>
             {
-                var creator = new AssetCreatorHelper(genericType, paramTypes, namespaceName, scriptsPath, fileName);
+                var creator = new AssetCreatorHelper(genericType, paramTypes, fileName);
                 creator.CreateAsset();
             });
         }
@@ -54,8 +51,6 @@ private static void OnScriptsReload()
                 var creator = new AssetCreatorHelper(
                     genericTypeWithoutArgs,
                     paramTypes,
-                    GenericObjectsPersistentStorage.NamespaceName,
-                    GenericObjectsPersistentStorage.ScriptsPath,
                     GenericObjectsPersistentStorage.FileName);
 
                 creator.CreateAssetFromExistingType();
@@ -65,25 +60,5 @@ private static void OnScriptsReload()
                 GenericObjectsPersistentStorage.Clear();
             }
         }
-
-        private static string ValidateNamespaceName(string namespaceName)
-        {
-            if (namespaceName.IsValidIdentifier())
-                return namespaceName;
-
-            Debug.LogError($"The provided namespace name '{namespaceName}' is not a valid identifier.");
-            namespaceName = Config.DefaultNamespaceName;
-            return namespaceName;
-        }
-
-        private static string ValidateScriptsPath(string scriptsPath)
-        {
-            if (scriptsPath.IsValidPath())
-                return scriptsPath;
-
-            Debug.LogError($"The provided path '{scriptsPath}' is not a valid Unity path. Restricted characters are /?<>\\:*|\"");
-            scriptsPath = Config.DefaultScriptsPath;
-            return scriptsPath;
-        }
     }
 }
diff --git a/Editor/BehaviourSelectorEditor.cs b/Editor/BehaviourSelectorEditor.cs
@@ -1,13 +1,11 @@
 ﻿namespace GenericScriptableObjects.Editor
 {
-    using System.Collections.Generic;
     using System.Linq;
     using AssetCreation;
     using GenericScriptableObjects.Util;
     using SolidUtilities.Editor.Helpers;
     using SolidUtilities.Extensions;
     using SolidUtilities.Helpers;
-    using TypeReferences.Editor.Util;
     using UnityEditor;
     using UnityEngine;
 
diff --git a/Editor/MenuItemsGeneration/GenericBehaviourChecker.cs b/Editor/MenuItemsGeneration/GenericBehaviourChecker.cs
@@ -42,7 +42,7 @@ private static void OnScriptsReload()
                 string niceFullName = CreatorUtil.GetGenericTypeDefinitionName(type);
 
                 string fileContent =
-                    $"namespace {Config.DefaultNamespaceName}{NewLine}" +
+                    $"namespace {Config.NamespaceName}{NewLine}" +
                     $"{{{NewLine}" +
                     $"    [UnityEngine.AddComponentMenu(\"Scripts/{componentName}\")]{NewLine}" +
                     $"    internal class {className} : {BehaviourSelectorFullName}{NewLine}" +
diff --git a/Editor/MenuItemsGeneration/GenericSOTypesChecker.cs b/Editor/MenuItemsGeneration/GenericSOTypesChecker.cs
@@ -38,8 +38,6 @@ private static void OnScriptsReload()
                     TypeName = type.FullName.MakeClassFriendly(),
                     FileName = assetMenuAttribute.FileName,
                     MenuName = assetMenuAttribute.MenuName,
-                    NamespaceName = assetMenuAttribute.NamespaceName,
-                    ScriptsPath = assetMenuAttribute.ScriptsPath,
                     Order = assetMenuAttribute.Order,
                     Type = type
                 });
diff --git a/Editor/MenuItemsGeneration/MenuItemMethod.cs b/Editor/MenuItemsGeneration/MenuItemMethod.cs
@@ -12,8 +12,6 @@ public struct MenuItemMethod
         public string TypeName;
         public string FileName;
         public string MenuName;
-        public string NamespaceName;
-        public string ScriptsPath;
         public int Order;
         public Type Type;
 
@@ -34,8 +32,7 @@ public class EqualityComparer : EqualityComparer<MenuItemMethod>
         {
             public override bool Equals(MenuItemMethod x, MenuItemMethod y)
             {
-                return x.TypeName == y.TypeName && x.FileName == y.FileName && x.MenuName == y.MenuName
-                       && x.NamespaceName == y.NamespaceName && x.ScriptsPath == y.ScriptsPath && x.Order == y.Order;
+                return x.TypeName == y.TypeName && x.FileName == y.FileName && x.MenuName == y.MenuName && x.Order == y.Order;
             }
 
             public override int GetHashCode(MenuItemMethod obj)
@@ -46,8 +43,6 @@ public override int GetHashCode(MenuItemMethod obj)
                     hash = hash * 23 + obj.TypeName.GetHashCode();
                     hash = hash * 23 + obj.FileName.GetHashCode();
                     hash = hash * 23 + obj.MenuName.GetHashCode();
-                    hash = hash * 23 + obj.NamespaceName.GetHashCode();
-                    hash = hash * 23 + obj.ScriptsPath.GetHashCode();
                     hash = hash * 23 + obj.Order.GetHashCode();
                     return hash;
                 }
diff --git a/Editor/MenuItemsGeneration/MenuItemsGenerator.cs b/Editor/MenuItemsGeneration/MenuItemsGenerator.cs
@@ -126,7 +126,7 @@ private static string CreateMenuItemMethod(MenuItemMethod method)
             string typeName = CreatorUtil.GetGenericTypeDefinitionName(method.Type);
 
             string methodLine = $"private static void Create{method.TypeName}() => CreateAsset(typeof({typeName}), " +
-                                $"\"{method.NamespaceName}\", \"{method.ScriptsPath}\", \"{fileName}\");";
+                                $"\"{Config.NamespaceName}\", \"{Config.ScriptsPath}\", \"{fileName}\");";
 
             return $"{attributeLine}{NewLine}{methodLine}{NewLine}{NewLine}";
         }
diff --git a/Editor/TypeSelectionWindows/MultipleTypeSelectionWindow.cs b/Editor/TypeSelectionWindows/MultipleTypeSelectionWindow.cs
@@ -8,7 +8,6 @@
     using TypeReferences;
     using UnityEditor;
     using UnityEngine;
-    using Util;
 
     /// <summary>
     /// A window that has as many TypeReference fields as needed for the asset creation. The user has to choose all
diff --git a/Editor/TypeSelectionWindows/OneTypeSelectionWindow.cs b/Editor/TypeSelectionWindows/OneTypeSelectionWindow.cs
@@ -37,7 +37,6 @@ protected override void OnGUI()
                 : new InheritsAttribute(_genericParamConstraints) { ExpandAllFolders = true };
 
             typeOptionsAttribute.ExcludeNone = true;
-            typeOptionsAttribute.SerializableOnly = true;
 
             var dropdownDrawer = new CenteredTypeDropdownDrawer(null, typeOptionsAttribute, null);
             _dropdownWindow = dropdownDrawer.Draw(type => _onTypeSelected(new[] { type }));
diff --git a/Editor/TypeSelectionWindows/Util/TypeReferenceWithBaseTypesDrawer.cs b/Editor/TypeSelectionWindows/Util/TypeReferenceWithBaseTypesDrawer.cs
@@ -44,7 +44,6 @@ private void DrawTypeReferenceField(Rect position, SerializedProperty property)
         {
             TypeOptionsAttribute typeOptionsAttribute = GetAttribute(property);
             typeOptionsAttribute.ExcludeNone = true;
-            typeOptionsAttribute.SerializableOnly = true;
             typeOptionsAttribute.IncludeAdditionalAssemblies = new[] { "Assembly-CSharp" };
             typeOptionsAttribute.ShortName = true;
 
diff --git a/Editor/Util/GenericObjectsPersistentStorage.cs b/Editor/Util/GenericObjectsPersistentStorage.cs
@@ -14,8 +14,6 @@
     public class GenericObjectsPersistentStorage : SingletonScriptableObject<GenericObjectsPersistentStorage>
     {
         [HideInInspector] [SerializeField] private TypeReference _genericSOType;
-        [HideInInspector] [SerializeField] private string _namespaceName;
-        [HideInInspector] [SerializeField] private string _scriptsPath;
         [HideInInspector] [SerializeField] private string _fileName;
 
         [HideInInspector] [SerializeField] private GameObject _gameObject;
@@ -29,8 +27,6 @@ public class GenericObjectsPersistentStorage : SingletonScriptableObject<Generic
         public static bool NeedsBehaviourCreation => OnlyCreatedInstance != null && OnlyCreatedInstance._genericBehaviourType?.Type != null;
 
         public static TypeReference GenericSOType => Instance._genericSOType;
-        public static string NamespaceName => Instance._namespaceName;
-        public static string ScriptsPath => Instance._scriptsPath;
         public static string FileName => Instance._fileName;
 
         public static MenuItemMethod[] MenuItemMethods
@@ -53,19 +49,15 @@ public static bool UsageExampleTypesAreAdded
             }
         }
 
-        public static void SaveForAssemblyReload(Type genericTypeToCreate, string namespaceName, string scriptsPath, string fileName)
+        public static void SaveForAssemblyReload(Type genericTypeToCreate, string fileName)
         {
             Instance._genericSOType = genericTypeToCreate;
-            Instance._namespaceName = namespaceName;
-            Instance._scriptsPath = scriptsPath;
             Instance._fileName = fileName;
         }
 
         public static void Clear()
         {
             Instance._genericSOType = null;
-            Instance._namespaceName = null;
-            Instance._scriptsPath = null;
             Instance._fileName = null;
             Instance._gameObject = null;
             Instance._genericBehaviourType = null;
diff --git a/Runtime/Config.cs b/Runtime/Config.cs
@@ -2,8 +2,8 @@
 {
     public static class Config
     {
-        public const string DefaultNamespaceName = "GenericTypes";
-        public const string DefaultScriptsPath = "GenericTypes";
+        public const string NamespaceName = "GenericScriptableObjects.GenericTypes";
+        public const string ScriptsPath = "GenericScriptableObjects.GenericTypes";
         public const string NewLine = "\r\n";
         public const string RawNewLine = @"\r\n";
     }
diff --git a/Runtime/CreateGenericAssetMenuAttribute.cs b/Runtime/CreateGenericAssetMenuAttribute.cs
@@ -15,17 +15,5 @@ public class CreateGenericAssetMenuAttribute : Attribute
 
         /// <summary>The position of the menu item within the Assets/Create menu.</summary>
         [PublicAPI] public int Order = 0;
-
-        /// <summary>
-        /// Custom namespace name to set for auto-generated classes derived from this class.
-        /// Default is "GenericScriptableObjectTypes".
-        /// </summary>
-        [PublicAPI, NotNull] public string NamespaceName = Config.DefaultNamespaceName;
-
-        /// <summary>
-        /// Custom path to a folder where auto-generated classes must be kept.
-        /// Default is "GenericSOTypes".
-        /// </summary>
-        [PublicAPI, NotNull] public string ScriptsPath = Config.DefaultScriptsPath;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,16 +15,12 @@ internal class AssetCreatorHelper`
`15`	`15`	`{`
`16`	`16`	`private readonly Type _genericType;`
`17`	`17`	`private readonly Type[] _argumentTypes;`
`18`		`- private readonly string _scriptsPath;`
`19`		`- private readonly string _namespaceName;`
`20`	`18`	`private readonly string _fileName;`
`21`	`19`
`22`		`- public AssetCreatorHelper(Type genericType, Type[] argumentTypes, string namespaceName, string scriptsPath, string fileName)`
	`20`	`+ public AssetCreatorHelper(Type genericType, Type[] argumentTypes, string fileName)`
`23`	`21`	`{`
`24`	`22`	`_genericType = genericType;`
`25`	`23`	`_argumentTypes = argumentTypes;`
`26`		`- _namespaceName = namespaceName;`
`27`		`- _scriptsPath = scriptsPath;`
`28`	`24`	`_fileName = fileName;`
`29`	`25`	`}`
`30`	`26`
`@@ -46,7 +42,7 @@ public void CreateAsset()`
`46`	`42`	`return;`
`47`	`43`	`}`
`48`	`44`
`49`		`- GenericObjectsPersistentStorage.SaveForAssemblyReload(genericTypeWithArgs, _namespaceName, _scriptsPath, _fileName);`
	`45`	`+ GenericObjectsPersistentStorage.SaveForAssemblyReload(genericTypeWithArgs, _fileName);`
`50`	`46`	`string className = GetUniqueClassName();`
`51`	`47`	`CreateScript(className);`
`52`	`48`	`}`
`@@ -95,7 +91,7 @@ private void CreateScript(string className)`
`95`	`91`	`{`
`96`	`92`	`#if UNITY_EDITOR_WIN`
`97`	`93`	`const string longPathPrefix = @"\\?\";`
`98`		`- string fullAssetPath = $"{longPathPrefix}{Application.dataPath}/{_scriptsPath}/{className}.cs";`
	`94`	`+ string fullAssetPath = $"{longPathPrefix}{Application.dataPath}/{Config.ScriptsPath}/{className}.cs";`
`99`	`95`
`100`	`96`	`if (fullAssetPath.Length > 260 + longPathPrefix.Length)`
`101`	`97`	`{`
`@@ -108,15 +104,15 @@ private void CreateScript(string className)`
`108`	`104`
`109`	`105`	`string scriptContent = GetScriptContent(className);`
`110`	`106`
`111`		`- AssetDatabaseHelper.MakeSureFolderExists(_scriptsPath);`
	`107`	`+ AssetDatabaseHelper.MakeSureFolderExists(Config.ScriptsPath);`
`112`	`108`	`File.WriteAllText(fullAssetPath, scriptContent);`
`113`	`109`	`AssetDatabase.Refresh();`
`114`	`110`	`}`
`115`	`111`
`116`	`112`	`private string GetScriptContent(string className)`
`117`	`113`	`{`
`118`	`114`	`string genericTypeWithBrackets = CreatorUtil.GetFullNameWithBrackets(_genericType, _argumentTypes);`
`119`		`- return $"namespace {_namespaceName} {{ public class {className} : {genericTypeWithBrackets} {{ }} }}";`
	`115`	`+ return $"namespace {Config.NamespaceName} {{ public class {className} : {genericTypeWithBrackets} {{ }} }}";`
`120`	`116`	`}`
`121`	`117`
`122`	`118`	`private void CreateAssetInteractively()`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ private static string GetUniqueClassName(Type genericTypeWithoutArgs, Type[] gen`
`105`	`105`	`public static string GetPathToGeneratedFile(Type genericTypeWithoutArgs, Type[] genericArgs)`
`106`	`106`	`{`
`107`	`107`	`string fileName = genericTypeWithoutArgs.FullName.MakeClassFriendly();`
`108`		`- string fileDir = $"Assets/{Config.DefaultScriptsPath}";`
	`108`	`+ string fileDir = $"Assets/{Config.ScriptsPath}";`
`109`	`109`	`return $"{fileDir}/{fileName}.cs";`
`110`	`110`	`}`
`111`	`111`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,6 @@ public struct MenuItemMethod`
`12`	`12`	`public string TypeName;`
`13`	`13`	`public string FileName;`
`14`	`14`	`public string MenuName;`
`15`		`- public string NamespaceName;`
`16`		`- public string ScriptsPath;`
`17`	`15`	`public int Order;`
`18`	`16`	`public Type Type;`
`19`	`17`
`@@ -34,8 +32,7 @@ public class EqualityComparer : EqualityComparer<MenuItemMethod>`
`34`	`32`	`{`
`35`	`33`	`public override bool Equals(MenuItemMethod x, MenuItemMethod y)`
`36`	`34`	`{`
`37`		`- return x.TypeName == y.TypeName && x.FileName == y.FileName && x.MenuName == y.MenuName`
`38`		`- && x.NamespaceName == y.NamespaceName && x.ScriptsPath == y.ScriptsPath && x.Order == y.Order;`
	`35`	`+ return x.TypeName == y.TypeName && x.FileName == y.FileName && x.MenuName == y.MenuName && x.Order == y.Order;`
`39`	`36`	`}`
`40`	`37`
`41`	`38`	`public override int GetHashCode(MenuItemMethod obj)`
`@@ -46,8 +43,6 @@ public override int GetHashCode(MenuItemMethod obj)`
`46`	`43`	`hash = hash * 23 + obj.TypeName.GetHashCode();`
`47`	`44`	`hash = hash * 23 + obj.FileName.GetHashCode();`
`48`	`45`	`hash = hash * 23 + obj.MenuName.GetHashCode();`
`49`		`- hash = hash * 23 + obj.NamespaceName.GetHashCode();`
`50`		`- hash = hash * 23 + obj.ScriptsPath.GetHashCode();`
`51`	`46`	`hash = hash * 23 + obj.Order.GetHashCode();`
`52`	`47`	`return hash;`
`53`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ private static string CreateMenuItemMethod(MenuItemMethod method)`
`126`	`126`	`string typeName = CreatorUtil.GetGenericTypeDefinitionName(method.Type);`
`127`	`127`
`128`	`128`	`string methodLine = $"private static void Create{method.TypeName}() => CreateAsset(typeof({typeName}), " +`
`129`		`- $"\"{method.NamespaceName}\", \"{method.ScriptsPath}\", \"{fileName}\");";`
	`129`	`+ $"\"{Config.NamespaceName}\", \"{Config.ScriptsPath}\", \"{fileName}\");";`
`130`	`130`
`131`	`131`	`return $"{attributeLine}{NewLine}{methodLine}{NewLine}{NewLine}";`
`132`	`132`	`}`