fix: add field tracking

README.md

@@ -124,6 +124,15 @@ preventing issues that arise from improperly constructed objects.
 public class Car {
 ```
 
+Another `ConstructorPolicy` that also enforces all the parameters to be set, but less strictly is
+`ENFORCED_ALLOW_NULLS`. By using this policy, you enforce all variables to be set, 
+but you can also set them to null, which is not allowed when using `ENFORCED`.
+
+```java
+@Buildable(constructorPolicy = ENFORCED_ALLOW_NULLS)
+public class Car {
+```
+
 ### Mandatory Fields
 
 Fields can be designated as mandatory;

annotations/src/main/java/io/jonasg/bob/Buildable.java

@@ -59,7 +59,11 @@
 	 * fields. Alternatively,
 	 * setting this to {@link ConstructorPolicy#ENFORCED} requires all fields to be
 	 * explicitly set, otherwise,
-	 * the builder throws an exception.
+	 * the builder throws an exception. <br/>
+	 * Setting it to {@link ConstructorPolicy#ENFORCED_ALLOW_NULLS} requires all
+	 * fields
+	 * to be explicitly set, otherwise the builder throws an exception. But by using
+	 * this policy, null can also be set.
 	 * </p>
 	 *
 	 * @return the constructor policy used by the builder

annotations/src/main/java/io/jonasg/bob/ConstructorPolicy.java

@@ -23,6 +23,17 @@ public enum ConstructorPolicy {
 	 */
 	ENFORCED,
 
+	/**
+	 * Requires all fields
+	 * to be explicitly set with a concrete value or {@code null} in the
+	 * constructor.
+	 * If any field is not set, the builder will throw an exception.
+	 * The main difference with {@link ConstructorPolicy#ENFORCED} is that fields
+	 * are considered
+	 * to be set to, even if set explicitly to {@code null}
+	 */
+	ENFORCED_ALLOW_NULLS,
+
 	/**
 	 * Allows the object to be constructed even if not all constructor parameters
 	 * have

annotations/src/main/java/io/jonasg/bob/NotNullableRequiredField.java

@@ -0,0 +1,36 @@
+package io.jonasg.bob;
+
+/**
+ * Container Object for a required field and its value that cannot be set as null
+ *
+ * @param <T>
+ *            the type of the required field its value
+ */
+@SuppressWarnings("unused")
+public final class NotNullableRequiredField<T> implements RequiredField<T> {
+
+	private T fieldValue;
+
+	private final String fieldName;
+
+	private final String typeName;
+
+	NotNullableRequiredField(T fieldValue, String fieldName, String typeName) {
+		this.fieldValue = fieldValue;
+		this.fieldName = fieldName;
+		this.typeName = typeName;
+	}
+
+	@Override
+	public void set(T value) {
+		this.fieldValue = value;
+	}
+
+	@Override
+	public T orElseThrow() {
+		if (fieldValue == null) {
+			throw new MandatoryFieldMissingException(fieldName, typeName);
+		}
+		return fieldValue;
+	}
+}

annotations/src/main/java/io/jonasg/bob/NullableRequiredField.java

@@ -0,0 +1,39 @@
+package io.jonasg.bob;
+
+/**
+ * Container Object for a required field and its value that can be set as null
+ *
+ * @param <T>
+ *            the type of the required field its value
+ */
+@SuppressWarnings("unused")
+public class NullableRequiredField<T> implements RequiredField<T> {
+
+	private T fieldValue;
+
+	private boolean fieldSet;
+
+	private final String fieldName;
+
+	private final String typeName;
+
+	public NullableRequiredField(T fieldValue, String fieldName, String typeName) {
+		this.fieldValue = fieldValue;
+		this.fieldName = fieldName;
+		this.typeName = typeName;
+	}
+
+	@Override
+	public void set(T value) {
+		this.fieldValue = value;
+		fieldSet = true;
+	}
+
+	@Override
+	public T orElseThrow() {
+		if (!fieldSet && fieldValue == null) {
+			throw new MandatoryFieldMissingException(fieldName, typeName);
+		}
+		return fieldValue;
+	}
+}

annotations/src/main/java/io/jonasg/bob/RequiredField.java

@@ -1,38 +1,17 @@
 package io.jonasg.bob;
 
-/**
- * Container Object for a required field and its value
- * 
- * @param <T>
- *            the type of the required field its value
- */
-@SuppressWarnings("unused")
-public final class RequiredField<T> {
+public interface RequiredField<T> {
 
-	private T fieldValue;
-
-	private final String fieldName;
-
-	private final String typeName;
-
-	private RequiredField(T fieldValue, String fieldName, String typeName) {
-		this.fieldValue = fieldValue;
-		this.fieldName = fieldName;
-		this.typeName = typeName;
+	static <T> RequiredField<T> notNullableOfNameWithinType(String fieldName, String typeName) {
+		return new NotNullableRequiredField<>(null, fieldName, typeName);
 	}
 
-	public static <T> RequiredField<T> ofNameWithinType(String fieldName, String typeName) {
-		return new RequiredField<>(null, fieldName, typeName);
+	static <T> RequiredField<T> nullableOfNameWithinType(String fieldName, String typeName) {
+		return new NullableRequiredField<>(null, fieldName, typeName);
 	}
 
-	public void set(T value) {
-		this.fieldValue = value;
-	}
+	void set(T value);
+
+	T orElseThrow();
 
-	public T orElseThrow() {
-		if (fieldValue == null) {
-			throw new MandatoryFieldMissingException(fieldName, typeName);
-		}
-		return fieldValue;
-	}
 }

annotations/src/test/java/io/jonasg/bob/RequiredFieldTest.java

@@ -2,36 +2,101 @@
 
 import org.assertj.core.api.Assertions;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 class RequiredFieldTest {
 
-	@Test
-	void throwIllegalBuildExceptionWhenFieldValueIsNotSet() {
-		// given
-		RequiredField<String> nameField = RequiredField.ofNameWithinType("name", "Person");
+	@Nested
+	class NotNullableRequiredFieldTest {
 
-		// when
-		ThrowingCallable whenOrElseThrowIsCalled = nameField::orElseThrow;
+		@Test
+		void throwIllegalBuildExceptionWhenFieldValueIsNotSet() {
+			// given
+			RequiredField<String> nameField = RequiredField.notNullableOfNameWithinType("name", "Person");
 
-		// then
-		Assertions.assertThatThrownBy(whenOrElseThrowIsCalled)
-				.isInstanceOf(MandatoryFieldMissingException.class)
-				.hasMessage("Mandatory field (name) not set when building type (Person)");
-	}
+			// when
+			ThrowingCallable whenOrElseThrowIsCalled = nameField::orElseThrow;
+
+			// then
+			Assertions.assertThatThrownBy(whenOrElseThrowIsCalled)
+					.isInstanceOf(MandatoryFieldMissingException.class)
+					.hasMessage("Mandatory field (name) not set when building type (Person)");
+		}
+
+		@Test
+		void returnFieldValue() {
+			// given
+			RequiredField<String> nameField = RequiredField.notNullableOfNameWithinType("name", "Person");
+			nameField.set("John");
+
+			// when
+			String value = nameField.orElseThrow();
 
-	@Test
-	void returnFieldValue() {
-		// given
-		RequiredField<String> nameField = RequiredField.ofNameWithinType("name", "Person");
-		nameField.set("John");
+			// then
+			Assertions.assertThat(value)
+					.isEqualTo("John");
+		}
 
-		// when
-		String value = nameField.orElseThrow();
+		@Test
+		void returnFieldValueWhenSetToNull() {
+			// given
+			RequiredField<String> nameField = RequiredField.notNullableOfNameWithinType("name", "Person");
+			nameField.set(null);
 
-		// then
-		Assertions.assertThat(value)
-				.isEqualTo("John");
+			// when
+			ThrowingCallable whenOrElseThrowIsCalled = nameField::orElseThrow;
+
+			// then
+			Assertions.assertThatThrownBy(whenOrElseThrowIsCalled)
+					.isInstanceOf(MandatoryFieldMissingException.class)
+					.hasMessage("Mandatory field (name) not set when building type (Person)");
+		}
 	}
 
+	@Nested
+	class NullableRequiredFieldTest {
+
+		@Test
+		void throwIllegalBuildExceptionWhenFieldValueIsNotSet() {
+			// given
+			RequiredField<String> nameField = RequiredField.nullableOfNameWithinType("name", "Person");
+
+			// when
+			ThrowingCallable whenOrElseThrowIsCalled = nameField::orElseThrow;
+
+			// then
+			Assertions.assertThatThrownBy(whenOrElseThrowIsCalled)
+					.isInstanceOf(MandatoryFieldMissingException.class)
+					.hasMessage("Mandatory field (name) not set when building type (Person)");
+		}
+
+		@Test
+		void returnFieldValue() {
+			// given
+			RequiredField<String> nameField = RequiredField.nullableOfNameWithinType("name", "Person");
+			nameField.set("John");
+
+			// when
+			String value = nameField.orElseThrow();
+
+			// then
+			Assertions.assertThat(value)
+					.isEqualTo("John");
+		}
+
+		@Test
+		void returnFieldValueWhenSetToNull() {
+			// given
+			RequiredField<String> nameField = RequiredField.nullableOfNameWithinType("name", "Person");
+			nameField.set(null);
+
+			// when
+			String value = nameField.orElseThrow();
+
+			// then
+			Assertions.assertThat(value)
+					.isEqualTo(null);
+		}
+	}
 }

processor/src/main/java/io/jonasg/bob/BuilderTypeSpecFactory.java

@@ -116,37 +116,58 @@ private List<MethodSpec> generateSetters() {
 	}
 
 	protected MethodSpec generateSetterForField(BuildableField field) {
+
 		var builder = MethodSpec.methodBuilder(setterName(field.fieldName()))
 				.addModifiers(Modifier.PUBLIC)
 				.returns(builderType())
 				.addParameter(TypeName.get(field.type()), field.fieldName());
-		if (field.isConstructorArgument() && isEnforcedConstructorPolicy() || field.isMandatory()) {
+		if (field.isConstructorArgument() && isAnEnforcedConstructorPolicy() || field.isMandatory()) {
 			builder.addStatement("this.$L.set($L)", field.fieldName(), field.fieldName());
+			if (isEnforcedAllowNullsConstructorPolicy()) {
+				builder.addStatement("this.fieldSet = true");
+			}
 		} else {
 			builder.addStatement("this.$L = $L", field.fieldName(), field.fieldName());
 		}
 		return builder.addStatement("return this")
 				.build();
 	}
 
+	private boolean isAnEnforcedConstructorPolicy() {
+		return this.buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED) ||
+				this.buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED_ALLOW_NULLS);
+	}
+
 	private boolean isEnforcedConstructorPolicy() {
 		return this.buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED);
 	}
 
+	private boolean isEnforcedAllowNullsConstructorPolicy() {
+		return this.buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED_ALLOW_NULLS);
+	}
+
 	private List<FieldSpec> generateFields() {
-		return buildableFields.stream()
+		var fieldSpecs = new ArrayList<>(buildableFields.stream()
 				.map(this::generateField)
-				.toList();
+				.toList());
+
+		if (isEnforcedAllowNullsConstructorPolicy()) {
+			fieldSpecs.add(FieldSpec.builder(TypeName.BOOLEAN, "fieldSet", Modifier.PRIVATE).build());
+		}
+		return fieldSpecs;
 	}
 
 	protected FieldSpec generateField(BuildableField field) {
-		if ((field.isConstructorArgument() && isEnforcedConstructorPolicy()) || field.isMandatory()) {
+		if (field.isConstructorArgument() && isAnEnforcedConstructorPolicy() || field.isMandatory()) {
+			String methodName = this.buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED)
+					? "notNullableOfNameWithinType"
+					: "nullableOfNameWithinType";
 			return FieldSpec
 					.builder(ParameterizedTypeName.get(ClassName.get(RequiredField.class),
 							TypeName.get(boxedType(field.type()))), field.fieldName(), Modifier.PRIVATE,
 							Modifier.FINAL)
-					.initializer("$T.ofNameWithinType(\"" + field.fieldName() + "\", \""
-							+ this.typeDefinition.typeName() + "\")", RequiredField.class)
+					.initializer("$T.$L(\"" + field.fieldName() + "\", \""
+							+ this.typeDefinition.typeName() + "\")", RequiredField.class, methodName)
 					.build();
 		} else {
 			return FieldSpec.builder(TypeName.get(field.type()), field.fieldName(), Modifier.PRIVATE)
@@ -189,7 +210,7 @@ protected String toConstructorCallingStatement(ConstructorDefinition constructor
 		return constructorDefinition.parameters().stream()
 				.map(param -> this.buildableFields.stream().anyMatch(f -> Objects.equals(f.fieldName(), param.name()))
 						? String.format("%s%s", param.name(),
-								buildable.constructorPolicy().equals(ConstructorPolicy.ENFORCED) ? ".orElseThrow()"
+								isAnEnforcedConstructorPolicy() ? ".orElseThrow()"
 										: "")
 						: defaultForType(param.type()))
 				.collect(Collectors.joining(", "));
@@ -209,7 +230,7 @@ private void createConstructorAndSetterAwareBuildMethod(Builder builder) {
 	}
 
 	protected CodeBlock generateFieldAssignment(BuildableField field) {
-		if (field.isConstructorArgument() && isEnforcedConstructorPolicy() || field.isMandatory()) {
+		if (field.isConstructorArgument() && isAnEnforcedConstructorPolicy() || field.isMandatory()) {
 			return CodeBlock.builder()
 					.addStatement("instance.$L(this.$L.orElseThrow())",
 							setterName(field.setterMethodName().orElseThrow()), field.fieldName())