Struct Request 

#[non_exhaustive]
pub struct Request<'source> {

    pub text: Option<Cow<'source, str>>,
    pub data: Option<Data<'source>>,
    pub language: String,
    pub username: Option<String>,
    pub api_key: Option<String>,
    pub dicts: Option<Vec<String>>,
    pub mother_tongue: Option<String>,
    pub preferred_variants: Option<Vec<String>>,
    pub enabled_rules: Option<Vec<String>>,
    pub disabled_rules: Option<Vec<String>>,
    pub enabled_categories: Option<Vec<String>>,
    pub disabled_categories: Option<Vec<String>>,
    pub enabled_only: bool,
    pub level: Level,
}

LanguageTool POST check request.

The main feature - check a text with LanguageTool for possible style and grammar issues.

The structure below tries to follow as closely as possible the JSON API described here.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

text: Option<Cow<'source, str>>

The text to be checked. This or ‘data’ is required.

data: Option<Data<'source>>

The text to be checked, given as a JSON document that specifies what’s text and what’s markup. This or ‘text’ is required.

Markup will be ignored when looking for errors. Example text:

A <b>test</b>

JSON for the example text:

{"annotation":[
 {"text": "A "},
 {"markup": "<b>"},
 {"text": "test"},
 {"markup": "</b>"}
]}

If you have markup that should be interpreted as whitespace, like <p> in HTML, you can have it interpreted like this:

{"markup": "<p>", "interpretAs": "\n\n"}

The ‘data’ feature is not limited to HTML or XML, it can be used for any kind of markup. Entities will need to be expanded in this input.

language: String

A language code like en-US, de-DE, fr, or auto to guess the language automatically (see preferredVariants below).

For languages with variants (English, German, Portuguese) spell checking will only be activated when you specify the variant, e.g. en-GB instead of just en.

username: Option<String>

Set to get Premium API access: Your username/email as used to log in at languagetool.org.

api_key: Option<String>

Set to get Premium API access: your API key (see https://languagetool.org/editor/settings/api).

dicts: Option<Vec<String>>

Comma-separated list of dictionaries to include words from; uses special default dictionary if this is unset.

mother_tongue: Option<String>

A language code of the user’s native language, enabling false friends checks for some language pairs.

preferred_variants: Option<Vec<String>>

Comma-separated list of preferred language variants.

The language detector used with language=auto can detect e.g. English, but it cannot decide whether British English or American English is used. Thus this parameter can be used to specify the preferred variants like en-GB and de-AT. Only available with language=auto. You should set variants for at least German and English, as otherwise the spell checking will not work for those, as no spelling dictionary can be selected for just en or de.

enabled_rules: Option<Vec<String>>

IDs of rules to be enabled, comma-separated.

disabled_rules: Option<Vec<String>>

IDs of rules to be disabled, comma-separated.

enabled_categories: Option<Vec<String>>

IDs of categories to be enabled, comma-separated.

disabled_categories: Option<Vec<String>>

IDs of categories to be disabled, comma-separated.

enabled_only: bool

If true, only the rules and categories whose IDs are specified with enabledRules or enabledCategories are enabled.

level: Level

If set to picky, additional rules will be activated, i.e. rules that you might only find useful when checking formal text.

Implementations

impl<'source> Request<'source>

pub fn new() -> Self

Create a new empty request with language set to "auto".

pub fn with_text<T: Into<Cow<'source, str>>>(self, text: T) -> Self

Set the text to be checked and remove potential data field.

pub fn with_data(self, data: Data<'source>) -> Self

Set the data to be checked and remove potential text field.

pub fn with_data_str(self, data: &str) -> Result<Self>

Set the data (obtained from string) to be checked and remove potential text field

pub fn with_language(self, language: String) -> Self

Set the language of the text / data.

pub fn try_get_text(&self) -> Result<Cow<'source, str>>

Return the text within the request.

Errors

If both self.text and self.data are None. If any data annotation does not contain text or markup.

pub fn get_text(&self) -> Cow<'source, str>

Return a copy of the text within the request. Call Request::try_get_text but panic on error.

Panics

If both self.text and self.data are None. If any data annotation does not contain text or markup.

pub fn try_split(self, n: usize, pat: &str) -> Result<Vec<Self>>

Split this request into multiple, using split_len function to split text.

Errors

If self.text is None and self.data is None.

pub fn split(self, n: usize, pat: &str) -> Vec<Self>

Split this request into multiple, using split_len function to split text. Call Request::try_split but panic on error.

Panics

If self.text is none.

Trait Implementations

impl<'source> Clone for Request<'source>

fn clone(&self) -> Request<'source>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'source> Debug for Request<'source>

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

Formats the value using the given formatter.

impl<'source> Default for Request<'source>

fn default() -> Request<'source>

Returns the “default value” for a type.

impl From<CliRequest> for Request<'_>

Available on crate feature cli only.

fn from(val: CliRequest) -> Self

Converts to this type from the input type.

impl<'source> Hash for Request<'source>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'source> IntoStatic for Request<'source>

type Static = Request<'static>

fn into_static(self) -> Request<'static>

impl<'source> PartialEq for Request<'source>

fn eq(&self, other: &Request<'source>) -> 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<'source> Serialize for Request<'source>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'source> Eq for Request<'source>

impl<'source> StructuralPartialEq for Request<'source>