Rename ignoringFieldsByRegexes to ignoringFieldsMatchingRegexes and ignoreFieldsByRegexes to ignoreFieldsMatchingRegexes.

Author: joel-costigliola

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert.java

@@ -300,20 +300,20 @@ public RecursiveComparisonAssert ignoringFields(String... fieldsToIgnore) {
    *
    * // assertion succeeds as name and all home fields are ignored in the comparison
    * assertThat(sherlock).usingRecursiveComparison()
-   *                     .ignoringFieldsByRegexes("n.me", "home.*")
+   *                     .ignoringFieldsMatchingRegexes("n.me", "home.*")
    *                     .isEqualTo(noName);
    *
    * // although home fields are ignored, assertion fails as name fields differ.
    * assertThat(sherlock).usingRecursiveComparison()
-   *                     .ignoringFields("home.*")
+   *                     .ignoringFieldsMatchingRegexes("home.*")
    *                     .isEqualTo(noName);</code></pre>
    *
    * @param regexes regexes used to ignore fields in the comparison.
    * @return this {@link RecursiveComparisonAssert} to chain other methods.
    */
   @CheckReturnValue
-  public RecursiveComparisonAssert ignoringFieldsByRegexes(String... regexes) {
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes(regexes);
+  public RecursiveComparisonAssert ignoringFieldsMatchingRegexes(String... regexes) {
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes(regexes);
     return this;
   }
 

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration.java

@@ -116,11 +116,11 @@ public void ignoreFields(String... fieldsToIgnore) {
   /**
    * Allows to ignore in the recursive comparison the object under test fields matching the given regexes. The given regexes are added to the already registered ones.
    * <p>
-   * See {@link RecursiveComparisonAssert#ignoringFieldsByRegexes(String...) RecursiveComparisonAssert#ignoringFieldsByRegexes(String...)} for examples.
+   * See {@link RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...) RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...)} for examples.
    *
    * @param regexes regexes used to ignore fields in the comparison.
    */
-  public void ignoreFieldsByRegexes(String... regexes) {
+  public void ignoreFieldsMatchingRegexes(String... regexes) {
     ignoredFieldsRegexes.addAll(Stream.of(regexes)
                                       .map(Pattern::compile)
                                       .collect(toList()));

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_fluent_API_Test.java

@@ -105,13 +105,13 @@ public void should_allow_to_ignore_fields() {
   }
 
   @Test
-  public void should_allow_to_ignore_fields_by_regexes() {
+  public void should_allow_to_ignore_fields_matching_regexes() {
     // GIVEN
     String regex1 = "foo";
     String regex2 = ".*foo.*";
     // WHEN
     RecursiveComparisonConfiguration configuration = assertThat(ACTUAL).usingRecursiveComparison()
-                                                                       .ignoringFieldsByRegexes(regex1, regex2)
+                                                                       .ignoringFieldsMatchingRegexes(regex1, regex2)
                                                                        .getRecursiveComparisonConfiguration();
     // THEN
     assertThat(configuration.getIgnoredFieldsRegexes()).extracting(Pattern::pattern)

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_isEqualTo_Test.java

@@ -321,7 +321,7 @@ public void should_fail_when_actual_differs_from_expected_even_when_some_fields_
     expected.neighbour.neighbour = new Person("James");
     expected.neighbour.neighbour.home.address.number = 457;
 
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes(".*name", ".*home.*number");
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes(".*name", ".*home.*number");
 
     // WHEN
     compareRecursivelyFailsAsExpected(actual, expected);

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration_multiLineDescription_Test.java

@@ -60,7 +60,7 @@ public void should_show_that_some_given_fields_are_ignored() {
   @Test
   public void should_show_the_regexes_used_to_ignore_fields() {
     // WHEN
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes("foo", "bar", "foo.bar");
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes("foo", "bar", "foo.bar");
     String multiLineDescription = recursiveComparisonConfiguration.multiLineDescription(STANDARD_REPRESENTATION);
     // THEN
     assertThat(multiLineDescription).contains(format("- the fields matching the following regexes were ignored in the comparison: foo, bar, foo.bar%n"));
@@ -161,7 +161,7 @@ public void should_show_a_complete_multiline_description() {
     // GIVEN
     recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);
     recursiveComparisonConfiguration.ignoreFields("foo", "bar", "foo.bar");
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes("f.*", ".ba.", "..b%sr..");
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes("f.*", ".ba.", "..b%sr..");
     recursiveComparisonConfiguration.ignoreOverriddenEqualsForFieldsMatchingRegexes(".*oo", ".ar", "oo.ba");
     recursiveComparisonConfiguration.ignoreOverriddenEqualsForTypes(String.class, Multimap.class);
     recursiveComparisonConfiguration.ignoreOverriddenEqualsForFields("foo", "baz", "foo.baz");

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration_shouldIgnoreFields_Test.java

@@ -94,18 +94,18 @@ private static Stream<Arguments> ignoringSpecifiedFieldsSource() {
   @Test
   public void ignoring_fields_with_regex_does_not_replace_previous_regexes() {
     // WHEN
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes("foo");
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes("bar", "baz");
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes("foo");
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes("bar", "baz");
     // THEN
     assertThat(recursiveComparisonConfiguration.getIgnoredFieldsRegexes()).extracting(Pattern::pattern)
                                                                           .containsExactlyInAnyOrder("foo", "bar", "baz");
   }
 
   @ParameterizedTest(name = "{0} should be ignored with these regexes {1}")
   @MethodSource("ignoringRegexSpecifiedFieldsSource")
-  public void should_ignore_fields_specified_with_regex(DualKey dualKey, List<String> regexes) {
+  public void should_ignore_fields_matching_given_regexes(DualKey dualKey, List<String> regexes) {
     // GIVEN
-    recursiveComparisonConfiguration.ignoreFieldsByRegexes(regexes.toArray(new String[0]));
+    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes(regexes.toArray(new String[0]));
     // WHEN
     boolean ignored = recursiveComparisonConfiguration.shouldIgnore(dualKey);
     // THEN