* Renamed assumeThat() to that(). Users are expected to invoke "assert that()"

* Removed all public references to the validator configuration and the ability to create custom validator factories.
* Renamed Configuration.lazyExceptions to recordStacktrace.
* Use normal StampedLock because we don't actually need a reentrant lock.

Author: cowwoc

README.md

@@ -20,9 +20,9 @@ To get started, add this Maven dependency:
 ```xml
 
 <dependency>
-	<groupId>com.github.cowwoc.requirements</groupId>
-	<artifactId>java</artifactId>
-	<version>10.0</version>
+  <groupId>com.github.cowwoc.requirements</groupId>
+  <artifactId>java</artifactId>
+  <version>9.0.0</version>
 </dependency>
 ```
 
@@ -32,38 +32,38 @@ To get started, add this Maven dependency:
 import java.util.List;
 import java.util.StringJoiner;
 
-import static com.github.cowwoc.requirements10.java.DefaultJavaValidators.assumeThat;
 import static com.github.cowwoc.requirements10.java.DefaultJavaValidators.checkIf;
 import static com.github.cowwoc.requirements10.java.DefaultJavaValidators.requireThat;
+import static com.github.cowwoc.requirements10.java.DefaultJavaValidators.that;
 
 public final class Cake
 {
-	private byte bitesTaken = 0;
-	private int piecesLeft;
-
-	public Cake(int piecesLeft)
-	{
-		requireThat(piecesLeft, "piecesLeft").isPositive();
-		this.piecesLeft = piecesLeft;
-	}
-
-	public int eat()
-	{
-		++bitesTaken;
-		assert assumeThat(bitesTaken, "bitesTaken").isNotNegative().elseThrow();
-
-		piecesLeft -= ThreadLocalRandom.current().nextInt(5);
-
-		assert assumeThat(piecesLeft, "piecesLeft").isNotNegative().elseThrow();
-		return piecesLeft;
-	}
-
-	public List<String> getFailures()
-	{
-		return checkIf(bitesTaken, "bitesTaken").isNotNegative().
-			and(checkIf(piecesLeft, "piecesLeft").isGreaterThan(3)).
-			elseGetMessages();
-	}
+  private byte bitesTaken = 0;
+  private int piecesLeft;
+
+  public Cake(int piecesLeft)
+  {
+    requireThat(piecesLeft, "piecesLeft").isPositive();
+    this.piecesLeft = piecesLeft;
+  }
+
+  public int eat()
+  {
+    ++bitesTaken;
+    assert that(bitesTaken, "bitesTaken").isNotNegative();
+
+    piecesLeft -= ThreadLocalRandom.current().nextInt(5);
+
+    assert that(piecesLeft, "piecesLeft").isNotNegative();
+    return piecesLeft;
+  }
+
+  public List<String> getFailures()
+  {
+    return checkIf(bitesTaken, "bitesTaken").isNotNegative().
+      and(checkIf(piecesLeft, "piecesLeft").isGreaterThan(3)).
+      elseGetMessages();
+  }
 }
 ```
 
@@ -84,10 +84,8 @@ If you violate a **class invariant**:
 
 ```java
 Cake cake = new Cake(1_000_000);
-while(true)
-	cake.
-
-eat();
+while (true)
+  cake.eat();
 ```
 
 You'll get:
@@ -101,10 +99,8 @@ If you violate a **postcondition**:
 
 ```java
 Cake cake = new Cake(100);
-while(true)
-	cake.
-
-eat();
+while (true)
+  cake.eat();
 ```
 
 You'll get:
@@ -118,19 +114,12 @@ If you violate **multiple** conditions at once:
 
 ```java
 Cake cake = new Cake(1);
-cake.bitesTaken =-1;
-cake.piecesLeft =2;
+cake.bitesTaken = -1;
+cake.piecesLeft = 2;
 StringJoiner failures = new StringJoiner("\n\n");
-for(
-String failure :cake.
-
-getFailures())
-	failures.
-
-add(failure);
-System.out.
-
-println(failures);
+for (String failure : cake.getFailures())
+    failures.add(failure);
+System.out.println(failures);
 ```
 
 You'll get:
@@ -155,8 +144,6 @@ This library offers the following features:
 * [Multiple validation failures](docs/Features.md#multiple-validation-failures) that report all the errors at
   once
 * [Nested validations](docs/Features.md#nested-validations) that allow you to validate complex objects
-* [Logical operators](docs/Features.md#logical-operators) that allow you to combine the validation of
-  unrelated values
 * [String diff](docs/Features.md#string-diff) that shows the differences between two strings
 * [Performant and robust](docs/Performance.md)
 
@@ -167,34 +154,19 @@ The main entry points are:
 
 * [requireThat(value, name)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/DefaultJavaValidators.html#requireThat(T,java.lang.String))
   for method preconditions.
-* [assumeThat(value, name)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/DefaultJavaValidators.html#assumeThat(T,java.lang.String))
-  for class invariants, method postconditions and private methods.
-* [checkIfThat(value, name)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/DefaultJavaValidators.html#checkIf(T,java.lang.String))
+* [that(value, name)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/DefaultJavaValidators.html#that(T,java.lang.String))
+  for [class invariants, method postconditions and private methods](docs/Features.md#assertion-support). 
+* [checkIf(value, name)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/DefaultJavaValidators.html#checkIf(T,java.lang.String))
   for multiple failures and customized error handling.
-* [JavaValidators](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/JavaValidators.html)
-  for custom configurations.
-
-The first three methods use a shared configuration, while `JavaValidators` allows you to create an independent
-configuration.
-
-* `requireThat()` and `assumeThat()` throw an exception on the first validation failure.
-* `checkIf()` returns multiple validation failures at once. It is more flexible than the others, but its
-  syntax
-  is more verbose.
-
-Thrown exceptions may be configured
-using [ConfigurationUpdater.exceptionTransformer(Function)](https://cowwoc.github.io/requirements.java/10.0/docs/api/com.github.cowwoc.requirements.java/com/github/cowwoc/requirements10/java/ConfigurationUpdater.html#exceptionTransformer(java.util.function.Function)).
 
 See the [API documentation](https://cowwoc.github.io/requirements.java/10.0/docs/api/) for more details.
 
-## Tips
+## Best practices
 
-* Use `assert` with `assumeThat().elseThrow()` for sanity checks. When assertions are disabled, the checks
-  will get removed.
 * Use `checkIf().elseGetMessages()` to return failure messages without throwing an exception.
   This is the fastest validation approach, ideal for web services.
 * To enhance the clarity of failure messages, you should provide parameter names, even when they are optional.
-  In other words, favor `assumeThat(value, name)` to `assumeThat(value)`.
+  In other words, favor `assert that(value, name)` over `assert that(value)`.
 
 ## Third-party libraries and tools
 

benchmark/assertj/src/test/java/com/github/cowwoc/requirements10/benchmark/assertj/AssertJTest.java

@@ -28,7 +28,7 @@
 @SuppressWarnings({"CanBeFinal", "LongLine", "FieldCanBeLocal", "FieldMayBeFinal"})
 public class AssertJTest
 {
-	private static final boolean FAST_ESTIMATE = false;
+	private static final boolean FAST_ESTIMATE = Boolean.getBoolean("FAST_ESTIMATE");
 	// Fields may not be final:
 	// https://github.com/openjdk/jmh/blob/cb3c3a90137dad781a2a37fda72dc11ebf253593/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_10_ConstantFold.java#L58
 	private String name = "map";

benchmark/benchmark.xlsx

@@ -25,7 +25,7 @@
 @SuppressWarnings({"FieldCanBeLocal", "CanBeFinal", "LongLine"})
 public class GuavaTest
 {
-	private static final boolean FAST_ESTIMATE = false;
+	private static final boolean FAST_ESTIMATE = Boolean.getBoolean("FAST_ESTIMATE");
 	// Fields may not be final:
 	// https://github.com/openjdk/jmh/blob/cb3c3a90137dad781a2a37fda72dc11ebf253593/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_10_ConstantFold.java#L58
 	private String name = "multimap";

benchmark/guava/src/test/java/com/github/cowwoc/requirements10/benchmark/guava/GuavaTest.java

@@ -4,8 +4,8 @@
  */
 package com.github.cowwoc.requirements10.benchmark.java;
 
-import com.github.cowwoc.requirements10.java.ConfigurationUpdater;
-import com.github.cowwoc.requirements10.java.JavaValidators;
+import com.github.cowwoc.requirements10.java.internal.ConfigurationUpdater;
+import com.github.cowwoc.requirements10.java.internal.JavaValidators;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.Scope;
@@ -26,23 +26,23 @@
 @SuppressWarnings({"CanBeFinal", "LongLine", "FieldCanBeLocal", "FieldMayBeFinal"})
 public class ExceptionTest
 {
-	private static final boolean FAST_ESTIMATE = false;
+	private static final boolean FAST_ESTIMATE = Boolean.getBoolean("FAST_ESTIMATE");
 	// Fields may not be final:
 	// https://github.com/openjdk/jmh/blob/cb3c3a90137dad781a2a37fda72dc11ebf253593/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_10_ConstantFold.java#L58
 	private String name = "map";
 	private Map<Integer, Integer> value;
 	private JavaValidators validators = JavaValidators.newInstance();
 	private JavaValidators withoutCleanStackTrace = JavaValidators.newInstance();
-	private JavaValidators withoutLazy = JavaValidators.newInstance();
+	private JavaValidators withoutRecordStacktrace = JavaValidators.newInstance();
 
 	public ExceptionTest()
 	{
 		value = HashMap.newHashMap(5);
 		for (int i = 0; i < 5; ++i)
 			value.put(i, 5 - i);
-		try (ConfigurationUpdater config = withoutLazy.updateConfiguration())
+		try (ConfigurationUpdater config = withoutRecordStacktrace.updateConfiguration())
 		{
-			config.lazyExceptions(false);
+			config.recordStacktrace(false);
 		}
 		try (ConfigurationUpdater config = withoutCleanStackTrace.updateConfiguration())
 		{
@@ -78,57 +78,57 @@ public void requireThatIsSuccessful(Blackhole bh)
 		bh.consume(validators.requireThat(value, name).size().isGreaterThan(3));
 	}
 
-	@Benchmark
-	public void throwExceptionCatchException(Blackhole bh)
-	{
-		try
-		{
-			throw new IllegalArgumentException("Hard-coded exception");
-		}
-		catch (IllegalArgumentException e)
-		{
-			// The stack trace is not populated unless we explicitly invoke getStackTrace()
-			bh.consume(e.getStackTrace());
-		}
-	}
-
-	@Benchmark
-	public void requireThatWithCleanStackTrace(Blackhole bh)
-	{
-		try
-		{
-			validators.requireThat(value, name).size().isLessThan(3);
-		}
-		catch (IllegalArgumentException e)
-		{
-			// The stack trace is not populated unless we explicitly invoke getStackTrace()
-			bh.consume(e.getStackTrace());
-		}
-	}
-
-	@Benchmark
-	public void requireThatWithoutCleanStackTrace(Blackhole bh)
-	{
-		try
-		{
-			withoutCleanStackTrace.requireThat(value, name).size().isLessThan(3);
-		}
-		catch (IllegalArgumentException e)
-		{
-			// The stack trace is not populated unless we explicitly invoke getStackTrace()
-			bh.consume(e.getStackTrace());
-		}
-	}
-
-	@Benchmark
-	public void checkIfAndGetMessagesWithLazyExceptions(Blackhole bh)
-	{
-		bh.consume(validators.checkIf(value, name).isNull().elseGetMessages());
-	}
-
-	@Benchmark
-	public void checkIfAndGetMessagesWithoutLazyExceptions(Blackhole bh)
-	{
-		bh.consume(withoutLazy.checkIf(value, name).isNull().elseGetMessages());
-	}
+//	@Benchmark
+//	public void throwExceptionCatchException(Blackhole bh)
+//	{
+//		try
+//		{
+//			throw new IllegalArgumentException("Hard-coded exception");
+//		}
+//		catch (IllegalArgumentException e)
+//		{
+//			// The stack trace is not populated unless we explicitly invoke getStackTrace()
+//			bh.consume(e.getStackTrace());
+//		}
+//	}
+//
+//	@Benchmark
+//	public void requireThatWithCleanStackTrace(Blackhole bh)
+//	{
+//		try
+//		{
+//			validators.requireThat(value, name).size().isLessThan(3);
+//		}
+//		catch (IllegalArgumentException e)
+//		{
+//			// The stack trace is not populated unless we explicitly invoke getStackTrace()
+//			bh.consume(e.getStackTrace());
+//		}
+//	}
+//
+//	@Benchmark
+//	public void requireThatWithoutCleanStackTrace(Blackhole bh)
+//	{
+//		try
+//		{
+//			withoutCleanStackTrace.requireThat(value, name).size().isLessThan(3);
+//		}
+//		catch (IllegalArgumentException e)
+//		{
+//			// The stack trace is not populated unless we explicitly invoke getStackTrace()
+//			bh.consume(e.getStackTrace());
+//		}
+//	}
+//
+//	@Benchmark
+//	public void checkIfAndGetMessagesWithRecordStacktrace(Blackhole bh)
+//	{
+//		bh.consume(validators.checkIf(value, name).isNull().elseGetMessages());
+//	}
+//
+//	@Benchmark
+//	public void checkIfAndGetMessagesWithoutRecordStacktrace(Blackhole bh)
+//	{
+//		bh.consume(withoutRecordStacktrace.checkIf(value, name).isNull().elseGetMessages());
+//	}
 }