Enum tailwind_parse::Plugin

pub enum Plugin {
    Position(Position),
    Visibility(Visibility),
    Display(Display),
    TextTransform(TextTransform),
    TextDecoration(TextDecoration),
    Border(Option<Border>),
    Rounded(Option<Rounded>),
    Min(Min),
    Max(Max),
    H,
    W,
    P,
    Px,
    Pl,
    Pr,
    Py,
    Pt,
    Pb,
    M,
    Mx,
    My,
    Ml,
    Mr,
    Mt,
    Mb,
    Z,
    Text,
    Bg,
    Font,
    Fill,
    Shadow,
    Transition,
    Placeholder,
    Inset(Option<Inset>),
    Delay,
    Duration,
    Divide(Option<Divide>),
    Rotate,
    Appearance,
    Truncate,
    Animate,
    Pointer,
    Ease,
    Order,
    Whitespace(Whitespace),
    From,
    To,
    Outline,
    Mix,
    Flex(Option<Flex>),
    Grid(Option<Grid>),
    Col,
    Grow,
    Shrink,
    Basis,
    Object(Object),
    Justify,
    Items,
    Leading,
    Gap(Option<Gap>),
    Cursor,
    Scale,
    Box,
    Select,
    Overflow,
    Top,
    Bottom,
    Left,
    Right,
    AlignSelf(AlignSelf),
    Translate,
    Tracking,
    Invert,
    Space,
    Transform,
    Opacity,
    Blur,
    Ring,
    Sr,
}

Variants

Position(Position)

Visibility(Visibility)

Display(Display)

TextTransform(TextTransform)

TextDecoration(TextDecoration)

Border(Option<Border>)

Rounded(Option<Rounded>)

Min(Min)

Max(Max)

H

W

P

Px

Pl

Pr

Py

Pt

Pb

M

Mx

My

Ml

Mr

Mt

Mb

Z

Text

Bg

Font

Fill

Shadow

Transition

Placeholder

Inset(Option<Inset>)

Delay

Duration

Divide(Option<Divide>)

Rotate

Appearance

Truncate

Animate

Pointer

Ease

Order

Whitespace(Whitespace)

From

To

Outline

Mix

Flex(Option<Flex>)

Grid(Option<Grid>)

Col

Grow

Shrink

Basis

Object(Object)

Justify

Items

Leading

Gap(Option<Gap>)

Cursor

Scale

Box

Select

Overflow

Top

Bottom

Left

Right

AlignSelf(AlignSelf)

Translate

Tracking

Invert

Space

Transform

Opacity

Blur

Ring

Sr

Implementations

impl<'a> Plugin

pub fn parse(s: NomSpan<'a>) -> IResult<NomSpan<'a>, Self, Error<NomSpan<'a>>>

At a hight level, this algorithm:

1. attempts to parse a valid plugin from the input
2. if it fails, checks to see if the input is a ‘rootless subcommand’ (ie, one where the command on its own is not valid)
3. if there is a subcommand, it attempts to parse the subcommand
4. if the subcommand fails to parse, it falls back to the first discovered error

impl Plugin

pub const fn max_dashes() -> usize

pub fn has_subcommand(&self) -> bool

pub fn is_rootless_subcommand(name: &str) -> bool

Trait Implementations

impl Clone for Plugin

fn clone(&self) -> Plugin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plugin

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

Formats the value using the given formatter.

impl FromStr for Plugin

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<Plugin> for Plugin

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

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

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

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

impl Copy for Plugin

impl Eq for Plugin

impl StructuralEq for Plugin

impl StructuralPartialEq for Plugin