Replace manual ParseDocument implementations with derive macro (#70)

Author: ryo33

Cargo.lock

@@ -12,3 +12,4 @@ keywords = ["codegen", "eure", "schema"]
 [dependencies]
 bon = "3"
 eure-document = { path = "../eure-document" }
+eure-macros = { workspace = true }

crates/eure-codegen/Cargo.toml

@@ -11,7 +11,7 @@
 //! - [`RecordCodegen`] - Codegen settings for record types
 //! - [`FieldCodegen`] - Codegen settings for individual record fields
 
-use eure_document::parse::{ParseContext, ParseDocument, ParseError};
+use eure_macros::ParseDocument;
 
 // ============================================================================
 // Root-Level Codegen Types
@@ -29,25 +29,14 @@ use eure_document::parse::{ParseContext, ParseDocument, ParseError};
 ///   type = "MyRootType"
 /// }
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document)]
 pub struct RootCodegen {
     /// The root type name for the generated code.
+    #[eure(rename = "type", default)]
     pub type_name: Option<String>,
 }
 
-impl ParseDocument<'_> for RootCodegen {
-    type Error = ParseError;
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let type_name = rec.parse_field_optional::<String>("type")?;
-
-        rec.deny_unknown_fields()?;
-
-        Ok(RootCodegen { type_name })
-    }
-}
-
 /// Default codegen settings applied to all types.
 ///
 /// Corresponds to `$types.codegen-defaults` in the schema.
@@ -63,41 +52,23 @@ impl ParseDocument<'_> for RootCodegen {
 ///   document-node-id-field = "doc_node"
 /// }
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document, rename_all = "kebab-case")]
 pub struct CodegenDefaults {
     /// Default derive macros for all generated types.
+    #[eure(default)]
     pub derive: Option<Vec<String>>,
     /// Prefix for extension type field names (e.g., "ext_" -> ext_types).
+    #[eure(default)]
     pub ext_types_field_prefix: Option<String>,
     /// Prefix for extension type names (e.g., "Ext" -> ExtTypes).
+    #[eure(default)]
     pub ext_types_type_prefix: Option<String>,
     /// Field name for storing document node ID in generated types.
+    #[eure(default)]
     pub document_node_id_field: Option<String>,
 }
 
-impl ParseDocument<'_> for CodegenDefaults {
-    type Error = ParseError;
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let derive = rec.parse_field_optional::<Vec<String>>("derive")?;
-        let ext_types_field_prefix =
-            rec.parse_field_optional::<String>("ext-types-field-prefix")?;
-        let ext_types_type_prefix = rec.parse_field_optional::<String>("ext-types-type-prefix")?;
-        let document_node_id_field =
-            rec.parse_field_optional::<String>("document-node-id-field")?;
-
-        rec.deny_unknown_fields()?;
-
-        Ok(CodegenDefaults {
-            derive,
-            ext_types_field_prefix,
-            ext_types_type_prefix,
-            document_node_id_field,
-        })
-    }
-}
-
 // ============================================================================
 // Type-Level Codegen Types
 // ============================================================================
@@ -122,42 +93,23 @@ impl ParseDocument<'_> for CodegenDefaults {
 ///   variants.b = `integer`
 /// }
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document, rename_all = "kebab-case")]
 pub struct UnionCodegen {
     /// Override the generated type name (from base-codegen).
+    #[eure(rename = "type", default)]
     pub type_name: Option<String>,
     /// Override the list of derive macros (from base-codegen).
+    #[eure(default)]
     pub derive: Option<Vec<String>>,
     /// Generate separate types for each variant instead of struct-like variants.
+    #[eure(default)]
     pub variant_types: Option<bool>,
     /// Suffix for variant type names (e.g., "Type" -> TextType, IntegerType).
+    #[eure(default)]
     pub variant_types_suffix: Option<String>,
 }
 
-impl ParseDocument<'_> for UnionCodegen {
-    type Error = ParseError;
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        // Parse base-codegen fields (flattened)
-        let type_name = rec.parse_field_optional::<String>("type")?;
-        let derive = rec.parse_field_optional::<Vec<String>>("derive")?;
-
-        // Parse union-specific fields
-        let variant_types = rec.parse_field_optional::<bool>("variant-types")?;
-        let variant_types_suffix = rec.parse_field_optional::<String>("variant-types-suffix")?;
-
-        rec.deny_unknown_fields()?;
-
-        Ok(UnionCodegen {
-            type_name,
-            derive,
-            variant_types,
-            variant_types_suffix,
-        })
-    }
-}
-
 /// Codegen settings for record types.
 ///
 /// Corresponds to `$types.record-codegen` in the schema.
@@ -179,29 +131,17 @@ impl ParseDocument<'_> for UnionCodegen {
 ///   age = `integer`
 /// }
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document)]
 pub struct RecordCodegen {
     /// Override the generated type name (from base-codegen).
+    #[eure(rename = "type", default)]
     pub type_name: Option<String>,
     /// Override the list of derive macros (from base-codegen).
+    #[eure(default)]
     pub derive: Option<Vec<String>>,
 }
 
-impl ParseDocument<'_> for RecordCodegen {
-    type Error = ParseError;
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        // Parse base-codegen fields (flattened)
-        let type_name = rec.parse_field_optional::<String>("type")?;
-        let derive = rec.parse_field_optional::<Vec<String>>("derive")?;
-
-        rec.deny_unknown_fields()?;
-
-        Ok(RecordCodegen { type_name, derive })
-    }
-}
-
 /// Codegen settings for individual record fields.
 ///
 /// Corresponds to `$types.field-codegen` in the schema.
@@ -215,25 +155,14 @@ impl ParseDocument<'_> for RecordCodegen {
 ///   user-name.$codegen.name = "username"  // Rename to `username` in Rust
 /// }
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document)]
 pub struct FieldCodegen {
     /// Override the field name in generated Rust code.
+    #[eure(default)]
     pub name: Option<String>,
 }
 
-impl ParseDocument<'_> for FieldCodegen {
-    type Error = ParseError;
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let name = rec.parse_field_optional::<String>("name")?;
-
-        rec.deny_unknown_fields()?;
-
-        Ok(FieldCodegen { name })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/eure-codegen/src/parse.rs

@@ -13,8 +13,9 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+use eure::ParseDocument;
 use eure::document::parse_to_document;
-use eure_document::parse::{ParseContext, ParseDocument, ParseError};
+use eure_document::parse::{ParseContext, ParseDocument as ParseDocumentTrait, ParseError};
 
 // Re-export for convenience
 pub use eure_document::parse::ParseError as ConfigParseError;
@@ -46,79 +47,36 @@ impl From<ParseError> for ConfigError {
 }
 
 /// A check target definition.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, ParseDocument)]
+#[eure(crate = eure_document, allow_unknown_fields)]
 pub struct Target {
     /// Glob patterns for files to include in this target.
     pub globs: Vec<String>,
     /// Optional schema file path (relative to config file).
+    #[eure(default)]
     pub schema: Option<String>,
 }
 
-impl ParseDocument<'_> for Target {
-    type Error = ParseError;
-
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let globs = rec.parse_field::<Vec<String>>("globs")?;
-        let schema = rec.parse_field_optional::<String>("schema")?;
-
-        rec.allow_unknown_fields()?;
-
-        Ok(Target { globs, schema })
-    }
-}
-
 /// CLI-specific configuration.
 #[cfg(feature = "cli")]
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document, rename_all = "kebab-case", allow_unknown_fields)]
 pub struct CliConfig {
     /// Default targets to check when running `eure check` without arguments.
+    #[eure(default)]
     pub default_targets: Vec<String>,
 }
 
-#[cfg(feature = "cli")]
-impl ParseDocument<'_> for CliConfig {
-    type Error = ParseError;
-
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let default_targets = rec
-            .parse_field_optional::<Vec<String>>("default-targets")?
-            .unwrap_or_default();
-
-        rec.allow_unknown_fields()?;
-
-        Ok(CliConfig { default_targets })
-    }
-}
-
 /// Language server configuration.
 #[cfg(feature = "ls")]
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, ParseDocument)]
+#[eure(crate = eure_document, rename_all = "kebab-case", allow_unknown_fields)]
 pub struct LsConfig {
     /// Whether to format on save.
+    #[eure(default)]
     pub format_on_save: bool,
 }
 
-#[cfg(feature = "ls")]
-impl ParseDocument<'_> for LsConfig {
-    type Error = ParseError;
-
-    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
-        let rec = ctx.parse_record()?;
-
-        let format_on_save = rec
-            .parse_field_optional::<bool>("format-on-save")?
-            .unwrap_or(false);
-
-        rec.allow_unknown_fields()?;
-
-        Ok(LsConfig { format_on_save })
-    }
-}
-
 /// The main Eure configuration.
 #[derive(Debug, Clone, Default)]
 pub struct EureConfig {
@@ -134,7 +92,7 @@ pub struct EureConfig {
     pub ls: Option<LsConfig>,
 }
 
-impl ParseDocument<'_> for EureConfig {
+impl ParseDocumentTrait<'_> for EureConfig {
     type Error = ParseError;
 
     fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {

crates/eure-config/src/lib.rs

@@ -830,9 +830,13 @@ pub enum ParseErrorKind {
     #[error("value out of range: {0}")]
     OutOfRange(String),
 
-    /// Invalid string pattern.
-    #[error("invalid pattern: expected {pattern}, got {value}")]
-    InvalidPattern { pattern: String, value: String },
+    /// Invalid value pattern or format.
+    ///
+    /// Used for validation errors in types like regex, URL, UUID, etc.
+    /// - `kind`: Type of validation (e.g., "regex", "url", "uuid", "pattern: <expected>")
+    /// - `reason`: Human-readable error message explaining the failure
+    #[error("invalid {kind}: {reason}")]
+    InvalidPattern { kind: String, reason: String },
 
     /// Nested parse error with path context.
     #[error("at {path}: {source}")]
@@ -1338,6 +1342,21 @@ where
     }
 }
 
+impl ParseDocument<'_> for regex::Regex {
+    type Error = ParseError;
+
+    fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error> {
+        let pattern: &str = ctx.parse()?;
+        regex::Regex::new(pattern).map_err(|e| ParseError {
+            node_id: ctx.node_id(),
+            kind: ParseErrorKind::InvalidPattern {
+                kind: format!("regex '{}'", pattern),
+                reason: e.to_string(),
+            },
+        })
+    }
+}
+
 /// `Option<T>` is a union with variants `some` and `none`.
 ///
 /// - `$variant: some` -> parse T

crates/eure-document/src/parse.rs

@@ -16,4 +16,12 @@ pub struct ContainerAttrs {
     /// When true, uses `ctx.parse_extension()` and `ext.parse_ext()` instead of
     /// `ctx.parse_record()` and `rec.parse_field()`.
     pub parse_ext: bool,
+    /// Allow unknown fields instead of denying them.
+    /// By default (false), unknown fields cause a parse error.
+    /// When true, uses `allow_unknown_fields()` instead of `deny_unknown_fields()`.
+    pub allow_unknown_fields: bool,
+    /// Allow unknown extensions instead of denying them.
+    /// By default (false), unknown extensions cause a parse error.
+    /// When true, skips the `deny_unknown_extensions()` check.
+    pub allow_unknown_extensions: bool,
 }

crates/eure-macros/src/attrs/container.rs

@@ -5,4 +5,8 @@ use darling::FromVariant;
 pub struct VariantAttrs {
     /// Explicit rename for this variant (overrides rename_all)
     pub rename: Option<String>,
+    /// Allow unknown fields for this variant instead of denying them.
+    /// By default (false), unknown fields cause a parse error.
+    /// When true, uses `allow_unknown_fields()` instead of `deny_unknown_fields()`.
+    pub allow_unknown_fields: bool,
 }