Struct slack_blocks::compose::Opt

pub struct Opt<'a, T = AnyText, U = NoUrl> { /* fields omitted */ }

Option Object

slack api docs 🔗

An object that represents a single selectable item in a

• select menu 🔗,
• multi-select menu 🔗,
• checkbox group 🔗,
• radio button group 🔗,
• or overflow menu 🔗.

Implementations

impl<'a> Opt<'a>

pub fn builder() -> OptBuilderInit<'a>

Build a new option composition object

Examples

use std::convert::TryFrom;

use slack_blocks::{blocks::Actions,
                   compose::Opt,
                   elems::{select::Static, BlockElement},
                   text};

struct City {
  name: String,
  short_code: String,
}

impl City {
  pub fn new(name: impl ToString, short_code: impl ToString) -> Self {
    Self { name: name.to_string(),
           short_code: short_code.to_string() }
  }
}

let cities = vec![City::new("Seattle", "SEA"),
                  City::new("Portland", "PDX"),
                  City::new("Phoenix", "PHX")];

let options =
  cities.iter().map(|City { name, short_code }| {
                 Opt::builder().text_plain(name).value(short_code).build()
               });

let select: BlockElement =
  Static::builder().placeholder("Choose your favorite city!")
                   .action_id("fave_city")
                   .options(options)
                   .build()
                   .into();

let block = Actions::try_from(select);

pub fn from_plain_text_and_value(
    text: impl Into<Plain>,
    value: impl Into<Cow<'a, str>>
) -> Opt<'a, Plain, NoUrl>

👎 Deprecated since 0.15.0:

Use Opt::builder instead

Create an Option composition object from its label and a value to be sent back to your app when it is chosen.

This returns an Opt that can be used by overflow, select, and multi-select menus. To construct an Opt that can be used by radio buttons or checkboxes, see from_mrkdwn_and_value.

Arguments

• text - A text object 🔗 that defines the text shown in the option on the menu. Overflow, select, and multi-select menus can only use plain_text objects, while radio buttons and checkboxes can use mrkdwn text objects. Maximum length for the text in this field is 75 characters.

• value - The string value that will be passed to your app when this option is chosen. Maximum length for this field is 75 characters.

Examples

use slack_blocks::text;
use slack_blocks::blocks::Block;
use slack_blocks::blocks::Section;
use slack_blocks::blocks::Actions;
use slack_blocks::compose::Opt;

let cities = vec![
  ("San Francisco", "san_francisco"),
  ("San Diego", "san_diego"),
  ("New York City", "nyc"),
  ("Phoenix", "phx"),
  ("Boston", "boston"),
  ("Seattle", "seattle"),
]
    .into_iter()
    .map(|(title, short_code)| Opt::from_plain_text_and_value(title, short_code))
    .collect::<Vec<_>>();

let blocks: Vec<Block> = vec![
  Section::from_text(text::Plain::from("Choose your favorite city...")).into(),
  Actions::from_action_elements(vec![]).into() // TODO: add overflow to this example once it exists
];

// < send block to slack's API >

pub fn from_mrkdwn_and_value(
    text: impl Into<Mrkdwn>,
    value: impl Into<Cow<'a, str>>
) -> Opt<'a, Mrkdwn, NoUrl>

👎 Deprecated since 0.15.0:

Use Opt::builder instead

Create an Option composition object from its label and a value to be sent back to your app when it is chosen.

This returns an Opt that can be used by radio buttons or checkboxes. To construct an Opt that can be used by overflow, select, and multi-select menus, see from_plain_text_and_value.

Arguments

• text - A text object 🔗 that defines the text shown in the option on the menu. Overflow, select, and multi-select menus can only use plain_text objects, while radio buttons and checkboxes can use mrkdwn text objects. Maximum length for the text in this field is 75 characters.

• value - The string value that will be passed to your app when this option is chosen. Maximum length for this field is 75 characters.

Examples

use slack_blocks::text;
use slack_blocks::blocks::Block;
use slack_blocks::blocks::Section;
use slack_blocks::blocks::Actions;
use slack_blocks::compose::Opt;

let options = vec![
    "1",
    "2",
    "3",
    "4",
    "5",
]
    .into_iter()
    .map(|num| Opt::from_mrkdwn_and_value(num, num))
    .collect::<Vec<_>>();

let blocks: Vec<Block> = vec![
  Section::from_text(text::Plain::from("On a scale from 1 to 5...")).into(),
  Actions::from_action_elements(vec![]).into() // TODO: add radio buttons to this example once it exists
];

// < send block to slack's API >

impl<'a, T, U> Opt<'a, T, U>

pub fn with_description(self, desc: impl Into<Plain>) -> Self

👎 Deprecated since 0.15.0:

Use Opt::builder instead

Chainable setter method, that sets a description for this Opt.

Arguments

• desc - A plain_text only text object 🔗 that defines a line of descriptive text shown below the text field beside the radio button. Maximum length for the text object within this field is 75 characters.

Example

use slack_blocks::text;
use slack_blocks::blocks::Block;
use slack_blocks::blocks::Section;
use slack_blocks::blocks::Actions;
use slack_blocks::compose::Opt;

let options = vec![
    ("1", "Hated it."),
    ("2", "Didn't like it."),
    ("3", "It was OK."),
    ("4", "Liked it!"),
    ("5", "New favorite!!"),
]
    .into_iter()
    .map(|(num, desc)| {
        Opt::from_mrkdwn_and_value(num, num)
            .with_description(desc)
    })
    .collect::<Vec<_>>();

let blocks: Vec<Block> = vec![
  Section::from_text(text::Plain::from("On a scale from 1 to 5...")).into(),
  Actions::from_action_elements(vec![]).into() // TODO: add radio buttons to this example once it exists
];

// < send block to slack's API >

pub fn validate(&self) -> Result<(), ValidationErrors>

Validate that this Option composition object agrees with Slack’s model requirements

Errors

• If from_plain_text_and_value or from_mrkdwn_and_value was called with text longer than 75 chars
• If from_plain_text_and_value or from_mrkdwn_and_value was called with value longer than 75 chars
• If with_url was called with url longer than 3000 chars
• If with_description was called with text longer than 75 chars

Example

use std::iter::repeat;

use slack_blocks::compose::Opt;

let long_string: String = repeat(' ').take(76).collect();

let opt = Opt::from_plain_text_and_value("My Option", long_string);

assert_eq!(true, matches!(opt.validate(), Err(_)));

impl<'a, U> Opt<'a, Plain, U>

pub fn with_url(self, url: impl Into<Cow<'a, str>>) -> Opt<'a, Plain, AllowUrl>

👎 Deprecated since 0.15.0:

Use Opt::builder instead

Chainable setter method, that sets a url for this Opt.

The url attribute is only available in overflow menus 🔗.

If you’re using url, you’ll still receive an interaction payload 🔗 and will need to send an acknowledgement response 🔗.

Arguments

• url - A URL to load in the user’s browser when the option is clicked. Maximum length for this field is 3000 characters.

Example

use slack_blocks::text;
use slack_blocks::blocks::Block;
use slack_blocks::blocks::Section;
use slack_blocks::blocks::Actions;
use slack_blocks::compose::Opt;

let cities = vec![
  ("San Francisco", "san_francisco", "https://www.sftravel.com/"),
  ("San Diego", "san_diego", "https://www.sandiego.org/explore.aspx"),
  ("New York City", "nyc", "https://www.nycgo.com/"),
  ("Phoenix", "phx", "https://www.visitphoenix.com/"),
  ("Boston", "boston", "https://www.boston.gov/visiting-boston"),
  ("Seattle", "seattle", "https://visitseattle.org/"),
]
    .into_iter()
    .map(|(title, short_code, travel_link)| {
        Opt::from_plain_text_and_value(title, short_code)
            .with_url(travel_link)
    })
    .collect::<Vec<_>>();

let blocks: Vec<Block> = vec![
  Section::from_text(text::Plain::from("Choose your favorite city...")).into(),
  Actions::from_action_elements(vec![]).into() // TODO: add overflow to this example once it exists
];

// < send block to slack's API >

Trait Implementations

impl<'a, T: Clone, U: Clone> Clone for Opt<'a, T, U>

fn clone(&self) -> Opt<'a, T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug, U: Debug> Debug for Opt<'a, T, U>

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

Formats the value using the given formatter.

impl<'de, 'a, T, U> Deserialize<'de> for Opt<'a, T, U>

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

Deserialize this value from the given Serde deserializer.

impl<'a, T: Into<Text>, U> From<Opt<'a, T, U>> for Opt<'a, AnyText, U>

fn from(o: Opt<'a, T, U>) -> Self

Performs the conversion.

impl<'a, T, U> From<Opt<'a, T, U>> for OptOrOptGroup<'a, T, U>

fn from(src: Opt<'a, T, U>) -> Self

Performs the conversion.

impl<'a, T: Hash, U: Hash> Hash for Opt<'a, T, U>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a, T: PartialEq, U: PartialEq> PartialEq<Opt<'a, T, U>> for Opt<'a, T, U>

fn eq(&self, other: &Opt<'a, T, U>) -> bool

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

fn ne(&self, other: &Opt<'a, T, U>) -> bool

This method tests for !=.

impl<'a, T, U> Serialize for Opt<'a, T, U>

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

Serialize this value into the given Serde serializer.

impl<'a, T, U> Validate for Opt<'a, T, U>

fn validate(&self) -> Result<(), ValidationErrors>

impl<'a, T, U> StructuralPartialEq for Opt<'a, T, U>