Crate ddragon 

ddragon

Rust library for accessing the latest League of Legends patch’s ddragon data.

• Fully (de)serializable, well-typed structs
• Supports TFT data
• Provides a synchronous API by default
  • Local caching via cacache
  • Accepts custom ureq agents (which can use the exposed cache middleware)
• Optionally, an asynchronous API can be used that maintains the same featureset
  • Local caching is handled by http-cache-reqwest rather than a custom middleware
  • Also accepts custom reqwest or reqwest-middleware clients
• Optionally, some useful functions to fetch and decode images, via image
• Optionally, minimal support of cdragon data

Usage

use ddragon::{cache_middleware::CacheMiddleware, Client, ClientBuilder, ClientError};

fn main() -> Result<(), ClientError> {
    let client = Client::new("/path/to/your/cache/dir")?;

    // If you want to use an existing agent
    let my_agent = ureq::Agent::config_builder()
        .middleware(CacheMiddleware::new("/path/to/your/cache/dir"))
        .build()
        .into();
    let client = ClientBuilder::new().agent(my_agent).build()?;

    // See available options on the client and in the models folder.
    let champions = client.champions()?;
    let runes = client.runes()?;
    let tft_items = client.tft_items()?;

    Ok(())
}

Features

The following crate features are available:

• sync (on by default) enables the synchronous client.

  • Provides the ddragon::client and ddragon::cache_middleware module.
  • Provides the re-exported ddragon::Client and ddragon::ClientBuilder impls.
  • Adds cacache, url, thiserror, and ureq with the json feature enabled as dependencies.

• async enables the asynchronous client.

  • Provides the ddragon::async_client module.
  • Provides the re-exported ddragon::AsyncClient and ddragon::AsyncClientBuilder impls.
  • Adds reqwest with the json feature, reqwest-middleware and http-cache-reqwest as dependencies.
  • If you would like the client to use rustls, use the async-rustls feature instead.

• image enables image fetching and caching.

  • Both clients will receive image_of and sprite_of for any model which implements HasImage.
  • Adds the image dependency.

• cdragon enables support for sourcing data from CommunityDragon.

  • At the moment, this just adds a method for fetching Arena mode augments.

• To use the library with just the synchronous version, it should be as simple as adding any other dependency:

[dependencies]
ddragon = "<version>"

• If you would also like to have the image fetching support, use:

[dependencies]
ddragon = { version = "<version>", features = ["image"] }

• If you want the asynchronous client only, you probably don’t want to pull in the dependencies related to the synchronous code, so you can do this:

[dependencies]
ddragon = { version = "<version>", default-features = false, features = ["async"] }

• If you want the async client and you want to use rustls (and you want ddragon to generate the client), you can use:

[dependencies]
ddragon = { version = "<version>", default-features = false, features = ["async-rustls"] }

Note that if you are providing your own client (via AsyncClientBuilder::new().agent()) you can use either async feature set.

• If you only want the DDragon models (none of the client code), you can use

[dependencies]
ddragon = { version = "<version>", default-features = false }

MSRV

Currently, this crate support Rust >= 1.71.1.

Re-exports

pub use client::Client;sync

pub use client::ClientBuilder;sync

pub use async_client::AsyncClient;async or async-rustls

pub use async_client::AsyncClientBuilder;async or async-rustls

Modules

async_clientasync or async-rustls

Contains the async version of the client API.

cache_middlewaresync

Contains the local file caching middleware used for ureq.

clientsync

Contains the sync version of the client API.

models

Contains the structs that can be returned by the client API.

Enums

ClientErrorsync or async-base

Any potential error the client may run into during operation.