rename

Author: abr-egn

fuzz/fuzz_targets/decode.rs

@@ -7,8 +7,8 @@ use bson::Document;
 use std::io::Cursor;
 
 fuzz_target!(|buf: &[u8]| {
-    if let Ok(doc) = Document::decode_from_reader(&mut Cursor::new(&buf[..])) {
+    if let Ok(doc) = Document::from_reader(&mut Cursor::new(&buf[..])) {
         let mut vec = Vec::with_capacity(buf.len());
-        let _ = doc.encode_to_writer(&mut vec);
+        let _ = doc.to_writer(&mut vec);
     }
 });

fuzz/fuzz_targets/encoding.rs

@@ -45,12 +45,12 @@ fn compare_values(val1: &Bson, val2: &Bson) -> bool {
 }
 
 fuzz_target!(|input: &[u8]| {
-    if let Ok(rawdoc) = RawDocument::decode_from_bytes(&input) {
+    if let Ok(rawdoc) = RawDocument::from_bytes(&input) {
         if let Ok(doc) = Document::try_from(rawdoc) {
             let out = RawDocumentBuf::try_from(&doc).unwrap();
             let out_bytes = out.as_bytes();
             if input != out_bytes {
-                let reencoded = RawDocument::decode_from_bytes(&out_bytes).unwrap();
+                let reencoded = RawDocument::from_bytes(&out_bytes).unwrap();
                 let reencoded_doc = Document::try_from(reencoded).unwrap();
                 // Ensure that the re-encoded document is the same as the original document, the
                 // bytes can differ while still resulting in the same Document.

fuzz/fuzz_targets/iterate.rs

@@ -5,7 +5,7 @@ extern crate bson;
 use bson::RawDocument;
 
 fuzz_target!(|buf: &[u8]| {
-    if let Ok(doc) = RawDocument::decode_from_bytes(buf) {
+    if let Ok(doc) = RawDocument::from_bytes(buf) {
         for _ in doc {}
     }
 });

fuzz/fuzz_targets/string_handling.rs

@@ -6,7 +6,7 @@ use bson::{RawBsonRef, RawDocument};
 use std::convert::TryInto;
 
 fuzz_target!(|buf: &[u8]| {
-    if let Ok(doc) = RawDocument::decode_from_bytes(buf) {
+    if let Ok(doc) = RawDocument::from_bytes(buf) {
         for elem in doc.iter_elements().flatten() {
             // Convert to RawBsonRef and check string-related types
             if let Ok(bson) = elem.try_into() {

fuzz/fuzz_targets/type_markers.rs

@@ -6,7 +6,7 @@ use bson::{RawBsonRef, RawDocument};
 use std::convert::TryInto;
 
 fuzz_target!(|buf: &[u8]| {
-    if let Ok(doc) = RawDocument::decode_from_bytes(buf) {
+    if let Ok(doc) = RawDocument::from_bytes(buf) {
         for elem in doc.iter_elements().flatten() {
             let _: Result<RawBsonRef, _> = elem.try_into();
         }

fuzz/generate_corpus.rs

@@ -30,7 +30,7 @@ fn generate_length_edge_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("min_doc"),
         min_doc
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 
@@ -39,7 +39,7 @@ fn generate_length_edge_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("large_doc"),
         large_doc
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 
@@ -78,7 +78,7 @@ fn generate_type_marker_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("all_types"),
         all_types
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 
@@ -107,7 +107,7 @@ fn generate_string_edge_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("utf8_cases"),
         utf8_cases
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 
@@ -133,7 +133,7 @@ fn generate_serialization_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("nested_doc"),
         nested_doc
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 
@@ -147,7 +147,7 @@ fn generate_serialization_cases(dir: &Path) -> std::io::Result<()> {
     fs::write(
         target_dir.join("large_binary"),
         large_binary
-            .encode_to_vec()
+            .to_vec()
             .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?,
     )?;
 

serde-tests/test.rs

@@ -59,7 +59,7 @@ fn run_test<T>(expected_value: &T, expected_doc: &Document, description: &str)
 where
     T: Serialize + DeserializeOwned + PartialEq + std::fmt::Debug,
 {
-    let expected_bytes = expected_doc.encode_to_vec().expect(description);
+    let expected_bytes = expected_doc.to_vec().expect(description);
 
     let expected_bytes_serde = bson::serialize_to_vec(&expected_value).expect(description);
 
@@ -104,7 +104,7 @@ fn run_deserialize_test<T>(expected_value: &T, expected_doc: &Document, descript
 where
     T: DeserializeOwned + PartialEq + std::fmt::Debug,
 {
-    let expected_bytes = expected_doc.encode_to_vec().expect(description);
+    let expected_bytes = expected_doc.to_vec().expect(description);
 
     assert_eq!(
         &bson::deserialize_from_document::<T>(expected_doc.clone()).expect(description),
@@ -445,7 +445,7 @@ fn type_conversion() {
     let deserialized: Foo = bson::deserialize_from_document(doc.clone()).unwrap();
     assert_eq!(deserialized, v);
 
-    let bytes = doc.encode_to_vec().unwrap();
+    let bytes = doc.to_vec().unwrap();
 
     let bson_deserialized: Foo = bson::deserialize_from_reader(bytes.as_slice()).unwrap();
     assert_eq!(bson_deserialized, v);
@@ -462,7 +462,7 @@ fn missing_errors() {
 
     bson::deserialize_from_document::<Foo>(doc.clone()).unwrap_err();
 
-    let bytes = doc.encode_to_vec().unwrap();
+    let bytes = doc.to_vec().unwrap();
 
     bson::deserialize_from_reader::<_, Foo>(bytes.as_slice()).unwrap_err();
 }
@@ -681,7 +681,7 @@ fn unused_fields_deny() {
     bson::deserialize_from_document::<Foo>(doc.clone())
         .expect_err("extra fields should cause failure");
 
-    let bytes = doc.encode_to_vec().unwrap();
+    let bytes = doc.to_vec().unwrap();
     bson::deserialize_from_reader::<_, Foo>(bytes.as_slice())
         .expect_err("extra fields should cause failure");
 }
@@ -946,7 +946,7 @@ impl AllTypes {
 
         let decimal = {
             let bytes = hex::decode("18000000136400D0070000000000000000000000003A3000").unwrap();
-            let d = Document::decode_from_reader(bytes.as_slice()).unwrap();
+            let d = Document::from_reader(bytes.as_slice()).unwrap();
             match d.get("d") {
                 Some(Bson::Decimal128(d)) => *d,
                 c => panic!("expected decimal128, got {:?}", c),
@@ -1065,7 +1065,7 @@ fn all_raw_types_rmp() {
         }
     })
     .unwrap();
-    let doc_buf = RawDocumentBuf::decode_from_bytes(doc_bytes).unwrap();
+    let doc_buf = RawDocumentBuf::from_bytes(doc_bytes).unwrap();
     let document = &doc_buf;
     let array = document.get_array("array").unwrap();
 
@@ -1121,7 +1121,7 @@ fn borrowed() {
         "cow": "cow",
         "array": ["borrowed string"],
     };
-    let bson = doc.encode_to_vec().unwrap();
+    let bson = doc.to_vec().unwrap();
 
     let s = "borrowed string".to_string();
     let ss = "another borrowed string".to_string();
@@ -1315,7 +1315,7 @@ fn hint_cleared() {
 
     let bytes = bson::serialize_to_vec(&doc_value).unwrap();
 
-    let doc = RawDocument::decode_from_bytes(&bytes).unwrap();
+    let doc = RawDocument::from_bytes(&bytes).unwrap();
     let binary = doc.get_binary("binary").unwrap();
 
     let f = Foo { doc, binary };

src/document.rs

@@ -674,7 +674,7 @@ impl Document {
     }
 
     /// Attempt to encode the [`Document`] into a byte [`Vec`].
-    pub fn encode_to_vec(&self) -> Result<Vec<u8>> {
+    pub fn to_vec(&self) -> Result<Vec<u8>> {
         Ok(crate::RawDocumentBuf::try_from(self)?.into_bytes())
     }
 
@@ -690,11 +690,11 @@ impl Document {
     ///
     /// let mut v: Vec<u8> = Vec::new();
     /// let doc = doc! { "x" : 1 };
-    /// doc.encode_to_writer(&mut v)?;
+    /// doc.to_writer(&mut v)?;
     /// # Ok(())
     /// # }
     /// ```
-    pub fn encode_to_writer<W: Write>(&self, mut writer: W) -> crate::error::Result<()> {
+    pub fn to_writer<W: Write>(&self, mut writer: W) -> crate::error::Result<()> {
         let buf = crate::RawDocumentBuf::try_from(self)?;
         writer.write_all(buf.as_bytes())?;
         Ok(())
@@ -714,22 +714,22 @@ impl Document {
     ///
     /// let mut v: Vec<u8> = Vec::new();
     /// let doc = doc! { "x" : 1 };
-    /// doc.encode_to_writer(&mut v)?;
+    /// doc.to_writer(&mut v)?;
     ///
     /// // read from mutable reference
     /// let mut reader = Cursor::new(v.clone());
-    /// let doc1 = Document::decode_from_reader(&mut reader)?;
+    /// let doc1 = Document::from_reader(&mut reader)?;
     ///
     /// // read from owned value
-    /// let doc2 = Document::decode_from_reader(Cursor::new(v))?;
+    /// let doc2 = Document::from_reader(Cursor::new(v))?;
     ///
     /// assert_eq!(doc, doc1);
     /// assert_eq!(doc, doc2);
     /// # Ok(())
     /// # }
     /// ```
-    pub fn decode_from_reader<R: Read>(reader: R) -> crate::error::Result<Document> {
-        let raw = crate::raw::RawDocumentBuf::decode_from_reader(reader)?;
+    pub fn from_reader<R: Read>(reader: R) -> crate::error::Result<Document> {
+        let raw = crate::raw::RawDocumentBuf::from_reader(reader)?;
         raw.try_into()
     }
 }

src/lib.rs

@@ -133,7 +133,7 @@
 //! use std::io::Read;
 //!
 //! let mut bytes = hex::decode("0C0000001069000100000000").unwrap();
-//! let doc = Document::decode_from_reader(&mut bytes.as_slice()).unwrap(); // { "i": 1 }
+//! let doc = Document::from_reader(&mut bytes.as_slice()).unwrap(); // { "i": 1 }
 //!
 //! let doc = doc! {
 //!    "hello": "world",

src/raw.rs

@@ -25,7 +25,7 @@
 //! };
 //!
 //! // See http://bsonspec.org/spec.html for details on the binary encoding of BSON.
-//! let doc = RawDocumentBuf::decode_from_bytes(b"\x13\x00\x00\x00\x02hi\x00\x06\x00\x00\x00y'all\x00\x00".to_vec())?;
+//! let doc = RawDocumentBuf::from_bytes(b"\x13\x00\x00\x00\x02hi\x00\x06\x00\x00\x00y'all\x00\x00".to_vec())?;
 //! let elem = doc.get("hi")?.unwrap();
 //!
 //! assert_eq!(
@@ -86,7 +86,7 @@
 //! use bson::raw::RawDocument;
 //!
 //! let bytes = b"\x13\x00\x00\x00\x02hi\x00\x06\x00\x00\x00y'all\x00\x00";
-//! assert_eq!(RawDocument::decode_from_bytes(bytes)?.get_str("hi")?, "y'all");
+//! assert_eq!(RawDocument::from_bytes(bytes)?.get_str("hi")?, "y'all");
 //! # Ok::<(), Box<dyn std::error::Error>>(())
 //! ```
 //!