Rename writer/newline to writer/endline to avoid conflict with clojure.core/newline

Add writef function to format values and then write
Refactor write-binary out of format-binary
Refactor write-binary-delta out of format-binary-delta
Adjust binary-test for newline at end of each line (not as a separator)

Author: hlship

src/io/aviso/binary.clj

@@ -1,6 +1,9 @@
 (ns io.aviso.binary
   "Utilities for formatting binary data (byte arrays) or binary deltas."
-  (require [io.aviso.ansi :as ansi]
+  (import (java.lang StringBuilder))
+  (require [io.aviso
+            [ansi :as ansi]
+            [writer :as w]]
            [clojure.string :as s]))
 
 (defprotocol BinaryData
@@ -31,21 +34,19 @@
 (def ^:private ^:const bytes-per-diff-line 16)
 (def ^:private ^:const bytes-per-line (* 2 bytes-per-diff-line))
 
-(defn- format-line
-  [offset data line-count]
-  (format
-    "%04X:%s"
-    offset
-    (apply str
-           (for [i (range line-count)]
-             (format " %02X" (byte-at data (+ offset i)))))))
+(defn- write-line
+  [writer offset data line-count]
+  (w/writef writer "%04X:" offset)
+  (doseq [i (range line-count)]
+    (w/writef writer " %02X" (byte-at data (+ offset i))))
+  (w/write writer w/endline))
 
 (defn- join-lines
   "Joins all the lines together seperated by newlines."
   [lines]
   (s/join \newline lines))
 
-(defn format-binary
+(defn write-binary
   "Formats a ByteData into a hex-dump string, consisting of multiple lines; each line formatted as:
 
   0000: 4E 6F 77 20 69 73 20 74 68 65 20 74 69 6D 65 20 66 6F 72 20 61 6C 6C 20 67 6F 6F 64 20 6D 65 6E
@@ -55,16 +56,21 @@
   (32 bytes per line)
 
   ... that is, a four-byte offset, then up-to 32 bytes (depending on the length of the data)."
-  [data]
-  (loop [offset 0
-         lines []]
-    (let [remaining (- (data-length data) offset)]
-      (if (< remaining 1)
-        (join-lines lines)
-        (recur (+ bytes-per-line offset)
-               (conj lines
-                     (format-line offset data (min bytes-per-line remaining))))))))
+  ([data]
+   (write-binary *out* data))
+  ([writer data]
+   (loop [offset 0]
+     (let [remaining (- (data-length data) offset)]
+       (when (pos? remaining)
+         (write-line writer offset data (min bytes-per-line remaining))
+         (recur (+ bytes-per-line offset)))))))
 
+(defn format-binary
+  "Formats the data as with write-binary and returns the result as a string."
+  [data]
+  (let [result (StringBuilder. (* 3 (data-length data)))]
+    (write-binary result data)
+    (.toString result)))
 
 (defn- match?
   [byte-offset data-length data alternate-length alternate]
@@ -75,35 +81,53 @@
 
 (defn- to-hex
   [byte-array byte-offset]
+  ;; This could be made a lot more efficient!
   (format "%02X" (byte-at byte-array byte-offset)))
 
-
-(defn- format-byte-deltas
-  [ansi-color pad? offset data-length data alternate-length alternate]
-  (apply str
-         (for [i (range bytes-per-diff-line)]
-           (let [byte-offset (+ offset i)]
-             (cond
-               ;; Exact match on both sides is easy, just print it out.
-               (match? byte-offset data-length data alternate-length alternate) (str " " (to-hex data byte-offset))
-               ;; Some kind of mismatch, so decorate with this side's color
-               (< byte-offset data-length) (str " " (ansi-color (to-hex data byte-offset)))
-               ;; Are we out of data on this side?  Print a "--" decorated with the color.
-               (< byte-offset alternate-length) (str " " (ansi-color "--"))
-               ;; This side must be longer than the alternate side.
-               ;; On the left/green side, we need to pad with spaces
-               pad? "   "
-               ;; On the right/red side, we need nothing.
-               :else "")))))
-
-(defn- format-delta-line
-  [offset expected-length ^bytes expected actual-length actual]
+(defn- write-byte-deltas
+  [writer ansi-color pad? offset data-length data alternate-length alternate]
+  (doseq [i (range bytes-per-diff-line)]
+    (let [byte-offset (+ offset i)]
+      (cond
+        ;; Exact match on both sides is easy, just print it out.
+        (match? byte-offset data-length data alternate-length alternate) (w/writes writer " " (to-hex data byte-offset))
+        ;; Some kind of mismatch, so decorate with this side's color
+        (< byte-offset data-length) (w/writes writer " " (ansi-color (to-hex data byte-offset)))
+        ;; Are we out of data on this side?  Print a "--" decorated with the color.
+        (< byte-offset alternate-length) (w/writes writer " " (ansi-color "--"))
+        ;; This side must be longer than the alternate side.
+        ;; On the left/green side, we need to pad with spaces
+        ;; On the right/red side, we need nothing.
+        pad? (w/write writer "   ")))))
+
+(defn- write-delta-line
+  [writer offset expected-length ^bytes expected actual-length actual]
   (let [line-count (max (min bytes-per-diff-line (- expected-length offset))
                         (min bytes-per-diff-line (- actual-length offset)))]
-    (format "%04X:%s |%s"
-            offset
-            (format-byte-deltas ansi/bold-green true offset expected-length expected actual-length actual)
-            (format-byte-deltas ansi/bold-red false offset actual-length actual expected-length expected))))
+    (w/writef writer "%04X:" offset)
+    (write-byte-deltas writer ansi/bold-green true offset expected-length expected actual-length actual)
+    (write-byte-deltas writer ansi/bold-red false offset actual-length actual expected-length expected)
+    (w/write writer w/endline)))
+
+(defn write-binary-delta
+  "Formats a hex dump of the expected data (on the left) and actual data (on the right). Bytes
+  that do not match are highlighted in green on the expected side, and red on the actual side.
+  When one side is shorter than the other, it is padded with -- placeholders to make this
+  more clearly visible.
+
+  expected - ByteData
+  actual - ByteData
+
+  Display 16 bytes (from each data set) per line."
+  ([expected actual] (write-binary-delta *out* expected actual))
+  ([writer expected actual]
+   (let [expected-length (data-length expected)
+         actual-length (data-length actual)
+         target-length (max actual-length expected-length)]
+     (loop [offset 0]
+       (when (pos? (- target-length offset))
+         (write-delta-line writer offset expected-length expected actual-length actual)
+         (recur (+ bytes-per-diff-line offset)))))))
 
 (defn format-binary-delta
   "Formats a hex dump of the expected data (on the left) and actual data (on the right). Bytes
@@ -116,13 +140,6 @@
 
   Display 16 bytes (from each data set) per line."
   [expected actual]
-  (let [expected-length (data-length expected)
-        actual-length (data-length actual)
-        target-length (max actual-length expected-length)]
-    (loop [offset 0
-           lines []]
-      (if (< (- target-length offset) 1)
-        (join-lines lines)
-        (recur (+ bytes-per-diff-line offset)
-               (conj lines
-                     (format-delta-line offset expected-length expected actual-length actual)))))))
+  (let [result (StringBuilder. 2000)]
+    (write-binary-delta result expected actual)
+    (.toString result)))

src/io/aviso/exception.clj

@@ -194,7 +194,7 @@
         (justify line-width line)
         (w/write "  ")
         (justify class-width class)
-        (w/writes "." method w/newline)))))
+        (w/writes "." method w/endline)))))
 
 
 (defn write-exception
@@ -220,7 +220,7 @@
                    (if message
                      (str " " message-font message reset-font)
                      "")
-                   w/newline)
+                   w/endline)
 
          (let [properties (update-keys (:properties e) name)
                prop-keys (keys properties)
@@ -231,7 +231,7 @@
                                   (max-length prop-keys))]
            (doseq [k (sort prop-keys)]
              (justify writer prop-name-width property-font k reset-font)
-             (w/writes writer ": " (get properties k) w/newline))
+             (w/writes writer ": " (get properties k) w/endline))
            (if (:root e)
              (write-stack-trace writer exception))))))))
 

src/io/aviso/writer.clj

@@ -18,7 +18,12 @@
   [writer & values]
   (write writer (apply str values)))
 
-(def newline
+(defn writef
+  "Writes formatted data."
+  [writer fmt & values]
+  (write writer (apply format fmt values)))
+
+(def endline
   "End-of-line terminator, platform specific."
   (System/getProperty "line.separator"))
 

test/io/aviso/binary_test.clj

@@ -11,17 +11,17 @@
   (are [input output]
     (= (format-string-as-byte-array input) output)
 
-    "Hello" "0000: 48 65 6C 6C 6F"
+    "Hello" "0000: 48 65 6C 6C 6F\n"
     "This is a longer text that spans to a second line."
-    "0000: 54 68 69 73 20 69 73 20 61 20 6C 6F 6E 67 65 72 20 74 65 78 74 20 74 68 61 74 20 73 70 61 6E 73\n0020: 20 74 6F 20 61 20 73 65 63 6F 6E 64 20 6C 69 6E 65 2E"))
+    "0000: 54 68 69 73 20 69 73 20 61 20 6C 6F 6E 67 65 72 20 74 65 78 74 20 74 68 61 74 20 73 70 61 6E 73\n0020: 20 74 6F 20 61 20 73 65 63 6F 6E 64 20 6C 69 6E 65 2E\n"))
 
 (deftest format-string-as-byte-data
   (are [input output]
     (= (format-binary input) output)
     "" ""
-    "Hello" "0000: 48 65 6C 6C 6F"
+    "Hello" "0000: 48 65 6C 6C 6F\n"
     "This is a longer text that spans to a second line."
-    "0000: 54 68 69 73 20 69 73 20 61 20 6C 6F 6E 67 65 72 20 74 65 78 74 20 74 68 61 74 20 73 70 61 6E 73\n0020: 20 74 6F 20 61 20 73 65 63 6F 6E 64 20 6C 69 6E 65 2E"))
+    "0000: 54 68 69 73 20 69 73 20 61 20 6C 6F 6E 67 65 72 20 74 65 78 74 20 74 68 61 74 20 73 70 61 6E 73\n0020: 20 74 6F 20 61 20 73 65 63 6F 6E 64 20 6C 69 6E 65 2E\n"))
 
 (deftest nil-is-an-empty-data
   (is (= (format-binary nil) "")))

test/user.clj

@@ -1,6 +1,7 @@
 (ns user
   (import (java.sql SQLException))
-  (use [io.aviso ansi binary exception]))
+  (use [io.aviso ansi binary exception]
+       [clojure test]))
 
 (defn make-exception
   "Creates a sample exception used to test the exception formatting logic."