Removed version from .jar filename

replaceInvalidXMLChar() attempts to implement replacement of invalid XML chars in JSON input with REPLACEMENT_CHAR (with unit test)
Version and encoding params for XML output
Maven release script

Author: namedgraph

Dockerfile

@@ -10,4 +10,4 @@ RUN mvn clean install
 
 ### entrypoint
 
-ENTRYPOINT ["java", "-jar", "target/json2xml-1.0.2-SNAPSHOT-jar-with-dependencies.jar"]
+ENTRYPOINT ["java", "-jar", "target/json2xml-jar-with-dependencies.jar"]

README.md

@@ -5,6 +5,13 @@ Reads any JSON data and produces [XML Representation of JSON](https://www.w3.org
 
 JSON2XML enables JSON transformation with XSLT even without having an XSLT 3.0 processor. You can simply pre-process the data by having JSON2XML before the transformation, and pipeline it into an XSLT 2.0 stylesheet, for example. That way your stylesheet stays forward compatible with XSLT 3.0, as the XML representation is exactly the same.
 
+## Invalid characters
+
+The JSON input might contain characters (for example, form feed `\f`) which would be invalid in the XML output. The [`json-to-xml()` function](https://www.w3.org/TR/xslt-30/#func-json-to-xml) specifies character escape rules that apply in this case.
+
+JSON2XML currently implements only the default escape rule: 
+> Any characters or codepoints that are not valid XML characters (for example, unpaired surrogates) are passed to the fallback function as described below; in the absence of a fallback function, they are replaced by the Unicode `REPLACEMENT CHARACTER (xFFFD)`.
+
 ## Build
 
     mvn clean install

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.atomgraph.etl.json</groupId>
     <artifactId>json2xml</artifactId>
-    <version>1.0.2</version>
+    <version>1.0.3</version>
     <packaging>jar</packaging>
 
     <name>JSON2XML</name>
@@ -52,9 +52,16 @@
             <artifactId>javax.json</artifactId>
             <version>1.1.4</version>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8.2</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
+        <finalName>json2xml</finalName>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>

release.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+mvn release:clean release:prepare
+
+mvn release:perform

src/main/java/com/atomgraph/etl/json/JSON2XML.java

@@ -40,13 +40,14 @@ public static void main(String[] args) throws IOException, XMLStreamException
         if (json.available() == 0)
         {
             System.err.println("JSON input: stdin");
-            System.err.println("Example: cat sample.json | java -jar json2xml-1.0.0-SNAPSHOT-jar-with-dependencies.jar > sample.xml");
+            System.err.println("Example: cat sample.json | java -jar json2xml-jar-with-dependencies.jar > sample.xml");
             System.exit(1);
         }
 
         try (Reader reader = new BufferedReader(new InputStreamReader(json, StandardCharsets.UTF_8)))
         {
-            new JsonStreamXMLWriter(reader, new BufferedWriter(new OutputStreamWriter(System.out))).convert();
+            new JsonStreamXMLWriter(reader, new BufferedWriter(new OutputStreamWriter(System.out, StandardCharsets.UTF_8))).
+                    convert(StandardCharsets.UTF_8.name(), "1.0");
         }
     }
 

src/main/java/com/atomgraph/etl/json/JsonStreamXMLWriter.java

@@ -37,6 +37,7 @@ public class JsonStreamXMLWriter
 {
 
     public static final String XPATH_FUNCTIONS_NS = "http://www.w3.org/2005/xpath-functions";
+    public static final String REPLACEMENT_CHAR = "\uFFFD";
     private static final XMLOutputFactory XOF = XMLOutputFactory.newInstance();
 
     static
@@ -123,19 +124,18 @@ public JsonStreamXMLWriter(JsonParser parser, XMLStreamWriter writer)
         this.writer = writer;
     }
 
-    public void convert() throws XMLStreamException
+    public void convert(String encoding, String version) throws XMLStreamException
     {
-        convert(getWriter());
+        convert(getWriter(), encoding, version);
     }
 
-    public void convert(XMLStreamWriter writer) throws XMLStreamException
+    public void convert(XMLStreamWriter writer, String encoding, String version) throws XMLStreamException
     {
-        convert(getParser(), writer);
+        convert(getParser(), writer, encoding, version);
     }
-
-    public static void convert(JsonParser parser, XMLStreamWriter writer) throws XMLStreamException
+    public static void convert(JsonParser parser, XMLStreamWriter writer, String encoding, String version) throws XMLStreamException
     {
-        writer.writeStartDocument();
+        writer.writeStartDocument(encoding, version);
         writer.setDefaultNamespace(XPATH_FUNCTIONS_NS);
 
         write(parser, writer);
@@ -198,7 +198,7 @@ public static void write(JsonParser parser, XMLStreamWriter writer) throws XMLSt
                     writer.writeEndElement();
                 break;
                 case KEY_NAME:
-                    keyName = parser.getString();
+                    keyName = replaceInvalidXMLChars(parser.getString(), REPLACEMENT_CHAR);
                 break;
                 case VALUE_STRING:
                     writer.writeStartElement(XPATH_FUNCTIONS_NS, "string");
@@ -207,7 +207,7 @@ public static void write(JsonParser parser, XMLStreamWriter writer) throws XMLSt
                         writer.writeAttribute("key", keyName);
                         keyName = null;
                     }
-                    writer.writeCharacters(parser.getString());
+                    writer.writeCharacters(replaceInvalidXMLChars(parser.getString(), REPLACEMENT_CHAR));
                     writer.writeEndElement();
                 break;
                 case VALUE_NUMBER:
@@ -217,7 +217,7 @@ public static void write(JsonParser parser, XMLStreamWriter writer) throws XMLSt
                         writer.writeAttribute("key", keyName);
                         keyName = null;
                     }
-                    writer.writeCharacters(parser.getString());
+                    writer.writeCharacters(replaceInvalidXMLChars(parser.getString(), REPLACEMENT_CHAR));
                     writer.writeEndElement();
                 break;
                 case VALUE_NULL:
@@ -234,6 +234,41 @@ public static void write(JsonParser parser, XMLStreamWriter writer) throws XMLSt
         }
     }
 
+    public static String replaceInvalidXMLChars(String text, String replacement)
+    {
+        if (null == text || text.isEmpty()) return text;
+
+        final int len = text.length();
+        char current = 0;
+        int codePoint = 0;
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < len; i++)
+        {
+            current = text.charAt(i);
+            boolean surrogate = false;
+            if (Character.isHighSurrogate(current)
+                    && i + 1 < len && Character.isLowSurrogate(text.charAt(i + 1)))
+            {
+                surrogate = true;
+                codePoint = text.codePointAt(i++);
+            }
+            else codePoint = current;
+
+            if ((codePoint == 0x9) || (codePoint == 0xA) || (codePoint == 0xD)
+                    || ((codePoint >= 0x20) && (codePoint <= 0xD7FF))
+                    || ((codePoint >= 0xE000) && (codePoint <= 0xFFFD))
+                    || ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF)))
+            {
+                sb.append(current);
+                if (surrogate)  sb.append(text.charAt(i));
+            }
+            else
+                sb.append(replacement);
+        }
+        
+        return sb.toString();
+    }
+    
     protected JsonParser getParser()
     {
         return parser;

src/test/java/com/atomgraph/etl/json/JsonStreamXMLWriterTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020 Martynas Jusevičius <martynas@atomgraph.com>.
+ *
+ * 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 com.atomgraph.etl.json;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import javax.xml.stream.XMLStreamException;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+/**
+ *
+ * @author Martynas Jusevičius <martynas@atomgraph.com>
+ */
+public class JsonStreamXMLWriterTest
+{
+    
+    @Test
+    public void testJsonKeyWithInvalidXMLChar() throws IOException, XMLStreamException
+    {
+        String jsonString = "{ \"a\\fb\": \"c\" }"; // form feed in the key (invalid in XML 1.0, valid in XML 1.1)
+        InputStream json = new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8));
+        ByteArrayOutputStream xml = new ByteArrayOutputStream();
+        
+        try (Reader reader = new BufferedReader(new InputStreamReader(json, StandardCharsets.UTF_8)))
+        {
+            new JsonStreamXMLWriter(reader, new BufferedWriter(new OutputStreamWriter(xml, StandardCharsets.UTF_8))).
+                    convert(StandardCharsets.UTF_8.name(), "1.0");
+            String xmlString = xml.toString(StandardCharsets.UTF_8.name());
+            assertTrue(xmlString.contains(JsonStreamXMLWriter.REPLACEMENT_CHAR)); // 
+        }
+    }
+    
+    @Test
+    public void testJsonValueWithInvalidXMLChar() throws IOException, XMLStreamException
+    {
+        String jsonString = "{ \"a\": \"b\\fc\" }"; // form feed in the value (invalid in XML 1.0, valid in XML 1.1)
+        InputStream json = new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8));
+        ByteArrayOutputStream xml = new ByteArrayOutputStream();
+        
+        try (Reader reader = new BufferedReader(new InputStreamReader(json, StandardCharsets.UTF_8)))
+        {
+            new JsonStreamXMLWriter(reader, new BufferedWriter(new OutputStreamWriter(xml, StandardCharsets.UTF_8))).
+                    convert(StandardCharsets.UTF_8.name(), "1.0");
+            String xmlString = xml.toString(StandardCharsets.UTF_8.name());
+            assertTrue(xmlString.contains(JsonStreamXMLWriter.REPLACEMENT_CHAR)); // form feed has been replaced
+        }
+    }
+    
+}