All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog and this project adheres to Semantic Versioning.
- Implement (De)Serialization for Pinned Smart Pointers by @Astralchroma (#733)
- Implement
JsonSchemaAs
forPickFirst
by @swlynch99 (#721)
- Bump
base64
dependency to v0.22 (#724) - Update dev dependencies
serde_conv
regressed and triggeredclippy::ptr_arg
and add test to prevent future problems. (#731)
- Implement
JsonSchemaAs
forEnumMap
by @swlynch99 (#697) - Implement
JsonSchemaAs
forIfIsHumanReadable
by @swlynch99 (#717) - Implement
JsonSchemaAs
forKeyValueMap
by @swlynch99 (#713) - Implement
JsonSchemaAs
forOneOrMany
by @swlynch99 (#719)
- Detect conflicting
schema_with
attributes on fields withschemars
annotations by @swlynch99 (#715) This extends the existing avoidance mechanism to a new variant fixing #712.
- Eliminate dependency on serde's "derive" feature by @dtolnay (#694)
This allows parallel compilation of
serde
andserde_derive
which can speed up the wallclock time. It requires that downstream crates do not use the "derive" feature either.
- Add
IfIsHumanReadable
for conditional implementation by @irriden (#690) Used to specify different transformations for text-based and binary formats. - Add more
JsonSchemaAs
impls for allDuration*
andTimestamp*
adaptors by @swlynch99 (#685)
- Bump MSRV to 1.65, since that is required for the
regex
dependency.
- The
serde_as
macro now better detects existingschemars
attributes on fields and incorporates them (#682) This avoids errors on existing#[schemars(with = ...)]
annotations.
- Support for
schemars
integration added by @swlynch99 (#666) The support uses a newSchema
top-level item which implementsJsonSchema
Theserde_as
macro can now detectschemars
usage and emits matching annotations for all fields withserde_as
attribute. Many types of this crate come already with support for theschemars
, but support is not complete and will be extended over time.
-
Lower minimum required serde version to 1.0.152 (#653) Thanks to @banool for submitting the PR.
This allows people that have a problem with 1.0.153 to still use
serde_with
. -
Add support for
core::ops::Bound
(#655) Thanks to @qsantos for submitting the PR.
-
Support the
hashbrown
typeHashMap
andHashSet
(#636, #637) Thanks to @OliverNChalk for raising the issue and submitting a PR.This extends the existing support for
HashMap
s andHashSet
s to thehashbrown
crate v0.14. The same conversions as for thestd
andindexmap
types are available, like general support for#[serde_as]
and converting it to/from sequences or maps.
-
Generalize some trait bounds for
DeserializeAs
implementationsWhile working on #637, it came to light that some macros for generating
DeserializeAs
implementations were not as generic as they could. This means they didn't work with custom hasher types, but only the default hashers. This has now been fixed and custom hashers should work better, as long as they implementBuildHasher + Default
. -
(internal) Change how features are documented (#639)
This change moves the feature documentation into
Cargo.toml
in a format that can be read by lib.rs. It will improve the generated features documentation there. The page with all features remains in the guide but is now generated from theCargo.toml
information.
- Add optional support for indexmap v2 (#621)
Support for v1 is already available using the
indexmap_1
feature. This adds identical support for v2 of indexmap using theindexmap_2
feature.
- Bump MSRV to 1.64, since that is required for the indexmap v2 dependency.
- Prevent panics when deserializing
i64::MIN
usingTimestampSeconds<i64>
(#632, #633) Thanks to @hollmmax for reporting and fixing the issue.
-
Add
FromIntoRef
andTryFromIntoRef
(#618) Thanks to @oblique for submitting the PR.The new types are similar to the existing
FromInto
andTryFromInto
types. They behave different during serialization, allowing the removal of theClone
bound on theirSerializeAs
trait implementation
- Improve documentation about cfg-gating
serde_as
(#607) - Bump MSRV to 1.61 because that is required by the crate
cfg_eval
.
This breaking release should not impact most users. It only affects custom character sets used for base64 of which there are no instances of on GitHub.
-
Upgrade base64 to v0.21 (#543) Thanks to @jeff-hiner for submitting the PR.
Remove support for custom character sets. This is technically a breaking change. A code search on GitHub revealed no instances of anyone using that, and
serde_with
ships with many predefined character sets. The removal means that future base64 upgrade will no longer be breaking changes.
- Update
syn
to v2 anddarling
to v0.20 (#578) Update proc-macro dependencies. This change should have no impact on users, but now uses the same dependency asserde_derive
.
-
Improve the error message when deserializing
OneOrMany
orPickFirst
fails. It now includes the original error message for each of the individual variants. This is possible by dropping untagged enums as the internal implementations, since they will likely never support this, as these old PRs show serde#2376 and serde#1544.The new errors look like:
OneOrMany could not deserialize any variant: One: invalid type: map, expected u32 Many: invalid type: map, expected a sequence
PickFirst could not deserialize any variant: First: invalid type: string "Abc", expected u32 Second: invalid digit found in string
- Specify the correct minimum serde version as dependency. (#588) Thanks to @nox for submitting a PR.
-
Undo the changes to the trait bound for
Seq
. (#570, #571) The new implementation caused issues with serialization formats that require the sequence length beforehand. It also caused problems such as that certain attributes which worked before no longer worked, due to a mismatching number of references.Thanks to @stefunctional for reporting and for @stephaneyfx for providing a test case.
-
Add
serde_as
compatible versions for the existing duplicate key and value handling. (#534) The new typesMapPreventDuplicates
,MapFirstKeyWins
,SetPreventDuplicates
, andSetLastValueWins
can replace the existing modulesmaps_duplicate_key_is_error
,maps_first_key_wins
,sets_duplicate_value_is_error
, andsets_last_value_wins
. -
Added a new
KeyValueMap
type using the map key as a struct field. (#341) This conversion is useful for maps, where an ID value is the map key, but the ID should become part of a single struct. The conversion allows this, by using a special field named$key$
.This conversion is possible for structs and maps, using the
$key$
field. Tuples, tuple structs, and sequences are supported by turning the first value into the map key.Each of the
SimpleStruct
s// Somewhere there is a collection: // #[serde_as(as = "KeyValueMap<_>")] // Vec<SimpleStruct>, #[derive(Serialize, Deserialize)] struct SimpleStruct { b: bool, // The field named `$key$` will become the map key #[serde(rename = "$key$")] id: String, i: i32, }
will turn into a JSON snippet like this.
"id-0000": { "b": false, "i": 123 },
- Relax the trait bounds of
Seq
to allow for more custom types. (#565) This extends the support beyond tuples.
EnumMap
passes thehuman_readable
status of theSerializer
to more places.- Support
alloc
on targets withouttarget_has_atomic = "ptr"
. (#560) Thanks to @vembacher for reporting and fixing the issue.
-
Add new
Map
andSeq
types for converting between maps and tuple lists. (#527)The behavior is not new, but already present using
BTreeMap
/HashMap
orVec
. However, the new typesMap
andSeq
are also available onno_std
, even without thealloc
feature.
- Pin the
serde_with_macros
dependency to the same version as the main crate. This simplifies publishing and ensures a compatible version is always picked.
serde_with::apply
had an issue matching types when invisible token groups where in use (#538) The token groups can stem from macro_rules expansion, but should be treated mostly transparent. The old code required a group to match a group, while now groups are silently removed when checking for type patterns.
-
Add new
apply
attribute to simplify repetitive attributes over many fields. Multiple rules and multiple attributes can be provided each.#[serde_with::apply( Option => #[serde(default)] #[serde(skip_serializing_if = "Option::is_none")], Option<bool> => #[serde(rename = "bool")], )] #[derive(serde::Serialize)] struct Data { a: Option<String>, b: Option<u64>, c: Option<String>, d: Option<bool>, }
The
apply
attribute will expand into this, applying the attributs to the matching fields:#[derive(serde::Serialize)] struct Data { #[serde(default)] #[serde(skip_serializing_if = "Option::is_none")] a: Option<String>, #[serde(default)] #[serde(skip_serializing_if = "Option::is_none")] b: Option<u64>, #[serde(default)] #[serde(skip_serializing_if = "Option::is_none")] c: Option<String>, #[serde(default)] #[serde(skip_serializing_if = "Option::is_none")] #[serde(rename = "bool")] d: Option<bool>, }
The attribute supports field matching using many rules, such as
_
to apply to all fields and partial generics likeOption
to match anyOption
be itOption<String>
,Option<bool>
, orOption<T>
.
-
The derive macros
SerializeDisplay
andDeserializeFromStr
now take better care not to use conflicting names for generic values. (#526) All used generics now start with__
to make conflicts with manually written code unlikely.Thanks to @Elrendio for submitting a PR fixing the issue.
time
added support for the well-knownIso8601
format. This extends the existing support ofRfc2822
andRfc3339
.
- Warn if
serde_as
is used on an enum variant. Attributes on enum variants were never supported. But#[serde(with = "...")]
can be added on variants, such that some confusion can occur when migration (#499).
A cargo bug (cargo#10801) means that upgrading from v1 to v2 may add unnecessary crates to the Cargo.lock
file.
A diff of the lock-file makes it seem that serde_with
depends on new crates, even though these crates are unused and will not get compiled or linked.
However, tools consuming Cargo.lock
or cargo metadata
might give wrong results.
-
Make
JsonString<T>
smarter by allowing nestingserde_as
definitions. This allows applying custom serialization logic before the value gets converted into a JSON string.// Rust #[serde_as(as = "JsonString<Vec<(JsonString, _)>>")] value: BTreeMap<[u8; 2], u32>, // JSON {"value":"[[\"[1,2]\",3],[\"[4,5]\",6]]"}
-
Make
#[serde_as]
behave more intuitive onOption<T>
fields.The
#[serde_as]
macro now detects if a#[serde_as(as = "Option<S>")]
is used on a field of typeOption<T>
and applies#[serde(default)]
to the field. This restores the ability to deserialize with missing fields and fixes a common annoyance (#183, #185, #311, #417). This is a breaking change, since now deserialization will pass where it did not before and this might be undesired.The
Option
field and transformation are detected by directly matching on the type name. These variants are detected asOption
.Option
std::option::Option
, with or without leading::
core::option::Option
, with or without leading::
If an existing
default
attribute is detected, the attribute is not applied again. This behavior can be suppressed by using#[serde_as(no_default)]
or#[serde_as(as = "Option<S>", no_default)]
. -
NoneAsEmptyString
andstring_empty_as_none
use a different serialization bound (#388).Both types used
AsRef<str>
as the serialization bound. This is limiting for non-string types likeOption<i32>
. The deserialization often was already more flexible, due to theFromStr
bound.For most std types this should have little impact, as the types implementing
AsRef<str>
mostly implementDisplay
, too, such asString
,Cow<str>
, orRc<str>
. -
Bump MSRV to 1.60. This is required for the optional dependency feature syntax in cargo.
-
Remove old module-based conversions.
The newer
serde_as
based conversions are preferred.-
seq_display_fromstr
: UseDisplayFromStr
in combination with your container type:#[serde_as(as = "BTreeSet<DisplayFromStr>")] addresses: BTreeSet<Ipv4Addr>, #[serde_as(as = "Vec<DisplayFromStr>")] bools: Vec<bool>,
-
tuple_list_as_map
: UseBTreeMap
on aVec
of tuples:#[serde_as(as = "BTreeMap<_, _>")] // HashMap will also work s: Vec<(i32, String)>,
-
map_as_tuple_list
can be replaced with#[serde_as(as = "Vec<(_, _)>")]
. -
display_fromstr
can be replaced with#[serde_as(as = "DisplayFromStr")]
. -
bytes_or_string
can be replaced with#[serde_as(as = "BytesOrString")]
. -
default_on_error
can be replaced with#[serde_as(as = "DefaultOnError")]
. -
default_on_null
can be replaced with#[serde_as(as = "DefaultOnNull")]
. -
string_empty_as_none
can be replaced with#[serde_as(as = "NoneAsEmptyString")]
. -
StringWithSeparator
can now only be used inserde_as
. The definition of theSeparator
trait and its implementations have been moved to theformats
module. -
json::nested
can be replaced with#[serde_as(as = "json::JsonString")]
.
-
-
Remove previously deprecated modules.
sets_first_value_wins
btreemap_as_tuple_list
andhashmap_as_tuple_list
can be replaced with#[serde_as(as = "Vec<(_, _)>")]
.
A cargo bug (cargo#10801) means that upgrading from v1 to v2 may add unnecessary crates to the Cargo.lock
file.
A diff of the lock-file makes it seem that serde_with
depends on new crates, even though these crates are unused and will not get compiled or linked.
-
Make
#[serde_as]
behave more intuitive onOption<T>
fields.The
#[serde_as]
macro now detects if a#[serde_as(as = "Option<S>")]
is used on a field of typeOption<T>
and applies#[serde(default)]
to the field. This restores the ability to deserialize with missing fields and fixes a common annoyance (#183, #185, #311, #417). This is a breaking change, since now deserialization will pass where it did not before and this might be undesired.The
Option
field and transformation are detected by directly matching on the type name. These variants are detected asOption
.Option
std::option::Option
, with or without leading::
core::option::Option
, with or without leading::
If an existing
default
attribute is detected, the attribute is not applied again. This behavior can be suppressed by using#[serde_as(no_default)]
or#[serde_as(as = "Option<S>", no_default)]
. -
NoneAsEmptyString
andstring_empty_as_none
use a different serialization bound (#388).Both types used
AsRef<str>
as the serialization bound. This is limiting for non-string types likeOption<i32>
. The deserialization often was already more flexible, due to theFromStr
bound.For most std types this should have little impact, as the types implementing
AsRef<str>
mostly implementDisplay
, too, such asString
,Cow<str>
, orRc<str>
. -
Bump MSRV to 1.60. This is required for the optional dependency feature syntax in cargo.
-
Remove old module-based conversions.
The newer
serde_as
based conversions are preferred.-
seq_display_fromstr
: UseDisplayFromStr
in combination with your container type:#[serde_as(as = "BTreeSet<DisplayFromStr>")] addresses: BTreeSet<Ipv4Addr>, #[serde_as(as = "Vec<DisplayFromStr>")] bools: Vec<bool>,
-
tuple_list_as_map
: UseBTreeMap
on aVec
of tuples:#[serde_as(as = "BTreeMap<_, _>")] // HashMap will also work s: Vec<(i32, String)>,
-
map_as_tuple_list
can be replaced with#[serde_as(as = "Vec<(_, _)>")]
. -
display_fromstr
can be replaced with#[serde_as(as = "DisplayFromStr")]
. -
bytes_or_string
can be replaced with#[serde_as(as = "BytesOrString")]
. -
default_on_error
can be replaced with#[serde_as(as = "DefaultOnError")]
. -
default_on_null
can be replaced with#[serde_as(as = "DefaultOnNull")]
. -
string_empty_as_none
can be replaced with#[serde_as(as = "NoneAsEmptyString")]
. -
StringWithSeparator
can now only be used inserde_as
. The definition of theSeparator
trait and its implementations have been moved to theformats
module. -
json::nested
can be replaced with#[serde_as(as = "json::JsonString")]
.
-
-
Remove previously deprecated modules.
sets_first_value_wins
btreemap_as_tuple_list
andhashmap_as_tuple_list
can be replaced with#[serde_as(as = "Vec<(_, _)>")]
.
-
Add support for
time
crate v0.3 #450time::Duration
can now be serialized with theDurationSeconds
and related converters.// Rust #[serde_as(as = "serde_with::DurationSeconds<u64>")] value: Duration, // JSON "value": 86400,
time::OffsetDateTime
andtime::PrimitiveDateTime
can now be serialized with theTimestampSeconds
and related converters.// Rust #[serde_as(as = "serde_with::TimestampMicroSecondsWithFrac<String>")] value: time::PrimitiveDateTime, // JSON "value": "1000000",
time::OffsetDateTime
can be serialized in string format in different well-known formats. Two formats are supported,time::format_description::well_known::Rfc2822
andtime::format_description::well_known::Rfc3339
.// Rust #[serde_as(as = "time::format_description::well_known::Rfc2822")] rfc_2822: OffsetDateTime, #[serde_as(as = "Vec<time::format_description::well_known::Rfc3339>")] rfc_3339: Vec<OffsetDateTime>, // JSON "rfc_2822": "Fri, 21 Nov 1997 09:55:06 -0600", "rfc_3339": ["1997-11-21T09:55:06-06:00"],
-
Deserialize
bool
from integers #456 462Deserialize an integer and convert it into a
bool
.BoolFromInt<Strict>
(default) deserializes 0 tofalse
and1
totrue
, other numbers are errors.BoolFromInt<Flexible>
deserializes any non-zero astrue
. Serialization only emits 0/1.// Rust #[serde_as(as = "BoolFromInt")] // BoolFromInt<Strict> b: bool, // JSON "b": 1,
- Bump MSRV to 1.53, since the new dependency
time
requires that version.
- Make the documentation clearer by stating that the
#[serde_as]
and#[skip_serializing_none]
attributes must always be places before#[derive]
.
-
Added support for
indexmap::IndexMap
andindexmap::IndexSet
types. #431, #436Both types are now compatible with these functions:
maps_duplicate_key_is_error
,maps_first_key_wins
,sets_duplicate_value_is_error
,sets_last_value_wins
.serde_as
integration is provided by implementing bothSerializeAs
andDeserializeAs
for both types.IndexMap
s can also be serialized as a list of types via theserde_as(as = "Vec<(_, _)>")
annotation.All implementations are gated behind the
indexmap
feature.Thanks to @jgrund for providing parts of the implementation.
- Depend on a newer
serde_with_macros
version to pull in some fixes.- Account for generics when deriving implementations with
SerializeDisplay
andDeserializeFromStr
#413 - Provide better error messages when parsing types fails #423
- Account for generics when deriving implementations with
-
Deserialize a
Vec
and skip all elements failing to deserialize #383VecSkipError
acts like aVec
, but elements which fail to deserialize, like the"Yellow"
are ignored.#[derive(serde::Deserialize)] enum Color { Red, Green, Blue, } // JSON "colors": ["Blue", "Yellow", "Green"], // Rust #[serde_as(as = "VecSkipError<_>")] colors: Vec<Color>, // => vec![Blue, Green]
Thanks to @hdhoang for creating the PR.
-
Transform between maps and
Vec<Enum>
#375The new
EnumMap
type convertsVec
of enums into a single map. The key is the enum variant name, and the value is the variant value.// Rust VecEnumValues(vec![ EnumValue::Int(123), EnumValue::String("Foo".to_string()), EnumValue::Unit, EnumValue::Tuple(1, "Bar".to_string()), EnumValue::Struct { a: 666, b: "Baz".to_string(), }, ] // JSON { "Int": 123, "String": "Foo", "Unit": null, "Tuple": [ 1, "Bar", ], "Struct": { "a": 666, "b": "Baz", } }
- The
Timestamp*Seconds
andTimestamp*SecondsWithFrac
types can now be used withchrono::NaiveDateTime
. #389
-
Serialize bytes as base64 encoded strings.
The character set and padding behavior can be configured.// Rust #[serde_as(as = "serde_with::base64::Base64")] value: Vec<u8>, #[serde_as(as = "Base64<Bcrypt, Unpadded>")] bcrypt_unpadded: Vec<u8>, // JSON "value": "SGVsbG8gV29ybGQ=", "bcrypt_unpadded": "QETqZE6eT07wZEO",
-
The minimal supported Rust version (MSRV) is now specified in the
Cargo.toml
via therust-version
field. The field is supported in Rust 1.56 and has no effect on versions before.More details: https://doc.rust-lang.org/nightly/cargo/reference/manifest.html#the-rust-version-field
- Fixed RUSTSEC-2020-0071 in the
time
v0.1 dependency, but changing the feature flags of thechrono
dependency. This should not change anything. Crates requiring theoldtime
feature ofchrono
can enable it separately. - Allow
HashSet
s with custom hashers to be deserialized when used in combination withserde_as
. #408
-
Add
BorrowCow
which instructs serde to borrow data during deserialization ofCow<'_, str>
,Cow<'_, [u8]>
, orCow<'_, [u8; N]>
. (#347) The implementation is for serde#2072 and serde#2016, about#[serde(borrow)]
not working forOption<Cow<'a, str>>
.#[serde_as] #[derive(Deserialize, Serialize)] struct Data<'a> { #[serde_as(as = "Option<[BorrowCow; 1]>")] nested: Option<[Cow<'a, str>; 1]>, }
The
#[serde(borrow)]
annotation is automatically added by the#[serde_as]
attribute.
- Bump MSRV to 1.46, since the dev-dependency
bitflags
requires that version now. flattened_maybe!
no longer requires theserde_with
crate to be available with a specific name. This allows renaming the crate or usingflattened_maybe!
through a re-export without any complications.
-
with_prefix!
now supports an optional visibility modifier. (#327, #328)
If not specifiedpub(self)
is assumed.with_prefix!(prefix_active "active_"); // => mod {...} with_prefix!(pub prefix_active "active_"); // => pub mod {...} with_prefix!(pub(crate) prefix_active "active_"); // => pub(crate) mod {...} with_prefix!(pub(in other_mod) prefix_active "active_"); // => pub(in other_mod) mod {...}
Thanks to @elpiel for raising and fixing the issue.
-
The
Bytes
type now supports borrowed and Cow arrays of fixed size (requires Rust 1.51+)#[serde_as(as = "Bytes")] #[serde(borrow)] borrowed_array: &'a [u8; 15], #[serde_as(as = "Bytes")] #[serde(borrow)] cow_array: Cow<'a, [u8; 15]>,
Note: For borrowed arrays, the used Deserializer needs to support Serde's 0-copy deserialization.
- Suppress clippy warnings, which can occur while using
serde_conv
(#320) Thanks to @mkroening for reporting and fixing the issue.
NoneAsEmptyString
: Deserialize usingFromStr
instead of usingfor<'a> From<&'a str>
(#316) This will not change any behavior when applied to a field of typeOption<String>
as used in the documentation. Thanks to @mkroening for finding and fixing the issue.
-
Added
FromInto
andTryFromInto
adapters, which enable serialization by converting into a proxy type.// Rust #[serde_as(as = "FromInto<(u8, u8, u8)>")] value: Rgb, impl From<(u8, u8, u8)> for Rgb { ... } impl From<Rgb> for (u8, u8, u8) { ... } // JSON "value": [128, 64, 32],
-
New
serde_conv!
macro to create conversion types with reduced boilerplate. The generated types can be used with#[serde_as]
or serde's with-attribute.serde_with::serde_conv!( RgbAsArray, Rgb, |rgb: &Rgb| [rgb.red, rgb.green, rgb.blue], |value: [u8; 3]| -> Result<_, std::convert::Infallible> { Ok(Rgb { red: value[0], green: value[1], blue: value[2], }) } );
- The
hex::Hex
type also works for u8-arrays on Rust 1.48. Thanks to @TheAlgorythm for raising and fixing the issue.
-
Added
PickFirst
adapter forserde_as
. #291 It allows deserializing from multiple different forms. Deserializing a number from either a number or string can be implemented like:#[serde_as(as = "PickFirst<(_, DisplayFromStr)>")] value: u32,
-
Implement
SerializeAs
/DeserializeAs
for more wrapper types. #288, #293 This now supports:Arc
,sync::Weak
Rc
,rc::Weak
Cell
,RefCell
Mutex
,RwLock
Result
- Add a new
serde_with::rust::map_as_tuple_list
module as a replacement forserde_with::rust::btreemap_as_tuple_list
andserde_with::rust::hashmap_as_tuple_list
. The new module usesIntoIterator
andFromIterator
as trait bound making it usable in more situations. The old names continue to exist but are marked as deprecated.
- Deprecated the module names
serde_with::rust::btreemap_as_tuple_list
andserde_with::rust::hashmap_as_tuple_list
. You can useserde_with::rust::map_as_tuple_list
as a replacement.
- Implement
Timestamp*Seconds
andDuration*Seconds
also for chrono types. This closes #194. This was incompletely implemented in #199.
-
Add support for arrays of arbitrary size. (#272) This feature requires Rust 1.51+.
// Rust #[serde_as(as = "[[_; 64]; 33]")] value: [[u8; 64]; 33], // JSON "value": [[0,0,0,0,0,...], [0,0,0,...], ...],
Mapping of arrays was available before, but limited to arrays of length 32. All conversion methods are available for the array elements.
This is similar to the existing
serde-big-array
crate with three important improvements:- Support for the
serde_as
annotation. - Supports non-copy elements (see serde-big-array#6).
- Supports arbitrary nestings of arrays (see serde-big-array#7).
- Support for the
-
Arrays with tuple elements can now be deserialized from a map. (#272) This feature requires Rust 1.51+.
// Rust #[serde_as(as = "BTreeMap<_, _>")] value: [(String, u16); 3], // JSON "value": { "a": 1, "b": 2, "c": 3 },
-
The
Bytes
type is heavily inspired byserde_bytes
and ports it to theserde_as
system. (#277)#[serde_as(as = "Bytes")] value: Vec<u8>,
Compared to
serde_bytes
these improvements are available- Integration with the
serde_as
annotation (see serde-bytes#14). - Implementation for arrays of arbitrary size (Rust 1.51+) (see serde-bytes#26).
- Integration with the
-
The
OneOrMany
type allows deserializing aVec
from either a single element or a sequence. (#281)#[serde_as(as = "OneOrMany<_>")] cities: Vec<String>,
This allows deserializing from either
cities: "Berlin"
orcities: ["Berlin", "Paris"]
. The serialization can be configured to always emit a list withPreferMany
or emit a single element withPreferOne
.
- Fix compiling when having a struct field without the
serde_as
annotation by updatingserde_with_macros
. This broke in 1.4.0 ofserde_with_macros
. #267
- Bump macro crate dependency (
serde_with_macros
) to 1.4.0 to pull in those improvements.
-
New function
serde_with::rust::deserialize_ignore_any
. This function allows deserializing any data and returns the default value of the type. This can be used in conjunction with#[serde(other)]
to allow deserialization of unknown data carrying enum variants.Thanks to @lovasoa for suggesting and implementing it.
- Add new types similar to
DurationSeconds
andTimestampSeconds
but for base units of milliseconds, microseconds, and nanoseconds. The*WithFrac
variants also exist. - Add
SerializeAs
implementation for references.
- Release
Sized
trait bound fromAs
,Same
,SerializeAs
, andSerializeAsWrap
. Only theserialize
part is relaxed.
-
Add
DefaultOnNull
as the equivalent forrust::default_on_null
but for theserde_as
system. -
Support specifying a path to the
serde_with
crate for theserde_as
and derive macros. This is useful when using crate renaming in Cargo.toml or while re-exporting the macros.Many thanks to @tobz1000 for raising the issue and contributing fixes.
- Bump minimum supported rust version to 1.40.0
- Depend on serde with the
derive
feature enabled. Thederive
feature is required to deserialize untagged enums which are used in theDefaultOnError
helpers. This fixes compilation ofserde_with
in scenarios where no other crate enables thederive
feature.
-
The largest addition to this release is the addition of the
serde_as
de/serialization scheme. Its goal is to be a more flexible replacement to serde'swith
annotation, by being more composable than before. No longer is it a problem to add a custom de/serialization adapter is the type is within anOption
or aVec
.Thanks to
@markazmierczak
for the design of the trait without whom this wouldn't be possible.More details about this new scheme can be found in the also new user guide
-
This release also features a detailed user guide. The guide focuses more on how to use this crate by providing examples. For example, it includes a section about the available feature flags of this crate and how you can migrate to the shiny new
serde_as
scheme. -
The crate now features de/serialization adaptors for the std and
chrono
Duration
types. #56 #104 -
Add a
hex
module, which allows formatting bytes (i.e.Vec<u8>
) as a hexadecimal string. The formatting supports different arguments how the formatting is happening. -
Add two derive macros,
SerializeDisplay
andDeserializeFromStr
, which implement theSerialize
/Deserialize
traits based onDisplay
andFromStr
. This is in addition to the already existing methods likeDisplayFromStr
, which act locally, whereas the derive macros provide the traits expected by the rest of the ecosystem.This is part of
serde_with_macros
v1.2.0. -
Added some
serialize
functions to modules which previously had none. This makes it easier to use the conversion when also derivingSerialize
. The functions simply pass through to the underlyingSerialize
implementation. This affectssets_duplicate_value_is_error
,maps_duplicate_key_is_error
,maps_first_key_wins
,default_on_error
, anddefault_on_null
. -
Added
sets_last_value_wins
as a replacement forsets_first_value_wins
which is deprecated now. The default behavior of serde is to prefer the first value of a set, so the opposite is taking the last value. -
Added
#[serde_as]
compatible conversion methods for serializing durations and timestamps as numbers. The four typesDurationSeconds
,DurationSecondsWithFrac
,TimestampSeconds
,TimestampSecondsWithFrac
provide the serialization conversion with optional sub-second precision. There is support forstd::time::Duration
,chrono::Duration
,std::time::SystemTime
andchrono::DateTime
. Timestamps are serialized as durations since the UNIX epoch. The serialization can be customized. It supports multiple formats, such asi64
,f64
, orString
, and the deserialization can be tweaked if it should be strict or lenient when accepting formats.
- Convert the code to use 2018 edition.
- @peterjoel improved the performance of
with_prefix!
. #101
- The
with_prefix!
macro, to add a string prefixes during serialization, now also works with unit variant enum types. #115 #116 - The
serde_as
macro now supports serde attributes and no longer panic on unrecognized values in the attribute. This is part ofserde_with_macros
v1.2.0.
- Deprecate
sets_first_value_wins
. The default behavior of serde is to take the first value, so this module is not necessary.
-
Add a
hex
module, which allows formatting bytes (i.e.Vec<u8>
) as a hexadecimal string. The formatting supports different arguments how the formatting is happening. -
Add two derive macros,
SerializeDisplay
andDeserializeFromStr
, which implement theSerialize
/Deserialize
traits based onDisplay
andFromStr
. This is in addition to the already existing methods likeDisplayFromStr
, which act locally, whereas the derive macros provide the traits expected by the rest of the ecosystem.This is part of
serde_with_macros
v1.2.0-alpha.3.
- The
serde_as
macro now supports serde attributes and no longer panic on unrecognized values in the attribute. This is part ofserde_with_macros
v1.2.0-alpha.2.
-
The largest addition to this release is the addition of the
serde_as
de/serialization scheme. Its goal is to be a more flexible replacement to serde's with annotation, by being more composable than before. No longer is it a problem to add a custom de/serialization adapter is the type is within anOption
or aVec
.Thanks to
@markazmierczak
for the design of the trait without whom this wouldn't be possible.More details about this new scheme can be found in the also new user guide
-
This release also features a detailed user guide. The guide focuses more on how to use this crate by providing examples. For example, it includes a section about the available feature flags of this crate and how you can migrate to the shiny new
serde_as
scheme. -
The crate now features de/serialization adaptors for the std and
chrono
'sDuration
types. #56 #104
- Convert the code to use 2018 edition.
- @peterjoel improved the performance of
with_prefix!
. #101
- The
with_prefix!
macro, to add a string prefixes during serialization, now also works with unit variant enum types. #115 #116
- Add a helper to deserialize a
Vec<u8>
fromString
(#35) - Add
default_on_error
helper, which turns errors intoDefault
s of the type - Add
default_on_null
helper, which turnsnull
values intoDefault
s of the type
- Bump minimal Rust version to 1.36.0
- Supports Rust Edition 2018
- version-sync depends on smallvec, which requires 1.36
- Improved CI pipeline by running
cargo audit
andtarpaulin
in all configurations now.
- Use
serde_with_macros
with proper dependencies specified.
- Add
skip_serializing_none
attribute, which adds#[serde(skip_serializing_if = "Option::is_none")]
for each Option in a struct. This is helpful for APIs which have many optional fields. The effect of can be negated by addingserialize_always
on those fields, which should always be serialized. Existingskip_serializing_if
will never be modified and those fields keep their behavior.
- Add macro helper to support deserializing values with nested or flattened syntax #38
- Serialize tuple list as map helper
- Bumped minimal Rust version to 1.30.0
- Serialize HashMap/BTreeMap as a list of tuples
- No changes in this release.
- Bumped version number to indicate the stability of the library.
- Helper which deserializes an empty string as
None
and otherwise usesFromStr
andAsRef<str>
.
- De/Serialize sequences by using
Display
andFromStr
implementations on each element. Contributed by @katyo
- Add missing docs and enable deny missing_docs
- Add badges to Cargo.toml and crates.io
- Improve Travis configuration
- Various clippy improvements
unwrap_or_skip
allows to transparently serialize the inner part of aSome(T)
- Add deserialization helper for sets and maps, inspired by comment
- Create an error if duplicate values for a set are detected
- Create an error if duplicate keys for a map are detected
- Implement a "first value wins" strategy for sets/maps. This is different to serde's default, which implements a "last value wins" strategy.
- Double Option pattern to differentiate between missing, unset, or existing value
with_prefix!
macro, which puts a prefix on every struct field
- Add chrono support: Deserialize timestamps from int, float, and string
- Serialization of embedded JSON strings
- De/Serialization using
Display
andFromStr
implementations - String-based collections using
Display
andFromStr
, allows deserializing "#foo,#bar"
- Reserve name on crates.io