From 26c6eb2f062935a6848de37378cdbb936a5960b2 Mon Sep 17 00:00:00 2001
From: gered <gered@blarg.ca>
Date: Tue, 7 Oct 2014 18:37:42 -0400
Subject: [PATCH] refactoring extension stuff to improve pebble engine
 initialization

much of this refactoring is built around the idea of absolutely NOT
wanting applications using this library to be required to explicitly
call some kind of "init" function before templates can be rendered.

however, for this library's (eventual) unit tests, we will want the
ability to reset the engine state (reset-engine! function), so a way
to add extensions to an arbitrary PebbleEngine object is needed
---
 src/clj_pebble/core.clj       | 51 +++++++++--------------------------
 src/clj_pebble/extensions.clj | 48 +++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 39 deletions(-)
 create mode 100644 src/clj_pebble/extensions.clj

diff --git a/src/clj_pebble/core.clj b/src/clj_pebble/core.clj
index a1c4e2a..8354c3f 100644
--- a/src/clj_pebble/core.clj
+++ b/src/clj_pebble/core.clj
@@ -3,62 +3,35 @@
            (java.util Map)
            (com.mitchellbosecke.pebble PebbleEngine)
            (com.mitchellbosecke.pebble.loader ClasspathLoader FileLoader StringLoader)
-           (com.mitchellbosecke.pebble.template PebbleTemplate)
-           (com.mitchellbosecke.pebble.extension Function Filter Test))
-  (:require [clojure.walk :refer [stringify-keys]]))
+           (com.mitchellbosecke.pebble.template PebbleTemplate))
+  (:require [clojure.walk :refer [stringify-keys]]
+            [clj-pebble.extensions :as ext]
+            [clj-pebble.standard-extensions :as std]))
 
 (defonce classpath-loader (ClasspathLoader.))
 (defonce file-loader (FileLoader.))
 (defonce string-loader (StringLoader.))
 
 (defn- make-pebble-engine []
-  (PebbleEngine. classpath-loader))
+  (-> (PebbleEngine. classpath-loader)
+      (ext/add-extensions-library! std/extensions)))
 
 (defonce engine (atom (make-pebble-engine)))
 
 (defn reset-engine! []
   (reset! engine (make-pebble-engine)))
 
-(defn- get-sorted-args [args-map]
-  (->> args-map
-       (map
-         (fn [[k v]]
-           [(Integer/parseInt k) v]))
-       (sort-by first)
-       (map second)))
-
-(defn make-function [f]
-  (reify Function
-    (getArgumentNames [_] nil)
-    (execute [_ args]
-      (apply f (get-sorted-args args)))))
-
-(defn make-filter [f]
-  (reify Filter
-    (getArgumentNames [_] nil)
-    (apply [_ input args]
-      (apply f (concat [input] (get-sorted-args args))))))
-
-(defn make-test [f]
-  (reify Test
-    (getArgumentNames [_] nil)
-    (apply [_ input args]
-      (boolean (apply f (concat [input] (get-sorted-args args)))))))
-
 (defmacro defpebblefn [fn-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-function f#)]
-     (.put (.getFunctions @engine) ~fn-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-function! @engine ~fn-name f#)))
 
 (defmacro defpebblefilter [filter-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-filter f#)]
-     (.put (.getFilters @engine) ~filter-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-filter! @engine ~filter-name f#)))
 
 (defmacro defpebbletest [test-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-test f#)]
-     (.put (.getTests @engine) ~test-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-test! @engine ~test-name f#)))
 
 (defn- prepare-context-map [context]
   (if context
diff --git a/src/clj_pebble/extensions.clj b/src/clj_pebble/extensions.clj
new file mode 100644
index 0000000..38dddc7
--- /dev/null
+++ b/src/clj_pebble/extensions.clj
@@ -0,0 +1,48 @@
+(ns clj-pebble.extensions
+  (:import (java.util Map)
+           (com.mitchellbosecke.pebble PebbleEngine)
+           (com.mitchellbosecke.pebble.extension Function Filter Test)))
+
+(defn- get-sorted-args [args-map]
+  (->> args-map
+       (map
+         (fn [[k v]]
+           [(Integer/parseInt k) v]))
+       (sort-by first)
+       (map second)))
+
+(defn make-function [f]
+  (reify Function
+    (getArgumentNames [_] nil)
+    (execute [_ args]
+      (apply f (get-sorted-args args)))))
+
+(defn make-filter [f]
+  (reify Filter
+    (getArgumentNames [_] nil)
+    (apply [_ input args]
+      (apply f (concat [input] (get-sorted-args args))))))
+
+(defn make-test [f]
+  (reify Test
+    (getArgumentNames [_] nil)
+    (apply [_ input args]
+      (boolean (apply f (concat [input] (get-sorted-args args)))))))
+
+(defn add-function! [^PebbleEngine engine ^String name f]
+  (.put (.getFunctions engine) name (make-function f)))
+
+(defn add-filter! [^PebbleEngine engine ^String name f]
+  (.put (.getFilters engine) name (make-filter f)))
+
+(defn add-test! [^PebbleEngine engine ^String name f]
+  (.put (.getTests engine) name (make-test f)))
+
+(defn add-extensions-library! [^PebbleEngine engine {:keys [functions filters tests]}]
+  (doseq [[name func] functions]
+    (add-function! engine name func))
+  (doseq [[name func] filters]
+    (add-filter! engine name func))
+  (doseq [[name func] tests]
+    (add-test! engine name func))
+  engine)
\ No newline at end of file