Fixed incorrect property replacement

src/pluto/reader/blocks.cljc

@@ -14,13 +14,18 @@
   (fn [ctx ext [type]] type))
 
 (defn substitute-query-values [m v]
-  (walk/prewalk #(or (get m %) %) v))
+  (walk/prewalk #(or (get m %) (when (string? %) (utils/interpolate m %)) %) v))
+
+(defn- query? [binding-value]
+  (and (vector? binding-value)
+       (let [s (first binding-value)]
+         (or (symbol? s) (keyword? s)))))
 
 (defn resolve-rhs [env v]
   (cond
     (= v 'properties) (get env :pluto.reader/properties)
     (symbol? v) (get env v)
-    (vector? v) (some-> (re-frame/subscribe (substitute-query-values env v)) deref)
+    (query? v) (some-> (re-frame/subscribe (substitute-query-values env v)) deref)
     :else v))
 
 (defn destructure-into [env k v]
@@ -39,8 +44,8 @@
   (cond (contains? values o) (get values o)
         (symbol? o) nil
         (string? o) (utils/interpolate values o)
-        (and (fn? o) (:event (meta o))) #(o % (dissoc values :pluto.reader/properties)) ;; Intercept events and inject the env. TODO remove this hack
-        :else o))
+        (and (fn? o) (:event (meta o))) #(o % values) ;; Intercept events and inject the env. TODO remove this hack
+        :else (walk/postwalk-replace values o)))
 
 (defn walkup-upto-leaf [f lp? lf tree]
   (if (lp? tree)
@@ -75,9 +80,6 @@
 (defn static-value? [v]
   (or (utils/primitive? v) (map? v)))
 
-(defn- query? [binding-value]
-  (vector? binding-value))
-
 (defn valid-bindings? [k v]
   (and (or (symbol? k) (map? k))
        (or (symbol? v) (static-value? v) (query? v))))

src/pluto/reader/types.cljc

@@ -117,15 +117,22 @@
   (cond (contains? env o) (get env o)
         (symbol? o) nil
         (string? o) (utils/interpolate env o)
+        (fn? o) #(o % env)
         :else (walk/postwalk-replace env o)))
 
+(defn symbol-map->keyword-map [m]
+  (reduce-kv #(assoc %1 (keyword (name %2)) %3) {} m))
+
+(defn keyword-map->symbol-map [m]
+  (reduce-kv #(assoc %1 (symbol (name %2)) %3) {} m))
+
 (defn event-after-env [ctx ref data args bindings]
   (with-meta
     (fn [o env]
-      (let [env (merge env (reduce-kv #(assoc %1 (symbol (name %2)) %3) {} o)
-                       (:data (destructuring/destructure bindings (merge o args (reduce-kv #(assoc %1 (keyword (name %2)) %3) {} env)))))
+      (let [env (merge env (keyword-map->symbol-map o)
+                       (:data (destructuring/destructure bindings (merge o args (symbol-map->keyword-map env)))))
             dic (reduce-kv #(assoc %1 %2 (if (contains? env %3) (get env %3) %3)) {} env)]
-        [ref (:env ctx) (merge o (reduce-kv #(assoc %1 %2 (replace-atom dic  %3)) {} data))]))
+        [ref (:env ctx) (merge (symbol-map->keyword-map dic) (reduce-kv #(assoc %1 %2 (replace-atom dic  %3)) {} data) o)]))
     {:event true}))
 
 (defn- event-reference-with-arguments [ctx ext ref event arguments args bindings]
@@ -147,7 +154,18 @@
            (= 2 (count bindings))
            (map? (first bindings))
            (= 'properties (second bindings))
-           (vector? (reference-symbol data))))))
+           (let [s (reference-symbol data)]
+             (or (vector? s)
+                 (and (list? s) (= 'if (first s)))))))))
+
+(defn resolve-local-event [ctx ext type data]
+  (let [a (reference-symbol data)]
+    (cond
+      (vector? a)
+      (let [[event args :as reference] a
+            bindings (first (second data))
+            {:keys [data errors]} (reference/resolve ctx ext type reference)]
+        (errors/merge-errors {:data {:ref data :event event :args args :bindings bindings}} errors)))))
 
 (defn resolve-local-reference
   "References local references defining let blocks"
@@ -157,10 +175,7 @@
     (if data
       (cond
         (local-event? data)
-        (let [[event args :as reference] (reference-symbol data)
-              bindings (first (second data))
-              {:keys [data errors]} (reference/resolve ctx ext type reference)]
-          (errors/merge-errors {:data {:ref data :event event :args args :bindings bindings}} errors))
+        (resolve-local-event ctx ext type data)
         (keyword? data)
         {:data {:ref data :event name}}
         :else

test/pluto/reader/types_test.cljc

@@ -156,3 +156,6 @@
                                              {} :event ['event {:on-finished ['event]}])]
     (is (not errors))
     (is (fn? (:on-finished (last (data {} {})))))))
+
+(deftest local-event?
+  (is (types/local-event? '(let [{} properties] [alert {}]))))

test/pluto/utils_test.cljc

@@ -1,8 +1,11 @@
 (ns pluto.utils-test
-  (:refer-clojure :exclude [slurp])
-  (:require [clojure.test :refer [is deftest testing]]
-            [pluto.utils :as utils]))
+    (:refer-clojure :exclude [slurp])
+    (:require [clojure.test :refer [is deftest testing]]
+      [pluto.utils :as utils] [pluto.utils :as utils]))
 
 #?(:clj
  (defmacro slurp [file]
    (clojure.core/slurp file)))
+
+(deftest interpolate
+  (is (= "test-3" (utils/interpolate {'id 3} "test-${id}"))))