More documentation and traits for Locale

generate-api/src/generator.rs

@@ -491,29 +491,86 @@ impl CodeGenerator {
             f,
             r#"
 
+            /// Locales matching the locales in `glibc`.
+            ///
+            /// Most locale names follow the syntax `language[_territory][@modifier]`.
+            /// The `@` is replaced with `_` in the `enum` variant names.
+            ///
+            /// The default locale is `POSIX`.
+            ///
+            /// License note: The Free Software Foundation does not claim any copyright interest in the locale
+            /// data of the GNU C Library; they believe it is not copyrightable.
             #[allow(non_camel_case_types,dead_code)]
-            #[derive(Debug, Copy, Clone, PartialEq)]
+            #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
             pub enum Locale {{
             "#,
         )?;
         f.indent(1);
 
+        for (lang, norm) in self.normalized_langs.iter() {
+            let desc = match self
+                .by_language
+                .get(lang)
+                .and_then(|l| l.get("LC_IDENTIFICATION"))
+            {
+                Some(Category::Fields(fields)) => match fields.get("TITLE") {
+                    Some(Value::Literal(title)) => {
+                        let mut title = title.clone();
+                        if !title.ends_with('.') {
+                            title.push('.');
+                        }
+                        title
+                    }
+                    _ => match lang == "POSIX" {
+                        true => "POSIX Standard Locale.".to_string(),
+                        false => "".to_string(),
+                    },
+                },
+                _ => "".to_string(),
+            };
+            write!(f, "\n/// `{}`: {}\n", lang, desc)?;
+            if lang == &"POSIX" {
+                writeln!(f, "\n#[default]\n")?;
+            }
+            writeln!(f, "\n{},\n", norm)?;
+        }
+
+        f.dedent(1);
+        write!(
+            f,
+            r#"
+            }}
+
+            impl core::fmt::Display for Locale {{
+                fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {{
+                    f.write_str(match self {{
+            "#,
+        )?;
+        f.indent(3);
+
         for (lang, norm) in self.normalized_langs.iter() {
             write!(
                 f,
                 r#"
-                /// {lang}
-                {norm},
+                Locale::{norm} => {lang:?},
                 "#,
                 lang = lang,
                 norm = norm,
             )?;
         }
 
-        f.dedent(1);
+        f.dedent(3);
         write!(
             f,
             r#"
+                    }})
+                }}
+            }}
+
+            impl core::fmt::Debug for Locale {{
+                fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {{
+                    core::fmt::Display::fmt(self, f)
+                }}
             }}
 
             impl core::str::FromStr for Locale {{