reikland 0.1.3

A serde-compatible Ruby marshal parser and deserializer
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

use std::num::TryFromIntError;

use crate::cursor::{Cursor, FromCursor, TryFromCursor};

/// Ruby fixnum
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct FixNum(i32);

impl FixNum {
    pub fn new(val: i32) -> Self {
        Self(val)
    }

    pub fn inner(self) -> i32 {
        self.0
    }
}

impl From<i32> for FixNum {
    fn from(value: i32) -> Self {
        Self::new(value)
    }
}

impl TryFromCursor<'_> for FixNum {
    type Error = std::convert::Infallible;

    fn try_from_cursor(cursor: &mut Cursor<'_>) -> Option<Result<Self, Self::Error>> {
        match u8::from_cursor(cursor)? {
            0x00 => Some(Ok(FixNum(0))),
            0x01 => {
                let first_byte = cursor.take()?;
                Some(Ok(FixNum(i32::from_le_bytes([first_byte, 0, 0, 0]))))
            }
            0xff => {
                let first_byte = cursor.take()?;
                Some(Ok(FixNum(i32::from_le_bytes([
                    first_byte, 0xff, 0xff, 0xff,
                ]))))
            }
            0x02 => {
                let [first_byte, second_byte] = cursor.take_const::<2>().copied()?;
                Some(Ok(FixNum(i32::from_le_bytes([
                    first_byte,
                    second_byte,
                    0,
                    0,
                ]))))
            }
            0xfe => {
                let [first_byte, second_byte] = cursor.take_const::<2>().copied()?;
                Some(Ok(FixNum(i32::from_le_bytes([
                    first_byte,
                    second_byte,
                    0xff,
                    0xff,
                ]))))
            }
            0x03 => {
                let [first_byte, second_byte, third_byte] = cursor.take_const::<3>().copied()?;
                Some(Ok(FixNum(i32::from_le_bytes([
                    first_byte,
                    second_byte,
                    third_byte,
                    0,
                ]))))
            }
            0xfd => {
                let [first_byte, second_byte, third_byte] = cursor.take_const::<3>().copied()?;
                Some(Ok(FixNum(i32::from_le_bytes([
                    first_byte,
                    second_byte,
                    third_byte,
                    0xff,
                ]))))
            }
            0x04 | 0xfc => Some(Ok(FixNum(cursor.take::<i32>()?))),
            x => {
                let signed = x.cast_signed();
                Some(Ok(FixNum((signed - (signed.signum() * 5)) as i32)))
            }
        }
    }
}

/// Ruby fixnum, converted into a usize
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct FixNumLen(usize);

impl FixNumLen {
    pub fn new(len: usize) -> Self {
        Self(len)
    }

    pub fn inner(self) -> usize {
        self.0
    }
}

impl TryFromCursor<'_> for FixNumLen {
    type Error = TryFromIntError;

    fn try_from_cursor(cursor: &mut Cursor<'_>) -> Option<Result<Self, Self::Error>> {
        FixNum::try_from_cursor(cursor)
            .map(Result::unwrap)
            .map(|f| usize::try_from(f.inner()))
            .map(|o| o.map(FixNumLen))
    }
}