added a buffer for unfinished lines during progress bar printing. the lines will be completed by the next print, or way at the end when all progress bars are done.

src/org/rascalmpl/library/util/Monitor.rsc

@@ -199,4 +199,18 @@ test bool simpleAsyncPrintTest() {
   println("d");
   jobEnd("job");
   return true;
+}
+
+test bool unfinishedInputTest() {
+  jobStart("job", totalWork=26);
+  for (/<l:[a-z]>/ := "abcdefghijklmnopqrstuwvxyz") {
+    print(l); // no newline!
+    jobStep("job", "letter <l>", work=1);
+    if (arbInt(10) == 0) {
+      println(); // break it
+    }
+  }
+  // println(); // flush it
+  jobEnd("job");
+  return true;
 }

src/org/rascalmpl/repl/TerminalProgressBarMonitor.java

@@ -9,6 +9,8 @@
 import java.nio.charset.Charset;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -36,6 +38,13 @@
      */
     private List<ProgressBar> bars = new LinkedList<>();
 
+    /**
+     * We also keep a list of currently unfinished lines (one for each thread).
+     * Since there are generally very few threads a simple list beats a hash-map in terms
+     * of memory allocation and possibly also lookup efficiency.
+     */
+    private List<UnfinishedLine> unfinishedLines = new ArrayList<>(3);
+
     /**
      * This writer is there to help with the encoding to what the terminal needs. It writes directly to the
      * underlying stream.
@@ -109,6 +118,89 @@
         }  
     }
 
+    private static class UnfinishedLine {
+        final long threadId;
+        private int curCapacity = 512;
+        private byte[] buffer = new byte[curCapacity];
+        private int curEnd = 0;
+
+        public UnfinishedLine() {
+            this.threadId = Thread.currentThread().getId();
+        }
+
+        /**
+         * Adding input combines previously unfinished sentences with possible
+         * new (unfinished) sentences. 
+         * 
+         * The resulting buffer nevers contain any newline character.
+         */
+        private void store(byte[] newInput, int offset, int len) {
+            // first ensure capacity of the array
+            if (curEnd + len >= curCapacity) {
+                curCapacity *= 2; 
+                buffer = Arrays.copyOf(buffer, curCapacity);
+            }
+
+            System.arraycopy(newInput, offset, buffer, curEnd, len);
+            curEnd += len;
+        }
+
+        public void write(byte[] n, OutputStream out) throws IOException {
+            write(n, 0, n.length, out);
+        }
+
+        /**
+         * Main workhorse looks for newline characters in the new input.
+         *  - if there are newlines, than whatever is in the buffer can be flushed.
+         *  - all the characters up to the last new new line are flushed immediately.
+         *  - all the new characters after the last newline are buffered.
+         */
+        public void write(byte[] n, int offset, int len, OutputStream out) throws IOException {
+            int lastNL = startOfLastLine(n, offset, len);
+
+            if (lastNL == -1) {
+                store(n, offset, len);
+            }
+            else {
+                flush(out);
+                out.write(n, offset, lastNL + 1);
+                store(n, offset, lastNL - offset);
+            }
+        }
+
+        /**
+         * This empties the current buffer onto the stream,
+         * and resets the cursor.
+         */
+        private void flush(OutputStream out) throws IOException {
+            if (curEnd != 0) {
+                out.write(buffer, 0, curEnd);
+                curEnd = 0;
+            }
+        }
+
+        /**
+         * Prints whatever is the last line in the buffer,
+         * and adds a newline.
+         */
+        public void flushLastLine(OutputStream out) throws IOException {
+            if (curEnd != 0) {
+                flush(out);
+                out.write('\n');
+            }
+        }
+
+        private int startOfLastLine(byte[] buffer, int offset, int len) {
+            for (int i = offset + len - 1; i >= 0; i--) {
+                if (buffer[i] == '\n') {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+    }
+
     /**
      * Represents one currently running progress bar
      */
@@ -234,7 +326,7 @@
                 + " "
                 ;
 
-            writer.println("\r" + line); // note this puts us one line down
+            writer.println(line); // note this puts us one line down
         }
 
         private String threadLabel() {
@@ -395,6 +487,21 @@
             .filter(b -> b.threadId == Thread.currentThread().getId())
             .filter(b -> b.name.equals(name)).findFirst().orElseGet(() -> null);
     }
+
+    private UnfinishedLine findUnfinishedLine() {
+        UnfinishedLine before = unfinishedLines.stream()
+            .filter(l -> l.threadId == Thread.currentThread().getId())
+            .findAny()
+            .orElse(null);
+
+        if (before == null) {
+            UnfinishedLine l = new UnfinishedLine();
+            unfinishedLines.add(l);
+            before = l;
+        }
+
+        return before;
+    }
 
     @Override
     public synchronized void jobStart(String name, int workShare, int totalWork) {
@@ -483,12 +590,18 @@
      * Here we make sure the progress bars are gone just before
      * someone wants to print in the console. When the printing
      * is ready, we simply add our own progress bars again.
+     * 
+     * Special cases handle when there are unfinished lines in play.
+     * This code guarantees that printBars is only called when the cursor
+     * is before the first character of a line.
      */
     @Override
     public synchronized void write(byte[] b) throws IOException {
         if (!bars.isEmpty()) {
             eraseBars();
-            out.write(b);
+
+            findUnfinishedLine().write(b, out);
+
             printBars();
         }
         else {
@@ -505,7 +618,7 @@
     public synchronized void write(byte[] b, int off, int len) throws IOException {
         if (!bars.isEmpty()) {
             eraseBars();
-            out.write(b, off, len);
+            findUnfinishedLine().write(b, off, len, out);
             printBars();
         }
         else {
@@ -522,7 +635,7 @@
     public synchronized void write(int b) throws IOException {
         if (!bars.isEmpty()) {
             eraseBars();
-            out.write(b);
+            findUnfinishedLine().write(new byte[] { (byte) b }, out);
             printBars();
         }
         else {
@@ -541,6 +654,14 @@
         }
 
         bars.clear();
+        for (UnfinishedLine l : unfinishedLines) {
+            try {
+                l.flushLastLine(out);
+            }
+            catch (IOException e) {
+                // might happen if the terminal crashes before we stop running 
+            }
+        }
         writer.write(ANSI.showCursor());
         writer.flush();
     }

src/org/rascalmpl/test/infrastructure/TestFramework.java

@@ -28,7 +28,6 @@
 import java.util.Set;
 
 import org.junit.After;
-import org.rascalmpl.debug.IRascalMonitor;
 import org.rascalmpl.interpreter.Evaluator;
 import org.rascalmpl.interpreter.env.GlobalEnvironment;
 import org.rascalmpl.interpreter.env.ModuleEnvironment;

src/org/rascalmpl/uri/file/UNCResolver.java

@@ -2,8 +2,6 @@
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.util.regex.Pattern;
-
 import io.usethesource.vallang.ISourceLocation;
 
 /**

test/org/rascalmpl/MatchFingerprintTest.java

@@ -21,8 +21,6 @@
 import org.rascalmpl.interpreter.env.GlobalEnvironment;
 import org.rascalmpl.interpreter.env.ModuleEnvironment;
 import org.rascalmpl.test.infrastructure.RascalJUnitTestRunner;
-import org.rascalmpl.test.infrastructure.TestFramework;
-
 import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IInteger;
 import io.usethesource.vallang.ISourceLocation;