You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
647 lines
17 KiB
647 lines
17 KiB
use crate::errors::Error;
|
|
use serde::Serialize;
|
|
use std::{borrow::Cow, convert::Into};
|
|
|
|
mod bool_qs_serialize {
|
|
use serde::Serializer;
|
|
|
|
pub fn is_false(b: &bool) -> bool {
|
|
!*b
|
|
}
|
|
|
|
pub fn serialize<S: Serializer>(b: &bool, s: S) -> Result<S::Ok, S::Error> {
|
|
if *b {
|
|
s.serialize_i64(1)
|
|
} else {
|
|
s.serialize_i64(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Builder for making a client.statuses() call
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// request.only_media().pinned().since_id("foo");
|
|
/// # assert_eq!(&request.to_querystring().expect("Couldn't serialize qs")[..], "?only_media=1&pinned=1&since_id=foo");
|
|
/// ```
|
|
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
|
|
pub struct StatusesRequest<'a> {
|
|
#[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
|
|
#[serde(serialize_with = "bool_qs_serialize::serialize")]
|
|
only_media: bool,
|
|
#[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
|
|
#[serde(serialize_with = "bool_qs_serialize::serialize")]
|
|
exclude_replies: bool,
|
|
#[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
|
|
#[serde(serialize_with = "bool_qs_serialize::serialize")]
|
|
pinned: bool,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
max_id: Option<Cow<'a, str>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
since_id: Option<Cow<'a, str>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
limit: Option<usize>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
min_id: Option<Cow<'a, str>>,
|
|
#[serde(skip_serializing_if = "bool_qs_serialize::is_false")]
|
|
#[serde(serialize_with = "bool_qs_serialize::serialize")]
|
|
exclude_reblogs: bool,
|
|
}
|
|
|
|
impl<'a> From<&'a mut StatusesRequest<'a>> for Option<StatusesRequest<'a>> {
|
|
fn from(req: &'a mut StatusesRequest<'a>) -> Option<StatusesRequest<'a>> {
|
|
Some(StatusesRequest {
|
|
only_media: req.only_media,
|
|
exclude_replies: req.exclude_replies,
|
|
pinned: req.pinned,
|
|
max_id: req.max_id.clone(),
|
|
since_id: req.since_id.clone(),
|
|
limit: req.limit,
|
|
min_id: req.min_id.clone(),
|
|
exclude_reblogs: req.exclude_reblogs,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> StatusesRequest<'a> {
|
|
/// Construct a new `StatusesRequest` object
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let request = StatusesRequest::new();
|
|
/// ```
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
/// Set the `?only_media=1` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(&request.only_media().to_querystring().expect("Couldn't serialize qs"), "?only_media=1");
|
|
pub fn only_media(&mut self) -> &mut Self {
|
|
self.only_media = true;
|
|
self
|
|
}
|
|
|
|
/// Set the `?exclude_reblogs=1` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .exclude_reblogs()
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?exclude_reblogs=1"
|
|
/// );
|
|
/// ```
|
|
pub fn exclude_reblogs(&mut self) -> &mut Self {
|
|
self.exclude_reblogs = true;
|
|
self
|
|
}
|
|
|
|
/// Set the `?exclude_replies=1` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .exclude_replies()
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?exclude_replies=1"
|
|
/// );
|
|
/// ```
|
|
pub fn exclude_replies(&mut self) -> &mut Self {
|
|
self.exclude_replies = true;
|
|
self
|
|
}
|
|
|
|
/// Set the `?pinned=1` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .pinned()
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?pinned=1"
|
|
/// );
|
|
/// ```
|
|
pub fn pinned(&mut self) -> &mut Self {
|
|
self.pinned = true;
|
|
self
|
|
}
|
|
|
|
/// Set the `?max_id=:max_id` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .max_id("foo")
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?max_id=foo"
|
|
/// );
|
|
/// ```
|
|
pub fn max_id<S: Into<Cow<'a, str>>>(&mut self, max_id: S) -> &mut Self {
|
|
self.max_id = Some(max_id.into());
|
|
self
|
|
}
|
|
|
|
/// Set the `?since_id=:since_id` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .since_id("foo")
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?since_id=foo"
|
|
/// );
|
|
/// ```
|
|
pub fn since_id<S: Into<Cow<'a, str>>>(&mut self, since_id: S) -> &mut Self {
|
|
self.since_id = Some(since_id.into());
|
|
self
|
|
}
|
|
|
|
/// Set the `?limit=:limit` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .limit(10)
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?limit=10"
|
|
/// );
|
|
/// ```
|
|
pub fn limit(&mut self, limit: usize) -> &mut Self {
|
|
self.limit = Some(limit);
|
|
self
|
|
}
|
|
|
|
/// Set the `?min_id=:min_id` flag for the .statuses() request
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .min_id("foobar")
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?min_id=foobar"
|
|
/// );
|
|
/// ```
|
|
pub fn min_id<S: Into<Cow<'a, str>>>(&mut self, min_id: S) -> &mut Self {
|
|
self.min_id = Some(min_id.into());
|
|
self
|
|
}
|
|
|
|
/// Turns this builder into a querystring
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # extern crate elefren;
|
|
/// # use elefren::StatusesRequest;
|
|
/// let mut request = StatusesRequest::new();
|
|
/// assert_eq!(
|
|
/// &request
|
|
/// .limit(10)
|
|
/// .pinned()
|
|
/// .to_querystring()
|
|
/// .expect("Couldn't serialize qs"),
|
|
/// "?pinned=1&limit=10"
|
|
/// );
|
|
/// ```
|
|
pub fn to_querystring(&self) -> Result<String, Error> {
|
|
Ok(format!("?{}", serde_qs::to_string(&self)?))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_new() {
|
|
let request = StatusesRequest::new();
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_only_media() {
|
|
let mut request = StatusesRequest::new();
|
|
request.only_media();
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: true,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_exclude_replies() {
|
|
let mut request = StatusesRequest::new();
|
|
request.exclude_replies();
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: true,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_pinned() {
|
|
let mut request = StatusesRequest::new();
|
|
request.pinned();
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: true,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_max_id() {
|
|
let mut request = StatusesRequest::new();
|
|
request.max_id("foo");
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: Some("foo".into()),
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_since_id() {
|
|
let mut request = StatusesRequest::new();
|
|
request.since_id("foo");
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: Some("foo".into()),
|
|
limit: None,
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_limit() {
|
|
let mut request = StatusesRequest::new();
|
|
request.limit(42);
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: Some(42),
|
|
min_id: None,
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_min_id() {
|
|
let mut request = StatusesRequest::new();
|
|
request.min_id("foo");
|
|
assert_eq!(
|
|
request,
|
|
StatusesRequest {
|
|
only_media: false,
|
|
exclude_replies: false,
|
|
pinned: false,
|
|
max_id: None,
|
|
since_id: None,
|
|
limit: None,
|
|
min_id: Some("foo".into()),
|
|
exclude_reblogs: false,
|
|
}
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_to_querystring() {
|
|
macro_rules! qs_test {
|
|
(|$r:ident| $b:block, $expected:expr) => {
|
|
{
|
|
let mut $r = StatusesRequest::new();
|
|
$b
|
|
let qs = $r.to_querystring().expect("Failed to serialize querystring");
|
|
assert_eq!(&qs, $expected);
|
|
}
|
|
}
|
|
}
|
|
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media();
|
|
},
|
|
"?only_media=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies();
|
|
},
|
|
"?exclude_replies=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned();
|
|
},
|
|
"?pinned=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo");
|
|
},
|
|
"?max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo");
|
|
},
|
|
"?since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42);
|
|
},
|
|
"?limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media().exclude_replies();
|
|
},
|
|
"?only_media=1&exclude_replies=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media().pinned();
|
|
},
|
|
"?only_media=1&pinned=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media().max_id("foo");
|
|
},
|
|
"?only_media=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media().since_id("foo");
|
|
},
|
|
"?only_media=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.only_media().limit(42);
|
|
},
|
|
"?only_media=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies().only_media();
|
|
},
|
|
"?only_media=1&exclude_replies=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies().pinned();
|
|
},
|
|
"?exclude_replies=1&pinned=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies().max_id("foo");
|
|
},
|
|
"?exclude_replies=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies().since_id("foo");
|
|
},
|
|
"?exclude_replies=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.exclude_replies().limit(42);
|
|
},
|
|
"?exclude_replies=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned().only_media();
|
|
},
|
|
"?only_media=1&pinned=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned().exclude_replies();
|
|
},
|
|
"?exclude_replies=1&pinned=1"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned().max_id("foo");
|
|
},
|
|
"?pinned=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned().since_id("foo");
|
|
},
|
|
"?pinned=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.pinned().limit(42);
|
|
},
|
|
"?pinned=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo").only_media();
|
|
},
|
|
"?only_media=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo").exclude_replies();
|
|
},
|
|
"?exclude_replies=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo").pinned();
|
|
},
|
|
"?pinned=1&max_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo").since_id("foo");
|
|
},
|
|
"?max_id=foo&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.max_id("foo").limit(42);
|
|
},
|
|
"?max_id=foo&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo").only_media();
|
|
},
|
|
"?only_media=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo").exclude_replies();
|
|
},
|
|
"?exclude_replies=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo").pinned();
|
|
},
|
|
"?pinned=1&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo").max_id("foo");
|
|
},
|
|
"?max_id=foo&since_id=foo"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.since_id("foo").limit(42);
|
|
},
|
|
"?since_id=foo&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42).only_media();
|
|
},
|
|
"?only_media=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42).exclude_replies();
|
|
},
|
|
"?exclude_replies=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42).pinned();
|
|
},
|
|
"?pinned=1&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42).max_id("foo");
|
|
},
|
|
"?max_id=foo&limit=42"
|
|
);
|
|
qs_test!(
|
|
|request| {
|
|
request.limit(42).since_id("foo");
|
|
},
|
|
"?since_id=foo&limit=42"
|
|
);
|
|
}
|
|
}
|
|
|