condition in macro

.gitignore

@@ -1,3 +1,4 @@
+.*
 pom.xml
 pom.xml.asc
 *jar

src/jota/core.clj

@@ -42,28 +42,22 @@
 (defn reset-log! [] (reset! logconfig default-config))
 (reset-log!)
 
-(defn passes [level configured]
-  (let [order levels
-        ix-level (.indexOf order level)
-        ix-configured (.indexOf order configured)
-        ]
-    (<= ix-configured ix-level))
-  )
+(defn passes [current threshold]
+  (<= (.indexOf levels threshold) (.indexOf levels current)))
 
 (defn log? [x level] (passes level (get-level x)))
 
 (defn log-message [writers msg]
   (cond (set? writers) (doseq [w writers] (w msg))
         (fn? writers) (writers msg)
-        :default (throw (Exception. (str "Set or function expected, found " (class writers) ": " writers)))
+        :default (throw (Exception. (str "Set or function expected, found object of type " (class writers) ": " writers)))
         ))
-(defn logprint [x level txt]
-  (let [cat (category x)]
-    (if (log? cat level)
-      (log-message (get-writer cat) (str (name cat) ":" (name level) ": " txt)))))
+
+(defn logprint [cat level txt]
+  (log-message (get-writer cat) (str (name cat) ":" (name level) ": " txt)))
 
 (defmacro dolog [level & args]
-  `(logprint (getns) ~level (apply str (vector ~@args))))
+  `(let [cat# (category (getns))] (if (log? cat# ~level) (logprint cat# ~level (apply str (vector ~@args))))))
 
 (defmacro trace [& args] `(dolog :trace ~@args))
 (defmacro debug [& args] `(dolog :debug ~@args))
@@ -81,11 +75,10 @@
   (merge-with merge a b))
 
 (defn init-from-resource [r]
-  (if-let [c (read-config r)]
+  (when-let [c (read-config r)]
     (let [result (reset! logconfig (merge-configs default-config c))]
       (trace "jota initialized from " (.getFile (io/resource r)))
       result)
-    nil
     ))
 
 (defn jota-init []

test/jota/core_test.clj

@@ -22,14 +22,14 @@
 
 (fact
   "Initial configuration contains root level, writer"
-  (let [dummy (reset-log!)]
+  (let [_ (reset-log!)]
     (keys @logconfig) => [:root]
     (keys (:root @logconfig)) => [:level :writer]
     ))
 
 (fact
   "Setting level en writers ok"
-  (let [dummy (reset-log!)
+  (let [_ (reset-log!)
         some-fn1 (fn [x] 1)
         some-fn2 (fn [x] 2)]
     (do (set-level! "x" :error) (get-level "x")) => :error
@@ -41,7 +41,7 @@
 
 (fact
   "Adding writers ok"
-  (let [dummy (reset-log!)
+  (let [_ (reset-log!)
         some-fn1 (fn [x] 1)
         some-fn2 (fn [x] 2)]
     (do (set-writer! "x" some-fn1) (get-writer "x")) => some-fn1
@@ -58,25 +58,21 @@
 
 (fact
   "levels and writer honoured"
-  (let [dummy (reset-log!)
-        dummy (set-level! :root :debug)
-        dummy (set-writer! :root (fn [x] (print (str "r:" x))))
-        dummy (set-level! "x" :info)
-        dummy (set-writer! "x" (fn [x] (print (str "x:" x))))
-        dummy (set-level! "y" :warn)
-        dummy (set-writer! "y" (fn [x] (print (str "y:" x))))
+  (let [_ (reset-log!)
+        _ (set-level! :root :debug)
+        _ (set-writer! :root (fn [x] (print (str "r:" x))))
+        _ (set-level! "x" :info)
+        _ (set-writer! "x" (fn [x] (print (str "x:" x))))
+        _ (set-level! "y" :warn)
+        _ (set-writer! "y" (fn [x] (print (str "y:" x))))
         ]
 
-    (with-out-str (logprint "undefined" :trace "11")) => ""
-    (with-out-str (logprint "undefined" :debug "11")) => "r:undefined:debug: 11"
+     (with-out-str (logprint "undefined" :debug "11")) => "r:undefined:debug: 11"
 
-    (with-out-str (logprint "x" :trace "11")) => ""
     (with-out-str (logprint "x" :info "11")) => "x:x:info: 11"
     (with-out-str (logprint "x" :warn "11")) => "x:x:warn: 11"
     (with-out-str (logprint "x" :error "11")) => "x:x:error: 11"
 
-    (with-out-str (logprint "y" :trace "11")) => ""
-    (with-out-str (logprint "y" :info "11")) => ""
     (with-out-str (logprint "y" :warn "11")) => "y:y:warn: 11"
     (with-out-str (logprint "y" :error "11")) => "y:y:error: 11"
 
@@ -86,12 +82,12 @@
 
 (fact
   "multiple writers honoured"
-  (let [dummy (reset-log!)
-        dummy (set-level! :root :debug)
-        dummy (set-writer! :root (fn [x] (print (str "r:" x))))
+  (let [_ (reset-log!)
+        _ (set-level! :root :debug)
+        _ (set-writer! :root (fn [x] (print (str "r:" x))))
 
-        dummy (set-writer! "z" (fn [x] (print (str "X:" x))))
-        dummy (add-writer! "z" (fn [x] (print (str "X:" x))))
+        _ (set-writer! "z" (fn [x] (print (str "X:" x))))
+        _ (add-writer! "z" (fn [x] (print (str "X:" x))))
         ]
 
     (with-out-str (logprint "z" :error "11")) => "X:z:error: 11X:z:error: 11"