Add support for schema/fix class prefix validation and update related tests and documentation

Author: Splatcrafter

CHANGELOG.md

@@ -40,7 +40,9 @@ New module for schema analysis, validation, and migration coverage checking.
 - `StructureValidator` — Validates schema structure (cycles, version ordering, parent chains)
 - `ConventionChecker` — Validates naming conventions for types, fields, classes
 - `ConventionRules` — Configurable naming rules (STRICT, RELAXED, NONE, or custom)
-- Predefined patterns for snake_case, camelCase, class suffixes
+- Schema class prefix/suffix validation (e.g., "Schema" prefix for Schema100, Schema200)
+- Fix class prefix/suffix validation (e.g., "Fix" suffix for PlayerNameFix)
+- Predefined patterns for snake_case, camelCase
 - Custom validators via `customTypeValidator()` and `customFieldValidator()`
 
 **Type Introspection (`schematools.introspection`):**

aether-datafixers-schema-tools/src/main/java/de/splatgames/aether/datafixers/schematools/validation/ConventionChecker.java

@@ -114,8 +114,8 @@ public static ValidationResult checkSchema(
         if (!rules.isValidSchemaClassName(schemaClassName)) {
             result.add(createIssue(
                     CONVENTION_SCHEMA_CLASS,
-                    "Schema class name '" + schemaClassName + "' should end with '"
-                            + rules.schemaClassSuffix() + "'",
+                    buildClassNameViolationMessage(schemaClassName, "Schema",
+                            rules.schemaClassPrefix(), rules.schemaClassSuffix()),
                     schemaLocation,
                     rules
             ));
@@ -174,8 +174,8 @@ public static ValidationResult checkFix(
         if (!rules.isValidFixClassName(fixClassName)) {
             result.add(createIssue(
                     CONVENTION_FIX_CLASS,
-                    "Fix class name '" + fixClassName + "' should end with '"
-                            + rules.fixClassSuffix() + "'",
+                    buildClassNameViolationMessage(fixClassName, "Fix",
+                            rules.fixClassPrefix(), rules.fixClassSuffix()),
                     "Fix@" + fix.toVersion().getVersion(),
                     rules
             ));
@@ -215,6 +215,39 @@ private static void checkFieldNames(
         }
     }
 
+    /**
+     * Builds a descriptive message for class name convention violations.
+     *
+     * @param className the actual class name
+     * @param type      the type of class (e.g., "Schema", "Fix")
+     * @param prefix    the expected prefix, or {@code null}
+     * @param suffix    the expected suffix, or {@code null}
+     * @return the violation message
+     */
+    @NotNull
+    private static String buildClassNameViolationMessage(
+            @NotNull final String className,
+            @NotNull final String type,
+            final String prefix,
+            final String suffix
+    ) {
+        final StringBuilder message = new StringBuilder();
+        message.append(type).append(" class name '").append(className).append("' should ");
+
+        if (prefix != null && suffix != null) {
+            message.append("start with '").append(prefix)
+                    .append("' and end with '").append(suffix).append("'");
+        } else if (prefix != null) {
+            message.append("start with '").append(prefix).append("'");
+        } else if (suffix != null) {
+            message.append("end with '").append(suffix).append("'");
+        } else {
+            message.append("follow naming conventions");
+        }
+
+        return message.toString();
+    }
+
     /**
      * Creates a validation issue with the appropriate severity based on rules.
      */

aether-datafixers-schema-tools/src/main/java/de/splatgames/aether/datafixers/schematools/validation/ConventionRules.java

@@ -75,14 +75,14 @@ public final class ConventionRules {
      * <ul>
      *   <li>Type names must be snake_case</li>
      *   <li>Field names must be snake_case</li>
-     *   <li>Schema class names must end with "Schema"</li>
-     *   <li>DataFix class names must end with "Fix"</li>
+     *   <li>Schema class names must start with "Schema" (e.g., Schema100, Schema200)</li>
+     *   <li>DataFix class names must end with "Fix" (e.g., PlayerNameFix)</li>
      * </ul>
      */
     public static final ConventionRules STRICT = builder()
             .typeNamePattern(Pattern.compile("^[a-z][a-z0-9_]*$"))
             .fieldNamePattern(Pattern.compile("^[a-z][a-z0-9_]*$"))
-            .schemaClassSuffix("Schema")
+            .schemaClassPrefix("Schema")
             .fixClassSuffix("Fix")
             .treatViolationsAsErrors(true)
             .build();
@@ -128,11 +128,21 @@ public final class ConventionRules {
      */
     private final String typeNamePrefix;
 
+    /**
+     * Expected prefix for schema class names (e.g., "Schema"), or {@code null} to skip.
+     */
+    private final String schemaClassPrefix;
+
     /**
      * Expected suffix for schema class names (e.g., "Schema"), or {@code null} to skip.
      */
     private final String schemaClassSuffix;
 
+    /**
+     * Expected prefix for fix class names, or {@code null} to skip.
+     */
+    private final String fixClassPrefix;
+
     /**
      * Expected suffix for fix class names (e.g., "Fix"), or {@code null} to skip.
      */
@@ -162,7 +172,9 @@ public final class ConventionRules {
      * @param typeNamePattern         pattern for type names
      * @param fieldNamePattern        pattern for field names
      * @param typeNamePrefix          required prefix for type names
+     * @param schemaClassPrefix       expected prefix for schema classes
      * @param schemaClassSuffix       expected suffix for schema classes
+     * @param fixClassPrefix          expected prefix for fix classes
      * @param fixClassSuffix          expected suffix for fix classes
      * @param treatViolationsAsErrors whether violations are errors
      * @param customTypeValidator     custom type name validator
@@ -173,7 +185,9 @@ private ConventionRules(
             final Pattern typeNamePattern,
             final Pattern fieldNamePattern,
             final String typeNamePrefix,
+            final String schemaClassPrefix,
             final String schemaClassSuffix,
+            final String fixClassPrefix,
             final String fixClassSuffix,
             final boolean treatViolationsAsErrors,
             final Predicate<String> customTypeValidator,
@@ -183,7 +197,9 @@ private ConventionRules(
         this.typeNamePattern = typeNamePattern;
         this.fieldNamePattern = fieldNamePattern;
         this.typeNamePrefix = typeNamePrefix;
+        this.schemaClassPrefix = schemaClassPrefix;
         this.schemaClassSuffix = schemaClassSuffix;
+        this.fixClassPrefix = fixClassPrefix;
         this.fixClassSuffix = fixClassSuffix;
         this.treatViolationsAsErrors = treatViolationsAsErrors;
         this.customTypeValidator = customTypeValidator;
@@ -269,33 +285,59 @@ public boolean isValidFieldName(@NotNull final String fieldName) {
     /**
      * Validates a schema class name against conventions.
      *
+     * <p>Checks both prefix and suffix if configured. For example, with prefix "Schema",
+     * valid names include: Schema100, Schema200, SchemaV1.</p>
+     *
      * @param className the class name to validate, must not be {@code null}
      * @return {@code true} if the name follows conventions
      */
     public boolean isValidSchemaClassName(@NotNull final String className) {
         Preconditions.checkNotNull(className, "className must not be null");
 
-        if (!this.enabled || this.schemaClassSuffix == null) {
+        if (!this.enabled) {
             return true;
         }
 
-        return className.endsWith(this.schemaClassSuffix);
+        // Check prefix
+        if (this.schemaClassPrefix != null && !className.startsWith(this.schemaClassPrefix)) {
+            return false;
+        }
+
+        // Check suffix
+        if (this.schemaClassSuffix != null && !className.endsWith(this.schemaClassSuffix)) {
+            return false;
+        }
+
+        return true;
     }
 
     /**
      * Validates a fix class name against conventions.
      *
+     * <p>Checks both prefix and suffix if configured. For example, with suffix "Fix",
+     * valid names include: PlayerNameFix, SwordRenameFix.</p>
+     *
      * @param className the class name to validate, must not be {@code null}
      * @return {@code true} if the name follows conventions
      */
     public boolean isValidFixClassName(@NotNull final String className) {
         Preconditions.checkNotNull(className, "className must not be null");
 
-        if (!this.enabled || this.fixClassSuffix == null) {
+        if (!this.enabled) {
             return true;
         }
 
-        return className.endsWith(this.fixClassSuffix);
+        // Check prefix
+        if (this.fixClassPrefix != null && !className.startsWith(this.fixClassPrefix)) {
+            return false;
+        }
+
+        // Check suffix
+        if (this.fixClassSuffix != null && !className.endsWith(this.fixClassSuffix)) {
+            return false;
+        }
+
+        return true;
     }
 
     /**
@@ -325,6 +367,15 @@ public String typeNamePrefix() {
         return this.typeNamePrefix;
     }
 
+    /**
+     * Returns the expected schema class prefix.
+     *
+     * @return the prefix, or {@code null} if not required
+     */
+    public String schemaClassPrefix() {
+        return this.schemaClassPrefix;
+    }
+
     /**
      * Returns the expected schema class suffix.
      *
@@ -334,6 +385,15 @@ public String schemaClassSuffix() {
         return this.schemaClassSuffix;
     }
 
+    /**
+     * Returns the expected fix class prefix.
+     *
+     * @return the prefix, or {@code null} if not required
+     */
+    public String fixClassPrefix() {
+        return this.fixClassPrefix;
+    }
+
     /**
      * Returns the expected fix class suffix.
      *
@@ -361,7 +421,9 @@ public static final class Builder {
         private Pattern typeNamePattern;
         private Pattern fieldNamePattern;
         private String typeNamePrefix;
+        private String schemaClassPrefix;
         private String schemaClassSuffix;
+        private String fixClassPrefix;
         private String fixClassSuffix;
         private boolean treatViolationsAsErrors = false;
         private Predicate<String> customTypeValidator;
@@ -418,6 +480,21 @@ public Builder requireTypePrefix(final String prefix) {
             return this;
         }
 
+        /**
+         * Sets the expected prefix for schema class names.
+         *
+         * <p>For example, with prefix "Schema", valid class names include:
+         * Schema100, Schema200, SchemaV1.</p>
+         *
+         * @param prefix the expected prefix (e.g., "Schema"), or {@code null} to skip
+         * @return this builder for chaining
+         */
+        @NotNull
+        public Builder schemaClassPrefix(final String prefix) {
+            this.schemaClassPrefix = prefix;
+            return this;
+        }
+
         /**
          * Sets the expected suffix for schema class names.
          *
@@ -430,9 +507,24 @@ public Builder schemaClassSuffix(final String suffix) {
             return this;
         }
 
+        /**
+         * Sets the expected prefix for fix class names.
+         *
+         * @param prefix the expected prefix, or {@code null} to skip
+         * @return this builder for chaining
+         */
+        @NotNull
+        public Builder fixClassPrefix(final String prefix) {
+            this.fixClassPrefix = prefix;
+            return this;
+        }
+
         /**
          * Sets the expected suffix for fix class names.
          *
+         * <p>For example, with suffix "Fix", valid class names include:
+         * PlayerNameFix, SwordRenameFix.</p>
+         *
          * @param suffix the expected suffix (e.g., "Fix"), or {@code null} to skip
          * @return this builder for chaining
          */
@@ -490,7 +582,9 @@ public ConventionRules build() {
                     this.typeNamePattern,
                     this.fieldNamePattern,
                     this.typeNamePrefix,
+                    this.schemaClassPrefix,
                     this.schemaClassSuffix,
+                    this.fixClassPrefix,
                     this.fixClassSuffix,
                     this.treatViolationsAsErrors,
                     this.customTypeValidator,

aether-datafixers-schema-tools/src/test/java/de/splatgames/aether/datafixers/schematools/validation/ConventionCheckerTest.java

@@ -155,9 +155,10 @@ void typeNameIssueHasLocation() {
 
             final ValidationResult result = ConventionChecker.checkSchema(schema, ConventionRules.STRICT);
 
-            assertThat(result.issues()).isNotEmpty();
-            assertThat(result.issues().get(0).location()).isPresent();
-            assertThat(result.issues().get(0).location().orElseThrow()).contains("BadName");
+            final var typeNameIssues = result.byCode(ConventionChecker.CONVENTION_TYPE_NAME);
+            assertThat(typeNameIssues).isNotEmpty();
+            assertThat(typeNameIssues.get(0).location()).isPresent();
+            assertThat(typeNameIssues.get(0).location().orElseThrow()).contains("BadName");
         }
 
         @Test
@@ -169,8 +170,9 @@ void typeNameIssueHasContext() {
 
             final ValidationResult result = ConventionChecker.checkSchema(schema, ConventionRules.STRICT);
 
-            assertThat(result.issues()).isNotEmpty();
-            assertThat(result.issues().get(0).context()).containsKey("typeName");
+            final var typeNameIssues = result.byCode(ConventionChecker.CONVENTION_TYPE_NAME);
+            assertThat(typeNameIssues).isNotEmpty();
+            assertThat(typeNameIssues.get(0).context()).containsKey("typeName");
         }
 
         @Test
@@ -199,8 +201,9 @@ void issueMessageContainsPatternInfo() {
 
             final ValidationResult result = ConventionChecker.checkSchema(schema, ConventionRules.STRICT);
 
-            assertThat(result.issues()).isNotEmpty();
-            assertThat(result.issues().get(0).message()).contains("pattern");
+            final var typeNameIssues = result.byCode(ConventionChecker.CONVENTION_TYPE_NAME);
+            assertThat(typeNameIssues).isNotEmpty();
+            assertThat(typeNameIssues.get(0).message()).contains("pattern");
         }
     }
 
@@ -295,7 +298,15 @@ void handlesNestedFieldTypes() {
         void handlesEmptySchema() {
             final Schema schema = MockSchemas.minimal(100);
 
-            final ValidationResult result = ConventionChecker.checkSchema(schema, ConventionRules.STRICT);
+            // Use custom rules that only check type/field names, not schema class names
+            // (MockSchemas generates class names like "MinimalSchema" that don't match prefix rules)
+            final ConventionRules rules = ConventionRules.builder()
+                    .typeNamePattern(ConventionRules.STRICT.typeNamePattern())
+                    .fieldNamePattern(ConventionRules.STRICT.fieldNamePattern())
+                    .treatViolationsAsErrors(true)
+                    .build();
+
+            final ValidationResult result = ConventionChecker.checkSchema(schema, rules);
 
             assertThat(result.issues()).isEmpty();
         }