summaryrefslogtreecommitdiffstats
path: root/macro-dbg
diff options
context:
space:
mode:
Diffstat (limited to 'macro-dbg')
-rw-r--r--macro-dbg30158
1 files changed, 30158 insertions, 0 deletions
diff --git a/macro-dbg b/macro-dbg
new file mode 100644
index 0000000..27be5c5
--- /dev/null
+++ b/macro-dbg
@@ -0,0 +1,30158 @@
+#![feature(prelude_import)]
+//! # Elefren: API Wrapper around the Mastodon API.
+//!
+//! Most of the api is documented on [Mastodon's website](https://docs.joinmastodon.org/client/intro/)
+//!
+//! ```no_run
+//! # extern crate elefren;
+//! # fn main() {
+//! # run().unwrap();
+//! # }
+//! # fn run() -> elefren::Result<()> {
+//! use elefren::{helpers::cli, prelude::*};
+//!
+//! let registration = Registration::new("https://mastodon.social")
+//! .client_name("elefren_test")
+//! .build()?;
+//! let mastodon = cli::authenticate(registration)?;
+//!
+//! println!(
+//! "{:?}",
+//! mastodon
+//! .get_home_timeline()?
+//! .items_iter()
+//! .take(100)
+//! .collect::<Vec<_>>()
+//! );
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! Elefren also supports Mastodon's Streaming API:
+//!
+//! # Example
+//!
+//! ```no_run
+//! # extern crate elefren;
+//! # use elefren::prelude::*;
+//! # use std::error::Error;
+//! use elefren::entities::event::Event;
+//! # fn main() -> Result<(), Box<Error>> {
+//! # let data = Data {
+//! # base: "".into(),
+//! # client_id: "".into(),
+//! # client_secret: "".into(),
+//! # redirect: "".into(),
+//! # token: "".into(),
+//! # };
+//! let client = Mastodon::from(data);
+//! for event in client.streaming_user()? {
+//! match event {
+//! Event::Update(ref status) => { /* .. */ },
+//! Event::Notification(ref notification) => { /* .. */ },
+//! Event::Delete(ref id) => { /* .. */ },
+//! Event::FiltersChanged => { /* .. */ },
+//! }
+//! }
+//! # Ok(())
+//! # }
+//! ```
+
+#![deny(missing_docs, warnings, missing_debug_implementations,
+ missing_copy_implementations, trivial_casts, trivial_numeric_casts,
+ unsafe_code, unstable_features, unused_import_braces,
+ unused_qualifications)]
+#![allow(intra_doc_link_resolution_failure)]
+#[prelude_import]
+use std::prelude::v1::*;
+#[macro_use]
+extern crate std;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate serde_derive;
+#[macro_use]
+extern crate doc_comment;
+extern crate hyper_old_types;
+extern crate isolang;
+#[macro_use]
+extern crate serde_json;
+extern crate chrono;
+extern crate reqwest;
+extern crate serde;
+extern crate serde_qs;
+extern crate serde_urlencoded;
+extern crate tap_reader;
+extern crate try_from;
+extern crate url;
+extern crate tungstenite;
+
+
+
+
+
+use std::{borrow::Cow,
+ /*
+ io::BufRead,
+ */
+ ops};
+
+use async_trait::async_trait;
+use reqwest::{Client, RequestBuilder, Response};
+use tap_reader::Tap;
+/*
+use tungstenite::client::AutoStream;
+*/
+
+use crate::entities::prelude::*;
+use crate::page::Page;
+
+pub use crate::data::Data;
+pub use crate::errors::{ApiError, Error, Result};
+pub use isolang::Language;
+pub use crate::mastodon_client::{MastodonClient, MastodonUnauthenticated};
+pub use crate::registration::Registration;
+pub use crate::requests::{AddFilterRequest, AddPushRequest, StatusesRequest,
+ UpdateCredsRequest, UpdatePushRequest};
+pub use crate::status_builder::{NewStatus, StatusBuilder};
+
+/// Registering your App
+pub mod apps {
+
+
+
+
+
+
+ /*
+ type Stream = EventReader<WebSocket>;
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ /*
+ /// returns events that are relevant to the authorized user, i.e. home
+ /// timeline & notifications
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// # extern crate elefren;
+ /// # use elefren::prelude::*;
+ /// # use std::error::Error;
+ /// use elefren::entities::event::Event;
+ /// # fn main() -> Result<(), Box<Error>> {
+ /// # let data = Data {
+ /// # base: "".into(),
+ /// # client_id: "".into(),
+ /// # client_secret: "".into(),
+ /// # redirect: "".into(),
+ /// # token: "".into(),
+ /// # };
+ /// let client = Mastodon::from(data);
+ /// for event in client.streaming_user()? {
+ /// match event {
+ /// Event::Update(ref status) => { /* .. */ },
+ /// Event::Notification(ref notification) => { /* .. */ },
+ /// Event::Delete(ref id) => { /* .. */ },
+ /// Event::FiltersChanged => { /* .. */ },
+ /// }
+ /// }
+ /// # Ok(())
+ /// # }
+ /// ```
+ fn streaming_user(&self) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "user");
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// returns all public statuses
+ fn streaming_public(&self) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "public");
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// Returns all local statuses
+ fn streaming_local(&self) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "public:local");
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// Returns all public statuses for a particular hashtag
+ fn streaming_public_hashtag(&self, hashtag: &str) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "hashtag")
+ .append_pair("tag", hashtag);
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// Returns all local statuses for a particular hashtag
+ fn streaming_local_hashtag(&self, hashtag: &str) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "hashtag:local")
+ .append_pair("tag", hashtag);
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// Returns statuses for a list
+ fn streaming_list(&self, list_id: &str) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "list")
+ .append_pair("list", list_id);
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+
+ /// Returns all direct messages
+ fn streaming_direct(&self) -> Result<Self::Stream> {
+ let mut url: url::Url = self.route("/api/v1/streaming").parse()?;
+ url.query_pairs_mut()
+ .append_pair("access_token", &self.token)
+ .append_pair("stream", "direct");
+ let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?;
+ let new_scheme = match url.scheme() {
+ "http" => "ws",
+ "https" => "wss",
+ x => return Err(Error::Other(format!("Bad URL scheme: {}", x))),
+ };
+ url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?;
+
+ let client = tungstenite::connect(url.as_str())?.0;
+
+ Ok(EventReader(WebSocket(client)))
+ }
+ */
+
+ /*
+ #[derive(Debug)]
+ /// WebSocket newtype so that EventStream can be implemented without coherency issues
+ pub struct WebSocket(tungstenite::protocol::WebSocket<AutoStream>);
+
+ /// A type that streaming events can be read from
+ pub trait EventStream {
+ /// Read a message from this stream
+ fn read_message(&mut self) -> Result<String>;
+ }
+
+ impl<R: BufRead> EventStream for R {
+ fn read_message(&mut self) -> Result<String> {
+ let mut buf = String::new();
+ self.read_line(&mut buf)?;
+ Ok(buf)
+ }
+ }
+
+ impl EventStream for WebSocket {
+ fn read_message(&mut self) -> Result<String> {
+ Ok(self.0.read_message()?.into_text()?)
+ }
+ }
+
+ #[derive(Debug)]
+ /// Iterator that produces events from a mastodon streaming API event stream
+ pub struct EventReader<R: EventStream>(R);
+ impl<R: EventStream> Iterator for EventReader<R> {
+ type Item = Event;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let mut lines = Vec::new();
+ loop {
+ if let Ok(line) = self.0.read_message() {
+ let line = line.trim().to_string();
+ if line.starts_with(":") || line.is_empty() {
+ continue;
+ }
+ lines.push(line);
+ if let Ok(event) = self.make_event(&lines) {
+ lines.clear();
+ return Some(event);
+ } else {
+ continue;
+ }
+ }
+ }
+ }
+ }
+
+ impl<R: EventStream> EventReader<R> {
+ fn make_event(&self, lines: &[String]) -> Result<Event> {
+ let event;
+ let data;
+ if let Some(event_line) = lines
+ .iter()
+ .find(|line| line.starts_with("event:"))
+ {
+ event = event_line[6..].trim().to_string();
+ data = lines.iter().find(|line| line.starts_with("data:")).map(|x| x[5..].trim().to_string());
+ } else {
+ #[derive(Deserialize)]
+ struct Message {
+ pub event: String,
+ pub payload: Option<String>,
+ }
+ let message = serde_json::from_str::<Message>(&lines[0])?;
+ event = message.event;
+ data = message.payload;
+ }
+ let event: &str = &event;
+ Ok(match event {
+ "notification" => {
+ let data = data.ok_or_else(|| {
+ Error::Other("Missing `data` line for notification".to_string())
+ })?;
+ let notification = serde_json::from_str::<Notification>(&data)?;
+ Event::Notification(notification)
+ },
+ "update" => {
+ let data =
+ data.ok_or_else(|| Error::Other("Missing `data` line for update".to_string()))?;
+ let status = serde_json::from_str::<Status>(&data)?;
+ Event::Update(status)
+ },
+ "delete" => {
+ let data =
+ data.ok_or_else(|| Error::Other("Missing `data` line for delete".to_string()))?;
+ Event::Delete(data)
+ },
+ "filters_changed" => Event::FiltersChanged,
+ _ => return Err(Error::Other(format!("Unknown event `{}`", event))),
+ })
+ }
+ }
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // Convert the HTTP response body from JSON. Pass up deserialization errors
+ // transparently.
+
+ // If deserializing into the desired type fails try again to
+ // see if this is an error response.
+ use std::borrow::Cow;
+ use try_from::TryInto;
+ use crate::errors::{Error, Result};
+ use crate::scopes::Scopes;
+ /// Represents an application that can be registered with a mastodon instance
+ pub struct App {
+ client_name: String,
+ redirect_uris: String,
+ scopes: Scopes,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ website: Option<String>,
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl ::core::clone::Clone for App {
+ #[inline]
+ fn clone(&self) -> App {
+ match *self {
+ App {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ App{client_name: ::core::clone::Clone::clone(&(*__self_0_0)),
+ redirect_uris:
+ ::core::clone::Clone::clone(&(*__self_0_1)),
+ scopes: ::core::clone::Clone::clone(&(*__self_0_2)),
+ website: ::core::clone::Clone::clone(&(*__self_0_3)),},
+ }
+ }
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl ::core::fmt::Debug for App {
+ fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+ match *self {
+ App {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } => {
+ let mut debug_trait_builder = f.debug_struct("App");
+ let _ =
+ debug_trait_builder.field("client_name",
+ &&(*__self_0_0));
+ let _ =
+ debug_trait_builder.field("redirect_uris",
+ &&(*__self_0_1));
+ let _ =
+ debug_trait_builder.field("scopes", &&(*__self_0_2));
+ let _ =
+ debug_trait_builder.field("website", &&(*__self_0_3));
+ debug_trait_builder.finish()
+ }
+ }
+ }
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl ::core::default::Default for App {
+ #[inline]
+ fn default() -> App {
+ App{client_name: ::core::default::Default::default(),
+ redirect_uris: ::core::default::Default::default(),
+ scopes: ::core::default::Default::default(),
+ website: ::core::default::Default::default(),}
+ }
+ }
+ #[doc(hidden)]
+ #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+ const _IMPL_SERIALIZE_FOR_App: () =
+ {
+ #[allow(rust_2018_idioms, clippy :: useless_attribute)]
+ extern crate serde as _serde;
+ #[allow(unused_macros)]
+ macro_rules! try {
+ ($ __expr : expr) =>
+ {
+ match $ __expr
+ {
+ _serde :: export :: Ok(__val) => __val, _serde ::
+ export :: Err(__err) =>
+ { return _serde :: export :: Err(__err) ; }
+ }
+ }
+ }
+ #[automatically_derived]
+ impl _serde::Serialize for App {
+ fn serialize<__S>(&self, __serializer: __S)
+ -> _serde::export::Result<__S::Ok, __S::Error> where
+ __S: _serde::Serializer {
+ let mut __serde_state =
+ match _serde::Serializer::serialize_struct(__serializer,
+ "App",
+ false as
+ usize +
+ 1 + 1 +
+ 1 +
+ if Option::is_none(&self.website)
+ {
+ 0
+ } else {
+ 1
+ }) {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "client_name",
+ &self.client_name)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "redirect_uris",
+ &self.redirect_uris)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "scopes",
+ &self.scopes)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ if !Option::is_none(&self.website) {
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "website",
+ &self.website)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ } else {
+ match _serde::ser::SerializeStruct::skip_field(&mut __serde_state,
+ "website")
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ }
+ _serde::ser::SerializeStruct::end(__serde_state)
+ }
+ }
+ };
+ impl ::core::marker::StructuralPartialEq for App { }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl ::core::cmp::PartialEq for App {
+ #[inline]
+ fn eq(&self, other: &App) -> bool {
+ match *other {
+ App {
+ client_name: ref __self_1_0,
+ redirect_uris: ref __self_1_1,
+ scopes: ref __self_1_2,
+ website: ref __self_1_3 } =>
+ match *self {
+ App {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ (*__self_0_0) == (*__self_1_0) &&
+ (*__self_0_1) == (*__self_1_1) &&
+ (*__self_0_2) == (*__self_1_2) &&
+ (*__self_0_3) == (*__self_1_3),
+ },
+ }
+ }
+ #[inline]
+ fn ne(&self, other: &App) -> bool {
+ match *other {
+ App {
+ client_name: ref __self_1_0,
+ redirect_uris: ref __self_1_1,
+ scopes: ref __self_1_2,
+ website: ref __self_1_3 } =>
+ match *self {
+ App {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ (*__self_0_0) != (*__self_1_0) ||
+ (*__self_0_1) != (*__self_1_1) ||
+ (*__self_0_2) != (*__self_1_2) ||
+ (*__self_0_3) != (*__self_1_3),
+ },
+ }
+ }
+ }
+ impl App {
+ /// Get an AppBuilder object
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # extern crate elefren;
+ /// use elefren::apps::App;
+ ///
+ /// let mut builder = App::builder();
+ /// ```
+ pub fn builder<'a>() -> AppBuilder<'a> { AppBuilder::new() }
+ /// Retrieve the list of scopes that apply to this App
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # extern crate elefren;
+ /// # use elefren::Error;
+ /// use elefren::{apps::App, scopes::Scopes};
+ ///
+ /// # fn main() -> Result<(), Error> {
+ /// let mut builder = App::builder();
+ /// builder.client_name("elefren-test");
+ /// let app = builder.build()?;
+ /// let scopes = app.scopes();
+ /// assert_eq!(scopes, &Scopes::read_all());
+ /// # Ok(())
+ /// # }
+ /// ```
+ pub fn scopes(&self) -> &Scopes { &self.scopes }
+ }
+ /// Builder struct for defining your application.
+ /// ```
+ /// use elefren::apps::App;
+ /// use std::error::Error;
+ ///
+ /// # fn main() -> Result<(), Box<Error>> {
+ /// let mut builder = App::builder();
+ /// builder.client_name("elefren_test");
+ /// let app = builder.build()?;
+ /// # Ok(())
+ /// # }
+ /// ```
+ pub struct AppBuilder<'a> {
+ client_name: Option<Cow<'a, str>>,
+ redirect_uris: Option<Cow<'a, str>>,
+ scopes: Option<Scopes>,
+ website: Option<Cow<'a, str>>,
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl <'a> ::core::clone::Clone for AppBuilder<'a> {
+ #[inline]
+ fn clone(&self) -> AppBuilder<'a> {
+ match *self {
+ AppBuilder {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ AppBuilder{client_name:
+ ::core::clone::Clone::clone(&(*__self_0_0)),
+ redirect_uris:
+ ::core::clone::Clone::clone(&(*__self_0_1)),
+ scopes:
+ ::core::clone::Clone::clone(&(*__self_0_2)),
+ website:
+ ::core::clone::Clone::clone(&(*__self_0_3)),},
+ }
+ }
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl <'a> ::core::fmt::Debug for AppBuilder<'a> {
+ fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+ match *self {
+ AppBuilder {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } => {
+ let mut debug_trait_builder =
+ f.debug_struct("AppBuilder");
+ let _ =
+ debug_trait_builder.field("client_name",
+ &&(*__self_0_0));
+ let _ =
+ debug_trait_builder.field("redirect_uris",
+ &&(*__self_0_1));
+ let _ =
+ debug_trait_builder.field("scopes", &&(*__self_0_2));
+ let _ =
+ debug_trait_builder.field("website", &&(*__self_0_3));
+ debug_trait_builder.finish()
+ }
+ }
+ }
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl <'a> ::core::default::Default for AppBuilder<'a> {
+ #[inline]
+ fn default() -> AppBuilder<'a> {
+ AppBuilder{client_name: ::core::default::Default::default(),
+ redirect_uris: ::core::default::Default::default(),
+ scopes: ::core::default::Default::default(),
+ website: ::core::default::Default::default(),}
+ }
+ }
+ impl <'a> ::core::marker::StructuralPartialEq for AppBuilder<'a> { }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl <'a> ::core::cmp::PartialEq for AppBuilder<'a> {
+ #[inline]
+ fn eq(&self, other: &AppBuilder<'a>) -> bool {
+ match *other {
+ AppBuilder {
+ client_name: ref __self_1_0,
+ redirect_uris: ref __self_1_1,
+ scopes: ref __self_1_2,
+ website: ref __self_1_3 } =>
+ match *self {
+ AppBuilder {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ (*__self_0_0) == (*__self_1_0) &&
+ (*__self_0_1) == (*__self_1_1) &&
+ (*__self_0_2) == (*__self_1_2) &&
+ (*__self_0_3) == (*__self_1_3),
+ },
+ }
+ }
+ #[inline]
+ fn ne(&self, other: &AppBuilder<'a>) -> bool {
+ match *other {
+ AppBuilder {
+ client_name: ref __self_1_0,
+ redirect_uris: ref __self_1_1,
+ scopes: ref __self_1_2,
+ website: ref __self_1_3 } =>
+ match *self {
+ AppBuilder {
+ client_name: ref __self_0_0,
+ redirect_uris: ref __self_0_1,
+ scopes: ref __self_0_2,
+ website: ref __self_0_3 } =>
+ (*__self_0_0) != (*__self_1_0) ||
+ (*__self_0_1) != (*__self_1_1) ||
+ (*__self_0_2) != (*__self_1_2) ||
+ (*__self_0_3) != (*__self_1_3),
+ },
+ }
+ }
+ }
+ #[doc(hidden)]
+ #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+ const _IMPL_SERIALIZE_FOR_AppBuilder: () =
+ {
+ #[allow(rust_2018_idioms, clippy :: useless_attribute)]
+ extern crate serde as _serde;
+ #[allow(unused_macros)]
+ macro_rules! try {
+ ($ __expr : expr) =>
+ {
+ match $ __expr
+ {
+ _serde :: export :: Ok(__val) => __val, _serde ::
+ export :: Err(__err) =>
+ { return _serde :: export :: Err(__err) ; }
+ }
+ }
+ }
+ #[automatically_derived]
+ impl <'a> _serde::Serialize for AppBuilder<'a> {
+ fn serialize<__S>(&self, __serializer: __S)
+ -> _serde::export::Result<__S::Ok, __S::Error> where
+ __S: _serde::Serializer {
+ let mut __serde_state =
+ match _serde::Serializer::serialize_struct(__serializer,
+ "AppBuilder",
+ false as
+ usize +
+ 1 + 1 +
+ 1 + 1)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "client_name",
+ &self.client_name)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "redirect_uris",
+ &self.redirect_uris)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "scopes",
+ &self.scopes)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
+ "website",
+ &self.website)
+ {
+ _serde::export::Ok(__val) => __val,
+ _serde::export::Err(__err) => {
+ return _serde::export::Err(__err);
+ }
+ };
+ _serde::ser::SerializeStruct::end(__serde_state)
+ }
+ }
+ };
+ impl <'a> AppBuilder<'a> {
+ /// Creates a new AppBuilder object
+ pub fn new() -> Self { Default::default() }
+ /// Name of the application. Will be displayed when the user is deciding to
+ /// grant permission.
+ ///
+ /// In order to turn this builder into an App, this needs to be provided
+ pub fn client_name<I: Into<Cow<'a, str>>>(&mut self, name: I)
+ -> &mut Self {
+ self.client_name = Some(name.into());
+ self
+ }
+ /// Where the user should be redirected after authorization
+ ///
+ /// If none is specified, the default is `urn:ietf:wg:oauth:2.0:oob`
+ pub fn redirect_uris<I: Into<Cow<'a, str>>>(&mut self, uris: I)
+ -> &mut Self {
+ self.redirect_uris = Some(uris.into());
+ self
+ }
+ /// Permission scope of the application.
+ ///
+ /// IF none is specified, the default is Scopes::read_all()
+ pub fn scopes(&mut self, scopes: Scopes) -> &mut Self {
+ self.scopes = Some(scopes);
+ self
+ }
+ /// URL to the homepage of your application.
+ pub fn website<I: Into<Cow<'a, str>>>(&mut self, website: I)
+ -> &mut Self {
+ self.website = Some(website.into());
+ self
+ }
+ /// Attempts to convert this build into an `App`
+ ///
+ /// Will fail if no `client_name` was provided
+ pub fn build(self) -> Result<App> {
+ Ok(App{client_name:
+ self.client_name.ok_or_else(||
+ Error::MissingField("client_name"))?.into(),
+ redirect_uris:
+ self.redirect_uris.unwrap_or_else(||
+ "urn:ietf:wg:oauth:2.0:oob".into()).into(),
+ scopes: self.scopes.unwrap_or_else(|| Scopes::read_all()),
+ website: self.website.map(|s| s.into()),})
+ }
+ }
+ impl TryInto<App> for App {
+ type Err = Error;
+ fn try_into(self) -> Result<App> { Ok(self) }
+ }
+ impl <'a> TryInto<App> for AppBuilder<'a> {
+ type Err = Error;
+ fn try_into(self) -> Result<App> { Ok(self.build()?) }
+ }
+}
+/// Contains the struct that holds the client auth data
+pub mod data {
+ use std::borrow::Cow;
+ /// Raw data about mastodon app. Save `Data` using `serde` to prevent needing
+ /// to authenticate on every run.
+ pub struct Data {
+ /// Base url of instance eg. `https://mastodon.social`.
+ pub base: Cow<'static, str>,
+ /// The client's id given by the instance.
+ pub client_id: Cow<'static, str>,
+ /// The client's secret given by the instance.
+ pub client_secret: Cow<'static, str>,
+ /// Url to redirect back to your application from the instance signup.
+ pub redirect: Cow<'static, str>,
+ /// The client's access token.
+ pub token: Cow<'static, str>,
+ }
+ #[automatically_derived]
+ #[allow(unused_qualifications)]
+ impl ::core::clone::Clone for Data {
+ #[inline]
+ fn clone(&self) -> Data {
+ match *self {
+ Data {
+ base: ref __self_0_0,
+ client_id: ref __self_0_1,
+ client_secret: ref __self_0_2,
+ redirect: ref __self_0_3,
+ token: ref __self_0_4 } =>
+ Data{base: ::core::clone::Clone::clone(&(*__self_0_0)),