Rework naming with Async suffix

.gitignore

@@ -1,3 +1,11 @@
+# AI-related
+CLAUDE.md
+AGENTS.md
+
+# Temp
+TempDotnetTests
+
+
 # This .gitignore file should be placed at the root of your Unity project directory
 #
 # Get latest from https://github.com/github/gitignore/blob/master/Unity.gitignore

Assets/Benchmarks/UniStateFixtures/BarState.cs

@@ -14,14 +14,14 @@ public BarState(BenchmarkHelper benchmarkHelper)
             _benchmarkHelper = benchmarkHelper;
         }
 
-        public override UniTask Initialize(CancellationToken token)
+        public override UniTask InitializeAsync(CancellationToken token)
         {
             _benchmarkHelper.InitializeWasInvoked();
 
             return UniTask.CompletedTask;
         }
 
-        public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             _benchmarkHelper.ExecuteWasInvoked();
 
@@ -30,7 +30,7 @@ public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
                 : Transition.GoTo<FooState>());
         }
 
-        public override UniTask Exit(CancellationToken token)
+        public override UniTask ExitAsync(CancellationToken token)
         {
             _benchmarkHelper.ExitWasInvoked();
 

Assets/Benchmarks/UniStateFixtures/FooState.cs

@@ -14,14 +14,14 @@ public FooState(BenchmarkHelper benchmarkHelper)
             _benchmarkHelper = benchmarkHelper;
         }
 
-        public override UniTask Initialize(CancellationToken token)
+        public override UniTask InitializeAsync(CancellationToken token)
         {
             _benchmarkHelper.InitializeWasInvoked();
 
             return UniTask.CompletedTask;
         }
 
-        public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             _benchmarkHelper.ExecuteWasInvoked();
 
@@ -30,7 +30,7 @@ public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
                 : Transition.GoTo<BarState>());
         }
 
-        public override UniTask Exit(CancellationToken token)
+        public override UniTask ExitAsync(CancellationToken token)
         {
             _benchmarkHelper.ExitWasInvoked();
 

Assets/Benchmarks/UniStateFixtures/UniBenchmarkTestBase.cs

@@ -21,7 +21,7 @@ protected async UniTask Run(int stateCount, bool withoutHistory)
 
             stateMachine.SetResolver(resolver);
 
-            await stateMachine.Execute<FooState>(CancellationToken.None);
+            await stateMachine.ExecuteAsync<FooState>(CancellationToken.None);
         }
 
         public void Clear()

Assets/Examples/Infrastructure/Reflex/DiceEntryPoint.cs

@@ -13,7 +13,7 @@ public class DiceEntryPoint
 
         public void Start()
         {
-            _stateMachine.Execute<StartGameState>(CancellationToken.None).Forget();
+            _stateMachine.ExecuteAsync<StartGameState>(CancellationToken.None).Forget();
         }
     }
 }

Assets/Examples/Infrastructure/VContainer/DiceEntryPoint.cs

@@ -17,7 +17,7 @@ public DiceEntryPoint(IStateMachine stateMachine)
 
         public void Start()
         {
-            _stateMachine.Execute<StartGameState>(CancellationToken.None).Forget();
+            _stateMachine.ExecuteAsync<StartGameState>(CancellationToken.None).Forget();
         }
     }
 }

Assets/Examples/States/LostState.cs

@@ -8,7 +8,7 @@ namespace Examples.States
 {
     public class LostState : StateBase
     {
-        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override async UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             Debug.Log("You lost. You will have a another chance in...");
 

Assets/Examples/States/RollDiceState.cs

@@ -9,7 +9,7 @@ namespace Examples.States
 {
     public class RollDiceState : StateBase
     {
-        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override async UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             Debug.Log("Need to roll 5+. Rolling the dice...");
 

Assets/Examples/States/StartGameState.cs

@@ -8,7 +8,7 @@ namespace Examples.States
 {
     internal class StartGameState : StateBase
     {
-        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override async UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             Debug.Log("Welcome to the game! You game will be loaded in 2 seconds!");
 

Assets/Examples/States/WinState.cs

@@ -7,7 +7,7 @@ namespace Examples.States
 {
     public class WinState : StateBase
     {
-        public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             Debug.Log("Congratulations! You won this game!");
 

Assets/UniState/Runtime/Core/State/DefaultCompositeState.cs

@@ -9,8 +9,8 @@ public class DefaultCompositeState : DefaultCompositeState<EmptyPayload>
 
     public class DefaultCompositeState<TPayload> : CompositeStateBase<TPayload>
     {
-        public override UniTask<StateTransitionInfo> Execute(CancellationToken token) => SubStates.Execute(token);
-        public override UniTask Initialize(CancellationToken token) => SubStates.Initialize(token);
-        public override UniTask Exit(CancellationToken token) => SubStates.Exit(token);
+        public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token) => SubStates.ExecuteAsync(token);
+        public override UniTask InitializeAsync(CancellationToken token) => SubStates.InitializeAsync(token);
+        public override UniTask ExitAsync(CancellationToken token) => SubStates.ExitAsync(token);
     }
 }

Assets/UniState/Runtime/Core/State/Interfaces/IExecutableState.cs

@@ -6,8 +6,8 @@ namespace UniState
 {
     public interface IExecutableState : IDisposable
     {
-        UniTask Initialize(CancellationToken token);
-        UniTask<StateTransitionInfo> Execute(CancellationToken token);
-        UniTask Exit(CancellationToken token);
+        UniTask InitializeAsync(CancellationToken token);
+        UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token);
+        UniTask ExitAsync(CancellationToken token);
     }
 }

Assets/UniState/Runtime/Core/State/StateBase.cs

@@ -18,14 +18,14 @@ public abstract class StateBase<T> : IState<T>
         protected IStateTransitionFacade Transition { get; private set; }
         protected List<IDisposable> Disposables => _disposables ??= new(4);
 
-        public abstract UniTask<StateTransitionInfo> Execute(CancellationToken token);
+        public abstract UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token);
 
-        public virtual UniTask Initialize(CancellationToken token)
+        public virtual UniTask InitializeAsync(CancellationToken token)
         {
             return UniTask.CompletedTask;
         }
 
-        public virtual UniTask Exit(CancellationToken token)
+        public virtual UniTask ExitAsync(CancellationToken token)
         {
             return UniTask.CompletedTask;
         }

Assets/UniState/Runtime/Core/State/SubStatesContainer.cs

@@ -23,10 +23,10 @@ public void Initialize(List<IState<TPayload>> subStates)
         public void SetTransitionFacade(IStateTransitionFacade transitionFacade) =>
             _subStates.ForEach(s => s.SetTransitionFacade(transitionFacade));
 
-        public UniTask Initialize(CancellationToken token) =>
-            UniTask.WhenAll(List.Select(s => s.Initialize(token)).ToArray());
+        public UniTask InitializeAsync(CancellationToken token) =>
+            UniTask.WhenAll(List.Select(s => s.InitializeAsync(token)).ToArray());
 
-        public async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public async UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             if (List.Count == 0)
             {
@@ -38,7 +38,7 @@ public async UniTask<StateTransitionInfo> Execute(CancellationToken token)
             var ctx = CancellationTokenSource.CreateLinkedTokenSource(token);
             try
             {
-                var first = await UniTask.WhenAny(List.Select(s => s.Execute(ctx.Token)).ToArray());
+                var first = await UniTask.WhenAny(List.Select(s => s.ExecuteAsync(ctx.Token)).ToArray());
                 result = first.result;
             }
             finally
@@ -50,8 +50,8 @@ public async UniTask<StateTransitionInfo> Execute(CancellationToken token)
             return result;
         }
 
-        public UniTask Exit(CancellationToken token) =>
-            UniTask.WhenAll(List.Select(s => s.Exit(token)).ToArray());
+        public UniTask ExitAsync(CancellationToken token) =>
+            UniTask.WhenAll(List.Select(s => s.ExitAsync(token)).ToArray());
 
         public void Dispose() => _subStates.ForEach(s => s.Dispose());
     }

Assets/UniState/Runtime/Core/StateMachine/IStateMachine.cs

@@ -7,8 +7,8 @@ public interface IStateMachine
     {
         bool IsExecuting { get; }
 
-        UniTask Execute<TState>(CancellationToken token) where TState : class, IState<EmptyPayload>;
-        UniTask Execute<TState, TPayload>(TPayload payload, CancellationToken token)
+        UniTask ExecuteAsync<TState>(CancellationToken token) where TState : class, IState<EmptyPayload>;
+        UniTask ExecuteAsync<TState, TPayload>(TPayload payload, CancellationToken token)
             where TState : class, IState<TPayload>;
         void SetResolver(ITypeResolver resolver);
     }

Assets/UniState/Runtime/Core/StateMachine/StateMachine.cs

@@ -19,12 +19,12 @@ public virtual void SetResolver(ITypeResolver resolver)
             _transitionFactory = new StateTransitionFactory(resolver);
         }
 
-        public virtual async UniTask Execute<TState>(CancellationToken token) where TState : class, IState<EmptyPayload>
+        public virtual async UniTask ExecuteAsync<TState>(CancellationToken token) where TState : class, IState<EmptyPayload>
         {
             await ExecuteInternal(_transitionFactory.CreateStateTransition<TState>(), token);
         }
 
-        public virtual async UniTask Execute<TState, TPayload>(TPayload payload, CancellationToken token)
+        public virtual async UniTask ExecuteAsync<TState, TPayload>(TPayload payload, CancellationToken token)
             where TState : class, IState<TPayload>
         {
             await ExecuteInternal(_transitionFactory.CreateStateTransition<TState, TPayload>(payload), token);
@@ -59,33 +59,33 @@ private async UniTask ExecuteInternal(StateTransitionInfo initialTransition, Can
 
             try
             {
-                await InitializeSafe(activeStateMetadata.State, token);
+                await InitializeSafeAsync(activeStateMetadata.State, token);
 
-                var transitionInfo = await ExecuteSafe(activeStateMetadata.State, token);
+                var transitionInfo = await ExecuteSafeAsync(activeStateMetadata.State, token);
 
                 ProcessTransitionInfo(transitionInfo, activeStateMetadata.TransitionInfo, nextStateMetadata);
 
                 while (!nextStateMetadata.IsEmpty && !token.IsCancellationRequested)
                 {
                     if (nextStateMetadata.BehaviourData.InitializeOnStateTransition)
                     {
-                        await InitializeSafe(nextStateMetadata.State, token);
-                        await ExitAndDisposeSafe(activeStateMetadata.State, token);
+                        await InitializeSafeAsync(nextStateMetadata.State, token);
+                        await ExitAndDisposeSafeAsync(activeStateMetadata.State, token);
                     }
                     else
                     {
-                        await ExitAndDisposeSafe(activeStateMetadata.State, token);
-                        await InitializeSafe(nextStateMetadata.State, token);
+                        await ExitAndDisposeSafeAsync(activeStateMetadata.State, token);
+                        await InitializeSafeAsync(nextStateMetadata.State, token);
                     }
 
                     activeStateMetadata.CopyData(nextStateMetadata);
 
-                    transitionInfo = await ExecuteSafe(activeStateMetadata.State, token);
+                    transitionInfo = await ExecuteSafeAsync(activeStateMetadata.State, token);
 
                     ProcessTransitionInfo(transitionInfo, activeStateMetadata.TransitionInfo, nextStateMetadata);
                 }
 
-                await ExitAndDisposeSafe(activeStateMetadata.State, token);
+                await ExitAndDisposeSafeAsync(activeStateMetadata.State, token);
                 activeStateMetadata.Clear();
             }
             catch (OperationCanceledException)
@@ -153,13 +153,13 @@ private StateTransitionInfo GetInfoFromHistory(StateTransitionInfo nextTransitio
             return null;
         }
 
-        private async UniTask<StateTransitionInfo> ExecuteSafe(IExecutableState state, CancellationToken token)
+        private async UniTask<StateTransitionInfo> ExecuteSafeAsync(IExecutableState state, CancellationToken token)
         {
             try
             {
                 token.ThrowIfCancellationRequested();
 
-                return await state.Execute(token);
+                return await state.ExecuteAsync(token);
             }
             catch (OperationCanceledException)
             {
@@ -173,12 +173,12 @@ private async UniTask<StateTransitionInfo> ExecuteSafe(IExecutableState state, C
             return BuildRecoveryTransition(_transitionFactory);
         }
 
-        private async UniTask InitializeSafe(IExecutableState state, CancellationToken token)
+        private async UniTask InitializeSafeAsync(IExecutableState state, CancellationToken token)
         {
             try
             {
                 token.ThrowIfCancellationRequested();
-                await state.Initialize(token);
+                await state.InitializeAsync(token);
             }
             catch (OperationCanceledException)
             {
@@ -190,12 +190,12 @@ private async UniTask InitializeSafe(IExecutableState state, CancellationToken t
             }
         }
 
-        private async UniTask ExitAndDisposeSafe(IExecutableState state, CancellationToken token)
+        private async UniTask ExitAndDisposeSafeAsync(IExecutableState state, CancellationToken token)
         {
             try
             {
                 token.ThrowIfCancellationRequested();
-                await state.Exit(token);
+                await state.ExitAsync(token);
             }
             catch (OperationCanceledException)
             {

Assets/UniStateTests/Common/StateMachine/StateMachineTestHelper.cs

@@ -12,7 +12,7 @@ public static async UniTask RunAndVerify<TStateMachine, TState>(ITypeResolver ty
             where TState : class, IState<EmptyPayload>
         {
             var stateMachine = typeResolver.Resolve<TStateMachine>();
-            await stateMachine.Execute<TState>(cancellationToken);
+            await stateMachine.ExecuteAsync<TState>(cancellationToken);
 
             stateMachine.Verify();
         }

Assets/UniStateTests/EditMode/States/StateDisposablesTests.cs

@@ -14,7 +14,7 @@ internal class StateDisposablesTests: ZenjectTestsBase
     {
         private class DisposablesState : StateBase<IList<IDisposable>>
         {
-            public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
+            public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
             {
                 Disposables.AddRange(Payload);
 
@@ -24,9 +24,9 @@ public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
 
         private class ExceptionDisposableState : DisposablesState
         {
-            public override UniTask<StateTransitionInfo> Execute(CancellationToken token)
+            public override UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
             {
-                _ = base.Execute(token);
+                _ = base.ExecuteAsync(token);
 
                 throw new("Test exception");
             }
@@ -57,7 +57,7 @@ private void ExecuteState<TState>(IList<IDisposable> disposables)
             where TState: DisposablesState
         {
             var stateMachine = Container.Resolve<IStateMachine>();
-            stateMachine.Execute<TState, IList<IDisposable>>(disposables, default).GetAwaiter().GetResult();
+            stateMachine.ExecuteAsync<TState, IList<IDisposable>>(disposables, default).GetAwaiter().GetResult();
         }
 
         protected override void SetupBindings(DiContainer container)

Assets/UniStateTests/PlayMode/BehaviorAttributeTests/Infrastructure/FastInitializeState.cs

@@ -15,14 +15,14 @@ public FastInitializeState(ExecutionLogger logger)
             _logger = logger;
         }
 
-        public override async UniTask Initialize(CancellationToken token)
+        public override async UniTask InitializeAsync(CancellationToken token)
         {
             await UniTask.Yield(token);
 
             _logger.LogStep("FastInitializeState", $"Initialize");
         }
 
-        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        public override async UniTask<StateTransitionInfo> ExecuteAsync(CancellationToken token)
         {
             await UniTask.Yield(token);
 
@@ -31,7 +31,7 @@ public override async UniTask<StateTransitionInfo> Execute(CancellationToken tok
             return Transition.GoBack();
         }
 
-        public override async UniTask Exit(CancellationToken token)
+        public override async UniTask ExitAsync(CancellationToken token)
         {
             await UniTask.Yield(token);