Fix for minimise, plus cleanup/bumps/tooling

plexus · plexus · commit 8d35b6991be8 · 2026-04-07T15:59:04.000+02:00
diff --git a/.dir-locals.el b/.dir-locals.el
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,13 +1,19 @@
 # Unreleased
 
-## Added
+## Changed
+
+- General dependency and tooling version bumps
 
 ## Fixed
 
 - Fixed puget printer for futures
 
 ## Changed
 
+- Fix `mimimize` when inserting/removing map keys (should preserve associated
+  value)
+- Add `minimise` variant
+
 # 2.12.219 (2025-02-06 / 9e6942a)
 
 ## Changed
diff --git a/bb.edn b/bb.edn
@@ -1,7 +1,7 @@
 {:deps
  {lambdaisland/deep-diff2 {:local/root "."}
   lambdaisland/open-source {:git/url "https://github.com/lambdaisland/open-source"
-                            :git/sha "e0e234aea52aeafac6ebb06c4a5149d83977e6a0"}}
+                            :git/sha "34ce20d7b2af747227c345b392fe92cb5f4d3cda"}}
  :tasks
  {test:bb {:doc "Run babashka tests with custom runner"
            :extra-paths ["src" "test"]
diff --git a/deps.edn b/deps.edn
@@ -1,24 +1,24 @@
 {:paths ["resources" "src"]
- :deps  {fipp/fipp                   {:mvn/version "0.6.27"}
-         org.clojure/core.rrb-vector {:mvn/version "0.2.0"}
+ :deps  {fipp/fipp                   {:mvn/version "0.6.29"}
+         org.clojure/core.rrb-vector {:mvn/version "0.2.1"}
          lambdaisland/clj-diff       {:mvn/version "1.4.78"}
          mvxcvi/arrangement          {:mvn/version "2.1.0"}}
 
  :aliases {:cljs
-           {:extra-deps {org.clojure/clojurescript {:mvn/version "1.11.132"}}}
+           {:extra-deps {org.clojure/clojurescript {:mvn/version "1.12.134"}}}
 
            :dev
            {}
 
            :chui
            {:extra-deps  {lambdaisland/chui    {:local/root "../chui"}
-                          thheller/shadow-cljs {:mvn/version "2.28.20"}
+                          thheller/shadow-cljs {:mvn/version "3.3.8"}
                           garden/garden        {:mvn/version "1.3.10"}}
             :extra-paths ["../chui/resources" "../chui/dev"]}
 
            :test
            {:extra-paths ["test"]
             :extra-deps {lambdaisland/kaocha       {:mvn/version "1.91.1392"}
-                         com.lambdaisland/kaocha-cljs  {:mvn/version "1.5.154"}
-                         org.clojure/clojurescript {:mvn/version "1.11.132"}
-                         org.clojure/test.check    {:mvn/version "1.1.1"}}}}}
+                         com.lambdaisland/kaocha-cljs  {:mvn/version "1.9.181"}
+                         org.clojure/clojurescript {:mvn/version "1.12.134"}
+                         org.clojure/test.check    {:mvn/version "1.1.3"}}}}}
diff --git a/package.json b/package.json
@@ -4,6 +4,6 @@
   "dependencies": {
     "react": "^16.13.1",
     "react-dom": "^16.13.1",
-    "ws": "^8.18.0"
+    "ws": "^8.20.0"
   }
 }
diff --git a/src/lambdaisland/deep_diff2.cljc b/src/lambdaisland/deep_diff2.cljc
@@ -1,8 +1,9 @@
 (ns lambdaisland.deep-diff2
+  "Diff datastructures deeply, and pretty-print the result"
   (:require
    [lambdaisland.deep-diff2.diff-impl :as diff-impl]
-   [lambdaisland.deep-diff2.printer-impl :as printer-impl]
-   [lambdaisland.deep-diff2.minimize-impl :as minimize]))
+   [lambdaisland.deep-diff2.minimise-impl :as minimise]
+   [lambdaisland.deep-diff2.printer-impl :as printer-impl]))
 
 (defn diff
   "Compare two values recursively.
@@ -44,7 +45,12 @@
        (printer-impl/format-doc printer)
        (printer-impl/print-doc printer))))
 
+(defn minimise
+  "Return a minimal diff, removing any values that haven't changed."
+  [diff]
+  (minimise/minimise diff))
+
 (defn minimize
   "Return a minimal diff, removing any values that haven't changed."
   [diff]
-  (minimize/minimize diff))
+  (minimise/minimise diff))
diff --git a/src/lambdaisland/deep_diff2/diff_impl.cljc b/src/lambdaisland/deep_diff2/diff_impl.cljc
@@ -1,7 +1,8 @@
 (ns lambdaisland.deep-diff2.diff-impl
-  (:require [clojure.data :as data]
-            [clojure.set :as set]
-            [lambdaisland.clj-diff.core :as seq-diff]))
+  (:require
+   [clojure.data :as data]
+   [clojure.set :as set]
+   [lambdaisland.clj-diff.core :as seq-diff]))
 
 (declare diff diff-similar diff-meta)
 
diff --git a/src/lambdaisland/deep_diff2/minimise_impl.cljc b/src/lambdaisland/deep_diff2/minimise_impl.cljc
@@ -0,0 +1,53 @@
+(ns lambdaisland.deep-diff2.minimise-impl
+  "Provide API for manipulate the diff structure data "
+  (:require
+   [clojure.walk :refer [postwalk]]
+   #?(:clj [lambdaisland.deep-diff2.diff-impl]
+      :cljs [lambdaisland.deep-diff2.diff-impl :refer [Mismatch Deletion Insertion]]))
+  #?(:clj (:import [lambdaisland.deep_diff2.diff_impl Mismatch Deletion Insertion])))
+
+(defn diff-item?
+  "Checks if x is a Mismatch, Deletion, or Insertion"
+  [x]
+  (or (instance? Mismatch x)
+      (instance? Deletion x)
+      (instance? Insertion x)))
+
+(defn has-diff-item?
+  "Checks if there are any diff items in x or sub-tree of x"
+  [x]
+  (or (diff-item? x)
+      (and (map? x) (some #(or (has-diff-item? (key %))
+                               (has-diff-item? (val %))) x))
+      (and (coll? x) (some has-diff-item? x))))
+
+(defn minimise
+  "Postwalk diff, removing values that are unchanged"
+  [o]
+  (cond
+    (diff-item? o)
+    o
+
+    (map-entry? o)
+    (cond
+      (has-diff-item? (key o))
+      o
+      (has-diff-item? (val o))
+      #?(:clj
+         (clojure.lang.MapEntry/create (key o) (minimise (val o)))
+         :cljs
+         (MapEntry. (key o) (minimise (val o)))))
+
+    (record? o)
+    (into o (map minimise) o)
+
+    (map? o)
+    (into {} (keep minimise) o)
+
+    (coll? o)
+    (if (has-diff-item? o)
+      (into (empty o) (keep minimise) o)
+      (empty o))
+
+    :else
+    nil))
diff --git a/src/lambdaisland/deep_diff2/minimize_impl.cljc b/src/lambdaisland/deep_diff2/minimize_impl.cljc
diff --git a/src/lambdaisland/deep_diff2/printer_impl.cljc b/src/lambdaisland/deep_diff2/printer_impl.cljc
@@ -1,11 +1,12 @@
 (ns lambdaisland.deep-diff2.printer-impl
-  (:require [arrangement.core]
-            [fipp.engine :as fipp]
-            [lambdaisland.deep-diff2.diff-impl :as diff]
-            [lambdaisland.deep-diff2.puget.color :as color]
-            [lambdaisland.deep-diff2.puget.dispatch :as dispatch]
-            [lambdaisland.deep-diff2.puget.printer :as puget-printer]
-            #?(:cljs [goog.string :refer [format]]))
+  (:require
+   [arrangement.core]
+   [fipp.engine :as fipp]
+   [lambdaisland.deep-diff2.diff-impl :as diff]
+   [lambdaisland.deep-diff2.puget.color :as color]
+   [lambdaisland.deep-diff2.puget.dispatch :as dispatch]
+   [lambdaisland.deep-diff2.puget.printer :as puget-printer]
+   #?(:cljs [goog.string :refer [format]]))
   #?(:clj
      (:import)))
 
diff --git a/test/lambdaisland/deep_diff2/minimise_test.cljc b/test/lambdaisland/deep_diff2/minimise_test.cljc
@@ -1,14 +1,15 @@
-(ns lambdaisland.deep-diff2.minimize-test
-  (:require [clojure.test :refer [deftest testing is are]]
-            [lambdaisland.deep-diff2.diff-test :as diff-test]
-            [clojure.test.check.clojure-test :refer [defspec]]
-            [clojure.test.check.generators :as gen]
-            [clojure.test.check.properties :as prop]
-            [lambdaisland.deep-diff2.diff-impl :as diff]
-            [lambdaisland.deep-diff2 :as ddiff]))
+(ns lambdaisland.deep-diff2.minimise-test
+  (:require
+   [clojure.test :refer [deftest testing is are]]
+   [clojure.test.check.clojure-test :refer [defspec]]
+   [clojure.test.check.generators :as gen]
+   [clojure.test.check.properties :as prop]
+   [lambdaisland.deep-diff2 :as ddiff]
+   [lambdaisland.deep-diff2.diff-impl :as diff]
+   [lambdaisland.deep-diff2.diff-test :as diff-test]))
 
 (deftest basic-strip-test
-  (testing "diff without minimize"
+  (testing "diff without minimise"
     (let [x {:a 1 :b 2 :d {:e 1} :g [:e [:k 14 :g 15]]}
           y {:a 1 :c 3 :d {:e 15} :g [:e [:k 14 :g 15]]}]
       (is (= (ddiff/diff x y)
@@ -17,62 +18,67 @@
               :d {:e (diff/->Mismatch 1 15)}
               :g [:e [:k 14 :g 15]]
               (diff/->Insertion :c) 3}))))
-  (testing "diff with minimize"
+  (testing "diff with minimise"
     (let [x {:a 1 :b 2 :d {:e 1} :g [:e [:k 14 :g 15]]}
           y {:a 1 :c 3 :d {:e 15} :g [:e [:k 14 :g 15]]}]
-      (is (= (ddiff/minimize (ddiff/diff x y))
+      (is (= (ddiff/minimise (ddiff/diff x y))
              {(diff/->Deletion :b) 2
               :d {:e (diff/->Mismatch 1 15)}
               (diff/->Insertion :c) 3})))))
 
-(deftest minimize-on-diff-test
+(deftest minimise-on-diff-test
   (testing "diffing atoms"
     (testing "when different"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff :a :b))
              (diff/->Mismatch :a :b))))
 
     (testing "when equal"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff :a :a))
              nil))))
 
   (testing "diffing collections"
     (testing "when different collection types"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff [:a :b] #{:a :b}))
              (diff/->Mismatch [:a :b] #{:a :b}))))
 
     (testing "when equal with clojure set"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff #{:a :b} #{:a :b}))
              #{})))
 
     (testing "when different with clojure set"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff #{:a :b :c} #{:a :b :d}))
              #{(diff/->Insertion :d) (diff/->Deletion :c)})))
 
     (testing "when equal with clojure vector"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff [:a :b] [:a :b]))
              [])))
 
     (testing "when equal with clojure hashmap"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff {:a 1} {:a 1}))
              {})))
 
     (testing "when equal with clojure nesting vector"
-      (is (= (ddiff/minimize
+      (is (= (ddiff/minimise
               (ddiff/diff [:a [:b :c :d]] [:a [:b :c :d]]))
-             [])))))
+             [])))
+
+    (testing "inserting a new map"
+      (is
+       (= (ddiff/minimise (ddiff/diff {} {:foo {:a 1}}))
+          {(diff/->Insertion :foo) {:a 1}})))))
 
-;; "diff itself and minimize yields empty"
+;; "diff itself and minimise yields empty"
 (defspec diff-itself 100
   (prop/for-all
    [x diff-test/gen-any-except-NaN]
    (if (coll? x)
-     (= (ddiff/minimize (ddiff/diff x x))
+     (= (ddiff/minimise (ddiff/diff x x))
         (empty x))
-     (nil? (ddiff/minimize (ddiff/diff x x))))))
+     (nil? (ddiff/minimise (ddiff/diff x x))))))

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@`
`4`	`4`	`"dependencies": {`
`5`	`5`	`"react": "^16.13.1",`
`6`	`6`	`"react-dom": "^16.13.1",`
`7`		`- "ws": "^8.18.0"`
	`7`	`+ "ws": "^8.20.0"`
`8`	`8`	`}`
`9`	`9`	`}`