[inspect] Add hexdump view-mode

Author: alexander-yakushev

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## master (unreleased)
 
+- [#342](https://github.com/clojure-emacs/orchard/pull/342): Inspector: add hexdump view mode.
+
 ## 0.34.3 (2025-04-28)
 
 - Inspector: fix multiple frequencies not shown for the same value in analytics.

src/orchard/inspect.clj

@@ -35,7 +35,7 @@
                             (list 'get key)))
     (conj path '<unknown>)))
 
-(def ^:private supported-view-modes #{:normal :object :table})
+(def ^:private supported-view-modes #{:normal :object :table :hex})
 
 (def ^:private default-inspector-config
   "Default configuration values for the inspector."
@@ -121,8 +121,11 @@
 (defn- decide-if-paginated
   "Make early decision if the inspected object should be paginated. If so,
   assoc the `:chunk` to be displayed to `inspector`."
-  [{:keys [value current-page page-size] :as inspector}]
-  (let [pageable? (boolean (#{:list :map :set :array} (object-type value)))]
+  [{:keys [value current-page page-size view-mode] :as inspector}]
+  (let [pageable? (boolean (#{:list :map :set :array} (object-type value)))
+        page-size (if (= view-mode :hex)
+                    (* page-size 16) ;; In hex view mode, each row is 16 bytes.
+                    page-size)]
     (cond-> (assoc inspector :pageable pageable?)
       pageable? (merge (pagination-info value page-size current-page)))))
 
@@ -653,6 +656,45 @@
       (unindent ins))
     inspector))
 
+;; Hex view mode
+
+(defn- byte->ascii [b]
+  (let [c (bit-and b 0xFF)]
+    (if (and (>= c 32) (<= c 126))
+      (char c)
+      ;; Use MIDDLE DOT for non-printed chars as it is distinct from 0x2E.
+      \·)))
+
+(defn- format-hex-row
+  "Format 16 bytes as hex values."
+  [bytes]
+  (let [hex-strs (mapv #(format "%02x" (bit-and % 0xFF)) bytes)
+        padded (concat hex-strs (repeat (- 16 (count bytes)) "  "))
+        [left-half right-half] (split-at 8 padded)]
+    (str (str/join " " left-half) "  " (str/join " " right-half))))
+
+(defn format-ascii-row
+  "Format 16 bytes as ASCII characters."
+  [bytes]
+  (str/join (map byte->ascii bytes)))
+
+(defn render-hexdump
+  "Render the current array or array chunk as a hexdump-style table."
+  [{:keys [value chunk start-idx] :as inspector}]
+  (let [start-idx (or start-idx 0)
+        lines (eduction (comp (partition-all 16)
+                              (map-indexed vector))
+                        (or chunk value))]
+    (as-> inspector ins
+      (render-leading-page-ellipsis ins)
+      (reduce (fn [ins [i line]]
+                (let [addr (+ (* i 16) start-idx)]
+                  (render-indent-ln
+                   ins (format "0x%08x │ %s │ %s" addr (format-hex-row line)
+                               (format-ascii-row line)))))
+              ins lines)
+      (render-trailing-page-ellipsis ins))))
+
 ;; Inspector multimethod
 (defn- dispatch-inspect [{:keys [view-mode] :as _ins} obj]
   (if (= view-mode :object)
@@ -683,16 +725,18 @@
 (defmethod inspect :map  [inspector obj] (inspect-coll inspector obj))
 
 (defmethod inspect :array [inspector obj]
-  (-> (render-class-name inspector obj)
-      (render-counted-length obj)
-      (render-labeled-value "Component Type" (.getComponentType (class obj)))
-      (render-analytics)
-      (render-section-header "Contents")
-      (indent)
-      (render-collection-paged)
-      (unindent)
-      (render-datafy)
-      (render-page-info)))
+  (as-> (render-class-name inspector obj) ins
+    (render-counted-length ins obj)
+    (render-labeled-value ins "Component Type" (.getComponentType (class obj)))
+    (render-analytics ins)
+    (render-section-header ins "Contents")
+    (indent ins)
+    (if (= (:view-mode inspector) :hex)
+      (render-hexdump ins)
+      (render-collection-paged ins))
+    (unindent ins)
+    (render-datafy ins)
+    (render-page-info ins)))
 
 (defn- render-var-value [inspector ^clojure.lang.Var obj]
   (if-not (.isBound obj)

test/orchard/inspect_test.clj

@@ -1561,6 +1561,49 @@
                  (set-page-size 30)
                  (inspect/supports-table-view-mode?))))))
 
+(deftest hex-view-mode-test
+  (testing "in :hex view-mode byte arrays are rendered as hexdump tables"
+    (let [rendered (-> (byte-array (range 100))
+                       inspect
+                       (inspect/set-view-mode :hex)
+                       render)]
+      (is+ ["--- Contents:" [:newline]
+            "  0x00000000 │ 00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f │ ················" [:newline]
+            "  0x00000010 │ 10 11 12 13 14 15 16 17  18 19 1a 1b 1c 1d 1e 1f │ ················" [:newline]
+            "  0x00000020 │ 20 21 22 23 24 25 26 27  28 29 2a 2b 2c 2d 2e 2f │  !\"#$%&'()*+,-./" [:newline]
+            "  0x00000030 │ 30 31 32 33 34 35 36 37  38 39 3a 3b 3c 3d 3e 3f │ 0123456789:;<=>?" [:newline]
+            "  0x00000040 │ 40 41 42 43 44 45 46 47  48 49 4a 4b 4c 4d 4e 4f │ @ABCDEFGHIJKLMNO" [:newline]
+            "  0x00000050 │ 50 51 52 53 54 55 56 57  58 59 5a 5b 5c 5d 5e 5f │ PQRSTUVWXYZ[\\]^_" [:newline]
+            "  0x00000060 │ 60 61 62 63                                      │ `abc" [:newline] [:newline]]
+           (contents-section rendered))
+      (is+ ["--- View mode:" [:newline] "  :hex"]
+           (section rendered "View mode"))))
+
+  (testing "works with paging"
+    (is+ ["--- Contents:" [:newline]
+          "  0x00000000 │ 00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f │ ················" [:newline]
+          "  0x00000010 │ 10 11 12 13 14 15 16 17  18 19 1a 1b 1c 1d 1e 1f │ ················" [:newline]
+          "  ..." [:newline] [:newline]]
+         (-> (byte-array (range 100))
+             inspect
+             (inspect/set-view-mode :hex)
+             (set-page-size 2)
+             render
+             contents-section))
+
+    (is+ ["--- Contents:" [:newline]
+          "  ..." [:newline]
+          "  0x00000020 │ 20 21 22 23 24 25 26 27  28 29 2a 2b 2c 2d 2e 2f │  !\"#$%&'()*+,-./" [:newline]
+          "  0x00000030 │ 30 31 32 33 34 35 36 37  38 39 3a 3b 3c 3d 3e 3f │ 0123456789:;<=>?" [:newline]
+          "  ..." [:newline] [:newline]]
+         (-> (byte-array (range 100))
+             inspect
+             (inspect/set-view-mode :hex)
+             (set-page-size 2)
+             inspect/next-page
+             render
+             contents-section))))
+
 (deftest pretty-print-map-test
   (testing "in :pretty view-mode are pretty printed"
     (let [rendered (-> {:a 0