[MLv2] Short name display for filter clauses (#35933)

* [MLv2] Short name display for filter clauses

Fixes #35752

Built for the timeseries widget and the associated operators. Generally
shows the user selected dates and occasionally shows an operator.
The choices are about what looks correct more than following particular
rules.

* fix newline

src/metabase/lib/core.cljc

@@ -163,7 +163,8 @@
   lower]
  [lib.fe-util
   expression-clause
-  expression-parts]
+  expression-parts
+  filter-args-display-name]
  [lib.field
   add-field
   field-id

src/metabase/lib/fe_util.cljc

@@ -8,7 +8,13 @@
    [metabase.lib.schema :as lib.schema]
    [metabase.lib.schema.common :as lib.schema.common]
    [metabase.lib.schema.expression :as lib.schema.expression]
+   [metabase.lib.schema.temporal-bucketing :as lib.schema.temporal-bucketing]
+   [metabase.lib.temporal-bucket :as lib.temporal-bucket]
    [metabase.lib.util :as lib.util]
+   [metabase.mbql.util :as mbql.u]
+   [metabase.shared.util.i18n :as i18n]
+   [metabase.shared.util.time :as shared.ut]
+   [metabase.util :as u]
    [metabase.util.malli :as mu]))
 
 (def ^:private ExpressionParts
@@ -56,3 +62,46 @@
    args     :- [:sequential :any]
    options  :- [:maybe :map]]
   (lib.options/ensure-uuid (into [operator options] (map lib.common/->op-arg) args)))
+
+(mu/defn filter-args-display-name :- :string
+  "Provides a reasonable display name for the `filter-clause` excluding the column-name.
+   Can be expanded as needed but only currently defined for a narrow set of date filters.
+
+   Falls back to the full filter display-name"
+  [query stage-number filter-clause]
+  (let [->temporal-name #(shared.ut/format-unit % nil)
+        temporal? #(lib.util/original-isa? % :type/Temporal)
+        unit-is (fn [unit-or-units]
+                  (let [units (set (u/one-or-many unit-or-units))]
+                    (fn [maybe-clause]
+                      (clojure.core/and
+                        (temporal? maybe-clause)
+                        (lib.util/clause? maybe-clause)
+                        (clojure.core/contains? units (:temporal-unit (second maybe-clause)))))))]
+    (mbql.u/match-one filter-clause
+      [:= _ (x :guard (unit-is lib.schema.temporal-bucketing/datetime-truncation-units)) (y :guard string?)]
+      (shared.ut/format-relative-date-range y 0 (:temporal-unit (second x)) nil nil {:include-current true})
+
+      [:= _ (x :guard temporal?) (y :guard (some-fn int? string?))]
+      (lib.temporal-bucket/describe-temporal-pair x y)
+
+      [:< _ (x :guard temporal?) (y :guard string?)]
+      (i18n/tru "Before {0}" (->temporal-name y))
+
+      [:> _ (x :guard temporal?) (y :guard string?)]
+      (i18n/tru "After {0}" (->temporal-name y))
+
+      [:between _ (x :guard temporal?) (y :guard string?) (z :guard string?)]
+      (shared.ut/format-diff y z)
+
+      [:is-null & _]
+      (i18n/tru "Is Empty")
+
+      [:not-null & _]
+      (i18n/tru "Is Not Empty")
+
+      [:time-interval _ (x :guard temporal?) n unit]
+      (lib.temporal-bucket/describe-temporal-interval n unit)
+
+      _
+      (lib.metadata.calculation/display-name query stage-number filter-clause))))

src/metabase/lib/js.cljs

@@ -1060,6 +1060,14 @@
   [a-query]
   (lib.core/stage-count a-query))
 
+(defn ^:export filter-args-display-name
+  "Provides a reasonable display name for the `filter-clause` excluding the column-name.
+   Can be expanded as needed but only currently defined for a narrow set of date filters.
+
+   Falls back to the full filter display-name"
+  [a-query stage-number a-filter-clause]
+  (lib.core/filter-args-display-name a-query stage-number a-filter-clause))
+
 (defn ^:export expression-clause-for-legacy-expression
   "Create an expression clause from `legacy-expression` at stage `stage-number` of `a-query`."
   [a-query stage-number legacy-expression]

test/metabase/lib/fe_util_test.cljc

 (ns metabase.lib.fe-util-test
   (:require
-   [clojure.test :refer [deftest is testing]]
+   #?@(:cljs ([metabase.test-runner.assert-exprs.approximately-equal]))
+   [clojure.test :refer [are deftest is testing]]
    [medley.core :as m]
    [metabase.lib.core :as lib]
    [metabase.lib.test-metadata :as meta]
    [metabase.lib.test-util :as lib.tu]
-   [metabase.lib.types.isa :as lib.types.isa]
-   #?@(:cljs ([metabase.test-runner.assert-exprs.approximately-equal]))))
+   [metabase.lib.types.isa :as lib.types.isa]))
 
 (deftest ^:parallel basic-filter-parts-test
   (let [query (-> (lib/query meta/metadata-provider (meta/table-metadata :users))
@@ -116,3 +116,19 @@
                   1]}
           (lib/expression-parts lib.tu/venues-query -1 (lib/= (lib/ref (meta/field-metadata :products :id))
                                                               1)))))
+
+(deftest ^:parallel date-parts-display-name-test
+  (let [created-at (meta/field-metadata :products :created-at)
+        date-arg-1 "2023-11-02"
+        date-arg-2 "2024-01-03"]
+    (are [expected clause] (=? expected (lib/filter-args-display-name lib.tu/venues-query -1 clause))
+      "Nov 2, 2023" (lib/= created-at date-arg-1)
+      "Nov 2, 2023 – Jan 3, 2024" (lib/between created-at date-arg-1 date-arg-2)
+      "After Nov 2, 2023" (lib/> created-at date-arg-1)
+      "Before Nov 2, 2023" (lib/< created-at date-arg-1)
+      "Yesterday" (lib/time-interval created-at -1 :day)
+      "Tomorrow" (lib/time-interval created-at 1 :day)
+      "Previous 10 Days" (lib/time-interval created-at -10 :day)
+      "Next 10 Days" (lib/time-interval created-at 10 :day)
+      "Today" (lib/time-interval created-at :current :day)
+      "This Month" (lib/time-interval created-at :current :month))))