feat: add support for types from ascii crate (#255)

* Add support for types from ascii ccrate

* review

* review

* schema tests

* wip

* wip

* wip

* Update .github/test.sh

Co-authored-by: dj8yf0μl <26653921+dj8yfo@users.noreply.github.com>

* fix

* no_std

* fix

* unused

* test:  add missing assert

* chore: improve impl/test modularity

---------

Co-authored-by: dj8yf0μl <26653921+dj8yfo@users.noreply.github.com>
Co-authored-by: dj8yf0μl <feepdake27@gmail.com>

.github/test.sh

@@ -5,16 +5,18 @@ export INSTA_UPDATE=no
 pushd borsh
 cargo test --no-run
 cargo test
+cargo test --features unstable__schema,ascii --test test_ascii_strings
 cargo test --features derive
 cargo test --features unstable__schema
 cargo test --test test_rc --features rc
 cargo test --test test_hash_map --test test_btree_map --features de_strict_order
 
 cargo test --no-default-features
+cargo test --no-default-features --features unstable__schema,ascii --test test_ascii_strings
 cargo test --no-default-features --features derive
 cargo test --no-default-features --features unstable__schema
 cargo test --no-default-features --test test_rc --features rc
 cargo test --no-default-features --features hashbrown
 popd
 pushd borsh-derive
-cargo test --features schema
+cargo test --features schema

borsh/Cargo.toml

@@ -27,10 +27,11 @@ required-features = ["std", "unstable__schema"]
 cfg_aliases = "0.1.0"
 
 [dependencies]
+ascii = { version = "1.1", optional = true }
 borsh-derive = { path = "../borsh-derive", version = "~1.1.2", optional = true }
 
 # hashbrown can be used in no-std context.
-# NOTE: There is no reason to restrict use of older versions, but we don't want to get 
+# NOTE: There is no reason to restrict use of older versions, but we don't want to get
 # sudden breaking changes with an open range of versions, so we limit the range by not yet released 0.15.0 version:
 hashbrown = { version = ">=0.11,<0.15.0", optional = true }
 bytes = { version = "1", optional = true }

borsh/src/de/mod.rs

@@ -370,6 +370,35 @@ impl BorshDeserialize for String {
     }
 }
 
+/// Module is available if borsh is built with `features = ["ascii"]`.
+#[cfg(feature = "ascii")]
+pub mod ascii {
+    //!
+    //! Module defines [BorshDeserialize] implementation for
+    //! some types from [ascii](::ascii) crate.
+    use crate::BorshDeserialize;
+    use crate::__private::maybestd::{string::ToString, vec::Vec};
+    use crate::io::{Error, ErrorKind, Read, Result};
+
+    impl BorshDeserialize for ascii::AsciiString {
+        #[inline]
+        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+            let bytes = Vec::<u8>::deserialize_reader(reader)?;
+            ascii::AsciiString::from_ascii(bytes)
+                .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))
+        }
+    }
+
+    impl BorshDeserialize for ascii::AsciiChar {
+        #[inline]
+        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+            let byte = u8::deserialize_reader(reader)?;
+            ascii::AsciiChar::from_ascii(byte)
+                .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))
+        }
+    }
+}
+
 impl<T> BorshDeserialize for Vec<T>
 where
     T: BorshDeserialize,

borsh/src/lib.rs

@@ -44,6 +44,9 @@
 * **bson** -
   Gates implementation of [BorshSerialize] and [BorshDeserialize]
   for [ObjectId](bson::oid::ObjectId).
+* **ascii** -
+  Gates implementation of [BorshSerialize], [BorshDeserialize], [BorshSchema] for
+  types from [ascii](https://docs.rs/ascii/1.1.0/ascii/) crate.
 * **de_strict_order** -
   Enables check that keys, parsed during deserialization of
   [HashMap](std::collections::HashMap)/[HashSet](std::collections::HashSet) and

borsh/src/schema.rs

@@ -384,6 +384,7 @@ impl BorshSchema for String {
         str::declaration()
     }
 }
+
 impl BorshSchema for str {
     #[inline]
     fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {
@@ -401,6 +402,57 @@ impl BorshSchema for str {
     }
 }
 
+/// Module is available if borsh is built with `features = ["ascii"]`.
+#[cfg(feature = "ascii")]
+pub mod ascii {
+    //!
+    //! Module defines [BorshSchema] implementation for
+    //! some types from [ascii](::ascii) crate.
+    use crate::BorshSchema;
+
+    use super::{add_definition, Declaration, Definition};
+    use crate::__private::maybestd::collections::BTreeMap;
+
+    impl BorshSchema for ascii::AsciiString {
+        #[inline]
+        fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {
+            ascii::AsciiStr::add_definitions_recursively(definitions);
+        }
+        #[inline]
+        fn declaration() -> Declaration {
+            ascii::AsciiStr::declaration()
+        }
+    }
+
+    impl BorshSchema for ascii::AsciiStr {
+        #[inline]
+        fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {
+            let definition = Definition::Sequence {
+                length_width: Definition::DEFAULT_LENGTH_WIDTH,
+                length_range: Definition::DEFAULT_LENGTH_RANGE,
+                elements: ascii::AsciiChar::declaration(),
+            };
+            add_definition(Self::declaration(), definition, definitions);
+            ascii::AsciiChar::add_definitions_recursively(definitions);
+        }
+        #[inline]
+        fn declaration() -> Declaration {
+            "AsciiString".into()
+        }
+    }
+
+    impl BorshSchema for ascii::AsciiChar {
+        #[inline]
+        fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {
+            add_definition(Self::declaration(), Definition::Primitive(1), definitions);
+        }
+        #[inline]
+        fn declaration() -> Declaration {
+            "AsciiChar".into()
+        }
+    }
+}
+
 impl BorshSchema for core::ops::RangeFull {
     #[inline]
     fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {

borsh/src/ser/mod.rs

@@ -210,6 +210,37 @@ impl BorshSerialize for String {
     }
 }
 
+/// Module is available if borsh is built with `features = ["ascii"]`.
+#[cfg(feature = "ascii")]
+pub mod ascii {
+    //!
+    //! Module defines [BorshSerialize] implementation for
+    //! some types from [ascii](::ascii) crate.
+    use super::BorshSerialize;
+    use crate::io::{Result, Write};
+
+    impl BorshSerialize for ascii::AsciiChar {
+        #[inline]
+        fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+            self.as_byte().serialize(writer)
+        }
+    }
+
+    impl BorshSerialize for ascii::AsciiStr {
+        #[inline]
+        fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+            self.as_bytes().serialize(writer)
+        }
+    }
+
+    impl BorshSerialize for ascii::AsciiString {
+        #[inline]
+        fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+            self.as_bytes().serialize(writer)
+        }
+    }
+}
+
 /// Helper method that is used to serialize a slice of data (without the length marker).
 #[inline]
 fn serialize_slice<T: BorshSerialize, W: Write>(data: &[T], writer: &mut W) -> Result<()> {

borsh/tests/snapshots/test_ascii_strings__a.snap

@@ -0,0 +1,11 @@
+---
+source: borsh/tests/test_ascii_strings.rs
+expression: buf
+---
+[
+    1,
+    0,
+    0,
+    0,
+    97,
+]

borsh/tests/snapshots/test_ascii_strings__empty_string.snap

@@ -0,0 +1,10 @@
+---
+source: borsh/tests/test_ascii_strings.rs
+expression: buf
+---
+[
+    0,
+    0,
+    0,
+    0,
+]