Crate egg_mode [] [src]

A library for interacting with Twitter.

Repository

egg-mode is a Twitter library that aims to make as few assumptions about the user's codebase as possible. Endpoints are exposed as bare functions where authentication details are passed in as arguments, rather than as builder functions of a root "service" manager. The only exceptions to this guideline are endpoints with many optional parameters, like posting a status update or updating the metadata of a list.

About the examples in this documentation

There are a couple prerequisites to using egg-mode, which its examples also assume:

To load the profile information of a single user:

let rustlang = core.run(egg_mode::user::show("rustlang", &token, &handle)).unwrap();

println!("{} (@{})", rustlang.name, rustlang.screen_name);

To post a new tweet:

use egg_mode::tweet::DraftTweet;

let post = core.run(DraftTweet::new("Hey Twitter!").send(&token, &handle)).unwrap();

Types and Functions

All of the main content of egg-mode is in submodules, but there are a few things here in the crate root. To wit, it contains items related to authentication and a couple items that all the submodules use.

Response<T>

Every method that calls Twitter and carries rate-limit information wraps its return value in a Response struct, that transmits this information to your app. From there, you can handle the rate-limit information to hold off on that kind of request, or simply grab its response field to get the output of whatever method you called. Response also implements Deref, so for the most part you can access fields of the final result without having to grab the response field directly.

Response also has IntoIterator implementations and iterator creation methods that echo those on Vec<T>, for methods that return Vecs. These methods and iterator types distribute the rate-limit information across each iteration.

TwitterFuture<'a, T>

Any method that requires a network call will return a handle to the pending network call, in most cases the type TwitterFuture. This type (and any other *Future in this library) implements the Future trait, for use as an asynchronous network call. All Future implementations in this library use the Error enum as their Error value. For more information on how to use the Future trait, check out the Tokio documentation guides.

In addition, there is also a FutureResponse type alias, that corresponds to TwitterFuture<'a, Response<T>>, for methods that return rate-limit information.

Authentication Types/Functions

The remaining types and methods are explained as part of the authentication overview, with the exception of verify_tokens, which is a simple method to ensure a given token is still valid.

Modules

As there are many actions available in the Twitter API, egg-mode divides them roughly into several modules by their shared purpose. Here's a sort of high-level overview, in rough order from "most important" to "less directly used":

Primary actions

These could be considered the "core" actions within the Twitter API that egg-mode has made available.

Secondary actions

These modules still contain direct actions for Twitter, but they can be considered as having more of a helper role than something you might use directly.

Helper structs

These modules contain some implementations that wrap some pattern seen in multiple "action" modules.

Modules

cursor

Types and traits to navigate cursored collections.

direct

Structs and methods for working with direct messages.

entities

Data structures containing extracted URL, mention, tag, and media information.

error

A composite error type for errors that can occur while interacting with Twitter.

list

Structs and functions for working with lists.

media

Functionality to upload images, GIFs, and videos that can be attached to tweets.

place

Types and methods for looking up locations.

search

Structs and methods for searching for tweets.

service

Methods to inquire about the Twitter service itself.

tweet

Structs and functions for working with statuses and timelines.

user

Structs and methods for pulling user information from Twitter.

Structs

AuthFuture

Future which yields an access token when it finishes.

KeyPair

A key/secret pair representing an OAuth token.

Response

A helper struct to wrap response data with accompanying rate limit information.

ResponseIter

Iterator returned by calling .into_iter() on a Response<Vec<T>>.

ResponseIterMut

Iterator returned by calling .iter_mut() on a Response<Vec<T>>.

ResponseIterRef

Iterator returned by calling .iter() on a Response<Vec<T>>.

TwitterFuture

A Future that will resolve to a complete Twitter response.

Enums

Token

A token that can be used to sign requests to Twitter.

Functions

access_token

With the given OAuth tokens and verifier, ask Twitter for an access KeyPair that can be used to sign further requests to the Twitter API.

authenticate_url

With the given request KeyPair, return a URL to redirect a user to so they can accept or reject an authorization request.

authorize_url

With the given request KeyPair, return a URL that a user can access to accept or reject an authorization request.

bearer_token

With the given consumer KeyPair, request the current Bearer token to perform Application-only authentication.

invalidate_bearer

Invalidate the given Bearer token using the given consumer KeyPair. Upon success, the future returned by this function yields the Token that was just invalidated.

request_token

With the given consumer KeyPair, ask Twitter for a request KeyPair that can be used to request access to the user's account.

verify_tokens

If the given tokens are valid, return the user information for the authenticated user.

Type Definitions

FutureResponse

Type alias for futures that resolve to responses from Twitter.