Merge pull request #238 from metafacture/addDebugRecordFunction

Add `print_record()` Fix function.

Author: blackwinter

README.md

@@ -305,6 +305,36 @@ paste("my.string", "~Hi", "a", "~how are you?")
 # "my.string": "Hi eeny how are you?"
 ```
 
+##### `print_record`
+
+Prints the current record as JSON either to standard output or to a file.
+
+Parameters:
+
+- `prefix` (optional): Prefix to print before the record; may include [format directives](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html#syntax) for counter and record ID (in that order). (Default: Empty string)
+
+Options:
+
+- `compression` (file output only): Compression mode. (Default: `auto`)
+- `destination`: Destination to write the record to; may include [format directives](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html#syntax) for counter and record ID (in that order). (Default: `stdout`)
+- `encoding` (file output only): Encoding used by the underlying writer. (Default: `UTF-8`)
+- `footer`: Footer which is output after the record. (Default: `\n`)
+- `header`: Header which is output before the record. (Default: Empty string)
+- `id`: Field name which contains the record ID; if found, will be available for inclusion in `prefix` and `destination`. (Default: `_id`)
+- `pretty`: Whether to use pretty printing. (Default: `false`)
+
+```perl
+print_record(["<prefix>"][, <options>...])
+```
+
+E.g.:
+
+```perl
+print_record("%d) Before transformation: ")
+print_record(destination: "record-%2$s.json", id: "001", pretty: "true")
+print_record(destination: "record-%03d.json.gz", header: "After transformation: ")
+```
+
 ##### `random`
 
 Creates (or replaces) a field with a random number (less than the specified maximum).
@@ -369,8 +399,8 @@ Creates (or replaces) a field with the current timestamp.
 
 Options:
 
-- `format`: Date and time pattern as in [java.text.SimpleDateFormat](https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html). (Default: Unix timestamp)
-- `timezone`: Time zone as in [java.util.TimeZone](https://docs.oracle.com/javase/8/docs/api/java/util/TimeZone.html). (Default: UTC)
+- `format`: Date and time pattern as in [java.text.SimpleDateFormat](https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html). (Default: `timestamp`)
+- `timezone`: Time zone as in [java.util.TimeZone](https://docs.oracle.com/javase/8/docs/api/java/util/TimeZone.html). (Default: `UTC`)
 - `language`: Language tag as in [java.util.Locale](https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html). (Default: The locale of the host system)
 
 ```perl

build.gradle

@@ -34,6 +34,7 @@ subprojects {
     versions = [
       'ace':            '1.3.3',
       'equalsverifier': '3.8.2',
+      'jackson':        '2.13.3',
       'jetty':          '9.4.14.v20181114',
       'jquery':         '3.3.1-1',
       'junit_jupiter':  '5.8.2',

metafix/build.gradle

@@ -12,6 +12,7 @@ def passSystemProperties = {
 dependencies {
   implementation "org.eclipse.xtext:org.eclipse.xtext:${versions.xtext}"
   implementation "org.eclipse.xtext:org.eclipse.xtext.xbase:${versions.xtext}"
+  implementation "com.fasterxml.jackson.core:jackson-core:${versions.jackson}"
   implementation "com.google.guava:guava:${versions.guava}"
   implementation "org.slf4j:slf4j-api:${versions.slf4j}"
 
@@ -25,9 +26,11 @@ dependencies {
   runtimeOnly "org.slf4j:slf4j-simple:${versions.slf4j}"
 
   implementation "org.metafacture:metafacture-commons:${versions.metafacture}"
-  implementation "org.metafacture:metafacture-mangling:${versions.metafacture}"
-  implementation "org.metafacture:metafacture-javaintegration:${versions.metafacture}"
   implementation "org.metafacture:metafacture-flowcontrol:${versions.metafacture}"
+  implementation "org.metafacture:metafacture-framework:${versions.metafacture}"
+  implementation "org.metafacture:metafacture-io:${versions.metafacture}"
+  implementation "org.metafacture:metafacture-javaintegration:${versions.metafacture}"
+  implementation "org.metafacture:metafacture-mangling:${versions.metafacture}"
   implementation "org.metafacture:metamorph:${versions.metafacture}"
 
   testImplementation "nl.jqno.equalsverifier:equalsverifier:${versions.equalsverifier}"

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

@@ -16,19 +16,24 @@
 
 package org.metafacture.metafix;
 
+import org.metafacture.framework.StandardEventNames;
+import org.metafacture.io.ObjectWriter;
 import org.metafacture.metafix.api.FixFunction;
 import org.metafacture.metamorph.api.Maps;
 import org.metafacture.metamorph.functions.ISBN;
 import org.metafacture.metamorph.functions.Timestamp;
 import org.metafacture.metamorph.maps.FileMap;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
+import java.util.concurrent.atomic.LongAdder;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
@@ -208,6 +213,38 @@ private boolean literalString(final String s) {
             return s.startsWith("~");
         }
     },
+    print_record {
+        private final Map<Metafix, LongAdder> scopedCounter = new HashMap<>();
+
+        @Override
+        public void apply(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {
+            final String destination = options.getOrDefault("destination", ObjectWriter.STDOUT);
+            final Value idValue = record.get(options.getOrDefault("id", StandardEventNames.ID));
+
+            final boolean pretty = getBoolean(options, "pretty");
+
+            final LongAdder counter = scopedCounter.computeIfAbsent(metafix, k -> new LongAdder());
+            counter.increment();
+
+            final String id = Value.isNull(idValue) ? "" : idValue.toString();
+            final String prefix = params.isEmpty() ? "" : String.format(params.get(0), counter.sum(), id);
+            final ObjectWriter<String> writer = new ObjectWriter<>(String.format(destination, counter.sum(), id));
+
+            withOption(options, "compression", writer::setCompression);
+            withOption(options, "encoding", writer::setEncoding);
+            withOption(options, "footer", writer::setFooter);
+            withOption(options, "header", writer::setHeader);
+
+            try {
+                writer.process(prefix + record.toJson(pretty));
+            }
+            catch (final IOException e) {
+                // Log a warning? Print string representation instead?
+            }
+
+            writer.closeStream();
+        }
+    },
     random {
         @Override
         public void apply(final Metafix metafix, final Record record, final List<String> params, final Map<String, String> options) {

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

@@ -19,6 +19,14 @@
 import org.metafacture.metafix.FixPath.InsertMode;
 import org.metafacture.metafix.Value.TypeMatcher;
 
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.SerializableString;
+import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.UncheckedIOException;
 import java.util.Collection;
 import java.util.Deque;
 import java.util.LinkedHashMap;
@@ -110,6 +118,27 @@ public String toString() {
         return super.toString();
     }
 
+    public String toJson() throws IOException {
+        return toJson(false);
+    }
+
+    public String toJson(final boolean prettyPrinting) throws IOException {
+        final StringWriter writer = new StringWriter();
+        final JsonGenerator jsonGenerator = new JsonFactory().createGenerator(writer);
+        jsonGenerator.setPrettyPrinter(prettyPrinting ? new DefaultPrettyPrinter((SerializableString) null) : null);
+
+        try {
+            toJson(jsonGenerator);
+        }
+        catch (final UncheckedIOException e) {
+            throw e.getCause();
+        }
+
+        jsonGenerator.flush();
+
+        return writer.toString();
+    }
+
     /**
      * Retrieves the field value from this record. Falls back to retrieving the
      * <i>virtual</i> field if the field name is not already

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

@@ -19,6 +19,10 @@
 import org.metafacture.commons.tries.SimpleRegexTrie;
 import org.metafacture.commons.tries.WildcardTrie;
 
+import com.fasterxml.jackson.core.JsonGenerator;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.ConcurrentModificationException;
@@ -44,7 +48,7 @@
  * Represents a record value, i.e., either an {@link Array}, a {@link Hash},
  * or a {@link String}.
  */
-public class Value {
+public class Value { // checkstyle-disable-line ClassDataAbstractionCoupling
 
     private static final String FIELD_PATH_SEPARATOR = "\\.";
 
@@ -244,6 +248,31 @@ public String toString() {
         );
     }
 
+    private void toJson(final JsonGenerator jsonGenerator) {
+        if (isNull()) {
+            try {
+                jsonGenerator.writeNull();
+            }
+            catch (final IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+        else {
+            matchType()
+                .ifArray(a -> a.toJson(jsonGenerator))
+                .ifHash(h -> h.toJson(jsonGenerator))
+                .ifString(s -> {
+                    try {
+                        jsonGenerator.writeString(s);
+                    }
+                    catch (final IOException e) {
+                        throw new UncheckedIOException(e);
+                    }
+                })
+                .orElseThrow();
+        }
+    }
+
     /*package-private*/ static String[] split(final String fieldPath) {
         return fieldPath.split(FIELD_PATH_SEPARATOR);
     }
@@ -354,6 +383,8 @@ private abstract static class AbstractValueType {
         @Override
         public abstract String toString();
 
+        protected abstract void toJson(JsonGenerator jsonGenerator);
+
     }
 
     /**
@@ -427,6 +458,18 @@ public String toString() {
             return list.toString();
         }
 
+        @Override
+        protected void toJson(final JsonGenerator jsonGenerator) {
+            try {
+                jsonGenerator.writeStartArray();
+                forEach(v -> v.toJson(jsonGenerator));
+                jsonGenerator.writeEndArray();
+            }
+            catch (final IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
         public void remove(final int index) {
             list.remove(index);
         }
@@ -693,6 +736,29 @@ public String toString() {
             return map.toString();
         }
 
+        @Override
+        protected void toJson(final JsonGenerator jsonGenerator) {
+            try {
+                jsonGenerator.writeStartObject();
+
+                forEach((f, v) -> {
+                    try {
+                        jsonGenerator.writeFieldName(f);
+                    }
+                    catch (final IOException e) {
+                        throw new UncheckedIOException(e);
+                    }
+
+                    v.toJson(jsonGenerator);
+                });
+
+                jsonGenerator.writeEndObject();
+            }
+            catch (final IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
         /**
          * Avoids {@link ConcurrentModificationException} when modifying the hash based on matched fields.
          *