Format src/lib.rs

Author: smheidrich

src/lib.rs

@@ -25,19 +25,19 @@ mod read_string;
 mod remainder;
 mod suitable_seekable_buffered_bytes_stream;
 mod suitable_seekable_buffered_text_stream;
-mod suitable_unseekable_buffered_bytes_stream;
-mod suitable_unseekable_buffered_text_stream;
 mod suitable_stream;
 mod suitable_unbuffered_bytes_stream;
 mod suitable_unbuffered_text_stream;
+mod suitable_unseekable_buffered_bytes_stream;
+mod suitable_unseekable_buffered_text_stream;
 mod utf8_char_source;
 
 mod char_or_eof;
 use crate::char_or_eof::CharOrEof;
 use CharOrEof::{Char, Eof};
 
 mod unicode_utils;
-use crate::unicode_utils::{is_surrogate, decode_surrogate_pair, UnicodeError};
+use crate::unicode_utils::{decode_surrogate_pair, is_surrogate, UnicodeError};
 
 use crate::suitable_stream::BufferingMode;
 
@@ -123,7 +123,7 @@ impl IntoPy<PyObject> for TokenType {
 }
 
 #[derive(Error, Debug)]
-    pub enum ParsingError {
+pub enum ParsingError {
     #[error("{0}")]
     InvalidJson(String),
     #[error("Error due to limitation: {0}")]
@@ -372,7 +372,7 @@ impl RustTokenizer {
                             "Invalid JSON character: {c:?}"
                         )));
                     }
-                },
+                }
                 Eof => (),
             },
             State::Integer => match c {
@@ -721,41 +721,37 @@ impl RustTokenizer {
                     }
                 }
             }
-            State::UnicodeSurrogateStart => {
-                match c {
-                    Char('\\') => {
-                        slf.next_state = State::UnicodeSurrogateStringEscape;
-                    }
-                    Char(_) => {
-                        return Err(ParsingError::InvalidJson(format!(
-                            "Unpaired UTF-16 surrogate"
-                        )));
-                    }
-                    Eof => {
-                        return Err(ParsingError::InvalidJson(format!(
-                            "Unpaired UTF-16 surrogate at end of file"
-                        )));
-                    }
+            State::UnicodeSurrogateStart => match c {
+                Char('\\') => {
+                    slf.next_state = State::UnicodeSurrogateStringEscape;
                 }
-            }
-            State::UnicodeSurrogateStringEscape => {
-                match c {
-                    Char('u') => {
-                        slf.unicode_buffer = CompactString::with_capacity(4);
-                        slf.next_state = State::UnicodeSurrogate;
-                    }
-                    Char(_) => {
-                        return Err(ParsingError::InvalidJson(format!(
-                            "Unpaired UTF-16 surrogate"
-                        )));
-                    }
-                    Eof => {
-                        return Err(ParsingError::InvalidJson(format!(
-                            "Unpaired UTF-16 surrogate at end of file"
-                        )));
-                    }
+                Char(_) => {
+                    return Err(ParsingError::InvalidJson(format!(
+                        "Unpaired UTF-16 surrogate"
+                    )));
                 }
-            }
+                Eof => {
+                    return Err(ParsingError::InvalidJson(format!(
+                        "Unpaired UTF-16 surrogate at end of file"
+                    )));
+                }
+            },
+            State::UnicodeSurrogateStringEscape => match c {
+                Char('u') => {
+                    slf.unicode_buffer = CompactString::with_capacity(4);
+                    slf.next_state = State::UnicodeSurrogate;
+                }
+                Char(_) => {
+                    return Err(ParsingError::InvalidJson(format!(
+                        "Unpaired UTF-16 surrogate"
+                    )));
+                }
+                Eof => {
+                    return Err(ParsingError::InvalidJson(format!(
+                        "Unpaired UTF-16 surrogate at end of file"
+                    )));
+                }
+            },
             State::UnicodeSurrogate => {
                 match c {
                     Char(c) => {
@@ -786,13 +782,12 @@ impl RustTokenizer {
                             "This should never happen, please report it as a bug..."
                         )));
                     };
-                    c = Char(
-                        decode_surrogate_pair(prev_charcode, charcode)
-                        .map_err(|_| ParsingError::InvalidJson(format!(
+                    c = Char(decode_surrogate_pair(prev_charcode, charcode).map_err(|_| {
+                        ParsingError::InvalidJson(format!(
                             "Error decoding UTF-16 surrogate pair \
                             \\u{prev_charcode:x}\\u{charcode:x}"
-                        )))?
-                    );
+                        ))
+                    })?);
                     slf.prev_charcode = None;
                     slf.next_state = State::String_;
                     add_char = true;

tests/test_using_json_stream_tokenizer_tests.py

@@ -5,14 +5,16 @@
 
 import pytest
 
-from json_stream.tests.test_tokenizer import TestJsonTokenization
+from json_stream.tokenizer.tests.test_tokenizer import TestJsonTokenization
 from json_stream.tests.test_buffering import TestBuffering
 from json_stream_rs_tokenizer import RustTokenizer
 
 
 @pytest.fixture(autouse=True, scope="module")
 def override_tokenizer():
-    with patch("json_stream.tests.test_tokenizer.tokenize", RustTokenizer):
+    with patch(
+        "json_stream.tokenizer.tests.test_tokenizer.tokenize", RustTokenizer
+    ), patch("json_stream.tests.test_buffering.tokenize", RustTokenizer):
         yield