fix: Warning when loading the options object

samples/unity-of-bugs/Assets/Editor/SentryBuildtimeOptionsConfiguration.cs → samples/unity-of-bugs/Assets/Scripts/SentryBuildtimeOptionsConfiguration.cs

@@ -1,10 +1,8 @@
-using System;
 using UnityEngine;
 using Sentry.Unity;
-using Sentry.Unity.Editor;
 
-[CreateAssetMenu(fileName = "Assets/Plugins/Sentry/SentryBuildtimeOptionsConfiguration.asset", menuName = "Sentry/Assets/Plugins/Sentry/SentryBuildtimeOptionsConfiguration.asset", order = 999)]
-public class SentryBuildtimeOptionsConfiguration : Sentry.Unity.Editor.ScriptableOptionsConfiguration
+[CreateAssetMenu(fileName = "Assets/Resources/Sentry/SentryBuildtimeOptionsConfiguration.asset", menuName = "Sentry/Assets/Resources/Sentry/SentryBuildtimeOptionsConfiguration.asset", order = 999)]
+public class SentryBuildtimeOptionsConfiguration : Sentry.Unity.BuildtimeOptionsConfiguration
 {
     /// See base class for documentation.
     /// Learn more at https://docs.sentry.io/platforms/unity/configuration/options/#programmatic-configuration

samples/unity-of-bugs/Assets/Scripts/SentryRuntimeOptionsConfiguration.cs

@@ -1,17 +1,16 @@
-using System;
 using UnityEngine;
 using Sentry.Unity;
 
 [CreateAssetMenu(fileName = "Assets/Resources/Sentry/SentryRuntimeOptionsConfiguration.asset", menuName = "Sentry/Assets/Resources/Sentry/SentryRuntimeOptionsConfiguration.asset", order = 999)]
-public class SentryRuntimeOptionsConfiguration : Sentry.Unity.ScriptableOptionsConfiguration
+public class SentryRuntimeOptionsConfiguration : Sentry.Unity.RuntimeOptionsConfiguration
 {
     /// See base class for documentation.
     /// Learn more at https://docs.sentry.io/platforms/unity/configuration/options/#programmatic-configuration
     public override void Configure(SentryUnityOptions options)
     {
         Debug.Log("SentryRuntimeOptionsConfiguration::Configure() called");
 
-        /// BeforeSend is only relevant at runtime. It wouldn't hurt to be set at build time, just wouldn't do anything.
+        // BeforeSend is only relevant at runtime. It wouldn't hurt to be set at build time, just wouldn't do anything.
         options.BeforeSend = sentryEvent =>
         {
             if (sentryEvent.Tags.ContainsKey("SomeTag"))

src/Sentry.Unity.Editor/ConfigurationWindow/OptionsConfigurationTab.cs

@@ -3,8 +3,6 @@
 using System.Text;
 using UnityEditor;
 using UnityEngine;
-using RuntimeConfiguration = Sentry.Unity.ScriptableOptionsConfiguration;
-using BuildtimeConfiguration = Sentry.Unity.Editor.ScriptableOptionsConfiguration;
 
 namespace Sentry.Unity.Editor.ConfigurationWindow
 {
@@ -41,10 +39,10 @@ public static void Display(ScriptableSentryUnityOptions options)
             );
 
             options.BuildtimeOptionsConfiguration = OptionsConfigurationItem.Display(
-                options.BuildtimeOptionsConfiguration as BuildtimeConfiguration,
+                options.BuildtimeOptionsConfiguration,
                 "Buildtime Options Script",
                 "SentryBuildtimeOptionsConfiguration"
-            ) as ScriptableObject;
+            );
         }
     }
 
@@ -71,21 +69,18 @@ internal static class OptionsConfigurationItem
             return result;
         }
 
-        private static string SentryAssetPath(string scriptName, bool isEditorScript) =>
-            string.Format("Assets/{0}/Sentry/{1}.asset", isEditorScript ? "Plugins" : "Resources", scriptName);
+        private static string SentryAssetPath(string scriptName) => $"Assets/Resources/Sentry/{scriptName}.asset";
 
         private static void CreateScript<T>(string fieldName, string scriptName)
         {
-            var isEditorScript = typeof(T) == typeof(BuildtimeConfiguration);
-            var directory = isEditorScript ? "Assets/Editor" : "Assets/Scripts";
-
+            const string directory = "Assets/Scripts";
             if (!AssetDatabase.IsValidFolder(directory))
             {
                 AssetDatabase.CreateFolder(Path.GetDirectoryName(directory), Path.GetFileName(directory));
             }
 
             var scriptPath = EditorUtility.SaveFilePanel(fieldName, directory, scriptName, "cs");
-            if (String.IsNullOrEmpty(scriptPath))
+            if (string.IsNullOrEmpty(scriptPath))
             {
                 return;
             }
@@ -99,21 +94,16 @@ private static void CreateScript<T>(string fieldName, string scriptName)
             scriptName = Path.GetFileNameWithoutExtension(scriptPath);
 
             var template = new StringBuilder();
-            template.AppendLine("using System;");
             template.AppendLine("using UnityEngine;");
             template.AppendLine("using Sentry.Unity;");
-            if (isEditorScript)
-            {
-                template.AppendLine("using Sentry.Unity.Editor;");
-            }
             template.AppendLine();
-            template.AppendFormat("[CreateAssetMenu(fileName = \"{0}\", menuName = \"Sentry/{0}\", order = 999)]\n", SentryAssetPath(scriptName, isEditorScript));
+            template.AppendFormat("[CreateAssetMenu(fileName = \"{0}\", menuName = \"Sentry/{0}\", order = 999)]\n", SentryAssetPath(scriptName));
             template.AppendFormat("public class {0} : {1}\n", scriptName, typeof(T).FullName);
             template.AppendLine("{");
             template.AppendLine("    /// See base class for documentation.");
             template.AppendLine("    /// Learn more at https://docs.sentry.io/platforms/unity/configuration/options/#programmatic-configuration");
             template.AppendFormat("    public override void Configure(SentryUnityOptions options{0})\n",
-                                  typeof(T) == typeof(BuildtimeConfiguration) ? ", SentryCliOptions cliOptions" : "");
+                                  typeof(T) == typeof(BuildtimeOptionsConfiguration) ? ", SentryCliOptions cliOptions" : "");
             template.AppendLine("    {");
             template.AppendLine("        // TODO implement");
             template.AppendLine("    }");
@@ -146,30 +136,24 @@ private static void OnScriptsReloaded()
             SetScript(scriptName);
         }
 
-        internal static void SetScript(String scriptNameWithoutExtension)
+        internal static void SetScript(string scriptNameWithoutExtension)
         {
             var optionsConfigurationObject = ScriptableObject.CreateInstance(scriptNameWithoutExtension);
-            var isEditorScript = optionsConfigurationObject is BuildtimeConfiguration;
-            AssetDatabase.CreateAsset(optionsConfigurationObject, SentryAssetPath(scriptNameWithoutExtension, isEditorScript));
+            var isEditorScript = optionsConfigurationObject is BuildtimeOptionsConfiguration;
+            AssetDatabase.CreateAsset(optionsConfigurationObject, SentryAssetPath(scriptNameWithoutExtension));
             AssetDatabase.Refresh();
 
             var options = EditorWindow.GetWindow<SentryWindow>().Options;
 
             if (isEditorScript)
             {
                 // Don't overwrite already set OptionsConfiguration
-                if (options.BuildtimeOptionsConfiguration is null)
-                {
-                    options.BuildtimeOptionsConfiguration = optionsConfigurationObject;
-                }
+                options.BuildtimeOptionsConfiguration ??= optionsConfigurationObject as BuildtimeOptionsConfiguration;
             }
             else
             {
                 // Don't overwrite already set OptionsConfiguration
-                if (options.OptionsConfiguration is null)
-                {
-                    options.OptionsConfiguration = optionsConfigurationObject as RuntimeConfiguration;
-                }
+                options.OptionsConfiguration ??= optionsConfigurationObject as RuntimeOptionsConfiguration;
             }
         }
     }

src/Sentry.Unity.Editor/ScriptableSentryUnityOptionsEditor.cs

@@ -71,8 +71,10 @@ public override void OnInspectorGUI()
             EditorGUILayout.Space();
 
             EditorGUILayout.LabelField("Options Configuration", EditorStyles.boldLabel);
-            EditorGUILayout.ObjectField(".NET (C#)", options.OptionsConfiguration,
-                typeof(ScriptableOptionsConfiguration), false);
+            EditorGUILayout.ObjectField("Runtime Configuration", options.OptionsConfiguration,
+                typeof(RuntimeOptionsConfiguration), false);
+            EditorGUILayout.ObjectField("Buildtime Configuration", options.BuildtimeOptionsConfiguration,
+                typeof(BuildtimeOptionsConfiguration), false);
 
             EditorGUILayout.Space();
             EditorGUI.DrawRect(EditorGUILayout.GetControlRect(false, 1), Color.gray);

src/Sentry.Unity.Editor/SentryScriptableObject.cs

@@ -37,10 +37,13 @@ internal static (SentryUnityOptions?, SentryCliOptions?) ConfiguredBuildtimeOpti
             if (scriptableOptions is not null)
             {
                 options = scriptableOptions.ToSentryUnityOptions(isBuilding: true);
-                /// Must be non-nullable in the interface otherwise Unity script compilation fails...
+                // Must be non-nullable in the interface otherwise Unity script compilation fails...
                 cliOptions ??= ScriptableObject.CreateInstance<SentryCliOptions>();
-                var setupScript = scriptableOptions.BuildtimeOptionsConfiguration as Sentry.Unity.Editor.ScriptableOptionsConfiguration;
-                setupScript?.Configure(options, cliOptions);
+                var setupScript = scriptableOptions.BuildtimeOptionsConfiguration;
+                if (setupScript != null)
+                {
+                    setupScript.Configure(options, cliOptions);
+                }
             }
 
             return (options, cliOptions);

src/Sentry.Unity.Editor/ScriptableOptionsConfiguration.cs → src/Sentry.Unity/BuildtimeOptionsConfiguration.cs

@@ -1,15 +1,15 @@
 using UnityEngine;
 
-namespace Sentry.Unity.Editor
+namespace Sentry.Unity
 {
-    public abstract class ScriptableOptionsConfiguration : ScriptableObject
+    public abstract class BuildtimeOptionsConfiguration : ScriptableObject
     {
         /// <summary>
         /// Called during app build. Changes made here will affect build-time processing, symbol upload, etc.
         /// Additionally, because iOS, macOS and Android native error handling is configured at build time,
         /// you can make changes to these options here.
         /// </summary>
-        /// <seealso cref="Sentry.Unity.ScriptableOptionsConfiguration"/>
+        /// <seealso cref="RuntimeOptionsConfiguration"/>
         public abstract void Configure(SentryUnityOptions options, SentryCliOptions cliOptions);
     }
 }

src/Sentry.Unity/ScriptableOptionsConfiguration.cs → src/Sentry.Unity/RuntimeOptionsConfiguration.cs

@@ -2,14 +2,14 @@
 
 namespace Sentry.Unity
 {
-    public abstract class ScriptableOptionsConfiguration : ScriptableObject
+    public abstract class RuntimeOptionsConfiguration : ScriptableObject
     {
         /// <summary>
         /// Called at the player startup by SentryInitialization.
         /// You can alter configuration for the C# error handling and also
         /// native error handling in platforms other than iOS, macOS and Android.
         /// </summary>
-        /// <seealso cref="Sentry.Unity.Editor.ScriptableOptionsConfiguration"/>
+        /// <seealso cref="BuildtimeOptionsConfiguration"/>
         public abstract void Configure(SentryUnityOptions options);
     }
 }

src/Sentry.Unity/ScriptableSentryUnityOptions.cs

@@ -75,10 +75,8 @@ public static string GetConfigPath(string? notDefaultConfigName = null)
         [field: SerializeField] public bool LinuxNativeSupportEnabled { get; set; } = true;
         [field: SerializeField] public bool Il2CppLineNumberSupportEnabled { get; set; } = true;
 
-        [field: SerializeField] public Sentry.Unity.ScriptableOptionsConfiguration? OptionsConfiguration { get; set; }
-
-        // Actual type is `Sentry.Unity.Editor.ScriptableOptionsConfiguration` but we can't reference it here because we don't depend on the editor Assembly.
-        [field: SerializeField] public ScriptableObject? BuildtimeOptionsConfiguration { get; set; }
+        [field: SerializeField] public RuntimeOptionsConfiguration? OptionsConfiguration { get; set; }
+        [field: SerializeField] public BuildtimeOptionsConfiguration? BuildtimeOptionsConfiguration { get; set; }
 
         [field: SerializeField] public bool Debug { get; set; } = true;
         [field: SerializeField] public bool DebugOnlyInEditor { get; set; } = true;
@@ -188,7 +186,10 @@ internal SentryUnityOptions ToSentryUnityOptions(bool isBuilding, ISentryUnityIn
 
             if (!isBuilding)
             {
-                OptionsConfiguration?.Configure(options);
+                if (OptionsConfiguration != null)
+                {
+                    OptionsConfiguration.Configure(options);
+                }
 
                 // Doing this after the configure callback to allow users to programmatically opt out
                 if (options.Il2CppLineNumberSupportEnabled && unityInfo is not null)

src/Sentry.Unity.Editor/SentryCliOptions.cs → src/Sentry.Unity/SentryCliOptions.cs

@@ -2,7 +2,7 @@
 using Sentry.Extensibility;
 using UnityEngine;
 
-namespace Sentry.Unity.Editor
+namespace Sentry.Unity
 {
     [Serializable]
     public sealed class SentryCliOptions : ScriptableObject

test/Sentry.Unity.Tests/ScriptableSentryUnityOptionsTests.cs

@@ -20,7 +20,7 @@ class Fixture
                 persistentDataPath: "test/persistent/data/path");
         }
 
-        class TestOptionsConfiguration : ScriptableOptionsConfiguration
+        class TestOptionsConfiguration : RuntimeOptionsConfiguration
         {
             public bool GotCalled;
             public override void Configure(SentryUnityOptions options) => GotCalled = true;