Merge pull request #1 from opencastsoftware/fold-intersperse-bracket

Add fold and intersperse functions, add bracket overload where we can choose line separator

Author: DavidGregory084

src/main/java/com/opencastsoftware/prettier4j/Doc.java

@@ -2,8 +2,11 @@
 
 import java.util.AbstractMap.SimpleEntry;
 import java.util.ArrayDeque;
+import java.util.Collection;
 import java.util.Deque;
 import java.util.Map;
+import java.util.function.BinaryOperator;
+import java.util.stream.Stream;
 
 /**
  * Implements the algorithm described in Philip Wadler's "A prettier printer", a
@@ -151,6 +154,8 @@ public Doc indent(int indent) {
      * Bracket the current document by the {@code left} and {@code right} Strings,
      * indented by {@code indent} spaces.
      *
+     * When collapsed, line separators are replaced by spaces.
+     *
      * @param indent the number of spaces of indent to apply.
      * @param left   the left-hand bracket String.
      * @param right  the right-hand bracket String.
@@ -164,16 +169,50 @@ public Doc bracket(int indent, String left, String right) {
      * Bracket the current document by the {@code left} and {@code right} documents,
      * indented by {@code indent} spaces.
      *
+     * When collapsed, line separators are replaced by spaces.
+     *
      * @param indent the number of spaces of indent to apply.
      * @param left   the left-hand bracket document.
      * @param right  the right-hand bracket document.
      * @return the bracketed document.
      */
     public Doc bracket(int indent, Doc left, Doc right) {
+        return bracket(indent, Doc.lineOrSpace(), left, right);
+    }
+
+    /**
+     * Bracket the current document by the {@code left} and {@code right} Strings,
+     * indented by {@code indent} spaces.
+     *
+     * When collapsed, line separators are replaced by the {@code lineDoc}.
+     *
+     * @param indent  the number of spaces of indent to apply.
+     * @param lineDoc the line separator document.
+     * @param left    the left-hand bracket document.
+     * @param right   the right-hand bracket document.
+     * @return the bracketed document.
+     */
+    public Doc bracket(int indent, Doc lineDoc, String left, String right) {
+        return bracket(indent, lineDoc, Doc.text(left), Doc.text(right));
+    }
+
+    /**
+     * Bracket the current document by the {@code left} and {@code right} documents,
+     * indented by {@code indent} spaces.
+     *
+     * When collapsed, line separators are replaced by the {@code lineDoc}.
+     *
+     * @param indent  the number of spaces of indent to apply.
+     * @param lineDoc the line separator document.
+     * @param left    the left-hand bracket document.
+     * @param right   the right-hand bracket document.
+     * @return the bracketed document.
+     */
+    public Doc bracket(int indent, Doc lineDoc, Doc left, Doc right) {
         return group(
                 left
-                        .append(lineOrSpace().append(this).indent(indent))
-                        .appendLineOrSpace(right));
+                        .append(lineDoc.append(this).indent(indent))
+                        .append(lineDoc.append(right)));
     }
 
     /**
@@ -691,13 +730,67 @@ public static Doc lineOr(String altText) {
         return new LineOr(text(altText));
     }
 
+    /**
+     * Reduce a collection of documents using the binary operator {@code fn},
+     * returning an empty document if the collection is empty.
+     *
+     * @param documents the collection of documents.
+     * @param fn        the binary operator for combining documents.
+     * @return a document built by reducing the {@code documents} using the operator
+     *         {@code fn}.
+     */
+    public static Doc fold(Collection<Doc> documents, BinaryOperator<Doc> fn) {
+        return fold(documents.stream(), fn);
+    }
+
+    /**
+     * Reduce a stream of documents using the binary operator {@code fn}, returning
+     * an empty document if the stream is empty.
+     *
+     * @param documents the stream of documents.
+     * @param fn        the binary operator for combining documents.
+     * @return a document built by reducing the {@code documents} using the operator
+     *         {@code fn}.
+     */
+    public static Doc fold(Stream<Doc> documents, BinaryOperator<Doc> fn) {
+        return documents.reduce(fn).orElse(Doc.empty());
+    }
+
+    /**
+     * Intersperse a {@code separator} document in between the elements of a
+     * collection of documents.
+     *
+     * @param separator the separator document.
+     * @param documents the collection of documents.
+     * @return a document containing the concatenation of {@code documents}
+     *         separated by the {@code separator}.
+     */
+    public static Doc intersperse(Doc separator, Collection<Doc> documents) {
+        return intersperse(separator, documents.stream());
+    }
+
+    /**
+     * Intersperse a {@code separator} document in between the elements of a stream
+     * of documents.
+     *
+     * @param separator the separator document.
+     * @param documents the stream of documents.
+     * @return a document containing the concatenation of {@code documents}
+     *         separated by the {@code separator}.
+     */
+    public static Doc intersperse(Doc separator, Stream<Doc> documents) {
+        return Doc.fold(documents, (left, right) -> {
+            return left.append(separator).append(right);
+        });
+    }
+
     /**
      * Creates a {@link com.opencastsoftware.prettier4j.Doc Doc} which represents a
      * group that can be flattened into a more compact layout.
      *
      * @param doc the document which is declared as a group which may be flattened.
      * @return a {@link com.opencastsoftware.prettier4j.Doc Doc} which represents a
-     * group that can be flattened into a more compact layout.
+     *         group that can be flattened into a more compact layout.
      */
     public static Doc group(Doc doc) {
         return alternatives(doc.flatten(), doc);

src/test/java/com/opencastsoftware/prettier4j/DocTest.java

@@ -158,6 +158,93 @@ void testAppendLineOrFlattening() {
         assertThat(actual, is(equalTo(expected)));
     }
 
+    @Test
+    void testBracket() {
+        String expected = "functionCall(a, b, c)";
+        String actual = text("functionCall")
+                .append(
+                        Doc.intersperse(
+                                Doc.text(",").append(Doc.lineOrSpace()),
+                                Arrays.asList("a", "b", "c").stream().map(Doc::text))
+                                .bracket(2, Doc.lineOrEmpty(), Doc.text("("), Doc.text(")")))
+                .render(80);
+
+        assertThat(actual, is(equalTo(expected)));
+    }
+
+    @Test
+    void testBracketStringOverload() {
+        String expected = "functionCall(a, b, c)";
+        String actual = text("functionCall")
+                .append(
+                        Doc.intersperse(
+                                Doc.text(",").append(Doc.lineOrSpace()),
+                                Arrays.asList("a", "b", "c").stream().map(Doc::text))
+                                .bracket(2, Doc.lineOrEmpty(), "(", ")"))
+                .render(80);
+
+        assertThat(actual, is(equalTo(expected)));
+    }
+
+    @Test
+    void testBracketFlattening() {
+        String expected = "functionCall(\n  a,\n  b,\n  c\n)";
+        String actual = text("functionCall")
+                .append(
+                        Doc.intersperse(
+                                Doc.text(",").append(Doc.lineOrSpace()),
+                                Arrays.asList("a", "b", "c").stream().map(Doc::text))
+                                .bracket(2, Doc.lineOrEmpty(), Doc.text("("), Doc.text(")")))
+                .render(10);
+
+        assertThat(actual, is(equalTo(expected)));
+    }
+
+    @Test
+    void testIntersperse() {
+        String expected = "a, b, c";
+        String actual = Doc.intersperse(
+                Doc.text(", "),
+                Arrays.asList(Doc.text("a"), Doc.text("b"), Doc.text("c"))).render(80);
+        assertThat(actual, is(equalTo(expected)));
+    }
+
+    /**
+     * This tests the {@code spread} operator of the original paper, implemented via
+     * the Haskell functions:
+     *
+     * <pre>{@code
+     * x <+> y = x <> text " " <> y
+     * spread = folddoc (<+>)
+     * }</pre>
+     */
+    @Test
+    void testSpreadOperator() {
+        String expected = "a b c";
+        String actual = Doc.fold(
+                Arrays.asList(Doc.text("a"), Doc.text("b"), Doc.text("c")),
+                (l, r) -> l.appendSpace(r)).render(80);
+        assertThat(actual, is(equalTo(expected)));
+    }
+
+    /**
+     * This tests the {@code stack} operator of the original paper, implemented via
+     * the Haskell functions:
+     *
+     * <pre>{@code
+     * x </> y = x <> line <> y
+     * stack = folddoc (</>)
+     * }</pre>
+     */
+    @Test
+    void testStackOperator() {
+        String expected = "a\nb\nc";
+        String actual = Doc.fold(
+                Arrays.asList(Doc.text("a"), Doc.text("b"), Doc.text("c")),
+                (l, r) -> l.appendLine(r)).render(80);
+        assertThat(actual, is(equalTo(expected)));
+    }
+
     /**
      * This property represents the observation that an atomic token must render
      * as nothing more than its text content.
@@ -407,6 +494,10 @@ Arbitrary<Doc> docs() {
                 () -> Arbitraries.just(Doc.empty()),
                 // Append
                 () -> docs().tuple2().map(tuple -> tuple.get1().append(tuple.get2())),
+                // Indent
+                () -> docs().map(doc -> doc.indent(2)),
+                // Bracketing
+                () -> docs().map(doc -> doc.bracket(2, Doc.lineOrEmpty(), Doc.text("["), Doc.text("]"))),
                 // Alternatives
                 () -> docs().map(Doc::group));
     }

src/test/java/com/opencastsoftware/prettier4j/Node.java

@@ -17,12 +17,9 @@ public Doc show() {
                         subTrees.isEmpty() ? Doc.empty()
                                 : Doc.text("[")
                                         .append(
-                                                subTrees.stream()
-                                                        .map(Node::show)
-                                                        .reduce(Doc.empty(), (left, right) -> {
-                                                            return left instanceof Doc.Empty ? right
-                                                                    : left.append(Doc.text(",")).appendLineOrSpace(right);
-                                                        }).indent(1))
+                                                Doc.intersperse(
+                                                        Doc.text(",").append(Doc.lineOrSpace()),
+                                                        subTrees.stream().map(Node::show)).indent(1))
                                         .append(Doc.text("]"))
                                         .indent(data.length())));
     }
@@ -31,12 +28,9 @@ public Doc showPrime() {
         return Doc.text(data)
                 .append(
                         subTrees.isEmpty() ? Doc.empty()
-                                : subTrees.stream()
-                                        .map(Node::showPrime)
-                                        .reduce(Doc.empty(), (left, right) -> {
-                                            return left instanceof Doc.Empty ? right
-                                                    : left.append(Doc.text(",")).appendLineOrSpace(right);
-                                        })
+                                : Doc.intersperse(
+                                        Doc.text(",").append(Doc.lineOrSpace()),
+                                        subTrees.stream().map(Node::showPrime))
                                         .bracket(2, "[", "]"));
     }
 }