Merge #75

75: Allow implicit Some r=kvark a=torkleyy

Fixes #55

src/de/mod.rs

@@ -228,23 +228,28 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor<'de>
     {
-        if self.bytes.consume("Some") && { self.bytes.skip_ws(); self.bytes.consume("(") } {
-            self.bytes.skip_ws();
+        if self.bytes.consume("None") {
+            visitor.visit_none()
+        } else {
+            if self.bytes.exts.contains(Extensions::IMPLICIT_SOME) {
+                visitor.visit_some(&mut *self)
+            } else {
+                if self.bytes.consume("Some") && { self.bytes.skip_ws(); self.bytes.consume("(") } {
+                    self.bytes.skip_ws();
 
-            let v = visitor.visit_some(&mut *self)?;
+                    let v = visitor.visit_some(&mut *self)?;
 
-            self.bytes.skip_ws();
+                    self.bytes.skip_ws();
 
-            if self.bytes.consume(")") {
-                Ok(v)
-            } else {
-                self.bytes.err(ParseError::ExpectedOptionEnd)
+                    if self.bytes.consume(")") {
+                        Ok(v)
+                    } else {
+                        self.bytes.err(ParseError::ExpectedOptionEnd)
+                    }
+                } else {
+                    self.bytes.err(ParseError::ExpectedOption)
+                }
             }
-
-        } else if self.bytes.consume("None") {
-            visitor.visit_none()
-        } else {
-            self.bytes.err(ParseError::ExpectedOption)
         }
     }
 

src/de/tests.rs

@@ -209,3 +209,28 @@ fn uglified_attribute() {
 
     assert_eq!(de, Ok(()));
 }
+
+#[test]
+fn implicit_some() {
+    use serde::de::DeserializeOwned;
+
+    fn de<T: DeserializeOwned>(s: &str) -> Option<T> {
+        let enable = "#![enable(implicit_some)]\n".to_string();
+
+        from_str::<Option<T>>(&(enable + s)).unwrap()
+    }
+
+    assert_eq!(de("'c'"), Some('c'));
+    assert_eq!(de("5"), Some(5));
+    assert_eq!(de("\"Hello\""), Some("Hello".to_owned()));
+    assert_eq!(de("false"), Some(false));
+    assert_eq!(de("MyStruct(x: .4, y: .5)"), Some(MyStruct {
+        x: 0.4,
+        y: 0.5,
+    }));
+
+    assert_eq!(de::<char>("None"), None);
+
+    // Not concise
+    assert_eq!(de::<Option<Option<char>>>("None"), None);
+}

src/parse.rs

@@ -459,6 +459,7 @@ impl<'a> Bytes<'a> {
 bitflags! {
     pub struct Extensions: usize {
         const UNWRAP_NEWTYPES = 0x1;
+        const IMPLICIT_SOME = 0x2;
     }
 }
 
@@ -467,6 +468,7 @@ impl Extensions {
     pub fn from_ident(ident: &[u8]) -> Option<Extensions> {
         match ident {
             b"unwrap_newtypes" => Some(Extensions::UNWRAP_NEWTYPES),
+            b"implicit_some" => Some(Extensions::IMPLICIT_SOME),
             _ => None,
         }
     }

tests/extensions.rs

@@ -54,3 +54,31 @@ fn unwrap_newtypes() {
 
     println!("unwrap_newtypes: {:#?}", d);
 }
+
+const CONFIG_I_S: &str = "
+#![enable(implicit_some)]
+
+(
+    tuple: ((), (0.5), ((), -5)),
+    vec: [
+        None,
+        (),
+        UnitStruct,
+        None,
+        (),
+    ],
+    map: {
+        (7): Bool(true),
+        (9): Chars('x', \"\"),
+        (6): Bool(false),
+        (5): Unit,
+    },
+)
+";
+
+#[test]
+fn implicit_some() {
+    let d: Struct = ron::de::from_str(&CONFIG_I_S).expect("Failed to deserialize");
+
+    println!("implicit_some: {:#?}", d);
+}