Struct scryfall::card::Card

pub struct Card {
    pub arena_id: Option<usize>,
    pub id: Uuid,
    pub lang: String,
    pub mtgo_id: Option<usize>,
    pub mtgo_foil_id: Option<usize>,
    pub multiverse_ids: Option<Vec<usize>>,
    pub tcgplayer_id: Option<usize>,
    pub oracle_id: Uuid,
    pub prints_search_uri: PaginatedURI<Card>,
    pub rulings_uri: URI<Vec<Ruling>>,
    pub scryfall_uri: String,
    pub uri: URI<Card>,
    pub card_faces: Option<Vec<CardFace>>,
    pub all_parts: Option<Vec<RelatedCard>>,
    pub cmc: f32,
    pub colors: Vec<Colour>,
    pub color_identity: Vec<Colour>,
    pub color_indicator: Option<Vec<Colour>>,
    pub edhrec_rank: Option<usize>,
    pub foil: bool,
    pub hand_modifier: Option<String>,
    pub layout: Layout,
    pub legalities: HashMap<String, Legality>,
    pub life_modifier: Option<String>,
    pub loyalty: Option<String>,
    pub mana_cost: Option<String>,
    pub name: String,
    pub nonfoil: bool,
    pub oracle_text: Option<String>,
    pub oversized: bool,
    pub power: Option<String>,
    pub reserved: bool,
    pub toughness: Option<String>,
    pub type_line: Option<String>,
    pub artist: Option<String>,
    pub border_color: BorderColour,
    pub collector_number: String,
    pub digital: bool,
    pub flavor_text: Option<String>,
    pub frame_effects: Vec<FrameEffect>,
    pub frame: Frame,
    pub full_art: bool,
    pub games: Vec<Game>,
    pub highres_image: bool,
    pub illustration_id: Option<Uuid>,
    pub image_uris: Option<HashMap<String, String>>,
    pub prices: Price,
    pub printed_name: Option<String>,
    pub printed_text: Option<String>,
    pub printed_type_line: Option<String>,
    pub promo: bool,
    pub purchase_uris: HashMap<String, String>,
    pub rarity: Rarity,
    pub related_uris: HashMap<String, String>,
    pub released_at: NaiveDate,
    pub reprint: bool,
    pub scryfall_set_uri: String,
    pub set_name: String,
    pub set_search_uri: PaginatedURI<Card>,
    pub set_uri: URI<Set>,
    pub set: String,
    pub story_spotlight: bool,
    pub watermark: Option<String>,
    pub preview: Preview,
}

A Card object containing all fields that scryfall provides,

For documentation on each field please refer to their documentation

Fields

arena_id: Option<usize>

id: Uuid

lang: String

mtgo_id: Option<usize>

mtgo_foil_id: Option<usize>

multiverse_ids: Option<Vec<usize>>

tcgplayer_id: Option<usize>

oracle_id: Uuid

prints_search_uri: PaginatedURI<Card>

rulings_uri: URI<Vec<Ruling>>

scryfall_uri: String

uri: URI<Card>

card_faces: Option<Vec<CardFace>>

all_parts: Option<Vec<RelatedCard>>

cmc: f32

colors: Vec<Colour>

color_identity: Vec<Colour>

color_indicator: Option<Vec<Colour>>

edhrec_rank: Option<usize>

foil: bool

hand_modifier: Option<String>

layout: Layout

legalities: HashMap<String, Legality>

life_modifier: Option<String>

loyalty: Option<String>

mana_cost: Option<String>

name: String

nonfoil: bool

oracle_text: Option<String>

oversized: bool

power: Option<String>

reserved: bool

toughness: Option<String>

type_line: Option<String>

artist: Option<String>

border_color: BorderColour

collector_number: String

digital: bool

flavor_text: Option<String>

frame_effects: Vec<FrameEffect>

frame: Frame

full_art: bool

games: Vec<Game>

highres_image: bool

illustration_id: Option<Uuid>

image_uris: Option<HashMap<String, String>>

prices: Price

printed_name: Option<String>

printed_text: Option<String>

printed_type_line: Option<String>

promo: bool

purchase_uris: HashMap<String, String>

rarity: Rarity

related_uris: HashMap<String, String>

released_at: NaiveDate

reprint: bool

scryfall_set_uri: String

set_name: String

set_search_uri: PaginatedURI<Card>

set_uri: URI<Set>

set: String

story_spotlight: bool

watermark: Option<String>

preview: Preview

Implementations

impl Card

pub fn all() -> PaginatedURI<Card>

👎 Deprecated since 0.6.0:

Scryfall is deprecating this endpoint on the 30/May/2020 in favour of the bulk endpoints

Returns a PaginatedURI of all the cards in the scryfall database.

Examples

use scryfall::card::Card;
match Card::all().next().unwrap() {
    Ok(cards) => assert_ne!(cards.len(), 0),
    Err(e) => eprintln!("{:?}", e)
}

pub fn random() -> Result<Card>

Fetches a random card.

Examples

use scryfall::card::Card;
match Card::random() {
    Ok(card) => println!("{}", card.name),
    Err(e) => eprintln!("{:?}", e)
}

pub fn search<S: Search>(query: S) -> PaginatedURI<Card>

Returns a PaginatedURI of the cards that match the search terms.

Examples

use scryfall::card::Card;
assert!(Card::search("lightning")
    .filter_map(Result::ok)
    .flatten()
    .all(|x| x.name.to_lowercase().contains("lightning")))

use scryfall::card::Card;
use scryfall::card_searcher::{
    NumericParam::CollectorNumber, Search, SearchBuilder, StringParam::Set,
};
use scryfall::set::SetCode;
use std::convert::TryFrom;

assert!(SearchBuilder::new()
    .param(CollectorNumber(123))
    .param(Set(SetCode::try_from("war").expect("Not a valid set code")))
    .search()
    .all(|x| x.map(|x| x[0].name == "Demolish").unwrap_or(false)))

use scryfall::card::Card;
use scryfall::card_searcher::{
    ComparisonExpr, Search, SearchBuilder, StringParam,
};
use scryfall::error::Error;

let error = SearchBuilder::new()
    .param(StringParam::Power(ComparisonExpr::AtLeast, "pow".to_string()))
    .search()
    .find_map(Result::err);
match error {
    Some(Error::ScryfallError(e)) => {
            assert!(e.details.contains("All of your terms were ignored"));
            assert!(e.warnings.len() > 0);
        },
    _ => ()
};

pub fn named(query: &str) -> Result<Card>

Return a card with the exact name.

Examples

use scryfall::card::Card;
match Card::named("Lightning Bolt") {
    Ok(card) => assert_eq!(card.name, "Lightning Bolt"),
    Err(e) => panic!(format!("{:?}", e)),
}

use scryfall::error::Error;
assert!(Card::named("Name that doesn't exist").is_err())

pub fn named_fuzzy(query: &str) -> Result<Card>

Return a card using the scryfall fuzzy finder.

Examples

use scryfall::card::Card;
match Card::named_fuzzy("Light Bolt") {
    Ok(card) => assert_eq!(card.name, "Lightning Bolt"),
    Err(e) => panic!(format!("{:?}", e))
}

pub fn multiverse(query: usize) -> Result<Card>

Fetch a card by it's multiverse id.

Examples

use scryfall::card::Card;
match Card::multiverse(409574) {
    Ok(card) => assert_eq!(card.name, "Strip Mine"),
    Err(e) => panic!(format!("{:?}", e)),
}

pub fn mtgo(query: usize) -> Result<Card>

Fetch a card by it's mtgo id.

Examples

use scryfall::card::Card;
match Card::mtgo(54957) {
    Ok(card) => assert_eq!(card.name, "Ghost Quarter"),
    Err(e) => panic!(format!("{:?}", e)),
}

pub fn arena(query: usize) -> Result<Card>

Fetch a card by it's arena id.

Examples

use scryfall::card::Card;
match Card::arena(67330) {
    Ok(card) => assert_eq!(card.name, "Yargle, Glutton of Urborg"),
    Err(e) => panic!(format!("{:?}", e)),
}

pub fn tcgplayer(query: usize) -> Result<Card>

Fetch a card by it's tcgplayer id.

Examples

use scryfall::card::Card;
match Card::tcgplayer(67330) {
    Ok(card) => assert_eq!(card.name, "Fathom Mage"),
    Err(e) => panic!(format!("{:?}", e)),
}

pub fn card(query: Uuid) -> Result<Card>

Fetch a card by it's Uuid.

Examples

use scryfall::card::Card;
match Card::card("0b81b329-4ef5-4b55-9fe7-9ed69477e96b".to_string()) {
    Ok(card) => assert_eq!(card.name, "Cowed by Wisdom"),
    Err(e) => panic!(format!("{:?}", e)),
}

Trait Implementations

impl Clone for Card

fn clone(&self) -> Card

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Card

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Card

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Card> for Card

fn eq(&self, other: &Card) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Card) -> bool

This method tests for !=.

impl Serialize for Card

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Card