GroupAction -> ActionGroup

Author: lkdvos

docs/src/logging.md

@@ -226,7 +226,7 @@ history2 = CaptureHistory()
 
 with_algorithmlogger(
     :Start => record_start,
-    :PostStep => GroupAction([iter_printer, history2]),
+    :PostStep => ActionGroup(iter_printer, history2),
     :Stop => CallbackAction() do problem, algorithm, state
         @printf("Captured %d iterates in %.3fs\n", length(history2.iterates), time() - start_time[])
     end,
@@ -473,7 +473,7 @@ Implementing logging involves three main components:
 
 2. **AlgorithmLogger**: Map contexts (`:Start`, `:PostStep`, etc.) to actions.
    - Construct with `with_algorithmlogger(:Context => action, ...)`.
-   - Use `GroupAction` to compose multiple actions at one context.
+   - Use `ActionGroup` to compose multiple actions at one context.
 
 3. **Custom contexts**: Emit domain-specific events from algorithms.
    - Call `emit_message(problem, algorithm, state, :YourContext)`.

src/AlgorithmsInterface.jl

@@ -33,7 +33,7 @@ export StopAfter, StopAfterIteration, StopWhenAll, StopWhenAny
 export is_finished, is_finished!, get_reason, indicates_convergence
 
 # Logging interface
-export LoggingAction, CallbackAction, IfAction, GroupAction
+export LoggingAction, CallbackAction, IfAction, ActionGroup
 export with_algorithmlogger, emit_message
 
 end # module AlgorithmsInterface

src/logging.jl

@@ -21,18 +21,18 @@ Entry-point for defining an implementation of how to handle a logging event for
 # Concrete LoggingActions
 # -----------------------
 """
-    GroupAction(actions::LoggingAction...)
-    GroupAction(actions::Vector{<:LoggingAction})
+    ActionGroup(actions::LoggingAction...)
+    ActionGroup(actions::Vector{<:LoggingAction})
 
 Concrete [`LoggingAction`](@ref) that can be used to sequentially perform each of the `actions`.
 """
-struct GroupAction{A <: LoggingAction} <: LoggingAction
+struct ActionGroup{A <: LoggingAction} <: LoggingAction
     actions::Vector{A}
 end
-GroupAction(actions::LoggingAction...) = GroupAction(collect(LoggingAction, actions))
+ActionGroup(actions::LoggingAction...) = ActionGroup(collect(LoggingAction, actions))
 
 function handle_message!(
-        action::GroupAction, problem::Problem, algorithm::Algorithm, state::State; kwargs...
+        action::ActionGroup, problem::Problem, algorithm::Algorithm, state::State; kwargs...
     )
     for child in action.actions
         handle_message!(child, problem, algorithm, state; kwargs...)

test/logging.jl

@@ -100,7 +100,7 @@ end
     end
 end
 
-@testset "GroupAction logs multiple actions" begin
+@testset "ActionGroup logs multiple actions" begin
     problem = LogDummyProblem()
     algorithm = LogDummyAlgorithm(StopAfterIteration(2))
 
@@ -114,7 +114,7 @@ end
         @info "Logger2 Iter $(state.iteration)"
     end
 
-    group_logger = GroupAction(logger1, logger2)
+    group_logger = ActionGroup(logger1, logger2)
 
     # Expect both loggers to log for each iteration
     @test_logs (:info, "Logger1 Iter 1") (:info, "Logger2 Iter 1") (:info, "Logger1 Iter 2") (:info, "Logger2 Iter 2") begin