Remove uses of the word "Dummy"

It looks like using "Dummy" is not considered good practice - see:
simgine/bevy_enhanced_input#76

I've decided to adopt the following convention:
* Instead of `DummySomething`, use just `Something` unless it
  conflicts with a trait.
* If it conflicts with a trait, use `ExampleSomething` in docs and
  `TestSomething` in tests.
* Where possible, use more contextual names — e.g., `TableStorage`
  instead of `DummyComponent` in storage tests.
* If multiple types are involved, use `SomethingA`, `SomethingB`, etc.
* For variables, prefer `something` instead of `dummy_something`, or
  use more contextual names when necessary.

Overall, I think this makes things clearer and more concise.
No API changes required, it just tests and doc examples.

Author: Shatur

bevy_replicon_example_backend/tests/backend.rs

@@ -89,22 +89,22 @@ fn server_event() {
             }),
             RepliconExampleBackendPlugins,
         ))
-        .add_server_event::<DummyEvent>(Channel::Ordered)
+        .add_server_event::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
     setup(&mut server_app, &mut client_app).unwrap();
 
     server_app.world_mut().send_event(ToClients {
         mode: SendMode::Broadcast,
-        event: DummyEvent,
+        event: TestEvent,
     });
 
     server_app.update();
     client_app.update();
 
-    let dummy_events = client_app.world().resource::<Events<DummyEvent>>();
-    assert_eq!(dummy_events.len(), 1);
+    let events = client_app.world().resource::<Events<TestEvent>>();
+    assert_eq!(events.len(), 1);
 }
 
 #[test]
@@ -120,20 +120,20 @@ fn client_event() {
             }),
             RepliconExampleBackendPlugins,
         ))
-        .add_client_event::<DummyEvent>(Channel::Ordered)
+        .add_client_event::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
     setup(&mut server_app, &mut client_app).unwrap();
 
-    client_app.world_mut().send_event(DummyEvent);
+    client_app.world_mut().send_event(TestEvent);
 
     client_app.update();
     server_app.update();
 
     let client_events = server_app
         .world()
-        .resource::<Events<FromClient<DummyEvent>>>();
+        .resource::<Events<FromClient<TestEvent>>>();
     assert_eq!(client_events.len(), 1);
 }
 
@@ -152,4 +152,4 @@ fn setup(server_app: &mut App, client_app: &mut App) -> io::Result<()> {
 }
 
 #[derive(Deserialize, Event, Serialize)]
-struct DummyEvent;
+struct TestEvent;

src/lib.rs

@@ -114,10 +114,10 @@ Use [`AppRuleExt::replicate`] to create a replication rule for a single componen
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(RepliconPlugins);
-app.replicate::<DummyComponent>();
+app.replicate::<ExampleComponent>();
 
 #[derive(Component, Deserialize, Serialize)]
-struct DummyComponent;
+struct ExampleComponent;
 ```
 
 If your component contains an entity, it cannot be deserialized as is
@@ -251,7 +251,7 @@ contains sender ID and the sent event.
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(RepliconPlugins);
-app.add_client_event::<DummyEvent>(Channel::Ordered)
+app.add_client_event::<ExampleEvent>(Channel::Ordered)
     .add_systems(
         PreUpdate,
         receive_events
@@ -263,18 +263,18 @@ app.add_client_event::<DummyEvent>(Channel::Ordered)
         send_events.before(ClientSet::Send).run_if(client_connected),
     );
 
-fn send_events(mut dummy_events: EventWriter<DummyEvent>) {
-    dummy_events.send_default();
+fn send_events(mut events: EventWriter<ExampleEvent>) {
+    events.send_default();
 }
 
-fn receive_events(mut dummy_events: EventReader<FromClient<DummyEvent>>) {
-    for FromClient { client_entity, event } in dummy_events.read() {
+fn receive_events(mut events: EventReader<FromClient<ExampleEvent>>) {
+    for FromClient { client_entity, event } in events.read() {
         info!("received event `{event:?}` from client `{client_entity}`");
     }
 }
 
 #[derive(Debug, Default, Deserialize, Event, Serialize)]
-struct DummyEvent;
+struct ExampleEvent;
 ```
 
 If an event contains an entity, implement
@@ -295,19 +295,19 @@ using [`ClientTriggerAppExt::add_client_trigger`], and then use [`ClientTriggerE
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(RepliconPlugins);
-app.add_client_trigger::<DummyEvent>(Channel::Ordered)
+app.add_client_trigger::<ExampleEvent>(Channel::Ordered)
     .add_observer(receive_events)
     .add_systems(Update, send_events.run_if(client_connected));
 
 fn send_events(mut commands: Commands) {
-    commands.client_trigger(DummyEvent);
+    commands.client_trigger(ExampleEvent);
 }
 
-fn receive_events(trigger: Trigger<FromClient<DummyEvent>>) {
+fn receive_events(trigger: Trigger<FromClient<ExampleEvent>>) {
     info!("received event `{:?}` from client `{}`", **trigger, trigger.client_entity);
 }
 # #[derive(Event, Debug, Deserialize, Serialize)]
-# struct DummyEvent;
+# struct ExampleEvent;
 ```
 
 Trigger targets are also supported via [`ClientTriggerExt::client_trigger_targets`], no change
@@ -329,7 +329,7 @@ and the event itself.
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(RepliconPlugins);
-app.add_server_event::<DummyEvent>(Channel::Ordered)
+app.add_server_event::<ExampleEvent>(Channel::Ordered)
     .add_systems(
         PreUpdate,
         receive_events
@@ -341,21 +341,21 @@ app.add_server_event::<DummyEvent>(Channel::Ordered)
         send_events.before(ServerSet::Send).run_if(server_running),
     );
 
-fn send_events(mut dummy_events: EventWriter<ToClients<DummyEvent>>) {
-    dummy_events.write(ToClients {
+fn send_events(mut events: EventWriter<ToClients<ExampleEvent>>) {
+    events.write(ToClients {
         mode: SendMode::Broadcast,
-        event: DummyEvent,
+        event: ExampleEvent,
     });
 }
 
-fn receive_events(mut dummy_events: EventReader<DummyEvent>) {
-    for event in dummy_events.read() {
+fn receive_events(mut events: EventReader<ExampleEvent>) {
+    for event in events.read() {
         info!("received event {event:?} from server");
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, Event, Serialize)]
-struct DummyEvent;
+struct ExampleEvent;
 ```
 
 Just like for client events, we provide [`ServerEventAppExt::add_mapped_server_event`]
@@ -370,22 +370,22 @@ with [`ServerTriggerAppExt::add_server_trigger`] and then use [`ServerTriggerExt
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(RepliconPlugins);
-app.add_server_trigger::<DummyEvent>(Channel::Ordered)
+app.add_server_trigger::<ExampleEvent>(Channel::Ordered)
     .add_observer(receive_events)
     .add_systems(Update, send_events.run_if(server_running));
 
 fn send_events(mut commands: Commands) {
     commands.server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: DummyEvent,
+        event: ExampleEvent,
     });
 }
 
-fn receive_events(trigger: Trigger<DummyEvent>) {
+fn receive_events(trigger: Trigger<ExampleEvent>) {
     info!("received event {:?} from server", *trigger);
 }
 # #[derive(Event, Debug, Deserialize, Serialize)]
-# struct DummyEvent;
+# struct ExampleEvent;
 ```
 
 And just like for client trigger, we provide [`ServerTriggerAppExt::add_mapped_server_trigger`]

src/shared/event/server_event/client_event_queue.rs

@@ -76,7 +76,7 @@ mod tests {
 
     #[test]
     fn lower_tick() {
-        let mut queue = ClientEventQueue::<DummyEvent>::default();
+        let mut queue = ClientEventQueue::<TestEvent>::default();
         queue.insert(RepliconTick::new(1), Default::default());
 
         assert_eq!(queue.len(), 1);
@@ -85,7 +85,7 @@ mod tests {
 
     #[test]
     fn bigger_tick() {
-        let mut queue = ClientEventQueue::<DummyEvent>::default();
+        let mut queue = ClientEventQueue::<TestEvent>::default();
         queue.insert(RepliconTick::new(1), Default::default());
 
         assert!(queue.pop_if_le(RepliconTick::new(2)).is_some());
@@ -94,7 +94,7 @@ mod tests {
 
     #[test]
     fn ticks_ordering() {
-        let mut queue = ClientEventQueue::<DummyEvent>::default();
+        let mut queue = ClientEventQueue::<TestEvent>::default();
         queue.insert(RepliconTick::new(0), Default::default());
         queue.insert(RepliconTick::new(1), Default::default());
         queue.insert(RepliconTick::new(2), Default::default());
@@ -111,7 +111,7 @@ mod tests {
 
     #[test]
     fn messages_ordering() {
-        let mut queue = ClientEventQueue::<DummyEvent>::default();
+        let mut queue = ClientEventQueue::<TestEvent>::default();
         queue.insert(RepliconTick::new(0), Bytes::from_static(&[0]));
         queue.insert(RepliconTick::new(0), Bytes::from_static(&[1]));
 
@@ -121,5 +121,5 @@ mod tests {
         assert!(queue.is_empty());
     }
 
-    struct DummyEvent;
+    struct TestEvent;
 }

src/shared/replication/command_markers.rs

@@ -319,9 +319,9 @@ mod tests {
         let mut app = App::new();
         app.init_resource::<CommandMarkers>()
             .init_resource::<ReplicationRegistry>()
-            .set_marker_fns::<DummyMarkerA, DummyComponent>(
+            .set_marker_fns::<Marker, TestComponent>(
                 command_fns::default_write,
-                command_fns::default_remove::<DummyComponent>,
+                command_fns::default_remove::<TestComponent>,
             );
     }
 
@@ -330,16 +330,16 @@ mod tests {
         let mut app = App::new();
         app.init_resource::<CommandMarkers>()
             .init_resource::<ReplicationRegistry>()
-            .register_marker::<DummyMarkerA>()
-            .register_marker_with::<DummyMarkerB>(MarkerConfig {
+            .register_marker::<MarkerA>()
+            .register_marker_with::<MarkerB>(MarkerConfig {
                 priority: 2,
                 ..Default::default()
             })
-            .register_marker_with::<DummyMarkerC>(MarkerConfig {
+            .register_marker_with::<MarkerC>(MarkerConfig {
                 priority: 1,
                 ..Default::default()
             })
-            .register_marker::<DummyMarkerD>();
+            .register_marker::<MarkerD>();
 
         let markers = app.world().resource::<CommandMarkers>();
         let priorities: Vec<_> = markers
@@ -351,17 +351,20 @@ mod tests {
     }
 
     #[derive(Component)]
-    struct DummyMarkerA;
+    struct Marker;
 
     #[derive(Component)]
-    struct DummyMarkerB;
+    struct MarkerA;
 
     #[derive(Component)]
-    struct DummyMarkerC;
+    struct MarkerB;
 
     #[derive(Component)]
-    struct DummyMarkerD;
+    struct MarkerC;
+
+    #[derive(Component)]
+    struct MarkerD;
 
     #[derive(Component, Serialize, Deserialize)]
-    struct DummyComponent;
+    struct TestComponent;
 }

src/shared/replication/replication_registry/test_fns.rs

@@ -45,25 +45,25 @@ let tick = RepliconTick::default();
 let (_, fns_id) = app
     .world_mut()
     .resource_scope(|world, mut registry: Mut<ReplicationRegistry>| {
-        registry.register_rule_fns(world, RuleFns::<DummyComponent>::default())
+        registry.register_rule_fns(world, RuleFns::<ExampleComponent>::default())
     });
 
-let mut entity = app.world_mut().spawn(DummyComponent);
+let mut entity = app.world_mut().spawn(ExampleComponent);
 let data = entity.serialize(fns_id, tick);
-entity.remove::<DummyComponent>();
+entity.remove::<ExampleComponent>();
 
 entity.apply_write(data, fns_id, tick);
-assert!(entity.contains::<DummyComponent>());
+assert!(entity.contains::<ExampleComponent>());
 
 entity.apply_remove(fns_id, tick);
-assert!(!entity.contains::<DummyComponent>());
+assert!(!entity.contains::<ExampleComponent>());
 
 entity.apply_despawn(tick);
-let mut replicated = app.world_mut().query::<&DummyComponent>();
+let mut replicated = app.world_mut().query::<&ExampleComponent>();
 assert_eq!(replicated.iter(app.world()).len(), 0);
 
 #[derive(Component, Serialize, Deserialize)]
-struct DummyComponent;
+struct ExampleComponent;
 ```
 **/
 pub trait TestFnsEntityExt {