bench:

                        time:   [22.139 µs 22.176 µs 22.217 µs]
                        thrpt:  [45.010 Kelem/s 45.093 Kelem/s 45.170 Kelem/s]
                 change:
                        time:   [-23.567% -23.340% -23.129%] (p = 0.00 < 0.05)
                        thrpt:  [+30.087% +30.447% +30.833%

• handle number keys
  • closes https://github.com/ahdinosaur/json-canon/issues/5
• handle numbers greater than JavaScript's Number.MAX_SAFE_INTEGER
  • closes https://github.com/ahdinosaur/json-canon/issues/6
• add more unit tests
• add more code docs

any integer above JavaScript's Number.MAX_SAFE_INTEGER should error.

at the moment, we serialize them as is, which could lead to the following problem:

JSON.stringify(JSON.parse("[1152921504606846976,2305843009213693952,4611686018427387904]"))
// '[1152921504606847000,2305843009213694000,4611686018427388000]'

another option is we cast integers as f64, but this is lossy and i'd rather throw an error than silently convert data.

references:

• https://github.com/l1h3r/serde_jcs/issues/3
• https://github.com/cyberphone/json-canonicalization/issues/20

failing test:

macro_rules! treemap {
    () => {
        BTreeMap::new()
    };
    ($($k:expr => $v:expr),+) => {
        {
            let mut m = BTreeMap::new();
            $(
                m.insert($k, $v);
            )+
            m
        }
    };
}

#[test]
fn test_object_with_wacky_keys() {
    #[derive(PartialEq, Eq, PartialOrd, Ord, serde_derive::Serialize)]
    #[serde(untagged)]
    enum Key<'a> {
        Str(&'a str),
        Num(u32),
    }
    let expected = r#"{"\n":"Newline","1":"One","2":"Two","3":"Three","4":"Four"}"#;
    let input = treemap![
        Key::Num(2) => "Two",
        Key::Str("4") => "Four",
        Key::Str("1") => "One",
        Key::Num(3) => "Three",
        Key::Str("\u{000a}") => "Newline"
    ];
    let actual = to_string(&input).unwrap();
    assert_eq!(actual, expected);
}

failures:

---- test_object_with_wacky_keys stdout ----
thread 'test_object_with_wacky_keys' panicked at 'assertion failed: `(left == right)`
  left: `"{\"2\":\"Two\",\"3\":\"Three\",\"\\n\":\"Newline\",\"1\":\"One\",\"4\":\"Four\"}"`,
 right: `"{\"\\n\":\"Newline\",\"1\":\"One\",\"2\":\"Two\",\"3\":\"Three\",\"4\":\"Four\"}"`', 

i'll admit i didn't realize numbers could be keys, but that's because i keep thinking that the Rust is deserialized to serde_json::Value (where keys can only be strings) before being serialized, which is just not the case.

• add JavaScript json-canon-fuzz fuzzer to output test cases
• fix bug in how Rust json-canon used original bytes for sorting keys
• fuzz all the things, everything seems to work

inspired by https://www.reddit.com/r/rust/comments/ozpspr/improved_my_base64_encoders_performance_3x_by/,

i tried to re-use the many ObjectEntry objects that get created (and their byte Vec<u8>'s) using a pool.

benchmarks look very promising!

                        time:   [13.003 µs 13.027 µs 13.061 µs]
                        thrpt:  [76.564 Kelem/s 76.761 Kelem/s 76.904 Kelem/s]
                 change:
                        time:   [-39.290% -39.190% -39.087%] (p = 0.00 < 0.05)
                        thrpt:  [+64.169% +64.447% +64.716%]