Merge branch 'master' of https://github.com/metafacture/metafacture-core into fixJavadoc

Author: dr0i

README.md

@@ -2,7 +2,7 @@
 
 [![Build](https://github.com/metafacture/metafacture-core/workflows/Build/badge.svg?branch=master)](https://github.com/metafacture/metafacture-core/actions?query=workflow%3ABuild) [![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=org.metafacture:metafacture-core&metric=alert_status)](https://sonarcloud.io/dashboard/index/org.metafacture:metafacture-core)
 
-Metafacture is a toolkit for processing semi-structured data with a focus on library metadata. It provides a versatile set of tools for reading, writing and transforming data. Metafacture can be used as a stand-alone application or as a Java library in other applications. The name Metafacture is a portmanteau of the words *meta* data and manu*facture*.
+Metafacture is a toolkit for processing semi-structured data with a focus on library metadata. It provides a versatile set of tools for reading, writing and transforming data. Metafacture can be used as a stand-alone application or as a Java library in other applications. The name Metafacture is a portmanteau of the words *meta*data and manu*facture*.
 
 Metafacture includes a [large number of modules](https://github.com/metafacture/metafacture-documentation/blob/master/flux-commands.md) for operating on semi-structured data. These modules can be combined to build pipelines to perform complex metadata processing tasks. The pipelines can be constructed either in Java code or with the domain-specific language **Flux**. One of the core features of Metafacture is the **Metamorph** module. Metamorph is an xml-based language for specifying transformations of semi-structured data. It can be seamlessly integrated into Java code.
 
@@ -83,7 +83,8 @@ $ cd metafacture-core
 $ ./gradlew install
 ```
 
-The resulting distribution can be found in `metafacture-core/metafacture-runner/build/distributions/`.
+Besides the resulting distribution in `metafacture-core/metafacture-runner/build/distributions/` this also provides builds in your local maven repository.
+
 
 See [Code Quality and Style](https://github.com/metafacture/metafacture-core/wiki/Code-Quality-and-Style) on the wiki for further information on the sources.
 

metafacture-runner/build.gradle

@@ -55,6 +55,7 @@ dependencies {
   plugins project(':metafacture-triples')
   plugins project(':metafacture-xml')
   plugins project(':metafacture-html')
+  plugins project(':metafacture-yaml')
   plugins project(':metamorph')
 
   // The plugins configuration needs to be on the runtime classpath:

metafacture-triples/build.gradle

@@ -24,3 +24,10 @@ dependencies {
   testImplementation 'junit:junit:4.12'
   testImplementation 'org.mockito:mockito-core:2.5.5'
 }
+
+test {
+  testLogging {
+    showStandardStreams = true
+    exceptionFormat = 'full'
+  }
+}

metafacture-triples/src/main/java/org/metafacture/triples/AbstractTripleSort.java

@@ -30,13 +30,13 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.PriorityQueue;
+import java.util.function.Function;
 
 /**
  * @author markus geipel
  *
  */
-public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>>
-        implements MemoryWarningSystem.Listener {
+public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>> implements MemoryWarningSystem.Listener {
 
     /**
      * Specifies the comparator. Can be one of {@link #SUBJECT}, {@link #PREDICATE},
@@ -70,10 +70,11 @@ public int order(final int indicator) {
     private final List<File> tempFiles = new ArrayList<>();
     private Compare compare = Compare.SUBJECT;
     private Order order = Order.INCREASING;
+    private boolean numeric;
     private volatile boolean memoryLow;
 
     /**
-     * Constructs an AbstractTripleSort. Calls {@link #MemoryWarningSystem}.
+     * Constructs an AbstractTripleSort. Calls {@link MemoryWarningSystem}.
      */
     protected AbstractTripleSort() {
         MemoryWarningSystem.addListener(this);
@@ -96,6 +97,10 @@ protected final void setSortOrder(final Order newOrder) {
         order = newOrder;
     }
 
+    protected final void setSortNumeric(final boolean newNumeric) {
+        numeric = newNumeric;
+    }
+
     @Override
     public final void process(final Triple namedValue) {
         if (memoryLow) {
@@ -115,47 +120,38 @@ public final void process(final Triple namedValue) {
     }
 
     private void nextBatch() throws IOException {
-        Collections.sort(buffer, createComparator(compare, order));
+        Collections.sort(buffer, createComparator());
         final File tempFile = File.createTempFile("sort", "namedValues", null);
         tempFile.deleteOnExit();
-        final ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile));
 
-        try {
+        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile))) {
             for (final Triple triple : buffer) {
                 triple.write(out);
             }
         }
-        finally {
-            out.close();
-        }
+
         buffer.clear();
         tempFiles.add(tempFile);
     }
 
     @Override
     public final void onCloseStream() {
-
         if (tempFiles.isEmpty()) {
-            Collections.sort(buffer, createComparator(compare, order));
+            Collections.sort(buffer, createComparator());
+
             for (final Triple triple : buffer) {
                 sortedTriple(triple);
             }
+
             onFinished();
         }
         else {
-            final Comparator<Triple> comparator = createComparator(compare, order);
-            final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<SortedTripleFileFacade>(11,
-                    new Comparator<SortedTripleFileFacade>() {
-                        // private final Comparator<Triple> comparator =
-                        // getComparator();
-
-                        @Override
-                        public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade o2) {
-                            return comparator.compare(o1.peek(), o2.peek());
-                        }
-                    });
+            final Comparator<Triple> comparator = createComparator();
+            final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<>(11, (o1, o2) -> comparator.compare(o1.peek(), o2.peek()));
+
             try {
                 nextBatch();
+
                 for (final File file : tempFiles) {
                     queue.add(new SortedTripleFileFacade(file));
                 }
@@ -171,6 +167,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
                         queue.add(sortedFileFacade);
                     }
                 }
+
                 onFinished();
             }
             catch (final IOException e) {
@@ -182,6 +179,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
                 }
             }
         }
+
         MemoryWarningSystem.removeListener(this);
     }
 
@@ -192,65 +190,56 @@ protected void onFinished() {
     protected abstract void sortedTriple(Triple namedValue);
 
     public final Comparator<Triple> createComparator() {
-        return createComparator(compare, order);
+        return createComparator(compare, order, numeric);
+    }
+
+    public static Comparator<Triple> createComparator(final Compare compare, final Order order) {
+        return createComparator(compare, order, false);
     }
 
     /**
      * Creates a Comparator.
      *
-     * @param compareBy one of {@link #Compare}
-     * @param order     the {@link #Order}
+     * @param compare one of {@link #Compare}
+     * @param order   the {@link #Order}
+     * @param numeric "true" if comparison should be numeric. "false" if comparison
+     *                should be alphanumeric. Defaults to "false".
      * @return a Comparator of type Triple
      */
-    public static Comparator<Triple> createComparator(final Compare compareBy, final Order order) {
-        final Comparator<Triple> comparator;
-        switch (compareBy) {
+    private static Comparator<Triple> createComparator(final Compare compare, final Order order, final boolean numeric) {
+        final Function<Triple, String> tripleFunction;
+        switch (compare) {
             case ALL:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.compareTo(o2));
-                    }
-                };
-                break;
+                return (o1, o2) -> order.order(o1.compareTo(o2));
             case OBJECT:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getObject().compareTo(o2.getObject()));
-                    }
-                };
+                tripleFunction = Triple::getObject;
                 break;
             case SUBJECT:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getSubject().compareTo(o2.getSubject()));
-                    }
-                };
+                tripleFunction = Triple::getSubject;
                 break;
             case PREDICATE:
             default:
-                comparator = new Comparator<Triple>() {
-                    @Override
-                    public int compare(final Triple o1, final Triple o2) {
-                        return order.order(o1.getPredicate().compareTo(o2.getPredicate()));
-                    }
-                };
+                tripleFunction = Triple::getPredicate;
                 break;
         }
 
-        return comparator;
+        final Function<Triple, Integer> numericFunction = tripleFunction.andThen(Integer::valueOf);
+        return numeric ?
+            (o1, o2) -> order.order(numericFunction.apply(o1).compareTo(numericFunction.apply(o2))) :
+            (o1, o2) -> order.order(tripleFunction.apply(o1).compareTo(tripleFunction.apply(o2)));
     }
 
     @Override
     public final void onResetStream() {
         buffer.clear();
+
         for (final File file : tempFiles) {
             if (file.exists()) {
                 file.delete();
             }
         }
+
         tempFiles.clear();
     }
+
 }

metafacture-triples/src/main/java/org/metafacture/triples/TripleSort.java

@@ -27,7 +27,7 @@
  * @author markus geipel
  *
  */
-@Description("Sorts triples")
+@Description("Sorts triples. Several options can be combined, e.g. `by=\"object\",numeric=\"true\",order=\"decreasing\"` will numerically sort the Object of the triples in decreasing order (given that all Objects are indeed of numeric type).")
 @In(Triple.class)
 @Out(Triple.class)
 @FluxCommand("sort-triples")
@@ -49,4 +49,8 @@ public void setOrder(final Order order) {
         setSortOrder(order);
     }
 
+    public void setNumeric(final boolean numeric) {
+        setSortNumeric(numeric);
+    }
+
 }