feat(here-now): add limit and offset configuration options

Add `limit` (default `1000`) and `offset` parameters for `here_now` to fetch presence in portions.

fix(subscribe): fix duplicated channels and groups for `subscribe`

Fix issue that allowed passing duplicated channels and groups for `subscribe`.

fix(heartbeat): fix duplicated channels and groups for `heartbeat`

Fix issue that allowed passing duplicated channels and groups for `heartbeat`.

Author: parfeon

Cargo.toml

@@ -17,7 +17,7 @@ build = "build.rs"
 full = ["publish", "subscribe", "presence", "access", "serde", "reqwest", "crypto", "parse_token", "blocking", "std", "tokio"]
 
 # Enables all default features
-default = ["publish", "subscribe", "serde", "reqwest", "std", "blocking", "tokio"]
+default = ["publish", "subscribe", "serde", "reqwest", "std", "blocking", "tokio", "presence"]
 
 # [PubNub features]
 
@@ -79,7 +79,7 @@ spin = "0.9"
 phantom-type = { version = "0.4.2", default-features = false }
 percent-encoding = { version = "2.1", default-features = false }
 base64 = { version = "0.21", features = ["alloc"], default-features = false }
-derive_builder = { version = "0.12", default-features = false }
+derive_builder = { version = "0.20.2", default-features = false }
 uuid = { version = "1.3", features = ["v4"], default-features = false }
 snafu = { version = "0.7", features = ["rust_1_46"], default-features = false }
 rand = { version = "0.8.5", default-features = false }

examples/no_std/src/here_now.rs

@@ -28,20 +28,23 @@ use pubnub::{
 fn custom_random(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     // We're using `42` as a random number, because it's the answer
     // to the Ultimate Question of Life, the Universe, and Everything.
-    // In your program, you should use proper random number generator that is supported by your target.
+    // In your program, you should use proper random number generator that is
+    // supported by your target.
     for i in buf.iter_mut() {
         *i = 42;
     }
 
     Ok(())
 }
 
-// This function is used to register the custom implementation of `getrandom` function.
+// This function is used to register the custom implementation of `getrandom`
+// function.
 #[no_mangle]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
 ) -> Result<(), getrandom::Error> {
+    #[allow(unsafe_code)]
     let buf = unsafe {
         // fill the buffer with zeros
         core::ptr::write_bytes(dest, 0, len);
@@ -53,7 +56,8 @@ unsafe extern "Rust" fn __getrandom_v03_custom(
 
 // Many targets have very specific requirements for networking, so it's hard to
 // provide a generic implementation.
-// Depending on the target, you will probably need to implement `Transport` trait.
+// Depending on the target, you will probably need to implement `Transport`
+// trait.
 struct MyTransport;
 
 impl Transport for MyTransport {
@@ -69,8 +73,8 @@ impl Transport for MyTransport {
 // As our target does not have `std` library, we need to provide custom
 // implementation of `GlobalAlloc` trait.
 //
-// In your program, you should use proper allocator that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper allocator that is supported by your
+// target. Here you have dummy implementation that does nothing.
 #[derive(Default)]
 pub struct Allocator;
 
@@ -87,23 +91,23 @@ static GLOBAL_ALLOCATOR: Allocator = Allocator;
 // As our target does not have `std` library, we need to provide custom
 // implementation of `panic_handler`.
 //
-// In your program, you should use proper panic handler that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper panic handler that is supported by
+// your target. Here you have dummy implementation that does nothing.
 #[panic_handler]
 fn panicking(_: &PanicInfo) -> ! {
     loop {}
 }
 
-// As we're using `no_main` attribute, we need to define `main` function manually.
-// For this example we're using `extern "C"` ABI to make it work.
+// As we're using `no_main` attribute, we need to define `main` function
+// manually. For this example we're using `extern "C"` ABI to make it work.
 #[no_mangle]
 pub extern "C" fn main(_argc: isize, _argv: *const *const u8) -> usize {
     publish_example().map(|_| 0).unwrap()
 }
 
-// In standard subscribe examples we use `println` macro to print the result of the operation
-// and it shows the idea of the example. `no_std` does not support `println` macro,
-// so we're using `do_a_thing` function instead.
+// In standard subscribe examples we use `println` macro to print the result of
+// the operation and it shows the idea of the example. `no_std` does not support
+// `println` macro, so we're using `do_a_thing` function instead.
 fn do_a_thing<T>(_: &T) {}
 
 // As `no_std` does not support `Error` trait, we use `PubNubError` instead.
@@ -129,8 +133,8 @@ fn publish_example() -> Result<(), PubNubError> {
         .include_user_id(true)
         .execute_blocking()?;
 
-    // As `no_std` does not support `println` macro, we're using `do_a_thing` function instead
-    // to show possible usage of the result.
+    // As `no_std` does not support `println` macro, we're using `do_a_thing`
+    // function instead to show possible usage of the result.
 
     channels_now.iter().for_each(|channel| {
         do_a_thing(&channel.name);

examples/no_std/src/presence_state.rs

@@ -35,20 +35,23 @@ struct State {
 fn custom_random(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     // We're using `42` as a random number, because it's the answer
     // to the Ultimate Question of Life, the Universe, and Everything.
-    // In your program, you should use proper random number generator that is supported by your target.
+    // In your program, you should use proper random number generator that is
+    // supported by your target.
     for i in buf.iter_mut() {
         *i = 42;
     }
 
     Ok(())
 }
 
-// This function is used to register the custom implementation of `getrandom` function.
+// This function is used to register the custom implementation of `getrandom`
+// function.
 #[no_mangle]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
 ) -> Result<(), getrandom::Error> {
+    #[allow(unsafe_code)]
     let buf = unsafe {
         // fill the buffer with zeros
         core::ptr::write_bytes(dest, 0, len);
@@ -60,7 +63,8 @@ unsafe extern "Rust" fn __getrandom_v03_custom(
 
 // Many targets have very specific requirements for networking, so it's hard to
 // provide a generic implementation.
-// Depending on the target, you will probably need to implement `Transport` trait.
+// Depending on the target, you will probably need to implement `Transport`
+// trait.
 struct MyTransport;
 
 impl Transport for MyTransport {
@@ -76,8 +80,8 @@ impl Transport for MyTransport {
 // As our target does not have `std` library, we need to provide custom
 // implementation of `GlobalAlloc` trait.
 //
-// In your program, you should use proper allocator that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper allocator that is supported by your
+// target. Here you have dummy implementation that does nothing.
 #[derive(Default)]
 pub struct Allocator;
 
@@ -94,23 +98,23 @@ static GLOBAL_ALLOCATOR: Allocator = Allocator;
 // As our target does not have `std` library, we need to provide custom
 // implementation of `panic_handler`.
 //
-// In your program, you should use proper panic handler that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper panic handler that is supported by
+// your target. Here you have dummy implementation that does nothing.
 #[panic_handler]
 fn panicking(_: &PanicInfo) -> ! {
     loop {}
 }
 
-// As we're using `no_main` attribute, we need to define `main` function manually.
-// For this example we're using `extern "C"` ABI to make it work.
+// As we're using `no_main` attribute, we need to define `main` function
+// manually. For this example we're using `extern "C"` ABI to make it work.
 #[no_mangle]
 pub extern "C" fn main(_argc: isize, _argv: *const *const u8) -> usize {
     publish_example().map(|_| 0).unwrap()
 }
 
-// In standard subscribe examples we use `println` macro to print the result of the operation
-// and it shows the idea of the example. `no_std` does not support `println` macro,
-// so we're using `do_a_thing` function instead.
+// In standard subscribe examples we use `println` macro to print the result of
+// the operation and it shows the idea of the example. `no_std` does not support
+// `println` macro, so we're using `do_a_thing` function instead.
 fn do_a_thing<T>(_: &T) {}
 
 // As `no_std` does not support `Error` trait, we use `PubNubError` instead.
@@ -129,8 +133,8 @@ fn publish_example() -> Result<(), PubNubError> {
         .with_user_id("user_id")
         .build()?;
 
-    // As `no_std` does not support `println` macro, we're using `do_a_thing` function instead
-    // to show possible usage of the result.
+    // As `no_std` does not support `println` macro, we're using `do_a_thing`
+    // function instead to show possible usage of the result.
 
     client
         .set_presence_state(State {

examples/no_std/src/publish.rs

@@ -36,20 +36,23 @@ struct Message {
 fn custom_random(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     // We're using `42` as a random number, because it's the answer
     // to the Ultimate Question of Life, the Universe, and Everything.
-    // In your program, you should use proper random number generator that is supported by your target.
+    // In your program, you should use proper random number generator that is
+    // supported by your target.
     for i in buf.iter_mut() {
         *i = 42;
     }
 
     Ok(())
 }
 
-// This function is used to register the custom implementation of `getrandom` function.
+// This function is used to register the custom implementation of `getrandom`
+// function.
 #[no_mangle]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
 ) -> Result<(), getrandom::Error> {
+    #[allow(unsafe_code)]
     let buf = unsafe {
         // fill the buffer with zeros
         core::ptr::write_bytes(dest, 0, len);
@@ -61,7 +64,8 @@ unsafe extern "Rust" fn __getrandom_v03_custom(
 
 // Many targets have very specific requirements for networking, so it's hard to
 // provide a generic implementation.
-// Depending on the target, you will probably need to implement `Transport` trait.
+// Depending on the target, you will probably need to implement `Transport`
+// trait.
 struct MyTransport;
 
 impl Transport for MyTransport {
@@ -77,8 +81,8 @@ impl Transport for MyTransport {
 // As our target does not have `std` library, we need to provide custom
 // implementation of `GlobalAlloc` trait.
 //
-// In your program, you should use proper allocator that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper allocator that is supported by your
+// target. Here you have dummy implementation that does nothing.
 #[derive(Default)]
 pub struct Allocator;
 
@@ -95,15 +99,15 @@ static GLOBAL_ALLOCATOR: Allocator = Allocator;
 // As our target does not have `std` library, we need to provide custom
 // implementation of `panic_handler`.
 //
-// In your program, you should use proper panic handler that is supported by your target.
-// Here you have dummy implementation that does nothing.
+// In your program, you should use proper panic handler that is supported by
+// your target. Here you have dummy implementation that does nothing.
 #[panic_handler]
 fn panicking(_: &PanicInfo) -> ! {
     loop {}
 }
 
-// As we're using `no_main` attribute, we need to define `main` function manually.
-// For this example we're using `extern "C"` ABI to make it work.
+// As we're using `no_main` attribute, we need to define `main` function
+// manually. For this example we're using `extern "C"` ABI to make it work.
 #[no_mangle]
 pub extern "C" fn main(_argc: isize, _argv: *const *const u8) -> usize {
     publish_example().map(|_| 0).unwrap()

examples/no_std/src/subscribe.rs

@@ -37,20 +37,23 @@ struct Message {
 fn custom_random(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     // We're using `42` as a random number, because it's the answer
     // to the Ultimate Question of Life, the Universe, and Everything.
-    // In your program, you should use proper random number generator that is supported by your target.
+    // In your program, you should use proper random number generator that is
+    // supported by your target.
     for i in buf.iter_mut() {
         *i = 42;
     }
 
     Ok(())
 }
 
-// This function is used to register the custom implementation of `getrandom` function.
+// This function is used to register the custom implementation of `getrandom`
+// function.
 #[no_mangle]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
 ) -> Result<(), getrandom::Error> {
+    #[allow(unsafe_code)]
     let buf = unsafe {
         // fill the buffer with zeros
         core::ptr::write_bytes(dest, 0, len);

src/core/utils/encoding.rs

@@ -1,4 +1,5 @@
 use crate::lib::alloc::{
+    collections::HashSet,
     string::{String, ToString},
     vec::Vec,
 };
@@ -76,10 +77,19 @@ pub fn join_url_encoded(strings: &[&str], sep: &str) -> Option<String> {
 /// Channels list used as part of URL path and therefore required.
 #[cfg(any(feature = "subscribe", feature = "presence"))]
 pub(crate) fn url_encoded_channels(channels: &[String]) -> String {
+    let mut seen_channels = HashSet::new();
+
     join_url_encoded(
         channels
             .iter()
-            .map(|v| v.as_str())
+            .filter_map(|channel| {
+                let channel_string = channel.as_str();
+                if seen_channels.insert(channel_string) {
+                    Some(channel_string)
+                } else {
+                    None
+                }
+            })
             .collect::<Vec<&str>>()
             .as_slice(),
         ",",
@@ -90,10 +100,19 @@ pub(crate) fn url_encoded_channels(channels: &[String]) -> String {
 /// URL-encode channel groups list.
 #[cfg(any(feature = "subscribe", feature = "presence"))]
 pub(crate) fn url_encoded_channel_groups(channel_groups: &[String]) -> Option<String> {
+    let mut seen_groups = HashSet::new();
+
     join_url_encoded(
         channel_groups
             .iter()
-            .map(|v| v.as_str())
+            .filter_map(|group| {
+                let group_string = group.as_str();
+                if seen_groups.insert(group_string) {
+                    Some(group_string)
+                } else {
+                    None
+                }
+            })
             .collect::<Vec<&str>>()
             .as_slice(),
         ",",

src/dx/presence/builders/here_now.rs

@@ -81,6 +81,24 @@ pub struct HereNowRequest<T, D> {
         default = "false"
     )]
     pub(in crate::dx::presence) include_state: bool,
+
+    /// Maximum number of occupants to return per channel.
+    ///
+    /// > **Important**: Maximum and default value is `1000` users per request.
+    #[builder(
+        field(vis = "pub(in crate::dx::presence)"),
+        setter(strip_option),
+        default = "1000"
+    )]
+    pub(in crate::dx::presence) limit: usize,
+
+    /// Zero-based starting index for pagination.
+    #[builder(
+        field(vis = "pub(in crate::dx::presence)"),
+        setter(strip_option),
+        default
+    )]
+    pub(in crate::dx::presence) offset: Option<usize>,
 }
 
 impl<T, D> HereNowRequestBuilder<T, D> {
@@ -127,6 +145,12 @@ impl<T, D> HereNowRequest<T, D> {
             query.insert("disable_uuids".into(), "1".into());
         });
 
+        query.insert("limit".into(), self.limit.to_string());
+
+        if let Some(offset) = self.offset {
+            (offset > 0).then(|| query.insert("offset".into(), offset.to_string()));
+        }
+
         Ok(TransportRequest {
             path: format!(
                 "/v2/presence/sub-key/{}/channel/{}",