com.wallstop-studios.unity-helpers 2.0.0-rc27 → 2.0.0-rc31

package/Runtime/Core/Attributes/ParentComponent.cs

@@ -1,184 +1,184 @@
-namespace UnityHelpers.Core.Attributes
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Reflection;
-    using Extension;
-    using Helper;
-    using JetBrains.Annotations;
-    using UnityEngine;
-
-    [AttributeUsage(AttributeTargets.Field)]
-    [MeansImplicitUse]
-    public sealed class ParentComponentAttribute : Attribute
-    {
-        public bool optional = false;
-        public bool onlyAncestors = false;
-    }
-
-    public static class ParentComponentExtensions
-    {
-        private static readonly Dictionary<
-            Type,
-            (FieldInfo field, Action<object, object> setter)[]
-        > FieldsByType = new();
-
-        public static void AssignParentComponents(this Component component)
-        {
-            Type componentType = component.GetType();
-            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
-                componentType,
-                type =>
-                {
-                    FieldInfo[] fields = type.GetFields(
-                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
-                    );
-                    return fields
-                        .Where(field =>
-                            Attribute.IsDefined(field, typeof(ParentComponentAttribute))
-                        )
-                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
-                        .ToArray();
-                }
-            );
-
-            foreach ((FieldInfo field, Action<object, object> setter) in fields)
-            {
-                Type fieldType = field.FieldType;
-                bool isArray = fieldType.IsArray;
-                Type parentComponentType = isArray ? fieldType.GetElementType() : fieldType;
-
-                bool foundParent;
-                if (field.GetCustomAttribute<ParentComponentAttribute>().onlyAncestors)
-                {
-                    Transform parent = component.transform.parent;
-                    if (parent == null)
-                    {
-                        foundParent = false;
-                    }
-                    else if (isArray)
-                    {
-                        Component[] parentComponents = parent.GetComponentsInParent(
-                            parentComponentType,
-                            true
-                        );
-                        foundParent = 0 < parentComponents.Length;
-
-                        Array correctTypedArray = ReflectionHelpers.CreateArray(
-                            parentComponentType,
-                            parentComponents.Length
-                        );
-                        Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
-                        setter(component, correctTypedArray);
-                    }
-                    else if (
-                        fieldType.IsGenericType
-                        && fieldType.GetGenericTypeDefinition() == typeof(List<>)
-                    )
-                    {
-                        parentComponentType = fieldType.GenericTypeArguments[0];
-
-                        Component[] parents = parent.GetComponentsInParent(
-                            parentComponentType,
-                            true
-                        );
-
-                        IList instance = ReflectionHelpers.CreateList(
-                            parentComponentType,
-                            parents.Length
-                        );
-
-                        foundParent = false;
-                        foreach (Component parentComponent in parents)
-                        {
-                            instance.Add(parentComponent);
-                            foundParent = true;
-                        }
-
-                        setter(component, instance);
-                    }
-                    else
-                    {
-                        Component childComponent = parent.GetComponentInParent(
-                            parentComponentType,
-                            true
-                        );
-                        foundParent = childComponent != null;
-                        if (foundParent)
-                        {
-                            setter(component, childComponent);
-                        }
-                    }
-                }
-                else
-                {
-                    if (isArray)
-                    {
-                        Component[] parentComponents = component.GetComponentsInParent(
-                            parentComponentType,
-                            true
-                        );
-                        foundParent = 0 < parentComponents.Length;
-
-                        Array correctTypedArray = ReflectionHelpers.CreateArray(
-                            parentComponentType,
-                            parentComponents.Length
-                        );
-                        Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
-                        setter(component, correctTypedArray);
-                    }
-                    else if (
-                        fieldType.IsGenericType
-                        && fieldType.GetGenericTypeDefinition() == typeof(List<>)
-                    )
-                    {
-                        parentComponentType = fieldType.GenericTypeArguments[0];
-
-                        Component[] parents = component.GetComponentsInParent(
-                            parentComponentType,
-                            true
-                        );
-
-                        IList instance = ReflectionHelpers.CreateList(
-                            parentComponentType,
-                            parents.Length
-                        );
-
-                        foundParent = false;
-                        foreach (Component parentComponent in parents)
-                        {
-                            instance.Add(parentComponent);
-                            foundParent = true;
-                        }
-                        setter(component, instance);
-                    }
-                    else
-                    {
-                        Component childComponent = component.GetComponentInParent(
-                            parentComponentType,
-                            true
-                        );
-                        foundParent = childComponent != null;
-                        if (foundParent)
-                        {
-                            setter(component, childComponent);
-                        }
-                    }
-                }
-
-                if (!foundParent)
-                {
-                    if (
-                        field.GetCustomAttributes(typeof(ParentComponentAttribute), false)[0]
-                        is ParentComponentAttribute { optional: false } _
-                    )
-                    {
-                        component.LogError($"Unable to find parent component of type {fieldType}");
-                    }
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extension;
+    using Helper;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class ParentComponentAttribute : Attribute
+    {
+        public bool optional = false;
+        public bool onlyAncestors = false;
+    }
+
+    public static class ParentComponentExtensions
+    {
+        private static readonly Dictionary<
+            Type,
+            (FieldInfo field, Action<object, object> setter)[]
+        > FieldsByType = new();
+
+        public static void AssignParentComponents(this Component component)
+        {
+            Type componentType = component.GetType();
+            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
+                componentType,
+                type =>
+                {
+                    FieldInfo[] fields = type.GetFields(
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                    );
+                    return fields
+                        .Where(field =>
+                            Attribute.IsDefined(field, typeof(ParentComponentAttribute))
+                        )
+                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
+                        .ToArray();
+                }
+            );
+
+            foreach ((FieldInfo field, Action<object, object> setter) in fields)
+            {
+                Type fieldType = field.FieldType;
+                bool isArray = fieldType.IsArray;
+                Type parentComponentType = isArray ? fieldType.GetElementType() : fieldType;
+
+                bool foundParent;
+                if (field.GetCustomAttribute<ParentComponentAttribute>().onlyAncestors)
+                {
+                    Transform parent = component.transform.parent;
+                    if (parent == null)
+                    {
+                        foundParent = false;
+                    }
+                    else if (isArray)
+                    {
+                        Component[] parentComponents = parent.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+                        foundParent = 0 < parentComponents.Length;
+
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
+                            parentComponentType,
+                            parentComponents.Length
+                        );
+                        Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
+                        setter(component, correctTypedArray);
+                    }
+                    else if (
+                        fieldType.IsGenericType
+                        && fieldType.GetGenericTypeDefinition() == typeof(List<>)
+                    )
+                    {
+                        parentComponentType = fieldType.GenericTypeArguments[0];
+
+                        Component[] parents = parent.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+
+                        IList instance = ReflectionHelpers.CreateList(
+                            parentComponentType,
+                            parents.Length
+                        );
+
+                        foundParent = false;
+                        foreach (Component parentComponent in parents)
+                        {
+                            instance.Add(parentComponent);
+                            foundParent = true;
+                        }
+
+                        setter(component, instance);
+                    }
+                    else
+                    {
+                        Component childComponent = parent.GetComponentInParent(
+                            parentComponentType,
+                            true
+                        );
+                        foundParent = childComponent != null;
+                        if (foundParent)
+                        {
+                            setter(component, childComponent);
+                        }
+                    }
+                }
+                else
+                {
+                    if (isArray)
+                    {
+                        Component[] parentComponents = component.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+                        foundParent = 0 < parentComponents.Length;
+
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
+                            parentComponentType,
+                            parentComponents.Length
+                        );
+                        Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
+                        setter(component, correctTypedArray);
+                    }
+                    else if (
+                        fieldType.IsGenericType
+                        && fieldType.GetGenericTypeDefinition() == typeof(List<>)
+                    )
+                    {
+                        parentComponentType = fieldType.GenericTypeArguments[0];
+
+                        Component[] parents = component.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+
+                        IList instance = ReflectionHelpers.CreateList(
+                            parentComponentType,
+                            parents.Length
+                        );
+
+                        foundParent = false;
+                        foreach (Component parentComponent in parents)
+                        {
+                            instance.Add(parentComponent);
+                            foundParent = true;
+                        }
+                        setter(component, instance);
+                    }
+                    else
+                    {
+                        Component childComponent = component.GetComponentInParent(
+                            parentComponentType,
+                            true
+                        );
+                        foundParent = childComponent != null;
+                        if (foundParent)
+                        {
+                            setter(component, childComponent);
+                        }
+                    }
+                }
+
+                if (!foundParent)
+                {
+                    if (
+                        field.GetCustomAttributes(typeof(ParentComponentAttribute), false)[0]
+                        is ParentComponentAttribute { optional: false } _
+                    )
+                    {
+                        component.LogError($"Unable to find parent component of type {fieldType}");
+                    }
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Attributes/ReadOnlyAttribute.cs

@@ -1,6 +1,6 @@
-using PropertyAttribute = UnityEngine.PropertyAttribute;
-
-namespace UnityHelpers.Core.Attributes
-{
-    public sealed class ReadOnlyAttribute : PropertyAttribute { }
-}
+using PropertyAttribute = UnityEngine.PropertyAttribute;
+
+namespace UnityHelpers.Core.Attributes
+{
+    public sealed class ReadOnlyAttribute : PropertyAttribute { }
+}

package/Runtime/Core/Attributes/RelationalComponentExtensions.cs

@@ -1,14 +1,14 @@
-namespace UnityHelpers.Core.Attributes
-{
-    using UnityEngine;
-
-    public static class RelationalComponentExtensions
-    {
-        public static void AssignRelationalComponents(this Component component)
-        {
-            component.AssignParentComponents();
-            component.AssignSiblingComponents();
-            component.AssignChildComponents();
-        }
-    }
-}
+namespace UnityHelpers.Core.Attributes
+{
+    using UnityEngine;
+
+    public static class RelationalComponentExtensions
+    {
+        public static void AssignRelationalComponents(this Component component)
+        {
+            component.AssignParentComponents();
+            component.AssignSiblingComponents();
+            component.AssignChildComponents();
+        }
+    }
+}

package/Runtime/Core/Attributes/SiblingComponentAttribute.cs

@@ -1,119 +1,119 @@
-namespace UnityHelpers.Core.Attributes
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Reflection;
-    using Extension;
-    using Helper;
-    using JetBrains.Annotations;
-    using UnityEngine;
-
-    [AttributeUsage(AttributeTargets.Field)]
-    [MeansImplicitUse]
-    public sealed class SiblingComponentAttribute : Attribute
-    {
-        public bool optional = false;
-    }
-
-    public static class SiblingComponentExtensions
-    {
-        private static readonly Dictionary<
-            Type,
-            (FieldInfo field, Action<object, object> setter)[]
-        > FieldsByType = new();
-
-        public static void AssignSiblingComponents(this Component component)
-        {
-            Type componentType = component.GetType();
-            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
-                componentType,
-                type =>
-                {
-                    FieldInfo[] fields = type.GetFields(
-                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
-                    );
-                    return fields
-                        .Where(field =>
-                            Attribute.IsDefined(field, typeof(SiblingComponentAttribute))
-                        )
-                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
-                        .ToArray();
-                }
-            );
-
-            foreach ((FieldInfo field, Action<object, object> setter) in fields)
-            {
-                Type fieldType = field.FieldType;
-                bool isArray = fieldType.IsArray;
-                Type siblingComponentType = isArray ? fieldType.GetElementType() : fieldType;
-
-                bool foundSibling;
-                if (isArray)
-                {
-                    Component[] siblingComponents = component.GetComponents(siblingComponentType);
-                    foundSibling = 0 < siblingComponents.Length;
-
-                    Array correctTypedArray = ReflectionHelpers.CreateArray(
-                        siblingComponentType,
-                        siblingComponents.Length
-                    );
-                    Array.Copy(siblingComponents, correctTypedArray, siblingComponents.Length);
-                    setter(component, correctTypedArray);
-                }
-                else if (
-                    fieldType.IsGenericType
-                    && fieldType.GetGenericTypeDefinition() == typeof(List<>)
-                )
-                {
-                    siblingComponentType = fieldType.GenericTypeArguments[0];
-
-                    Component[] siblings = component.GetComponents(siblingComponentType);
-
-                    IList instance = ReflectionHelpers.CreateList(
-                        siblingComponentType,
-                        siblings.Length
-                    );
-
-                    foundSibling = false;
-                    foreach (Component siblingComponent in siblings)
-                    {
-                        instance.Add(siblingComponent);
-                        foundSibling = true;
-                    }
-
-                    setter(component, instance);
-                }
-                else
-                {
-                    if (
-                        component.TryGetComponent(
-                            siblingComponentType,
-                            out Component siblingComponent
-                        )
-                    )
-                    {
-                        foundSibling = true;
-                        setter(component, siblingComponent);
-                    }
-                    else
-                    {
-                        foundSibling = false;
-                    }
-                }
-
-                if (!foundSibling)
-                {
-                    if (
-                        field.GetCustomAttributes(typeof(SiblingComponentAttribute), false)[0]
-                        is SiblingComponentAttribute { optional: false } _
-                    )
-                    {
-                        component.LogError($"Unable to find sibling component of type {fieldType}");
-                    }
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extension;
+    using Helper;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class SiblingComponentAttribute : Attribute
+    {
+        public bool optional = false;
+    }
+
+    public static class SiblingComponentExtensions
+    {
+        private static readonly Dictionary<
+            Type,
+            (FieldInfo field, Action<object, object> setter)[]
+        > FieldsByType = new();
+
+        public static void AssignSiblingComponents(this Component component)
+        {
+            Type componentType = component.GetType();
+            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
+                componentType,
+                type =>
+                {
+                    FieldInfo[] fields = type.GetFields(
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                    );
+                    return fields
+                        .Where(field =>
+                            Attribute.IsDefined(field, typeof(SiblingComponentAttribute))
+                        )
+                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
+                        .ToArray();
+                }
+            );
+
+            foreach ((FieldInfo field, Action<object, object> setter) in fields)
+            {
+                Type fieldType = field.FieldType;
+                bool isArray = fieldType.IsArray;
+                Type siblingComponentType = isArray ? fieldType.GetElementType() : fieldType;
+
+                bool foundSibling;
+                if (isArray)
+                {
+                    Component[] siblingComponents = component.GetComponents(siblingComponentType);
+                    foundSibling = 0 < siblingComponents.Length;
+
+                    Array correctTypedArray = ReflectionHelpers.CreateArray(
+                        siblingComponentType,
+                        siblingComponents.Length
+                    );
+                    Array.Copy(siblingComponents, correctTypedArray, siblingComponents.Length);
+                    setter(component, correctTypedArray);
+                }
+                else if (
+                    fieldType.IsGenericType
+                    && fieldType.GetGenericTypeDefinition() == typeof(List<>)
+                )
+                {
+                    siblingComponentType = fieldType.GenericTypeArguments[0];
+
+                    Component[] siblings = component.GetComponents(siblingComponentType);
+
+                    IList instance = ReflectionHelpers.CreateList(
+                        siblingComponentType,
+                        siblings.Length
+                    );
+
+                    foundSibling = false;
+                    foreach (Component siblingComponent in siblings)
+                    {
+                        instance.Add(siblingComponent);
+                        foundSibling = true;
+                    }
+
+                    setter(component, instance);
+                }
+                else
+                {
+                    if (
+                        component.TryGetComponent(
+                            siblingComponentType,
+                            out Component siblingComponent
+                        )
+                    )
+                    {
+                        foundSibling = true;
+                        setter(component, siblingComponent);
+                    }
+                    else
+                    {
+                        foundSibling = false;
+                    }
+                }
+
+                if (!foundSibling)
+                {
+                    if (
+                        field.GetCustomAttributes(typeof(SiblingComponentAttribute), false)[0]
+                        is SiblingComponentAttribute { optional: false } _
+                    )
+                    {
+                        component.LogError($"Unable to find sibling component of type {fieldType}");
+                    }
+                }
+            }
+        }
+    }
+}