Enum Format 

pub enum Format {
    Html,
    Json,
    Xml,
    Text,
    Markdown,
    Other,
}

Response format a client asks for in its Accept header, for actions that answer HTML or JSON (Rails’ respond_to).

The media type with the highest q wins (first listed on ties): text/html and application/xhtml+xml are Html, application/json and any +json type Json, application/xml, text/xml and +xml types Xml, text/plain Text, text/markdown Markdown, */* and text/* the first format of the list above. A missing or empty Accept header is Html, like Rails; types Ocre does not know are Other, usually answered with 406 Not Acceptable. Never rejects; no binding call.

Examples

use axum::{extract::{Path, State}, response::{Html, IntoResponse, Response}};
use ocre::{Ctx, Format, Json, OptionExt, Result, params};

async fn show(State(ctx): State<Ctx>, format: Format, Path(id): Path<i64>) -> Result<Response> {
    let post: serde_json::Value =
        ctx.db()?.first("SELECT id, title FROM posts WHERE id = ?1", params![id]).await?.or_404()?;
    Ok(match format {
        Format::Json => Json(post).into_response(),
        _ => Html(format!("<h1>{}</h1>", post["title"])).into_response(),
    })
}

Variants

Html

text/html: a page.

Json

application/json.

Xml

application/xml or text/xml, e.g. an RSS or Atom feed.

Text

text/plain.

Markdown

text/markdown, e.g. for LLM clients (Rails’ format.md); answer with Markdown.

Other

Only types Ocre does not know, e.g. application/pdf.

Implementations

impl Format

pub fn from_headers(headers: &HeaderMap) -> Self

Reads the Accept header; see Format for the rules.

Examples

use axum::http::HeaderMap;
use ocre::Format;

let mut headers = HeaderMap::new();
headers.insert("accept", "text/html;q=0.9, application/json".parse().unwrap());
assert_eq!(Format::from_headers(&headers), Format::Json);
assert_eq!(Format::from_headers(&HeaderMap::new()), Format::Html);

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Format

impl Debug for Format

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

Formats the value using the given formatter.

impl Eq for Format

impl<S: Send + Sync> FromRequestParts<S> for Format

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Self, Self::Rejection>

Perform the extraction.

impl PartialEq for Format

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Format