Use a Strategy pattern for different types of output

src/main/java/rickwporter/prettytable/CsvTableRender.java

@@ -0,0 +1,32 @@
+package rickwporter.prettytable;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
+
+class CsvTableRender implements TableRenderInterface {
+
+    @Override
+    public String render(PrettyTable table, boolean removedRedundant) {
+        try {
+            StringBuilder result = new StringBuilder();
+            CSVFormat format = CSVFormat.DEFAULT.builder().setRecordSeparator("\n").build();
+            CSVPrinter printer = new CSVPrinter(result, format);
+            if (!table.getHeaders().isEmpty()) {
+                printer.printRecord(table.getHeaders());
+            }
+            for (List<? extends Object> row : table.getRows()) {
+                List<String> current = row.stream().map(c -> c.toString()).collect(Collectors.toList());
+                printer.printRecord(current);
+            }
+            printer.close();
+            return result.toString();
+        } catch (IOException ex) {
+            // nothing to do here
+        }
+        return null;
+    }
+}

src/main/java/rickwporter/prettytable/HtmlTableRender.java

@@ -0,0 +1,90 @@
+package rickwporter.prettytable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import rickwporter.prettytable.PrettyTable.HorizontalAlign;
+import rickwporter.prettytable.PrettyTable.OutputFormat;
+
+class HtmlTableRender implements TableRenderInterface {
+    private static final String HTML_TABLE_TAG = "table";
+    private static final String HTML_HEADER_TAG = "thead";
+    private static final String HTML_BODY_TAG = "tbody";
+    private static final String HTML_ROW_TAG = "tr";
+    private static final String HTML_CELL_BODY_TAG = "td";
+    private static final String HTML_CELL_HEADER_TAG = "th";
+
+    String htmlColumnFormat(Integer column, List<HorizontalAlign> hAligns) {
+        if (hAligns.isEmpty()) {
+            return "";
+        }
+        return " style=\"" + hAligns.get(column).getHtmlStyle() + "\"";
+    }
+
+    String htmlRow(
+        List<? extends Object> row,
+        String initIndent,
+        String indent,
+        String cellTag,
+        List<HorizontalAlign> hAligns
+    ) {
+        String result = String.format("%s<%s>\n", initIndent, HTML_ROW_TAG);
+        for (int column = 0; column < row.size(); column++) {
+            Object obj = row.get(column);
+            String cellFormat = htmlColumnFormat(column, hAligns);
+            result += String.format(
+                "%s%s<%s%s>%s</%s>\n", initIndent, indent, cellTag, cellFormat, obj.toString(), cellTag
+            );
+        }
+        result += String.format("%s</%s>\n", initIndent, HTML_ROW_TAG);
+        return result;
+    }
+
+    @Override
+    public String render(PrettyTable table, boolean removeRedundant) {
+        StringBuilder result = new StringBuilder();
+        String indent = "    ";
+        List<HorizontalAlign> hAligns = table.getHorizAligns();
+
+        result.append(String.format("<%s>\n", HTML_TABLE_TAG));
+        if (!table.getHeaders().isEmpty()) {
+            result.append(String.format("%s<%s>\n", indent, HTML_HEADER_TAG));
+            result.append(htmlRow(table.getHeaders(), indent + indent, indent, HTML_CELL_HEADER_TAG, hAligns));
+            result.append(String.format("%s</%s>\n", indent, HTML_HEADER_TAG));
+        }
+
+        result.append(String.format("%s<%s>\n", indent, HTML_BODY_TAG));
+        List<String> lastRow = new ArrayList<>();
+        for (List<Object> row : table.getRows()) {
+            List<String> currentRow = row.stream()
+                .map(c -> {
+                    if (c instanceof PrettyTable)  {
+                        PrettyTable t = (PrettyTable) c;
+                        if (t.getDefaultOutput() == OutputFormat.HTML) {
+                            String out = "\n" + t.toHtml(true);
+                            out = out.replaceAll("\n", "\n" + indent + indent + indent + indent);
+                            return out.substring(0, out.lastIndexOf(indent));
+                        }
+                        return t.toString().replace("\n", "<br/>");
+                    }
+                    return c.toString();
+                })
+                .collect(Collectors.toList());
+            List<String> fullRow = new ArrayList<String>(currentRow);  // make a copy before manipulating
+            if (removeRedundant) {
+                for (int i = 0; i < lastRow.size(); i++) {
+                    if (!lastRow.get(i).equals(currentRow.get(i))) {
+                        break;
+                    }
+                    currentRow.set(i, "");
+                }
+                lastRow = fullRow;
+            }
+            result.append(htmlRow(currentRow, indent + indent, indent, HTML_CELL_BODY_TAG, hAligns));
+        }
+        result.append(String.format("%s</%s>\n", indent, HTML_BODY_TAG));
+        result.append(String.format("</%s>\n", HTML_TABLE_TAG));
+        return result.toString();
+    }
+}

src/main/java/rickwporter/prettytable/JsonTableRender.java

@@ -0,0 +1,89 @@
+package rickwporter.prettytable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.StringUtils;
+
+import rickwporter.prettytable.PrettyTable.OutputFormat;
+
+class JsonTableRender implements TableRenderInterface {
+    String jsonEncode(Object object) {
+        if (object instanceof Integer) {
+            return object.toString();
+        }
+        try {
+            Integer value = Integer.parseInt(object.toString());
+            return value.toString();
+        } catch (NumberFormatException ex) {
+            // nothing to do here, just double-quote as below
+        }
+        return String.format(
+            "\"%s\"",
+            object.toString()
+                .replace("\r", "\\r")
+                .replace("\n", "\\n")
+                .replace("\"", "\\\"")
+            );
+    }
+
+    String jsonValue(Object cellObj, String initIndent, String indent) {
+        if (cellObj instanceof PrettyTable) {
+            PrettyTable t = (PrettyTable) cellObj;
+            if (t.getDefaultOutput() == OutputFormat.JSON) {
+                String out = t.toJson().replace("\n", "\n" + initIndent);
+                return out.substring(0, out.lastIndexOf("\n" + initIndent));
+            }
+        }
+        return jsonEncode(cellObj);
+    }
+
+    String jsonRow(List<Object> row, String initIndent, String indent, List<String> headers) {
+        List<String> rowValues = new ArrayList<>();
+        for (int cIdx = 0; cIdx < row.size(); cIdx++) {
+            String value = this.jsonValue(row.get(cIdx), initIndent + indent, indent);
+            if (!headers.isEmpty()) {
+                rowValues.add(
+                    String.format("%s%s\"%s\": %s",
+                        initIndent,
+                        indent,
+                        headers.get(cIdx),
+                        value)
+                );
+            } else {
+                rowValues.add(
+                    String.format("%s%s%s", initIndent, indent, value)
+                );
+            }
+        }
+        return StringUtils.join(rowValues, ",\n");
+    }
+
+    @Override
+    public String render(PrettyTable table, boolean removeRedundant) {
+        StringBuilder result = new StringBuilder();
+        String indent = "    ";
+        result.append("[\n");
+        String entryPrefix = "";
+        List<String> headers = table.getHeaders();
+        if (!headers.isEmpty()) {
+            result.append(String.format("%s[\n", indent));
+            List<String> headerValues = headers.stream()
+                .map(h -> String.format("%s%s\"%s\"", indent, indent, h))
+                .collect(Collectors.toList());
+            result.append(StringUtils.join(headerValues, ",\n") + "\n");
+            result.append(String.format("%s]", indent));
+            entryPrefix = ",\n";
+        }
+        String entryStart = table.getHeaders().isEmpty() ? "[" : "{";
+        String entryEnd = table.getHeaders().isEmpty() ? "]" : "}";
+        for (List<Object> row : table.getRows()) {
+            result.append(String.format("%s%s%s\n", entryPrefix, indent, entryStart));
+            result.append(jsonRow(row, indent, indent, headers) + "\n");
+            result.append(String.format("%s%s", indent, entryEnd));
+            entryPrefix = ",\n";
+        }
+        result.append("\n]\n");
+        return result.toString();
+    }
+}