expose deserialize convenience methods

examples/decode.rs

@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 use serde::Deserialize;
 use std::collections::HashMap;
 

examples/decode_file.rs

@@ -1,4 +1,4 @@
-use ron::de::from_reader;
+use ron::from_reader;
 use serde::Deserialize;
 use std::{collections::HashMap, fs::File};
 

examples/encode.rs

@@ -1,4 +1,4 @@
-use ron::ser::{to_string_pretty, PrettyConfig};
+use ron::{to_string_pretty, PrettyConfig};
 use serde::Serialize;
 use std::{collections::HashMap, iter::FromIterator};
 

src/lib.rs

@@ -59,17 +59,17 @@ Serializing / Deserializing is as simple as calling `to_string` / `from_str`.
 
 #![doc(html_root_url = "https://docs.rs/ron/0.6.0")]
 
-pub mod de;
-pub mod ser;
+mod de;
+mod ser;
 
 pub mod error;
 pub mod value;
 
 pub mod extensions;
 
-pub use de::{from_str, Deserializer};
+pub use de::{from_bytes, from_reader, from_str, Deserializer};
 pub use error::{Error, Result};
-pub use ser::{to_string, Serializer};
+pub use ser::{to_string, to_string_pretty, to_writer, to_writer_pretty, PrettyConfig, Serializer};
 pub use value::{Map, Number, Value};
 
 mod parse;

src/ser/mod.rs

@@ -62,7 +62,7 @@ struct Pretty {
 /// # Examples
 ///
 /// ```
-/// use ron::ser::PrettyConfig;
+/// use ron::PrettyConfig;
 ///
 /// let my_config = PrettyConfig::new()
 ///     .depth_limit(4)

tests/117_untagged_tuple_variant.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]

tests/123_enum_representation.rs

@@ -1,4 +1,4 @@
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 use std::{cmp::PartialEq, fmt::Debug};
 

tests/147_empty_sets_serialisation.rs

@@ -41,10 +41,10 @@ fn empty_sets_arrays() {
             .collect(),
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .enumerate_arrays(true)
         .new_line("\n".to_string());
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
@@ -63,7 +63,7 @@ fn empty_sets_arrays() {
         serial
     );
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }

tests/240_array_pretty.rs

@@ -1,4 +1,4 @@
-use ron::ser::{to_string_pretty, PrettyConfig};
+use ron::{to_string_pretty, PrettyConfig};
 
 #[test]
 fn small_array() {

tests/big_struct.rs

@@ -75,5 +75,5 @@ const CONFIG: &str = "(
 
 #[test]
 fn deserialize_big_struct() {
-    ron::de::from_str::<ImGuiStyleSave>(CONFIG).unwrap();
+    ron::from_str::<ImGuiStyleSave>(CONFIG).unwrap();
 }

tests/borrowed_str.rs

@@ -10,7 +10,7 @@ const BORROWED: &str = "Borrowed(value: \"test\")";
 #[test]
 fn borrowed_str() {
     assert_eq!(
-        ron::de::from_str(BORROWED).ok(),
+        ron::from_str(BORROWED).ok(),
         Some(Borrowed { value: "test" })
     );
 }

tests/comments.rs

@@ -1,4 +1,4 @@
-use ron::de::{from_str, Error as RonErr, ErrorCode, Position};
+use ron::{from_str, Error as RonErr, ErrorCode, Position};
 
 #[test]
 fn test_simple() {

tests/depth_limit.rs

@@ -48,12 +48,12 @@ fn depth_limit() {
         array: vec![(); 3],
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .depth_limit(1)
         .separate_tuple_members(true)
         .enumerate_arrays(true)
         .new_line("\n".to_string());
-    let s = ron::ser::to_string_pretty(&data, pretty);
+    let s = ron::to_string_pretty(&data, pretty);
 
     assert_eq!(s, Ok(EXPECTED.to_string()));
 }

tests/escape.rs

@@ -1,4 +1,4 @@
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 use std::{char::from_u32, fmt::Debug};
 

tests/extensions.rs

@@ -47,7 +47,7 @@ const CONFIG_U_NT: &str = "
 
 #[test]
 fn unwrap_newtypes() {
-    let d: Struct = ron::de::from_str(&CONFIG_U_NT).expect("Failed to deserialize");
+    let d: Struct = ron::from_str(&CONFIG_U_NT).expect("Failed to deserialize");
 
     println!("unwrap_newtypes: {:#?}", d);
 }
@@ -75,7 +75,7 @@ const CONFIG_I_S: &str = "
 
 #[test]
 fn implicit_some() {
-    let d: Struct = ron::de::from_str(&CONFIG_I_S).expect("Failed to deserialize");
+    let d: Struct = ron::from_str(&CONFIG_I_S).expect("Failed to deserialize");
 
     println!("implicit_some: {:#?}", d);
 }

tests/floats.rs

@@ -1,7 +1,4 @@
-use ron::{
-    de::from_str,
-    ser::{to_string_pretty, PrettyConfig},
-};
+use ron::{from_str, to_string_pretty, PrettyConfig};
 
 #[test]
 fn test_inf_and_nan() {

tests/large_number.rs

@@ -3,8 +3,8 @@ use ron::value::{Number, Value};
 #[test]
 fn test_large_number() {
     let test_var = Value::Number(Number::new(10000000000000000000000.0f64));
-    let test_ser = ron::ser::to_string(&test_var).unwrap();
-    let test_deser = ron::de::from_str::<Value>(&test_ser);
+    let test_ser = ron::to_string(&test_var).unwrap();
+    let test_deser = ron::from_str::<Value>(&test_ser);
 
     assert_eq!(
         test_deser.unwrap(),
@@ -17,9 +17,9 @@ fn test_large_integer_to_float() {
     use ron::value::Float;
     let test_var = std::i64::MAX as u64 + 1;
     let expected = test_var as f64; // Is exactly representable by f64
-    let test_ser = ron::ser::to_string(&test_var).unwrap();
+    let test_ser = ron::to_string(&test_var).unwrap();
     assert_eq!(test_ser, test_var.to_string());
-    let test_deser = ron::de::from_str::<Value>(&test_ser);
+    let test_deser = ron::from_str::<Value>(&test_ser);
 
     assert_eq!(
         test_deser.unwrap(),

tests/min_max.rs

@@ -1,4 +1,4 @@
-use ron::{de::*, ser::*};
+use ron::*;
 
 #[test]
 fn test_i32_min() {

tests/numbers.rs

@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 
 #[test]
 fn test_hex() {

tests/preserve_sequence.rs

@@ -1,7 +1,4 @@
-use ron::{
-    de::from_str,
-    ser::{to_string_pretty, PrettyConfig},
-};
+use ron::{from_str, to_string_pretty, PrettyConfig};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 

tests/roundtrip.rs

@@ -44,11 +44,11 @@ fn roundtrip() {
         .collect(),
     };
 
-    let serial = ron::ser::to_string(&value).unwrap();
+    let serial = ron::to_string(&value).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
@@ -68,14 +68,14 @@ fn roundtrip_pretty() {
         .collect(),
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .enumerate_arrays(true)
         .extensions(Extensions::IMPLICIT_SOME);
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
@@ -110,12 +110,12 @@ fn roundtrip_sep_tuple_members() {
 
     let value = Both { a, b };
 
-    let pretty = ron::ser::PrettyConfig::new().separate_tuple_members(true);
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let pretty = ron::PrettyConfig::new().separate_tuple_members(true);
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }

tests/struct_integers.rs

@@ -28,8 +28,8 @@ fn roundtrip() {
         i: std::u64::MAX,
         j: std::u128::MAX,
     };
-    let serialized = ron::ser::to_string(&s).unwrap();
+    let serialized = ron::to_string(&s).unwrap();
     dbg!(&serialized);
-    let deserialized = ron::de::from_str(&serialized).unwrap();
+    let deserialized = ron::from_str(&serialized).unwrap();
     assert_eq!(s, deserialized,);
 }

tests/unicode.rs

@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 
 #[test]
 fn test_char() {

tests/value.rs

@@ -91,7 +91,7 @@ struct Scene2 {
 
 #[test]
 fn roundtrip() {
-    use ron::{de::from_str, ser::to_string};
+    use ron::{from_str, to_string};
 
     {
         let s = to_string(&Scene2 {