Factor out extensions and use in PrettyConfig to configure implicit_some

Author: cmaher

src/de/mod.rs

@@ -7,7 +7,8 @@ use std::{borrow::Cow, io, str};
 
 use self::id::IdDeserializer;
 use self::tag::TagDeserializer;
-use crate::parse::{AnyNum, Bytes, Extensions, ParsedStr};
+use crate::extensions::Extensions;
+use crate::parse::{AnyNum, Bytes, ParsedStr};
 
 mod error;
 mod id;

src/extensions.rs

@@ -0,0 +1,21 @@
+use bitflags::bitflags;
+use serde::{Deserialize, Serialize};
+
+bitflags! {
+    #[derive(Serialize, Deserialize)]
+    pub struct Extensions: usize {
+        const UNWRAP_NEWTYPES = 0x1;
+        const IMPLICIT_SOME = 0x2;
+    }
+}
+
+impl Extensions {
+    /// Creates an extension flag from an ident.
+    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,
+        }
+    }
+}

src/lib.rs

@@ -60,6 +60,7 @@ Serializing / Deserializing is as simple as calling `to_string` / `from_str`.
 pub mod de;
 pub mod ser;
 pub mod value;
+pub mod extensions;
 pub use crate::value::Value;
 
 mod parse;

src/parse.rs

@@ -1,4 +1,3 @@
-use bitflags::bitflags;
 use std::{
     char::from_u32 as char_from_u32,
     fmt::{Display, Formatter, Result as FmtResult},
@@ -7,6 +6,7 @@ use std::{
 };
 
 use crate::de::{Error, ParseError, Result};
+use crate::extensions::Extensions;
 
 const DIGITS: &[u8] = b"0123456789ABCDEFabcdef_";
 const FLOAT_CHARS: &[u8] = b"0123456789.+-eE";
@@ -773,23 +773,6 @@ impl<'a> Bytes<'a> {
     }
 }
 
-bitflags! {
-    pub struct Extensions: usize {
-        const UNWRAP_NEWTYPES = 0x1;
-        const IMPLICIT_SOME = 0x2;
-    }
-}
-
-impl Extensions {
-    /// Creates an extension flag from an ident.
-    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,
-        }
-    }
-}
 
 pub trait Num {
     fn from_u8(x: u8) -> Self;

src/ser/mod.rs

@@ -4,6 +4,8 @@ use std::{
     fmt::{Display, Formatter, Result as FmtResult, Write},
 };
 
+use crate::extensions::Extensions;
+
 mod value;
 
 /// Serializes `value` and returns it as string.
@@ -96,8 +98,8 @@ pub struct PrettyConfig {
     /// Enumerate array items in comments
     #[serde(default = "default_enumerate_arrays")]
     pub enumerate_arrays: bool,
-    /// Enable implicit_some extension
-    pub implicit_some: bool,
+    /// Enable extensions. Only configures 'implicit_some' for now.
+    pub extensions: Extensions,
     /// Private field to ensure adding a field is non-breaking.
     #[serde(skip)]
     _future_proof: (),
@@ -159,11 +161,11 @@ impl PrettyConfig {
         self
     }
 
-    /// Configures whether the implicit_some extension will be enabled
+    /// Configures extensions
     ///
-    /// Default: `false`
-    pub fn with_implicit_some(mut self, implicit_some: bool) -> Self {
-        self.implicit_some = implicit_some;
+    /// Default: Extensions::empty()
+    pub fn with_extensions(mut self, extensions: Extensions) -> Self {
+        self.extensions = extensions;
 
         self
     }
@@ -194,8 +196,8 @@ fn default_enumerate_arrays() -> bool {
     false
 }
 
-fn default_implicit_some() -> bool {
-    false
+fn default_extensions() -> Extensions {
+    Extensions::empty()
 }
 
 impl Default for PrettyConfig {
@@ -206,7 +208,7 @@ impl Default for PrettyConfig {
             indentor: default_indentor(),
             separate_tuple_members: default_separate_tuple_members(),
             enumerate_arrays: default_enumerate_arrays(),
-            implicit_some: default_implicit_some(),
+            extensions: default_extensions(),
             _future_proof: (),
         }
     }
@@ -229,7 +231,7 @@ impl Serializer {
     /// Most of the time you can just use `to_string` or `to_string_pretty`.
     pub fn new(config: Option<PrettyConfig>, struct_names: bool) -> Self {
         let initial_output = if let Some(conf) = &config {
-            if conf.implicit_some {
+            if conf.extensions.contains(Extensions::IMPLICIT_SOME) {
                 "#![enable(implicit_some)]".to_string() + &conf.new_line
             } else {
                 String::new()
@@ -271,10 +273,10 @@ impl Serializer {
             .map_or(false, |&(ref config, _)| config.separate_tuple_members)
     }
 
-    fn implicit_some(&self) -> bool {
+    fn extensions(&self) -> Extensions {
         self.pretty
             .as_ref()
-            .map_or(false, |&(ref config, _)| config.implicit_some)
+            .map_or(Extensions::empty(), |&(ref config, _)| config.extensions)
     }
 
     fn start_indent(&mut self) {
@@ -414,11 +416,12 @@ impl<'a> ser::Serializer for &'a mut Serializer {
     where
         T: ?Sized + Serialize,
     {
-        if !self.implicit_some() {
+        let implicit_some = self.extensions().contains(Extensions::IMPLICIT_SOME);
+        if !implicit_some {
             self.output += "Some(";
         }
         value.serialize(&mut *self)?;
-        if !self.implicit_some() {
+        if !implicit_some {
             self.output += ")";
         }
 

tests/roundtrip.rs

@@ -1,6 +1,8 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+use ron::extensions::Extensions;
+
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
 struct UnitStruct;
 
@@ -68,7 +70,7 @@ fn roundtrip_pretty() {
 
     let pretty = ron::ser::PrettyConfig::new()
         .with_enumerate_arrays(true)
-        .with_implicit_some(true);
+        .with_extensions(Extensions::IMPLICIT_SOME);
     let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);