wip: get references from property values

deps/graph-parser/src/logseq/graph_parser/block.cljs

@@ -157,10 +157,8 @@
              distinct)
     []))
 
-;; TODO: Use text/parse-property to determine refs rather than maintain this similar
-;; implementation to parse-property
 (defn- get-page-ref-names-from-properties
-  [format properties user-config]
+  [properties user-config]
   (let [page-refs (->>
                    properties
                    (remove (fn [[k _]]
@@ -170,30 +168,9 @@
                                            gp-property/editable-linkable-built-in-properties)
                                          (gp-property/hidden-built-in-properties))
                               (keyword k))))
+                   ;; get links ast
                    (map last)
-                   (map (fn [v]
-                          (cond
-                            (and (string? v)
-                                 (not (gp-mldoc/link? format v)))
-                            (let [v (string/trim v)
-                                  result (if (:rich-property-values? user-config)
-                                           (if (gp-util/wrapped-by-quotes? v)
-                                             []
-                                             (text/extract-page-refs-and-tags v))
-                                           (text/split-page-refs-without-brackets v {:un-brackets? false}))]
-                              (if (coll? result)
-                                (map text/page-ref-un-brackets! result)
-                                []))
-
-                            (coll? v)
-                            (map (fn [s]
-                                   (when-not (and (string? v)
-                                                  (gp-mldoc/link? format v))
-                                     (text/page-ref-un-brackets! s))) v)
-
-                            :else
-                            nil)))
-                   (apply concat))
+                   (mapcat text/extract-refs-from-mldoc-ast))
         page-refs-from-property-names (get-page-refs-from-property-names properties user-config)]
     (->> (concat page-refs page-refs-from-property-names)
          (remove string/blank?)
@@ -203,11 +180,11 @@
   [format properties user-config]
   (when (seq properties)
     (let [properties (seq properties)
-          page-refs (get-page-ref-names-from-properties format properties user-config)
+          page-refs (get-page-ref-names-from-properties properties user-config)
           *invalid-properties (atom #{})
           properties (->> properties
-                          (map (fn [[k v]]
-                                 (let [k (-> (string/lower-case (name k))
+                          (map (fn [[k v mldoc-ast]]
+                                 (let [k (-> (string/lower-case (subs (str k) 1))
                                              (string/replace " " "-")
                                              (string/replace "_" "-")
                                              (string/replace #"[\"|^|(|)|{|}]+" ""))]
@@ -217,20 +194,8 @@
                                                k)
                                            v (if (coll? v)
                                                (remove string/blank? v)
-                                               (cond
-                                                 (string/blank? v)
-                                                 nil
-                                                 (and (= (keyword k) :file-path)
-                                                      (string/starts-with? v "file:"))
-                                                 v
-                                                 :else
-                                                 (text/parse-property format k v user-config)))
+                                               (text/parse-property k v mldoc-ast user-config))
                                            k (keyword k)
-                                           v (if (and
-                                                  (string? v)
-                                                  (contains? gp-property/editable-linkable-built-in-properties k))
-                                               (set [v])
-                                               v)
                                            v (if (coll? v) (set v) v)]
                                        [k v])
                                      (do (swap! *invalid-properties conj k)
@@ -445,7 +410,7 @@
 
 (defn get-page-refs-from-properties
   [format properties db date-formatter user-config]
-  (let [page-refs (get-page-ref-names-from-properties format properties user-config)]
+  (let [page-refs (get-page-ref-names-from-properties properties user-config)]
     (map (fn [page] (page-name->map page true db true date-formatter)) page-refs)))
 
 (defn- with-page-block-refs

deps/graph-parser/src/logseq/graph_parser/extract.cljc

@@ -166,12 +166,9 @@
       (let [first-block (ffirst ast)
             properties (let [properties (and (gp-property/properties-ast? first-block)
                                              (->> (last first-block)
-                                                  (map (fn [[x y]]
-                                                         [x (if (and (string? y)
-                                                                     (not (and (= (keyword x) :file-path)
-                                                                               (string/starts-with? y "file:"))))
-                                                              (text/parse-property format x y user-config)
-                                                              y)]))
+                                                  (map (fn [[x y mldoc-ast]]
+                                                         (prn {:mldoc-ast mldoc-ast})
+                                                         [x (text/parse-property x y mldoc-ast user-config)]))
                                                   (into {})
                                                   (walk/keywordize-keys)))]
                          (when (and properties (seq properties))

deps/graph-parser/src/logseq/graph_parser/mldoc.cljc

@@ -106,6 +106,8 @@
 
 (defn collect-page-properties
   [ast parse-property config-state]
+  (prn "debug ast")
+  (frontend.util/pprint ast)
   (if (seq ast)
     (let [original-ast ast
           ast (map first ast)           ; without position meta
@@ -118,13 +120,15 @@
                                        [(->> (map first directive-ast)
                                              (map rest))
                                         (get grouped-ast false)])
+          _ (prn "debug:"
+                 {:properties-ast properties-ast})
           properties (->>
                       properties-ast
-                      (map (fn [[k v]]
+                      (map (fn [[k v mldoc-ast]]
                              (let [k (keyword (string/lower-case k))
                                    v (if (contains? #{:title :description :filters :macro} k)
                                        v
-                                       (parse-property k v config-state))]
+                                       (parse-property k v mldoc-ast config-state))]
                                [k v]))))
           properties (into (linked/map) properties)
           macro-properties (filter (fn [x] (= :macro (first x))) properties)
@@ -197,20 +201,24 @@
     (catch :default _e
       [])))
 
+(defn ast-link?
+  [{:keys [type link]}]
+  (let [[ref-type ref-value] (:url link)]
+    (and (= "Link" type)
+         (or
+          ;; 1. url
+          (not (contains? #{"Page_ref" "Block_ref"} ref-type))
+
+          (and (contains? #{"Page_ref"} ref-type)
+               (or
+                ;; 2. excalidraw link
+                (gp-config/draw? ref-value)
+
+                ;; 3. local asset link
+                (boolean (gp-config/local-asset? ref-value))))))))
+
 (defn link?
   [format link]
   (when (string? link)
-    (let [[type link] (first (inline->edn link (default-config format)))
-          [ref-type ref-value] (:url link)]
-      (and (= "Link" type)
-           (or
-            ;; 1. url
-            (not (contains? #{"Page_ref" "Block_ref"} ref-type))
-
-            (and (contains? #{"Page_ref"} ref-type)
-                 (or
-                  ;; 2. excalidraw link
-                  (gp-config/draw? ref-value)
-
-                  ;; 3. local asset link
-                  (boolean (gp-config/local-asset? ref-value)))))))))
+    (some-> (first (inline->edn link (default-config format)))
+            ast-link?)))

deps/graph-parser/src/logseq/graph_parser/text.cljs

@@ -218,44 +218,63 @@
                    ;; Don't capture punctuation at end of a tag
                    "#([\\S]+[^\\s.!,])")))
 
-(defn extract-page-refs-and-tags
-  "Returns set of page-refs and tags in given string or returns string if none
-  are found"
-  [string]
-  (let [refs (map #(or (second %) (get % 2))
-                  (re-seq page-ref-or-tag-re string))]
-    (if (seq refs) (set refs) string)))
+(defn- extract-refs-from-mldoc-ast
+  [v]
+  (->> v
+       (remove gp-mldoc/ast-link?)
+       (keep
+        (fn [[typ data]]
+          (case typ
+            "Link"
+            (case (first (:url data))
+              "Page_ref"
+              (second (:url data))
 
-(defn parse-property
-  "Property value parsing that takes into account built-in properties, format
-  and user config"
-  ([k v config-state]
-   (parse-property :markdown k v config-state))
-  ([format k v config-state]
-   (let [k (name k)
-         v (if (or (symbol? v) (keyword? v)) (name v) (str v))
-         v (string/trim v)]
-     (cond
-       (contains? (set/union
-                   #{"title" "filters"}
-                   (get config-state :ignored-page-references-keywords)) k)
-       v
+              "Search"
+              (second (:url data))
 
-       (gp-util/wrapped-by-quotes? v) ; wrapped in ""
-       v
+              nil)
 
-       (contains? @non-parsing-properties (string/lower-case k))
-       v
+            "Nested_link"
+            (page-ref/get-page-name (:content data))
 
-       (gp-mldoc/link? format v)
-       v
+            "Tag"
+            (second (first data))
 
-       (contains? gp-property/editable-linkable-built-in-properties (keyword k))
-       (split-page-refs-without-brackets v)
+            nil)))
+       (map string/trim)))
 
-       :else
-       (if-some [res (parse-non-string-property-value v)]
-         res
-         (if (:rich-property-values? config-state)
-           (extract-page-refs-and-tags v)
-           (split-page-refs-without-brackets v)))))))
+(defn parse-property
+  "Property value parsing that takes into account built-in properties, and user config"
+  [k v mldoc-ast config-state]
+  (prn {:k k
+        :v v
+        :mldoc-ast mldoc-ast})
+  (let [refs (extract-refs-from-mldoc-ast mldoc-ast)
+        k (subs (str k) 1)
+        v (if (or (symbol? v) (keyword? v))
+            (subs (str v) 1)
+            (str v))
+        v (string/trim v)
+        non-string-property (parse-non-string-property-value v)]
+    (cond
+      (contains? (set/union
+                  #{"title" "filters"}
+                  (get config-state :ignored-page-references-keywords)) k)
+      v
+
+      (string/blank? v)
+      nil
+
+      (seq refs)
+      refs
+
+      non-string-property
+      non-string-property
+
+      (and (= k "file-path")
+           (string/starts-with? v "file:"))
+      v
+
+      :else
+      v)))

deps/graph-parser/test/logseq/graph_parser/text_test.cljs

@@ -109,9 +109,4 @@
       :tags "\"[[foo]], [[bar]]\"" "\"[[foo]], [[bar]]\""
       :tags "baz, \"[[foo]], [[bar]]\"" #{"baz"})))
 
-(deftest extract-page-refs-and-tags
-  (is (= #{"cljs" "nbb" "js" "amazing"}
-       (text/extract-page-refs-and-tags "This project is written with #cljs, #nbb and #js. #amazing!"))
-      "Don't extract punctation at end of a tag"))
-
 #_(cljs.test/test-ns 'logseq.graph-parser.text-test)

package.json

@@ -106,7 +106,7 @@
         "ignore": "5.1.8",
         "is-svg": "4.3.0",
         "jszip": "3.5.0",
-        "mldoc": "1.4.0",
+        "mldoc": "1.4.1",
         "path": "0.12.7",
         "pixi-graph-fork": "0.2.0",
         "pixi.js": "6.2.0",

src/main/frontend/db/query_dsl.cljs

@@ -240,7 +240,7 @@
   [v]
   (if-some [res (text/parse-non-string-property-value v)]
     res
-    (text/split-page-refs-without-brackets v)))
+    (page-ref/get-page-name v)))
 
 (defn- build-property-two-arg
   [e]

yarn.lock

@@ -4809,10 +4809,10 @@ mkdirp@^1.0.3:
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
   integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
 
[email protected].0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/mldoc/-/mldoc-1.4.0.tgz#10dd8b57b1941a66b3d30fd031881ad31d499edb"
-  integrity sha512-6s1utUm03SCR1XH2EnHD3s0qAd+RLLGRc+1qb4SuHIjjmT5HMWbWGP+vADBLHKQKP6nwYCKsUJkiwLFjOXfP6w==
[email protected].1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/mldoc/-/mldoc-1.4.1.tgz#a239c9cc79c5e10a5a1e1602703f96588f26ee5a"
+  integrity sha512-RUCmIVfT+6tQ+Z6uqVcjLP5xppTmYlLEGO17S5uxZKIe2NHEsluryYhWvf+5yhER72zRXsBgxFGjF4zxp9eTGA==
   dependencies:
     yargs "^12.0.2"