tmi 0.10.0

twitch.tv messaging interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! This command is sent once upon successful login to Twitch IRC.

use super::{
  is_not_empty, maybe_clone, maybe_unescape, parse_badges, split_comma, Badge, MessageParseError,
};
use crate::irc::{Command, IrcMessageRef, Tag};
use std::borrow::Cow;

/// This command is sent once upon successful login to Twitch IRC.
#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GlobalUserState<'src> {
  #[cfg_attr(feature = "serde", serde(borrow))]
  id: Cow<'src, str>,

  #[cfg_attr(feature = "serde", serde(borrow))]
  name: Cow<'src, str>,

  #[cfg_attr(feature = "serde", serde(borrow))]
  badges: Vec<Badge<'src>>,

  #[cfg_attr(feature = "serde", serde(borrow))]
  emote_sets: Vec<Cow<'src, str>>,

  #[cfg_attr(feature = "serde", serde(borrow))]
  color: Option<Cow<'src, str>>,
}

generate_getters! {
  <'src> for GlobalUserState<'src> as self {
    /// ID of the logged in user.
    id -> &str = self.id.as_ref(),

    /// Display name of the logged in user.
    ///
    /// This is the name which appears in chat, and may contain arbitrary unicode characters.
    /// It is separate from the user login, which is always only ASCII.
    ///
    /// ⚠ This call will allocate and return a String if it needs to be unescaped.
    name -> Cow<'src, str> = maybe_unescape(self.name.clone()),

    /// Iterator over global badges.
    badges -> impl DoubleEndedIterator<Item = &Badge<'src>> + ExactSizeIterator
      = self.badges.iter(),

    /// Number of global badges.
    num_badges -> usize = self.badges.len(),

    /// Iterator over emote sets which are available globally.
    emote_sets -> impl DoubleEndedIterator<Item = &str> + ExactSizeIterator
      = self.emote_sets.iter().map(|v| v.as_ref()),

    /// Number of emote sets which are available globally.
    num_emote_sets -> usize = self.emote_sets.len(),

    /// Chat name color.
    ///
    /// [`None`] means the user has not selected a color.
    /// To match the behavior of Twitch, users should be
    /// given a globally-consistent random color.
    color -> Option<&str> = self.color.as_deref(),
  }
}

impl<'src> GlobalUserState<'src> {
  fn parse(message: IrcMessageRef<'src>) -> Option<Self> {
    if message.command() != Command::GlobalUserState {
      return None;
    }

    Some(GlobalUserState {
      id: message.tag(Tag::UserId)?.into(),
      name: message.tag(Tag::DisplayName)?.into(),
      badges: message
        .tag(Tag::Badges)
        .zip(message.tag(Tag::BadgeInfo))
        .map(|(badges, badge_info)| parse_badges(badges, badge_info))
        .unwrap_or_default(),
      emote_sets: message
        .tag(Tag::EmoteSets)
        .map(split_comma)
        .map(|i| i.map(Cow::Borrowed))
        .map(Iterator::collect)
        .unwrap_or_default(),
      color: message
        .tag(Tag::Color)
        .filter(is_not_empty)
        .map(Cow::Borrowed),
    })
  }

  /// Clone data to give the value a `'static` lifetime.
  pub fn into_owned(self) -> GlobalUserState<'static> {
    GlobalUserState {
      id: maybe_clone(self.id),
      name: maybe_clone(self.name),
      badges: self.badges.into_iter().map(Badge::into_owned).collect(),
      emote_sets: self.emote_sets.into_iter().map(maybe_clone).collect(),
      color: self.color.map(maybe_clone),
    }
  }
}

impl<'src> super::FromIrc<'src> for GlobalUserState<'src> {
  #[inline]
  fn from_irc(message: IrcMessageRef<'src>) -> Result<Self, MessageParseError> {
    Self::parse(message).ok_or(MessageParseError)
  }
}

impl<'src> From<GlobalUserState<'src>> for super::Message<'src> {
  fn from(msg: GlobalUserState<'src>) -> Self {
    super::Message::GlobalUserState(msg)
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn parse_globaluserstate() {
    assert_irc_snapshot!(GlobalUserState, "@badge-info=;badges=;color=;display-name=randers811;emote-sets=0;user-id=553170741;user-type= :tmi.twitch.tv GLOBALUSERSTATE");
  }

  #[cfg(feature = "serde")]
  #[test]
  fn roundtrip_globaluserstate() {
    assert_irc_roundtrip!(GlobalUserState, "@badge-info=;badges=;color=;display-name=randers811;emote-sets=0;user-id=553170741;user-type= :tmi.twitch.tv GLOBALUSERSTATE");
  }
}