Adds FromStr and TryFrom<&str> traits to enums implementations

src/codegen/enums.rs

@@ -82,6 +82,7 @@ fn generate_enum(
     struct Member<'a> {
         name: String,
         c_name: String,
+        nick: String,
         version: Option<Version>,
         deprecated_version: Option<Version>,
         cfg_condition: Option<&'a String>,
@@ -109,6 +110,7 @@ fn generate_enum(
         members.push(Member {
             name: enum_member_name(&member.name),
             c_name: member.c_identifier.clone(),
+            nick: member.nick.as_ref().unwrap_or(&member.name).to_owned(),
             version,
             deprecated_version,
             cfg_condition,
@@ -446,7 +448,7 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
                 type ParamSpec = {param_spec_enum};
                 type SetValue = Self;
                 type BuilderFn = fn(&str, Self) -> {param_spec_builder}<Self>;
-    
+
                 fn param_spec_builder() -> Self::BuilderFn {{
                     Self::ParamSpec::builder_with_default
                 }}
@@ -557,5 +559,50 @@ impl FromGlib<{sys_crate_name}::{ffi_name}> for {name} {{
         },
     )?;
 
+    // Generate FromStr trait implementation.
+    version_condition(w, env, None, enum_.version, false, 0)?;
+    cfg_condition_no_doc(w, config.cfg_condition.as_ref(), false, 0)?;
+    allow_deprecated(w, any_deprecated_version, false, 0)?;
+    writeln!(
+        w,
+        "impl std::str::FromStr for {name} {{
+    type Err = {boolerror};
+
+    fn from_str(s: &str) -> Result<Self, <Self as std::str::FromStr>::Err> {{
+        match s {{",
+        name = enum_.name,
+        boolerror = use_glib_type(env, "error::BoolError"),
+    )?;
+
+    for member in &members {
+        version_condition_no_doc(w, env, None, member.version, false, 3)?;
+        cfg_condition_no_doc(w, member.cfg_condition.as_ref(), false, 3)?;
+        writeln!(w, "\t\t\t\"{}\" => Ok(Self::{}),", member.nick, member.name)?;
+    }
+    writeln!(
+        w,
+        "\t\t\t_ => Err({}(\"'{{}}' is not a valid value for {}\", s)),",
+        use_glib_type(env, "bool_error!"),
+        enum_.name
+    )?;
+    writeln!(w, "\t\t}}\n\t}}\n}}\n")?;
+
+    // Generate From<&str> trait implementation, piggy-backing on FromStr
+    version_condition(w, env, None, enum_.version, false, 0)?;
+    cfg_condition_no_doc(w, config.cfg_condition.as_ref(), false, 0)?;
+    allow_deprecated(w, any_deprecated_version, false, 0)?;
+    writeln!(
+        w,
+        "impl std::convert::TryFrom<&str> for {name} {{
+    type Error = <Self as std::str::FromStr>::Err;
+
+    fn try_from(s: &str) -> Result<Self, <Self as std::convert::TryFrom<&str>>::Error> {{
+        <Self as std::str::FromStr>::from_str(s)
+    }}
+}}",
+        name = enum_.name
+    )?;
+    writeln!(w)?;
+
     Ok(())
 }

src/library.rs

@@ -393,6 +393,7 @@ pub struct Member {
     pub name: String,
     pub c_identifier: String,
     pub value: String,
+    pub nick: Option<String>,
     pub doc: Option<String>,
     pub doc_deprecated: Option<String>,
     pub status: GStatus,

src/parser.rs

@@ -991,6 +991,7 @@ impl Library {
         let member_name = elem.attr_required("name")?;
         let value = elem.attr_required("value")?;
         let c_identifier = elem.attr("identifier").map(|x| x.into());
+        let nick = elem.attr("nick").map(|x| x.into());
         let version = self.read_version(parser, ns_id, elem)?;
         let deprecated_version = self.read_deprecated_version(parser, ns_id, elem)?;
 
@@ -1010,6 +1011,7 @@ impl Library {
             doc,
             doc_deprecated,
             c_identifier: c_identifier.unwrap_or_else(|| member_name.into()),
+            nick,
             status: crate::config::gobjects::GStatus::Generate,
             version,
             deprecated_version,