Support deriving builder for enums

src/lib.rs

@@ -232,6 +232,44 @@ use core::ops::FnOnce;
 ///     Struct::builder().x(2).x_into_b().x_into_b().x_into_b_field().inc_a(2).build(),
 ///     Struct {x: 2, a: 3, b: vec![2, 2, 2]});
 /// ```
+///
+/// # Enum
+/// `TypedBuilder` also supports deriving builder of enums.
+/// By default (inconfigurable though), `TypedBuilder` generates builder methods with
+/// the name of "snake_case" of variant names.
+/// For example, the builder of `Foo::BarQux` is created by `Foo::bar_qux()`.
+/// Note that it does not support enums with generics or lifetime.
+///
+/// You can specify `#[builder(...)]` on enums, on variants, and on any fields.
+/// But since `TypedBuilder` internally generates a builder struct each enum variant,
+/// some subsections are prohibited; you cannot specify `builder_method(name=...)`,
+/// `builder_type(name=...)`, `build_method(into=...)` on enums.
+/// ```
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(PartialEq, TypedBuilder)]
+/// #[builder(field_defaults(setter(into)))]
+/// enum Foo {
+///     Bar {
+///         x: i32,
+///     },
+///     // builder method is `.baz_qux()`, "snake_case" of variant names
+///     #[builder(field_defaults(setter(prefix = "with_")))]
+///     BazQux {
+///         #[builder(default, setter(strip_option))]
+///         y: Option<i32>,
+///         z: String,
+///     },
+/// }
+///
+/// assert!(
+///     Foo::bar().x(1).build()
+///     == Foo::Bar { x: 1 });
+///
+/// assert!(
+///     Foo::baz_qux().with_y(1).with_z("bar").build()
+///     == Foo::BazQux { y: Some(1), z: "bar".to_owned() });
+/// ```
 pub use typed_builder_macro::TypedBuilder;
 
 #[doc(hidden)]
@@ -347,4 +385,114 @@ impl<T> Optional<T> for (T,) {
 /// #[deny(deprecated)]
 /// Foo::builder().value(42).build();
 ///```
-fn _compile_fail_tests() {}
+fn _struct_compile_fail_tests() {}
+
+#[doc(hidden)]
+/// Enum with generics:
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo<T> {
+///     Bar { value: T },
+/// }
+/// ```
+///
+/// Enum with lifetime:
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo<'a> {
+///     Bar { value: &'a i32 },
+/// }
+/// ```
+///
+/// Enum with builder_method(...):
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// #[builder(builder_method(name=builder))]
+/// enum Foo {
+///     Bar { value: i32 },
+/// }
+/// ```
+///
+/// But for variant:
+///
+/// ```
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo {
+///     #[builder(builder_method(name=builder))]
+///     Bar { value: i32 },
+/// }
+///
+/// let _ = Foo::builder().value(0).build();
+/// ```
+///
+/// Enum with builder_type(...):
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// #[builder(builder_type(name=FooBuilder))]
+/// enum Foo {
+///     Bar { value: i32 },
+/// }
+/// ```
+///
+/// But for variant:
+///
+/// ```
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo {
+///     #[builder(builder_type(name=CustomBuilder))]
+///     Bar { value: i32 },
+/// }
+///
+/// let _: CustomBuilder = Foo::bar();
+/// ```
+///
+/// Enum with build_method(into):
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// #[builder(build_method(into))]
+/// enum Foo {
+///     Bar { value: i32 },
+/// }
+/// ```
+///
+/// Enum with tuple variants:
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo {
+///     Bar(i32),
+/// }
+/// ```
+///
+/// Enum with unit variants:
+///
+/// ```compile_fail
+/// use typed_builder::TypedBuilder;
+///
+/// #[derive(TypedBuilder)]
+/// enum Foo {
+///     Bar,
+/// }
+/// ```
+fn _enum_compile_fail_tests() {}

tests/enum.rs

@@ -0,0 +1,181 @@
+use typed_builder::TypedBuilder;
+
+#[test]
+fn test_simple() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    enum Foo {
+        Bar { x: i32 },
+        Baz { y: i32, z: String },
+    }
+
+    assert_eq!(Foo::bar().x(1).build(), Foo::Bar { x: 1 });
+    assert_eq!(
+        Foo::baz().y(2).z("z".to_owned()).build(),
+        Foo::Baz { y: 2, z: "z".to_owned() }
+    );
+}
+
+#[test]
+fn test_into() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    #[builder(field_defaults(setter(into)))]
+    enum Foo {
+        Bar {
+            x: i32,
+        },
+        Baz {
+            #[builder(setter(!into))]
+            y: u32,
+            z: String,
+        },
+    }
+
+    assert_eq!(Foo::bar().x(1_u8).build(), Foo::Bar { x: 1 });
+    assert_eq!(Foo::baz().y(2).z("z").build(), Foo::Baz { y: 2, z: "z".to_owned() });
+}
+
+#[test]
+fn test_default() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    enum Foo {
+        #[builder(field_defaults(default = 1))]
+        Bar {
+            #[builder(default = 2)]
+            x: i32,
+            y: i32,
+        },
+        Baz {
+            #[builder(default = Some(3), setter(strip_option))]
+            y: Option<i32>,
+            #[builder(default = vec![1,2,3], setter(into))]
+            z: Vec<i32>,
+        },
+    }
+
+    assert_eq!(Foo::bar().build(), Foo::Bar { x: 2, y: 1 });
+    assert_eq!(Foo::bar().x(3).y(4).build(), Foo::Bar { x: 3, y: 4 });
+    assert_eq!(
+        Foo::baz().build(),
+        Foo::Baz {
+            y: Some(3),
+            z: vec![1, 2, 3]
+        }
+    );
+    assert_eq!(
+        Foo::baz().y(5).z([6, 7, 8]).build(),
+        Foo::Baz {
+            y: Some(5),
+            z: vec![6, 7, 8]
+        }
+    );
+}
+
+#[test]
+fn test_skip() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    enum Foo {
+        Bar {
+            #[builder(default, setter(skip))]
+            x: i32,
+        },
+        Baz {
+            #[builder(setter(strip_option))]
+            y: Option<i32>,
+            #[builder(default = y.into_iter().collect(), setter(skip))]
+            z: Vec<i32>,
+        },
+    }
+
+    assert_eq!(Foo::bar().build(), Foo::Bar { x: 0 });
+    assert_eq!(Foo::baz().y(1).build(), Foo::Baz { y: Some(1), z: vec![1] });
+}
+
+#[test]
+fn test_build_method_name() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    #[builder(doc, build_method(vis="", name=__build), field_defaults(default))]
+    pub enum Foo {
+        Bar { x: i32 },
+        Baz { y: i32 },
+    }
+
+    assert_eq!(Foo::bar().x(1).__build(), Foo::Bar { x: 1 });
+    assert_eq!(Foo::baz().__build(), Foo::Baz { y: 0 });
+}
+
+#[test]
+fn test_prefix_and_suffix() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    #[builder(field_defaults(setter(prefix = "with_")))]
+    enum Foo {
+        Bar {
+            x: i32,
+        },
+        #[builder(field_defaults(setter(suffix = "_value")))]
+        Baz {
+            y: i32,
+            #[builder(setter(prefix = ""))]
+            z: i32,
+        },
+    }
+
+    assert_eq!(Foo::bar().with_x(1).build(), Foo::Bar { x: 1 });
+    assert_eq!(Foo::baz().with_y_value(2).z_value(3).build(), Foo::Baz { y: 2, z: 3 });
+}
+
+#[test]
+fn test_builder_method() {
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    enum Foo {
+        BarBaz {
+            x: i32,
+        },
+        QuxHTTPQuux {
+            y: i32,
+        },
+        #[builder(builder_method(name = custom_builder))]
+        Custom {
+            z: i32,
+        },
+    }
+
+    assert_eq!(Foo::bar_baz().x(1).build(), Foo::BarBaz { x: 1 });
+    assert_eq!(Foo::qux_http_quux().y(2).build(), Foo::QuxHTTPQuux { y: 2 });
+    assert_eq!(Foo::custom_builder().z(3).build(), Foo::Custom { z: 3 });
+}
+
+#[test]
+fn test_builder_type_visibility() {
+    mod foo {
+        use typed_builder::TypedBuilder;
+
+        #[derive(PartialEq, Debug, TypedBuilder)]
+        enum Foo {
+            #[builder(builder_type(vis="pub", name=CustomBuilder))]
+            Bar { x: i32 },
+        }
+
+        pub fn foo_bar_builder() -> CustomBuilder {
+            Foo::bar()
+        }
+
+        pub fn build_and_get_x(builder: CustomBuilder, x: i32) -> i32 {
+            let Foo::Bar { x } = builder.x(x).build();
+            x
+        }
+    }
+
+    let builder: foo::CustomBuilder = foo::foo_bar_builder();
+    assert_eq!(foo::build_and_get_x(builder, 1), 1);
+}
+
+#[test]
+fn test_builder_on_enum_with_keywords() {
+    #[allow(non_camel_case_types)]
+    #[derive(PartialEq, Debug, TypedBuilder)]
+    enum r#enum {
+        Bar { r#type: i32 },
+    }
+
+    assert_eq!(r#enum::bar().r#type(1).build(), r#enum::Bar { r#type: 1 });
+}

typed-builder-macro/Cargo.toml

@@ -18,3 +18,4 @@ proc-macro = true
 syn = { version = "2", features = ["full", "extra-traits"] }
 quote = "1"
 proc-macro2 = "1"
+convert_case = "0.6.0"