wip

Author: athos

src/pogonos/context.cljc

@@ -0,0 +1,54 @@
+(ns pogonos.context
+  (:require [clojure.string :as str]
+            [pogonos.protocols :as proto]))
+
+(defn- lookup* [stack keys]
+  (if-let [k (peek keys)]
+    (when-let [v (loop [stack stack]
+                   (when-let [v (peek stack)]
+                     (if (and (map? v)
+                              (not #?(:clj (identical? (v k ::none) ::none)
+                                      :cljs (keyword-identical? (v k ::none) ::none))))
+                       v
+                       (recur (next stack)))))]
+      (if (next keys)
+        (get-in v keys)
+        (v k)))
+    (peek stack)))
+
+(defrecord NonCheckingContext [stack]
+  proto/IContext
+  (lookup [_ keys]
+    (lookup* stack keys))
+  (push [_ val]
+    (NonCheckingContext. (conj stack val))))
+
+(defrecord CheckingContext [stack on-missing-key]
+  proto/IContext
+  (lookup [_ keys]
+    (or (lookup* stack keys)
+        (on-missing-key stack keys)))
+  (push [_ val]
+    (CheckingContext. (conj stack val) on-missing-key)))
+
+(defmulti ^:private ->on-missing-key-fn (fn [x] x))
+
+(defmethod ->on-missing-key-fn :default [x]
+  (if (fn? x)
+    x
+    (throw
+     (ex-info (str ":on-missing-key must be :error or a function, but got " (type x)) {}))))
+
+(defmethod ->on-missing-key-fn :error [_]
+  (fn [stack keys]
+    (let [k (->> keys (map name) (str/join \.))]
+      (throw (ex-info (str "Key \"" k "\" not found in the given context")
+                      {:key k :context (last stack)})))))
+
+(defn make-context
+  ([data] (make-context data {}))
+  ([data {:keys [on-missing-key]}]
+   (let [stack (list data)]
+     (if on-missing-key
+       (->CheckingContext stack (->on-missing-key-fn on-missing-key))
+       (->NonCheckingContext stack)))))

src/pogonos/core.cljc

@@ -1,5 +1,6 @@
 (ns pogonos.core
   (:require #?(:clj [clojure.java.io :as io])
+            [pogonos.context :as context]
             [pogonos.error :as error]
             [pogonos.nodes :as nodes]
             [pogonos.output :as output]
@@ -103,14 +104,14 @@
                                        (merge opts)
                                        fixup-options)
          out (output)]
-     (render/render (list data) out template opts)
+     (render/render (context/make-context data opts) out template opts)
      (out))))
 
 (defn render-input
   ([in data]
    (render-input in data {}))
   ([in data opts]
-   (let [ctx (list data)
+   (let [ctx (context/make-context data opts)
          {:keys [output]
           :as opts} (fixup-options opts #?(:clj partials/resource-partials))
          out (output)]

src/pogonos/protocols.cljc

@@ -9,6 +9,10 @@
 (defprotocol ToReader
   (->reader [this]))
 
+(defprotocol IContext
+  (lookup [this keys])
+  (push [this val]))
+
 (defprotocol IRenderable
   (render [this ctx out]))
 

src/pogonos/render.cljc

@@ -35,18 +35,7 @@
      :cljs (gstr/htmlEscape s)))
 
 (defn lookup [ctx keys]
-  (if-let [k (peek keys)]
-    (when-let [v (loop [ctx ctx]
-                   (when-let [v (peek ctx)]
-                     (if (and (map? v)
-                              (not #?(:clj (identical? (v k ::none) ::none)
-                                      :cljs (keyword-identical? (v k ::none) ::none))))
-                       v
-                       (recur (next ctx)))))]
-      (if (next keys)
-        (get-in v keys)
-        (v k)))
-    (peek ctx)))
+  (proto/lookup ctx keys))
 
 (defn render* [ctx out x]
   (if (string? x)
@@ -93,12 +82,12 @@
 
             (map? val)
             (doseq [node (:nodes this)]
-              (render* (conj ctx val) out node))
+              (render* (proto/push ctx val) out node))
 
             (and (coll? val) (sequential? val))
             (when (seq val)
               (doseq [e val, node (:nodes this)]
-                (render* (conj ctx e) out node)))
+                (render* (proto/push ctx e) out node)))
 
             (fn? val)
             (let [{:keys [open close]} (meta this)
@@ -113,7 +102,7 @@
 
             :else
             (doseq [node (:nodes this)]
-              (render* (conj ctx val) out node)))))
+              (render* (proto/push ctx val) out node)))))
 
   #?(:clj Inverted :cljs nodes/Inverted)
   (render [this ctx out]

test/pogonos/render_test.cljc

@@ -1,12 +1,14 @@
 (ns pogonos.render-test
   (:require [clojure.string :as str]
             [clojure.test :refer [deftest are testing]]
+            [pogonos.context :as context]
             [pogonos.render :as render]
             [pogonos.nodes :as nodes]
             [pogonos.output :as output]))
 
 (deftest lookup-test
-  (are [ctx keys expected] (= expected (render/lookup ctx keys))
+  (are [ctx keys expected]
+       (= expected (render/lookup (context/->NonCheckingContext ctx) keys))
     '({:x 42})
     '(:x)
     42
@@ -36,7 +38,8 @@
    (render template data nil))
   ([template data partials]
    (let [out ((output/to-string))]
-     (render/render (list data) out
+     (render/render (context/make-context data)
+                    out
                     (nodes/->Root template)
                     {:partials partials})
      (out))))