Formatting

Author: laurmaedje

build.rs

@@ -1,8 +1,9 @@
-use self::shared::ModifierSet;
 use std::fmt::Write;
 use std::iter::Peekable;
 use std::path::Path;
 
+use self::shared::ModifierSet;
+
 type StrResult<T> = Result<T, String>;
 
 #[path = "src/shared.rs"]

src/lib.rs

@@ -1,12 +1,11 @@
 //! Human-friendly notation for Unicode symbols.
 //!
 //! ## Model
-//! A [`Symbol`] is a collection of one or more _variants_.
-//! Each variant is identified by a set of [_modifiers_](ModifierSet)
-//! and has a single character as its value.
-//! The modifiers themselves can in principle be any non-empty strings
-//! that don't contain the character `.`, but codex only defines
-//! ones that are entirely made of ASCII alphabetical characters.
+//! A [`Symbol`] is a collection of one or more _variants_. Each variant is
+//! identified by a set of [_modifiers_](ModifierSet) and has a single character
+//! as its value. The modifiers themselves can in principle be any non-empty
+//! strings that don't contain the character `.`, but codex only defines ones
+//! that are entirely made of ASCII alphabetical characters.
 
 pub use self::shared::ModifierSet;
 

src/shared.rs

@@ -2,44 +2,25 @@ use std::ops::Deref;
 
 /// A set of modifiers.
 ///
-/// Beware: The [`Eq`] and [`Hash`] implementations are dependent on the ordering
-/// of the modifiers, in opposition to what a set would usually constitute.
-/// To test for set-wise equality, use [`iter`](Self::iter) and collect into a
-/// true set type like [`HashSet`](std::collections::HashSet).
+/// Beware: The [`Eq`] and [`Hash`] implementations are dependent on the
+/// ordering of the modifiers, in opposition to what a set would usually
+/// constitute. To test for set-wise equality, use [`iter`](Self::iter) and
+/// collect into a true set type like [`HashSet`](std::collections::HashSet).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-// note: the visibility needs to be `pub(crate)`,
-// since build.rs outputs `ModifierSet(...)`
-pub struct ModifierSet<S>(pub(crate) S);
-
-impl<S: Default> Default for ModifierSet<S> {
-    /// Construct the default modifier set.
-    ///
-    /// This is typically the empty set,
-    /// though the remark from [`Self::new_unchecked`] applies
-    /// since `S::default()` could technically be anything.
-    fn default() -> Self {
-        Self(S::default())
-    }
-}
+pub struct ModifierSet<S>(
+    // Note: the visibility needs to be `pub(crate)`, since build.rs outputs
+    // `ModifierSet(...)`.
+    pub(crate) S,
+);
 
 impl<S: Deref<Target = str>> ModifierSet<S> {
-    /// Convert the underlying string to a slice.
-    pub fn as_deref(&self) -> ModifierSet<&str> {
-        ModifierSet(&self.0)
-    }
-
-    /// Get the string of modifiers separated by `.`.
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-
-    /// Construct a modifier set from a string,
-    /// where modifiers are separated by the character `.`.
+    /// Constructs a modifier set from a string, where modifiers are separated by
+    /// the character `.`.
     ///
     /// It is not unsafe to use this function wrongly, but it can produce
-    /// unexpected results down the line. Correct usage should ensure that
-    /// `s` does not contain any empty modifiers (i.e. the sequence `..`)
-    /// and that no modifier occurs twice.
+    /// unexpected results down the line. Correct usage should ensure that `s`
+    /// does not contain any empty modifiers (i.e. the sequence `..`) and that
+    /// no modifier occurs twice.
     pub fn new_unchecked(s: S) -> Self {
         Self(s)
     }
@@ -49,6 +30,16 @@ impl<S: Deref<Target = str>> ModifierSet<S> {
         self.0.is_empty()
     }
 
+    /// Gets the string of modifiers separated by `.`.
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    /// Converts the underlying string to a slice.
+    pub fn as_deref(&self) -> ModifierSet<&str> {
+        ModifierSet(&self.0)
+    }
+
     /// Add a modifier to the set, without checking that it is a valid modifier.
     ///
     /// It is not unsafe to use this method wrongly, but that can produce
@@ -64,7 +55,7 @@ impl<S: Deref<Target = str>> ModifierSet<S> {
         self.0 += m;
     }
 
-    /// Iterate over the list of modifiers in an arbitrary order.
+    /// Iterates over the list of modifiers in an arbitrary order.
     pub fn iter(&self) -> impl Iterator<Item = &str> {
         self.into_iter()
     }
@@ -74,12 +65,7 @@ impl<S: Deref<Target = str>> ModifierSet<S> {
         self.iter().any(|lhs| lhs == m)
     }
 
-    /// Whether all modifiers in `self` are also present in `other`.
-    pub fn is_subset(&self, other: ModifierSet<&str>) -> bool {
-        self.iter().all(|m| other.contains(m))
-    }
-
-    /// Find the best match from the list.
+    /// Finds the best match from the list.
     ///
     /// To be considered a match, the modifier set must be a superset of
     /// (or equal to) `self`. Among different matches, the best one is selected
@@ -115,6 +101,22 @@ impl<S: Deref<Target = str>> ModifierSet<S> {
 
         best
     }
+
+    /// Whether all modifiers in `self` are also present in `other`.
+    pub fn is_subset(&self, other: ModifierSet<&str>) -> bool {
+        self.iter().all(|m| other.contains(m))
+    }
+}
+
+impl<S: Default> Default for ModifierSet<S> {
+    /// Constructs the default modifier set.
+    ///
+    /// This is typically the empty set, though the remark from
+    /// [`Self::new_unchecked`] applies since `S::default()` could technically
+    /// be anything.
+    fn default() -> Self {
+        Self(S::default())
+    }
 }
 
 impl<'a, S: Deref<Target = str>> IntoIterator for &'a ModifierSet<S> {
@@ -180,34 +182,46 @@ mod tests {
     fn best_match() {
         // 1. more modifiers in common with self
         assert_eq!(
-            ModifierSet::new_unchecked("a.b").best_match_in([
-                (ModifierSet::new_unchecked("a.c"), 1),
-                (ModifierSet::new_unchecked("a.b"), 2),
-            ].into_iter()),
+            ModifierSet::new_unchecked("a.b").best_match_in(
+                [
+                    (ModifierSet::new_unchecked("a.c"), 1),
+                    (ModifierSet::new_unchecked("a.b"), 2),
+                ]
+                .into_iter()
+            ),
             Some(2)
         );
         // 2. fewer modifiers in general
         assert_eq!(
-            ModifierSet::new_unchecked("a").best_match_in([
-                (ModifierSet::new_unchecked("a"), 1),
-                (ModifierSet::new_unchecked("a.b"), 2),
-            ].into_iter()),
+            ModifierSet::new_unchecked("a").best_match_in(
+                [
+                    (ModifierSet::new_unchecked("a"), 1),
+                    (ModifierSet::new_unchecked("a.b"), 2),
+                ]
+                .into_iter()
+            ),
             Some(1)
         );
         // the first rule takes priority over the second
         assert_eq!(
-            ModifierSet::new_unchecked("a.b").best_match_in([
-                (ModifierSet::new_unchecked("a"), 1),
-                (ModifierSet::new_unchecked("a.b"), 2),
-            ].into_iter()),
+            ModifierSet::new_unchecked("a.b").best_match_in(
+                [
+                    (ModifierSet::new_unchecked("a"), 1),
+                    (ModifierSet::new_unchecked("a.b"), 2),
+                ]
+                .into_iter()
+            ),
             Some(2)
         );
         // among multiple best matches, the first one is returned
         assert_eq!(
-            ModifierSet::default().best_match_in([
-                (ModifierSet::new_unchecked("a"), 1),
-                (ModifierSet::new_unchecked("b"), 2)
-            ].into_iter()),
+            ModifierSet::default().best_match_in(
+                [
+                    (ModifierSet::new_unchecked("a"), 1),
+                    (ModifierSet::new_unchecked("b"), 2)
+                ]
+                .into_iter()
+            ),
             Some(1)
         );
     }