Next major update (#32)

* use dashmap and enable interior mutability

* remove debug trait requirement

* add support for other async-runtimes without feature flags

clean up dep tree too

* fix code coverage ci

Author: spencerjibz

.github/grcov.yml

@@ -1,7 +1,7 @@
-branch: true
-ignore-not-existing: true
-
-output-type: lcov
-output-path: coverage
-ignore:
-     - /tests/*
+branch: true
+ignore-not-existing: true
+
+output-type: lcov
+output-path: coverage
+ignore:
+     - /tests/*

.github/workflows/code_cov.yml

@@ -0,0 +1,85 @@
+name: Coverage
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Cache Cargo dependencies
+        uses: actions/cache@v3
+        with:
+          path: ~/.cargo/registry
+          key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            cargo-${{ runner.os }}-
+
+      - name: Install Rust nightly toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: llvm-tools-preview
+
+      - name: Download and install grcov
+        run: |
+          GRCOV_VERSION="0.8.20"
+          curl -L -o grcov.tar.bz2 "https://github.com/mozilla/grcov/releases/download/v$GRCOV_VERSION/grcov-x86_64-unknown-linux-gnu.tar.bz2"
+          tar xjf grcov.tar.bz2
+          chmod +x grcov
+          mv grcov /usr/local/bin/
+
+      - name: Ensure target directory exists
+        run: mkdir -p target/coverage
+
+      - name: Run tests with coverage
+        run: |
+          export CARGO_INCREMENTAL=0
+          export RUSTFLAGS="-Cinstrument-coverage"
+          export LLVM_PROFILE_FILE="$(pwd)/target/debug/deps/%p-%m.profraw"
+          cargo +nightly test
+
+      - name: Locate LLVM Tools
+        run: |
+          echo "LLVM_TOOLS_DIR=$(rustc --print sysroot)/lib/rustlib/$(rustc -vV | grep host | awk '{print $2}')/bin" >> $GITHUB_ENV
+
+      - name: Download and install rustfilt
+        run: |
+          curl -L -o rustfilt "https://github.com/luser/rustfilt/releases/latest/download/rustfilt-x86_64-unknown-linux-gnu"
+          chmod +x rustfilt
+          mv rustfilt /usr/local/bin/
+
+      - name: Merge and Convert Coverage Data
+        run: |
+          $LLVM_TOOLS_DIR/llvm-profdata merge -sparse $(find target/debug/deps -name '*.profraw') -o target/coverage/merged.profdata
+          $LLVM_TOOLS_DIR/llvm-cov export --format=lcov --instr-profile=target/coverage/merged.profdata \
+            --ignore-filename-regex='/.cargo/registry|rustc/' \
+            --Xdemangler=rustfilt $(find target/debug/deps -executable -type f) > target/coverage/lcov.info
+
+      - name: Verify Coverage File
+        run: |
+          ls -lah target/coverage/
+          head -n 20 target/coverage/lcov.info
+
+      - name: Upload coverage report as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: target/coverage/lcov.info
+
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          files: target/coverage/lcov.info
+          fail_ci_if_error: true
+          verbose: true
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/codecov.yml

@@ -1,4 +1,5 @@
 /target
 /Cargo.lock
 *.idea/
-.vscode
+.vscode
+*.profraw

.gitignore

@@ -3,39 +3,36 @@ name = "async-event-emitter"
 version = "0.1.3"
 edition = "2021"
 description = "Lightweight AsyncEventEmitter"
-authors = [ "Spencer Najib", "Dylan Kerler" ]
-keywords = [ "event-emitter", "tokio", "async-rust", "futures", "bincode" ]
+authors = ["Spencer Najib", "Dylan Kerler"]
+keywords = ["event-emitter", "tokio", "async-rust", "futures", "bincode"]
 license = "MIT"
 repository = "https://github.com/spencerjibz/async-event-emitter-rs"
 homepage = "https://github.com/spencerjibz/async-event-emitter-rs"
-categories = [ "asynchronous", "web-programming" ]
+categories = ["asynchronous", "web-programming"]
 readme = "./README.md"
 
 [dependencies]
-anyhow = "1.0.75"
+anyhow = "1.0.95"
 bincode = "1.3.3"
-futures = "0.3.29"
-lazy_static = "1.4.0"
-tokio-test = "0.4.3"
+futures = "0.3.31"
+lazy_static = "1.5.0"
 
-  [dependencies.async-std]
-  version = "1.12.0"
-  optional = true
-  features = [ "alloc", "attributes" ]
+[dependencies.dashmap]
+version = "6.1.0"
+default-features = false
 
-  [dependencies.serde]
-  version = "1.0.190"
-  features = [ "derive" ]
+[dependencies.serde]
+version = "1.0.217"
+features = ["derive"]
+default-features = false
 
-  [dependencies.tokio]
-  version = "1.33.0"
-  features = [ "rt", "macros", "rt-multi-thread" ]
-  optional = true
-
-  [dependencies.uuid]
-  version = "1.5.0"
-  features = [ "v4" ]
-
-[features]
-use-async-std = [ "async-std" ]
-default = [ "tokio" ]
+[dependencies.uuid]
+version = "1.13.1"
+features = ["v4"]
+default-features = false
+[dev-dependencies]
+tokio = { version = "*", features = [
+    "rt",
+    "macros",
+    "rt-multi-thread",
+], default-features = false }

Cargo.toml

@@ -12,19 +12,20 @@ Allows you to subscribe to events with callbacks and also fire those events.
 Events are in the form of (strings, value) and callbacks are in the form of closures that take in a value parameter;
 
 #### Differences between this crate and [`event-emitter-rs`](https://crates.io/crates/event-emitter-rs)
+ - This is an async implementation that works for all common async runtimes (Tokio, async-std and smol)
+ - The listener methods ***(on and once)*** take a callback that returns a future instead of a merely a closure.
+ - The emit methods executes each callback on each event by spawning a tokio task instead of a std::thread
+ - This emitter is thread safe and can  also be used lock-free (supports interior mutability).
 
--    Emitted values should implement an extra trait (Debug) in addition to Serde's Serialize and Deserialize.
--    This is an async implementation, not limited to tokio, but async-std is supported  under the ``` use-async-std ``` feature flag.
--    The listener methods **_(on and once)_** take a callback that returns a future instead of a merely a closure.
--    The emit methods executes each callback on each event by spawning a tokio task instead of a std::thread
+ ***Note***: To use strict return and event types, use [typed-emitter](https://crates.io/crates/typed-emitter), that crate solves [this issue](https://github.com/spencerjibz/async-event-emitter-rs/issues/31) too.  
 
 #### Getting Started
 
 ```rust
     use async_event_emitter::AsyncEventEmitter;
     #[tokio::main]
     async fn main() {
-        let mut event_emitter = AsyncEventEmitter::new();
+        let event_emitter = AsyncEventEmitter::new();
         // This will print <"Hello world!"> whenever the <"Say Hello"> event is emitted
         event_emitter.on("Say Hello", |_: ()| async move { println!("Hello world!") });
         event_emitter.emit("Say Hello", ()).await.unwrap();
@@ -43,7 +44,7 @@ A single EventEmitter instance can have listeners to values of multiple types.
 
     #[tokio::main]
     async fn main() -> anyhow::Result<()> {
-        let mut event_emitter = EventEmitter::new();
+        let event_emitter = EventEmitter::new();
         event_emitter.on("Add three", |number: f64| async move {
             println!("{}", number + 3.0)
         });
@@ -94,7 +95,7 @@ Removing listeners is also easy
 
 ```rust
     use async_event_emitter::AsyncEventEmitter as EventEmitter;
-    let mut event_emitter = EventEmitter::new();
+    let event_emitter = EventEmitter::new();
 
     let listener_id = event_emitter.on("Hello", |_: ()| async { println!("Hello World") });
     match event_emitter.remove_listener(&listener_id) {
@@ -112,40 +113,31 @@ After all, one of the main points of using an EventEmitter is to avoid passing d
 ```rust
         // global_event_emitter.rs
         use async_event_emitter::AsyncEventEmitter;
-        use futures::lock::Mutex;
         use lazy_static::lazy_static;
 
         // Use lazy_static! because the size of EventEmitter is not known at compile time
         lazy_static! {
         // Export the emitter with `pub` keyword
-        pub static ref EVENT_EMITTER: Mutex<AsyncEventEmitter> = Mutex::new(AsyncEventEmitter::new());
+        pub static ref EVENT_EMITTER: AsyncEventEmitter = AsyncEventEmitter::new();
         }
 
         #[tokio::main]
         async fn main() -> anyhow::Result<()> {
-            // We need to maintain a lock through the mutex so we can avoid data races
-            EVENT_EMITTER
-                .lock()
-                .await
-                .on("Hello", |_: ()| async { println!("hello there!") });
-            EVENT_EMITTER.lock().await.emit("Hello", ()).await?;
+            EVENT_EMITTER.on("Hello", |_: ()| async { println!("hello there!") });
+            EVENT_EMITTER.emit("Hello", ()).await?;
 
             Ok(())
         }
 
         async fn random_function() {
             // When the <"Hello"> event is emitted in main.rs then print <"Random stuff!">
             EVENT_EMITTER
-                .lock()
-                .await
                 .on("Hello", |_: ()| async { println!("Random stuff!") });
         }
 
 ```
- #### Using async-std instead of tokio
-Tokio is the default  runtime for this library but async-std support can be able enabled by disabling default-features on the crate and enabling the ```use-async-std``` feature.
-     <br>
-**Note**: Use simply replace tokio::main with async-std::main and tokio::test with async-std::test (provided you've enabled the "attributes" feature on the crate.
+#### Usage with other runtimes
+ Check out the examples from the [typed version of this crate](https://docs.rs/typed-emitter/0.1.2/typed_emitter/#getting-started), just replace the emntter type.
 
  #### Testing
  Run the tests on this crate with all-features enabled as follows: