Move Fix command enums to individual classes.

metafix/src/main/java/org/metafacture/metafix/FixBind.java

@@ -17,93 +17,39 @@
 package org.metafacture.metafix;
 
 import org.metafacture.metafix.api.FixContext;
+import org.metafacture.metafix.bind.*; // checkstyle-disable-line AvoidStarImport
 
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
+@Deprecated(since = "7.1.0", forRemoval = true)
 public enum FixBind implements FixContext {
 
     list {
         @Override
         public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {
-            final String scopeVariable = options.get("var");
-            Value.asList(record.get(options.get("path")), a -> {
-                for (int i = 0; i < a.size(); ++i) {
-                    final Value value = a.get(i);
-
-                    // with var -> keep full record in scope, add the var:
-                    if (scopeVariable != null) {
-                        record.put(scopeVariable, value, false);
-                        recordTransformer.transform(record);
-                        record.remove(scopeVariable);
-                    }
-                    // w/o var -> use the currently bound value as the record:
-                    else {
-                        final int index = i;
-
-                        value.matchType()
-                            .ifHash(h -> {
-                                final Record scopeRecord = new Record();
-                                scopeRecord.addAll(h);
-
-                                recordTransformer.transform(scopeRecord);
-                                a.set(index, new Value(scopeRecord));
-                            })
-                            // TODO: bind to arrays (if that makes sense) and strings (access with '.')
-                            .orElseThrow();
-                    }
-                }
-            });
+            new org.metafacture.metafix.bind.List().execute(metafix, record, params, options, recordTransformer);
         }
     },
 
     list_as {
         @Override
         public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {
-            final Map<String, Value.Array> lists = new HashMap<>();
-            options.forEach((k, v) -> Value.asList(record.get(v), a -> lists.put(k, a)));
-
-            final int size = lists.values().stream().mapToInt(a -> a.size()).max().orElse(0);
-            for (int i = 0; i < size; ++i) {
-                final int index = i;
-
-                lists.forEach((k, v) -> {
-                    final Value value = index < v.size() ? v.get(index) : null;
-
-                    if (value != null) {
-                        record.put(k, value);
-                    }
-                    else {
-                        record.remove(k);
-                    }
-                });
-
-                recordTransformer.transform(record);
-            }
-
-            lists.keySet().forEach(record::remove);
+            new ListAs().execute(metafix, record, params, options, recordTransformer);
         }
     },
 
     once {
-        private final Map<Metafix, Set<String>> executed = new HashMap<>();
-
         @Override
         public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {
-            if (executed.computeIfAbsent(metafix, k -> new HashSet<>()).add(params.isEmpty() ? null : params.get(0))) {
-                recordTransformer.transform(record);
-            }
+            new Once().execute(metafix, record, params, options, recordTransformer);
         }
     },
 
     put_macro {
         @Override
         public void execute(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options, final RecordTransformer recordTransformer) {
-            recordTransformer.setVars(options);
-            metafix.putMacro(params.get(0), recordTransformer);
+            new PutMacro().execute(metafix, record, params, options, recordTransformer);
         }
     }
 

metafix/src/main/java/org/metafacture/metafix/FixCommand.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2025 hbz NRW
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.metafacture.metafix;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface FixCommand {
+
+    /**
+     * Returns the Fix command name.
+     *
+     * @return Fix command name
+     */
+    String value();
+
+}

metafix/src/main/java/org/metafacture/metafix/FixConditional.java

@@ -17,183 +17,168 @@
 package org.metafacture.metafix;
 
 import org.metafacture.metafix.api.FixPredicate;
+import org.metafacture.metafix.conditional.*; // checkstyle-disable-line AvoidStarImport
 
 import java.util.List;
 import java.util.Map;
 
+@Deprecated(since = "7.1.0", forRemoval = true) // checkstyle-disable-line ClassDataAbstractionCoupling|ClassFanOutComplexity
 public enum FixConditional implements FixPredicate {
 
     all_contain {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ALL, CONTAINS);
+            return new AllContain().test(metafix, record, params, options);
         }
     },
     any_contain {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ANY, CONTAINS);
+            return new AnyContain().test(metafix, record, params, options);
         }
     },
     none_contain {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return !any_contain.test(metafix, record, params, options);
+            return new NoneContain().test(metafix, record, params, options);
         }
     },
     str_contain {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(params, CONTAINS);
+            return new StrContain().test(metafix, record, params, options);
         }
     },
 
     all_equal {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ALL, EQUALS);
+            return new AllEqual().test(metafix, record, params, options);
         }
     },
     any_equal {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ANY, EQUALS);
+            return new AnyEqual().test(metafix, record, params, options);
         }
     },
     none_equal {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return !any_equal.test(metafix, record, params, options);
+            return new NoneEqual().test(metafix, record, params, options);
         }
     },
     str_equal {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(params, EQUALS);
+            return new StrEqual().test(metafix, record, params, options);
         }
     },
 
     exists {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return record.containsPath(params.get(0));
+            return new Exists().test(metafix, record, params, options);
         }
     },
 
     in {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            final Value value1 = record.get(params.get(0));
-            final Value value2 = record.get(params.get(1));
-
-            return value1 != null && value2 != null && value1.<Boolean>extractType((m, c) -> m
-                .ifArray(a1 -> value2.matchType()
-                    .ifArray(a2 -> c.accept(a1.equals(a2)))
-                    .orElse(v -> c.accept(false))
-                )
-                .ifHash(h1 -> value2.matchType()
-                    .ifHash(h2 -> c.accept(h1.equals(h2)))
-                    .orElse(v -> c.accept(false))
-                )
-                .ifString(s1 -> value2.matchType()
-                    .ifArray(a2 -> c.accept(a2.stream().anyMatch(value1::equals)))
-                    .ifHash(h2 -> c.accept(h2.containsField(s1)))
-                    .ifString(s2 -> c.accept(s1.equals(s2)))
-                )
-            );
+            return new In().test(metafix, record, params, options);
         }
     },
     is_contained_in {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return in.test(metafix, record, params, options);
+            return new IsContainedIn().test(metafix, record, params, options);
         }
     },
 
     is_array {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, Value::isArray);
+            return new IsArray().test(metafix, record, params, options);
         }
     },
     is_empty {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, IS_EMPTY);
+            return new IsEmpty().test(metafix, record, params, options);
         }
     },
     is_false {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testStringConditional(record, params, IS_FALSE); // TODO: strict=false
+            return new IsFalse().test(metafix, record, params, options);
         }
     },
     is_hash {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return is_object.test(metafix, record, params, options);
+            return new IsHash().test(metafix, record, params, options);
         }
     },
     is_number {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testStringConditional(record, params, IS_NUMBER);
+            return new IsNumber().test(metafix, record, params, options);
         }
     },
     is_object {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, Value::isHash);
+            return new IsObject().test(metafix, record, params, options);
         }
     },
     is_string {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, Value::isString) && !is_number.test(metafix, record, params, options);
+            return new IsString().test(metafix, record, params, options);
         }
     },
     is_true {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testStringConditional(record, params, IS_TRUE); // TODO: strict=false
+            return new IsTrue().test(metafix, record, params, options);
         }
     },
 
     all_match {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ALL, MATCHES);
+            return new AllMatch().test(metafix, record, params, options);
         }
     },
     any_match {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ANY, MATCHES);
+            return new AnyMatch().test(metafix, record, params, options);
         }
     },
     none_match {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return !any_match.test(metafix, record, params, options);
+            return new NoneMatch().test(metafix, record, params, options);
         }
     },
     str_match {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(params, MATCHES);
+            return new StrMatch().test(metafix, record, params, options);
         }
     },
 
     greater_than {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ALL, GREATER_THAN);
+            return new GreaterThan().test(metafix, record, params, options);
         }
     },
     less_than {
         @Override
         public boolean test(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
-            return testConditional(record, params, ALL, LESS_THAN);
+            return new LessThan().test(metafix, record, params, options);
         }
     }