Grcov report - sticker

1

use crate::commands::{

2

    Command, GenericResponseValue, Request, RequestParserError, RequestParserResult,

3

    ResponseAttributes, ResponseParserError,

4

};

5

6

pub struct StickerFind;

7

8

pub struct StickerFindResponseEntry {

9

    pub uri: String,

10

    pub name: String,

11

    pub value: String,

12

13

14

pub type StickerFindResponse = Vec<StickerFindResponseEntry>;

15

16

impl Command for StickerFind {

17

    type Response = StickerFindResponse;

18

    const COMMAND: &'static str = "sticker find";

19

20

    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {

21

        let sticker_type = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

22

        let sticker_type = sticker_type

23

            .parse()

24

            .map_err(|_| RequestParserError::SyntaxError(1, sticker_type.to_owned()))?;

25

26

        let uri = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

27

        let uri = uri

28

            .parse()

29

            .map_err(|_| RequestParserError::SyntaxError(1, uri.to_owned()))?;

30

31

        let name = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

32

        let name = name

33

            .parse()

34

            .map_err(|_| RequestParserError::SyntaxError(1, name.to_owned()))?;

35

36

        // TODO: handle the case for this command as well:

37

        //       sticker find {TYPE} {URI} {NAME} = {VALUE} [sort {SORTTYPE}] [window {START:END}]

38

39

        let mut sort_or_window = parts.next();

40

        let mut sort = None;

41

        if let Some("sort") = sort_or_window {

42

            sort = Some(

43

                parts

44

                    .next()

45

                    .ok_or(RequestParserError::UnexpectedEOF)?

46

                    .to_string(),

47

);

48

            sort_or_window = parts.next();

49

50

51

        let mut window = None;

52

        if let Some("window") = sort_or_window {

53

            let w = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

54

            window = Some(

55

                w.parse()

56

                    .map_err(|_| RequestParserError::SyntaxError(0, w.to_string()))?,

57

);

58

59

60

        debug_assert!(parts.next().is_none());

61

62

        Ok((

63

            Request::StickerFind(sticker_type, uri, name, sort, window),

64

"",

65

))

66

67

68

    fn parse_response(

69

        parts: ResponseAttributes<'_>,

70

    ) -> Result<Self::Response, ResponseParserError> {

71

        let parts: Vec<_> = parts.into();

72

        let mut stickers = Vec::new();

73

74

        for sticker_uri_pair in parts.chunks_exact(2) {

75

            // TODO: don't assume that the order of the properties is fixed

76

            let uri = sticker_uri_pair

77

                .first()

78

                .ok_or(ResponseParserError::UnexpectedEOF)?;

79

            let sticker = sticker_uri_pair

80

                .get(1)

81

                .ok_or(ResponseParserError::UnexpectedEOF)?;

82

83

            debug_assert!(sticker.0 == "sticker");

84

            // TODO: debug assert that this is a valid sticker type

85

            // debug_assert!(uri.0 == "");

86

87

            let uri = match uri.1 {

88

                GenericResponseValue::Text(s) => s.to_string(),

89

                GenericResponseValue::Binary(_) => {

90

                    return Err(ResponseParserError::UnexpectedPropertyType(uri.0, "Binary"))

91

92

};

93

94

            let sticker = match sticker.1 {

95

                GenericResponseValue::Text(s) => s,

96

                GenericResponseValue::Binary(_) => {

97

                    return Err(ResponseParserError::UnexpectedPropertyType(

98

                        "sticker", "Binary",

99

))

100

101

};

102

103

            // TODO: This assumes the first = is the only one.

104

            //       See: https://github.com/MusicPlayerDaemon/MPD/issues/2166

105

            let mut split = sticker.split("=");

106

            let name = split

107

                .next()

108

                .ok_or(ResponseParserError::SyntaxError(0, sticker))?

109

                .to_string();

110

            let value = split

111

                .next()

112

                .ok_or(ResponseParserError::SyntaxError(1, sticker))?

113

                .to_string();

114

115

            stickers.push(StickerFindResponseEntry { uri, name, value });

116

117

118

        Ok(stickers)

119

120