Incorporate feedback

Author: xla

core/src/project_name.rs

@@ -24,25 +24,25 @@ use parity_scale_codec as codec;
 pub struct ProjectName(String);
 
 impl ProjectName {
-    fn from_string(input: String) -> Result<Self, InordinateProjectNameError> {
+    fn from_string(input: String) -> Result<Self, InvalidProjectNameError> {
         // Must be at least 1 character.
         if input.is_empty() {
-            return Err(InordinateProjectNameError("must be at least 1 character"));
+            return Err(InvalidProjectNameError("must be at least 1 character"));
         }
         // Must be no longer than 32.
         if input.len() > 32 {
-            return Err(InordinateProjectNameError("must not exceed 32 characters"));
+            return Err(InvalidProjectNameError("must not exceed 32 characters"));
         }
         // Must only consist of ASCII-encoded characters.
         if !input.is_ascii() {
-            return Err(InordinateProjectNameError("must be valid ASCII"));
+            return Err(InvalidProjectNameError("must be valid ASCII"));
         }
-        // Must only contain a-z, 0-9 and '-' characters.
+        // Must only contain a-z, 0-9, '-' and '_' characters.
         if !input
             .chars()
             .all(|c| c.is_ascii_digit() || c.is_ascii_lowercase() || c == '-' || c == '_')
         {
-            return Err(InordinateProjectNameError(
+            return Err(InvalidProjectNameError(
                 "must only include a-z, 0-9 and '-'",
             ));
         }
@@ -71,23 +71,23 @@ impl Into<String> for ProjectName {
 }
 
 impl TryFrom<String> for ProjectName {
-    type Error = InordinateProjectNameError;
+    type Error = InvalidProjectNameError;
 
     fn try_from(input: String) -> Result<Self, Self::Error> {
         Self::from_string(input)
     }
 }
 
 impl TryFrom<&str> for ProjectName {
-    type Error = InordinateProjectNameError;
+    type Error = InvalidProjectNameError;
 
     fn try_from(input: &str) -> Result<Self, Self::Error> {
         Self::from_string(input.to_string())
     }
 }
 
 impl core::str::FromStr for ProjectName {
-    type Err = InordinateProjectNameError;
+    type Err = InvalidProjectNameError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Self::from_string(s.to_string())
@@ -103,9 +103,9 @@ impl core::fmt::Display for ProjectName {
 
 /// Error type when conversion from an inordinate input failed.
 #[derive(codec::Encode, Clone, Debug, Eq, PartialEq)]
-pub struct InordinateProjectNameError(&'static str);
+pub struct InvalidProjectNameError(&'static str);
 
-impl InordinateProjectNameError {
+impl InvalidProjectNameError {
     /// Error description
     ///
     /// This function returns an actual error str when running in `std`
@@ -126,28 +126,28 @@ impl InordinateProjectNameError {
 }
 
 #[cfg(feature = "std")]
-impl std::fmt::Display for InordinateProjectNameError {
+impl std::fmt::Display for InvalidProjectNameError {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "InordinateOrgIdError({})", self.0)
+        write!(f, "InvalidOrgIdError({})", self.0)
     }
 }
 
 #[cfg(feature = "std")]
-impl std::error::Error for InordinateProjectNameError {
+impl std::error::Error for InvalidProjectNameError {
     fn description(&self) -> &str {
         self.0
     }
 }
 
-impl From<&'static str> for InordinateProjectNameError {
+impl From<&'static str> for InvalidProjectNameError {
     #[cfg(feature = "std")]
     fn from(s: &'static str) -> Self {
         Self(s)
     }
 
     #[cfg(not(feature = "std"))]
     fn from(s: &'static str) -> Self {
-        InordinateProjectNameError(s)
+        InvalidProjectNameError(s)
     }
 }