Add TransformedNamesComparison.IgnorePrefix name comparison

Adds a base `IgnorePrefix(prefix)` comparison that matches a source name to
a target name after stripping a fixed prefix from the source side. This is
common for code-generated types such as Protobuf enums whose variants repeat
the enum name as a prefix.

`IgnorePrefix` is intentionally not `sealed` so downstream code can extend it
(`case object Foo extends TransformedNamesComparison.IgnorePrefix("Foo")`),
which is the documented usage; a test object defined in another file guards
this. Ships with unit tests and a user-facing entry in
supported-transformations.md.

Co-authored-by: Mateusz Kubuszok <mateusz.kubuszok@gmail.com>

Author: Yann Moisan

chimney/src/main/scala/io/scalaland/chimney/dsl/TransformedNamesComparison.scala

@@ -76,6 +76,12 @@ object TransformedNamesComparison {
     }
   }
 
+  /** Matches names after stripping a fixed prefix from the source name. */
+  abstract class IgnorePrefix(prefix: String) extends TransformedNamesComparison { this: Singleton =>
+
+    def namesMatch(fromName: String, toName: String): Boolean = fromName == prefix + toName
+  }
+
   type FieldDefault = BeanAware.type
   val FieldDefault: FieldDefault = BeanAware
 

chimney/src/test/scala/io/scalaland/chimney/TransformedNamesComparisonSpec.scala

@@ -110,4 +110,28 @@ class TransformedNamesComparisonSpec extends ChimneySpec {
     }
 
   }
+
+  group("TransformedNamesComparison.IgnorePrefix") {
+
+    test("should match when the source name equals the prefix followed by the target name") {
+      IgnoreFooPrefix.namesMatch("FooBar", "Bar") ==> true
+      IgnoreFooPrefix.namesMatch("FooBaz", "Baz") ==> true
+    }
+
+    test("should match identical names only when the prefix is empty") {
+      IgnoreFooPrefix.namesMatch("Bar", "Bar") ==> false
+      IgnoreFooPrefix.namesMatch("Foo", "Foo") ==> false
+    }
+
+    test("should not match when the prefix is missing or the names differ") {
+      IgnoreFooPrefix.namesMatch("Bar", "FooBar") ==> false
+      IgnoreFooPrefix.namesMatch("BarFoo", "Bar") ==> false
+      IgnoreFooPrefix.namesMatch("FooBar", "Baz") ==> false
+    }
+  }
 }
+
+/** Extended outside of `TransformedNamesComparison` to make sure `IgnorePrefix` is not `sealed` and can be reused by
+  * downstream code, as documented.
+  */
+case object IgnoreFooPrefix extends TransformedNamesComparison.IgnorePrefix("Foo")

docs/docs/supported-transformations.md

@@ -6227,8 +6227,13 @@ Arguments taken by both `.enableCustomFieldNameComparison` and `.enableCustomSub
   `true`
  - `TransformedNamesComparison.CamelSnakeCaseEquality` - 2 names are considered equal if they are identical `String`s OR if they are
    identical after you convert them from snake to camel case (e.g. `snake_case` -> `snakeCase`, `camelCase` -> `camelCase`)
+ - `TransformedNamesComparison.IgnorePrefix` - a base class (rather than a ready-to-use value) that you extend with a fixed
+   prefix, e.g. `case object FooNamesComparison extends TransformedNamesComparison.IgnorePrefix("Foo")`. The source name
+   matches the target name if it equals the prefix followed by the target name (e.g. `FooBar` matches `Bar`). This is handy for
+   code-generated types such as Protobuf enums whose variants
+   [repeat the enum name as a prefix](https://buf.build/blog/totw-3-enum-names-need-prefixes)
 
-However, these 4 do not exhaust all possible comparisons, and you might need to provide one yourself. 
+However, these 5 do not exhaust all possible comparisons, and you might need to provide one yourself. 
 
 !!! warning