Struct CheckRequest

#[non_exhaustive]
pub struct CheckRequest {

    pub text: Option<String>,
    pub data: Option<Data>,
    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<String>

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

data: Option<Data>

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.

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 CheckRequest

pub fn with_text(self, text: String) -> Self

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

pub fn with_data(self, data: Data) -> 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<String>

Return a copy of 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) -> String

Return a copy of the text within the request. Call CheckRequest::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.

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

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

Panics

If self.text is none.

Trait Implementations

impl Args for CheckRequest

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self.

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can update self.

impl Clone for CheckRequest

fn clone(&self) -> CheckRequest

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CheckRequest

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

Formats the value using the given formatter.

impl Default for CheckRequest

fn default() -> CheckRequest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CheckRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArgMatches for CheckRequest

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for CheckRequest

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CheckRequest

impl StructuralPartialEq for CheckRequest