Merge pull request #13 from MidasLamb/traits

Add more traits that `String` implements.

Author: MidasLamb

.github/workflows/generic.yml

@@ -75,3 +75,11 @@ jobs:
         with:
           command: clippy
           args: -- -D warnings
+
+  semver-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Check semver
+        uses: obi1kenobi/cargo-semver-checks-action@v2

CHANGELOG.md

@@ -9,6 +9,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- More traits from `String` implemented on `NonEmptyString`
+  - Index
+  - Add
+  - AddAssign
+  - Extend
+  - Write
+  - PartialEq with `str` & `String`
+
 ### Changed
 
 ### Removed

Cargo.toml

@@ -8,6 +8,9 @@ description = "A simple type for non empty Strings, similar to NonZeroUsize and
 repository = "https://github.com/MidasLamb/non-empty-string"
 keywords = ["nonemptystring", "string", "str", "non-empty", "nonempty"]
 
+[package.metadata."docs.rs"]
+all-features = true
+
 [lib]
 name = "non_empty_string"
 

README.md

@@ -23,23 +23,42 @@ assert_eq!(result.unwrap_err(), "".to_owned())
 ```
 
 ## Methods of std::string::String
+
 `NonEmptyString` implements a subset of the functions of `std::string::String`, only the ones which are guaranteed to leave the `NonEmptyString` in a valid state.
 This means i.e. `push()` is implemented, but `pop()` is not.
 
 This allows you to mostly treat it as a String without having to constantly turn it into the inner `String` before you can do any sort of operation on it and then having to reconstruct a `NonEmptyString` afterwards.
 
+If a method is missing that you think upholds the invariant of `NonEmptyString`, don't hesitate to [open an issue].
+
+## Traits
+
+`NonEmptyString` implements quite a few of the traits that `String` implements, where it simply forwards it to the underlying string,
+which allows e.g. indexing with ranges:
+
+```rust
+use non_empty_string::NonEmptyString;
+
+let non_empty = NonEmptyString::new("ABC".to_owned()).unwrap();
+assert_eq!(&non_empty[1..], "BC");
+
+```
+
+If a trait is missing that you think upholds the invariant of `NonEmptyString`, don't hesitate to [open an issue].
 
 ## Serde Support
 
 [serde] support is available behind the `serde` feature flag:
+
 ```toml
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 non-empty-string = { version = "*", features = ["serde"]}
 ```
 
 Afterwards you can use it in a struct:
-```rust
+
+```ignore
 use serde::{Serialize, Deserialize};
 use non_empty_string::NonEmptyString;
 
@@ -55,10 +74,10 @@ Deserialization will fail if the field is present as a String, but the length of
 
 Licensed under either of
 
- * Apache License, Version 2.0
-   ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license
-   ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0
+  ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license
+  ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
 
 at your option.
 
@@ -68,4 +87,5 @@ Unless you explicitly state otherwise, any contribution intentionally submitted
 for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
 dual licensed as above, without any additional terms or conditions.
 
-[serde]: https://docs.rs/serde
+[serde]: https://docs.rs/serde
+[open an issue]: https://github.com/MidasLamb/non-empty-string/issues

src/error.rs

@@ -9,13 +9,15 @@ mod test_readme {
     #[doc = include_str!("../README.md")]
     mod something {}
 }
-mod error;
+
+use std::str::FromStr;
+
+use delegate::delegate;
+
 #[cfg(feature = "serde")]
 mod serde_support;
 
-use delegate::delegate;
-pub use error::EmptyString;
-use std::{fmt::Display, str::FromStr};
+mod trait_impls;
 
 /// A simple String wrapper type, similar to NonZeroUsize and friends.
 /// Guarantees that the String contained inside is not of length 0.
@@ -149,21 +151,11 @@ impl TryFrom<String> for NonEmptyString {
     }
 }
 
-impl Display for NonEmptyString {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
 impl FromStr for NonEmptyString {
-    type Err = EmptyString;
+    type Err = <NonEmptyString as TryFrom<String>>::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.is_empty() {
-            return Err(EmptyString);
-        }
-
-        Ok(Self(s.to_string()))
+        <Self as TryFrom<String>>::try_from(s.to_string())
     }
 }
 
@@ -175,8 +167,7 @@ impl From<NonEmptyString> for String {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashMap;
-    use std::collections::HashSet;
+    use std::hash::Hash;
 
     use super::*;
 
@@ -231,12 +222,9 @@ mod tests {
     #[test]
     fn from_str_works() {
         let valid_str = "string";
-
-        let _non_empty_string = NonEmptyString::from_str("").expect_err("operation must be failed");
-
         let non_empty_string = NonEmptyString::from_str(valid_str).unwrap();
-        assert_eq!(non_empty_string.as_str(), valid_str);
-        assert_eq!(non_empty_string, valid_str.parse().unwrap());
+        let parsed: NonEmptyString = valid_str.parse().unwrap();
+        assert_eq!(non_empty_string, parsed);
     }
 
     #[test]
@@ -250,16 +238,7 @@ mod tests {
 
     #[test]
     fn hash_works() {
-        let mut map = HashMap::new();
-        map.insert(NonEmptyString::from_str("id.1").unwrap(), 1);
-        map.insert(NonEmptyString::from_str("id.2").unwrap(), 2);
-
-        assert_eq!(map.len(), 2);
-
-        let mut set = HashSet::new();
-        set.insert(NonEmptyString::from_str("1").unwrap());
-        set.insert(NonEmptyString::from_str("2").unwrap());
-
-        assert_eq!(set.len(), 2);
+        fn is_hash<T: Hash>() {}
+        is_hash::<NonEmptyString>();
     }
 }

src/lib.rs

@@ -0,0 +1,181 @@
+//! This module contains traits that are simply delegated to the underlying [`NonEmptyString`].
+//!
+//! The order of traits implemented here follow the same structure as defined in the standard library.
+//! When adding new ones, add them in the same order, so it's easy to keep track.
+//!
+//! The source at the moment of writing is [here](https://github.com/rust-lang/rust/blob/22d41ae90facbffdef9115809e8b6c1f71ebbf7c/library/alloc/src/string.rs#L2019).
+//! The link to master is [here](https://github.com/rust-lang/rust/blob/master/library/alloc/src/string.rs#L2019).
+//!
+
+use crate::NonEmptyString;
+use std::borrow::Cow;
+use std::fmt::Display;
+use std::ops::{self, Add, AddAssign};
+
+#[cfg(not(no_global_oom_handling))]
+impl Extend<char> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
+        self.0.extend(iter)
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl<'a> Extend<&'a char> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
+        self.extend(iter.into_iter().cloned());
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl<'a> Extend<&'a str> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
+        iter.into_iter().for_each(move |s| self.push_str(s));
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl Extend<Box<str>> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I) {
+        iter.into_iter().for_each(move |s| self.push_str(&s));
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl Extend<String> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
+        iter.into_iter().for_each(move |s| self.0.push_str(&s));
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl<'a> Extend<Cow<'a, str>> for NonEmptyString {
+    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
+        iter.into_iter().for_each(move |s| self.push_str(&s));
+    }
+}
+
+macro_rules! impl_eq {
+    ($lhs:ty, $rhs: ty) => {
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialEq<$rhs> for $lhs {
+            #[inline]
+            fn eq(&self, other: &$rhs) -> bool {
+                PartialEq::eq(&self[..], &other[..])
+            }
+        }
+
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialEq<$lhs> for $rhs {
+            #[inline]
+            fn eq(&self, other: &$lhs) -> bool {
+                PartialEq::eq(&self[..], &other[..])
+            }
+        }
+    };
+}
+
+impl_eq! { NonEmptyString, str }
+impl_eq! { NonEmptyString, &'a str }
+#[cfg(not(no_global_oom_handling))]
+impl_eq! { Cow<'a, str>, NonEmptyString }
+#[cfg(not(no_global_oom_handling))]
+impl_eq! { String, NonEmptyString }
+
+// No sensible implementation for Default
+// impl Default for NonEmptyString {
+// }
+
+impl Display for NonEmptyString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+// Derived:
+// impl fmt::Debug for String {
+// }
+
+// Derived:
+// impl hash::Hash for NonEmptyString {
+// }
+
+#[cfg(not(no_global_oom_handling))]
+impl Add<&str> for NonEmptyString {
+    type Output = NonEmptyString;
+
+    #[inline]
+    fn add(mut self, other: &str) -> NonEmptyString {
+        self.push_str(other);
+        self
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+impl AddAssign<&str> for NonEmptyString {
+    #[inline]
+    fn add_assign(&mut self, other: &str) {
+        self.push_str(other);
+    }
+}
+
+macro_rules! index_impl {
+    ($t:ty) => {
+        impl ops::Index<$t> for NonEmptyString {
+            type Output = str;
+
+            #[inline]
+            fn index(&self, index: $t) -> &str {
+                <String as ops::Index<$t>>::index(&self.0, index)
+            }
+        }
+    };
+}
+
+index_impl!(ops::Range<usize>);
+index_impl!(ops::RangeTo<usize>);
+index_impl!(ops::RangeFrom<usize>);
+index_impl!(ops::RangeFull);
+index_impl!(ops::RangeInclusive<usize>);
+index_impl!(ops::RangeToInclusive<usize>);
+
+// Not 100% sure if index_mut allows turning a NonEmptyString into an empty string or not, let's leave it out until sure.
+// macro_rules! index_mut_impl {
+//     ($t:ty) => {
+//         impl ops::IndexMut<$t> for NonEmptyString {
+//             #[inline]
+//             fn index_mut(&mut self, index: $t) -> &mut str {
+//                 <String as ops::IndexMut<$t>>::index_mut(&mut self.0, index)
+//             }
+//         }
+//     };
+// }
+
+// index_mut_impl!(ops::Range<usize>);
+// index_mut_impl!(ops::RangeTo<usize>);
+// index_mut_impl!(ops::RangeFrom<usize>);
+// index_mut_impl!(ops::RangeFull);
+// index_mut_impl!(ops::RangeInclusive<usize>);
+// index_mut_impl!(ops::RangeToInclusive<usize>);
+
+// Point of discussion, see https://github.com/MidasLamb/non-empty-string/pull/11
+// impl ops::Deref for NonEmptyString {
+// }
+
+// This would mean people could empty out the string, so no.
+// impl ops::DerefMut for NonEmptyString {
+// }
+
+#[cfg(not(no_global_oom_handling))]
+impl std::fmt::Write for NonEmptyString {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.push_str(s);
+        Ok(())
+    }
+
+    #[inline]
+    fn write_char(&mut self, c: char) -> std::fmt::Result {
+        self.push(c);
+        Ok(())
+    }
+}