diff --git a/Cargo.toml b/Cargo.toml index 7ef6e41..9026810 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,7 +17,6 @@ json = ["serde_json"] yaml = ["serde_yaml"] parse-value = ["pear"] test = ["tempfile", "parking_lot"] -magic = ["serde/derive"] # toml = ["toml"] [dependencies] @@ -33,6 +32,7 @@ parking_lot = { version = "0.11", optional = true } [dev-dependencies] tempfile = "3" parking_lot = "0.11" +serde = { version = "1.0", features = ["derive"] } [build-dependencies] version_check = "0.9" diff --git a/scripts/test.sh b/scripts/test.sh index 4611bc7..005595e 100755 --- a/scripts/test.sh +++ b/scripts/test.sh @@ -74,7 +74,6 @@ if [ "$1" = "--core" ]; then json yaml test - magic ) echo ":: Building and testing core [no features]..." diff --git a/src/figment.rs b/src/figment.rs index c6bb13a..318c07c 100644 --- a/src/figment.rs +++ b/src/figment.rs @@ -413,7 +413,7 @@ impl Figment { self.metadata.get(&self.find_value(key).ok()?.tag()) } - /// Returns the metadata with the given `id` if this figment contains a + /// Returns the metadata with the given `tag` if this figment contains a /// value with said metadata. /// /// # Example @@ -442,8 +442,8 @@ impl Figment { /// Ok(()) /// }); /// ``` - pub fn get_metadata(&self, id: Tag) -> Option<&Metadata> { - self.metadata.get(&id) + pub fn get_metadata(&self, tag: Tag) -> Option<&Metadata> { + self.metadata.get(&tag) } } diff --git a/src/lib.rs b/src/lib.rs index 2ccf363..427e5e6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -285,7 +285,6 @@ //! | feature | gated namespace | description | //! |---------|---------------------|-----------------------------------------| //! | `test` | [`Jail`] | Semi-sandboxed environment for testing. | -//! | `magic` | [`value::magic`] | "Magic" deserializable values. | //! | `env` | [`providers::Env`] | Environment variable [`Provider`]. | //! | `toml` | [`providers::Toml`] | TOML file/string [`Provider`]. | //! | `json` | [`providers::Json`] | JSON file/string [`Provider`]. | diff --git a/src/profile.rs b/src/profile.rs index 849f068..7904464 100644 --- a/src/profile.rs +++ b/src/profile.rs @@ -61,11 +61,11 @@ impl From<&Profile> for ProfileTag { impl Profile { /// The default profile: `"default"`. #[allow(non_upper_case_globals)] - pub const Default: Profile = Profile(Uncased::from_borrowed("default")); + pub const Default: Profile = Profile::const_new("default"); /// The global profile: `"global"`. #[allow(non_upper_case_globals)] - pub const Global: Profile = Profile(Uncased::from_borrowed("global")); + pub const Global: Profile = Profile::const_new("global"); /// Constructs a profile with the name `name`. /// @@ -82,6 +82,22 @@ impl Profile { Profile(name.to_string().into()) } + /// A `const` to construct a profile with the name `name`. + /// + /// # Example + /// + /// ```rust + /// use figment::Profile; + /// + /// const STAGING: Profile = Profile::const_new("staging"); + /// + /// assert_eq!(STAGING, "staging"); + /// assert_eq!(STAGING, "STAGING"); + /// ``` + pub const fn const_new(name: &'static str) -> Profile { + Profile(Uncased::from_borrowed(name)) + } + /// Constructs a profile from the value of the environment variable with /// name `name`, if one is present. The search for `name` is /// case-insensitive. @@ -248,6 +264,18 @@ impl PartialEq for &str { } } +impl PartialEq for &Profile { + fn eq(&self, other: &Profile) -> bool { + self.as_str() == other.as_str() + } +} + +impl PartialEq<&Profile> for Profile { + fn eq(&self, other: &&Profile) -> bool { + self.as_str() == other.as_str() + } +} + struct Visitor; impl<'de> de::Deserialize<'de> for Profile { diff --git a/src/value/de.rs b/src/value/de.rs index 1e40837..85e0f53 100644 --- a/src/value/de.rs +++ b/src/value/de.rs @@ -60,14 +60,12 @@ impl<'de: 'c, 'c> Deserializer<'de> for ConfiguredValueDe<'c> { _fields: &'static [&'static str], visitor: V ) -> Result { - #[cfg(feature = "magic")] use crate::value::magic::*; + use crate::value::magic::*; let (config, tag) = (self.config, self.value.tag()); let result = match name { Value::NAME => Value::deserialize_from(self, visitor), - #[cfg(feature = "magic")] RelativePathBuf::NAME => RelativePathBuf::deserialize_from(self, visitor), - #[cfg(feature = "magic")] Tagged::<()>::NAME => Tagged::<()>::deserialize_from(self, visitor), // SelectedProfile::NAME => SelectedProfile::deserialize_from(self, visitor), _ => self.deserialize_any(visitor) diff --git a/src/value/magic.rs b/src/value/magic.rs index 36d4bc5..65cbbfb 100644 --- a/src/value/magic.rs +++ b/src/value/magic.rs @@ -4,7 +4,7 @@ use std::ops::Deref; use std::path::{PathBuf, Path}; -use serde::{Deserialize, Serialize, de}; +use serde::{Deserialize, de}; use crate::{Error, value::{ConfiguredValueDe, MapDe, Tag}}; @@ -70,12 +70,13 @@ pub trait Magic: for<'de> Deserialize<'de> { /// Ok(()) /// }); /// ``` -#[derive(Debug, Clone, Deserialize, Serialize)] -#[serde(rename = "___figment_relative_path_buf")] +#[derive(Debug, Clone)] +// #[derive(Deserialize, Serialize)] +// #[serde(rename = "___figment_relative_path_buf")] pub struct RelativePathBuf { - #[serde(rename = "___figment_relative_metadata_path")] + // #[serde(rename = "___figment_relative_metadata_path")] metadata_path: Option, - #[serde(rename = "___figment_relative_path")] + // #[serde(rename = "___figment_relative_path")] path: PathBuf, } @@ -297,7 +298,8 @@ impl RelativePathBuf { /// assert_eq!(config.int_or_str, Either::Right("boo!".into())); /// assert_eq!(config.path_or_bytes, Either::Right(vec![4, 5, 6].into())); /// ``` -#[derive(Serialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +// #[derive(Serialize)] pub enum Either { /// The "left" variant. Left(A), @@ -368,12 +370,13 @@ impl<'de: 'b, 'b, A, B> Deserialize<'de> for Either /// Ok(()) /// }); /// ``` -#[derive(Debug, Clone, Deserialize, Serialize)] -#[serde(rename = "___figment_tagged_item")] +#[derive(Debug, Clone)] +// #[derive(Deserialize, Serialize)] +// #[serde(rename = "___figment_tagged_item")] pub struct Tagged { - #[serde(rename = "___figment_tagged_tag")] + // #[serde(rename = "___figment_tagged_tag")] tag: Tag, - #[serde(rename = "___figment_tagged_value")] + // #[serde(rename = "___figment_tagged_value")] value: T, } @@ -453,6 +456,686 @@ impl From for Tagged { } } +/// These were generated by serde's derive. We don't want to depend on the +/// 'derive' feature, so we simply expand it and copy the impls here. +mod _serde { + use super::*; + + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _: () = { + #[allow(rust_2018_idioms, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for RelativePathBuf { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "___figment_relative_metadata_path" => { + _serde::export::Ok(__Field::__field0) + } + "___figment_relative_path" => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"___figment_relative_metadata_path" => { + _serde::export::Ok(__Field::__field0) + } + b"___figment_relative_path" => { + _serde::export::Ok(__Field::__field1) + } + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = RelativePathBuf; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct RelativePathBuf", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct RelativePathBuf with 2 elements", + )); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::( + &mut __seq, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"struct RelativePathBuf with 2 elements", + )); + } + }; + _serde::export::Ok(RelativePathBuf { + metadata_path: __field0, + path: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option> = + _serde::export::None; + let mut __field1: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "___figment_relative_metadata_path", + ), + ); + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::>( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "___figment_relative_path", + ), + ); + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => match _serde::private::de::missing_field( + "___figment_relative_metadata_path", + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => match _serde::private::de::missing_field( + "___figment_relative_path", + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(RelativePathBuf { + metadata_path: __field0, + path: __field1, + }) + } + } + const FIELDS: &'static [&'static str] = &[ + "___figment_relative_metadata_path", + "___figment_relative_path", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "___figment_relative_path_buf", + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::, + lifetime: _serde::export::PhantomData, + }, + ) + } + } + }; + + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _: () = { + #[allow(rust_2018_idioms, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for RelativePathBuf { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_struct( + __serializer, + "___figment_relative_path_buf", + false as usize + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "___figment_relative_metadata_path", + &self.metadata_path, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "___figment_relative_path", + &self.path, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _: () = { + #[allow(rust_2018_idioms, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Either + where + A: _serde::Serialize, + B: _serde::Serialize, + { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Either::Left(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Either", + 0u32, + "Left", + __field0, + ) + } + Either::Right(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Either", + 1u32, + "Right", + __field0, + ) + } + } + } + } + }; + + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _: () = { + #[allow(rust_2018_idioms, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T> _serde::Deserialize<'de> for Tagged + where + T: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "___figment_tagged_tag" => _serde::export::Ok(__Field::__field0), + "___figment_tagged_value" => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"___figment_tagged_tag" => _serde::export::Ok(__Field::__field0), + b"___figment_tagged_value" => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + type Value = Tagged; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct Tagged") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::( + &mut __seq, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct Tagged with 2 elements", + )); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Tagged with 2 elements", + ), + ); + } + }; + _serde::export::Ok(Tagged { + tag: __field0, + value: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = _serde::export::None; + let mut __field1: _serde::export::Option = _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "___figment_tagged_tag", + ), + ); + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "___figment_tagged_value", + ), + ); + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => match _serde::private::de::missing_field( + "___figment_tagged_tag", + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => match _serde::private::de::missing_field( + "___figment_tagged_value", + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Tagged { + tag: __field0, + value: __field1, + }) + } + } + const FIELDS: &'static [&'static str] = + &["___figment_tagged_tag", "___figment_tagged_value"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "___figment_tagged_item", + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } + }; + + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _: () = { + #[allow(rust_2018_idioms, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Tagged + where + T: _serde::Serialize, + { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_struct( + __serializer, + "___figment_tagged_item", + false as usize + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "___figment_tagged_tag", + &self.tag, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "___figment_tagged_value", + &self.value, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; +} + #[cfg(test)] mod tests { use crate::Figment; diff --git a/src/value/mod.rs b/src/value/mod.rs index 2a2859d..6738c8a 100644 --- a/src/value/mod.rs +++ b/src/value/mod.rs @@ -7,8 +7,6 @@ mod parse; mod de; mod tag; -#[cfg(feature = "magic")] -#[cfg_attr(nightly, doc(cfg(feature = "magic")))] pub mod magic; pub(crate) use {self::ser::*, self::de::*}; diff --git a/src/value/tag.rs b/src/value/tag.rs index 5a68a68..6514893 100644 --- a/src/value/tag.rs +++ b/src/value/tag.rs @@ -75,8 +75,8 @@ impl Tag { self.0 == Tag::Default.0 } - /// Returns the profile `self` refers to if it either `Profile::Default` or - /// `Profile::Custom`; otherwise returns `None`. + /// Returns the profile `self` refers to if it is either `Profile::Default` + /// or `Profile::Custom`; otherwise returns `None`. /// /// # Example ///