Extensive linting whilst trying to resolve Tomcat config issue.

src/smeagol/authenticate.clj

@@ -2,7 +2,6 @@
       :author "Simon Brooke"}
   smeagol.authenticate
   (:require [crypto.password.scrypt :as password]
-            [environ.core :refer [env]]
             [noir.io :as io]
             [smeagol.configuration :refer [config]]
             [taoensso.timbre :as log]))
@@ -65,7 +64,7 @@
 (defn get-email
   "Return the email address associated with this `username`."
   [username]
-  (if username
+  (when username
     (let [user ((keyword username)  (get-users))]
       (:email user))))
 
@@ -73,7 +72,7 @@
 (defn get-admin
   "Return a flag indicating whether the user with this username is an administrator."
   [username]
-  (if username
+  (when username
     (let [user ((keyword username)  (get-users))]
       (:admin user))))
 
@@ -84,7 +83,7 @@
    (cond
      (< (count pass1) 8) :chpass-too-short
      (.equals pass1 pass2) true
-     true :chpass-bad-match))
+     :else :chpass-bad-match))
   ([password]
    (evaluate-password password password)))
 
@@ -97,8 +96,7 @@
   (log/info (format "Changing password for user %s" username))
   (let [users (get-users)
         keywd (keyword username)
-        user (keywd users)
+        user (keywd users)]
-        email (:email user)]
     (try
       (cond
         (and user
@@ -130,7 +128,7 @@
 (defn fetch-user-details
   "Return the map of features of this user, if any."
   [username]
-  (if
+  (when
     (and username (pos? (count (str username))))
     ((keyword username) (get-users))))
 
@@ -144,9 +142,9 @@
   (cond
     (not (string? username)) (throw (Exception. "Username must be a string."))
     (zero? (count username)) (throw (Exception. "Username cannot be zero length"))
-    true (let [users (get-users)
+    :else (let [users (get-users)
                user ((keyword username) users)
-               password (if
+               password (when
                           (and newpass (evaluate-password newpass))
                           (password/encrypt newpass))
                details {:email email

src/smeagol/configuration.clj

@@ -5,7 +5,8 @@
             [clojure.string :as s]
             [environ.core :refer [env]]
             [noir.io :as io]
-            [taoensso.timbre :as log]))
+            [taoensso.timbre :as log])
+  (:import (javax.naming InitialContext )))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;
@@ -30,12 +31,9 @@
 ;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;
-;;;; Right, doing the data visualisation thing is tricky. Doing it in the
+;;;; Configuration may have to be pulled from different places depending on the
-;;;; pipeline doesn't work, because the md-to-html-string filter messes up
+;;;; environment in which Smeagol runs. This handles that problem reasonably
-;;;; both YAML and JSON notation. So we need to extract the visualisation
+;;;; seamlessly.
-;;;; fragments from the Markdown text and replace them with tokens we will
-;;;; recognise afterwards, perform md-to-html-string, and then replace our
-;;;; tokens with the transformed visualisation specification.
 ;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -47,13 +45,44 @@
 
 
 (defn- from-env-vars
-  "Read a map from those of these environment variables which have values"
+  "Read a map from those of these environment `vars` which have values"
-  [& vars]
+  [vars]
   (reduce
-    #(let [v (env %2)]
+   #(let [v (env %2)]
-       (if v (assoc %1 %2 v) %1))
+      (if v
-    {}
+        (do
-    vars))
+          (log/info (str "Read value of " %2 " from shell environment as " v))
+          (assoc %1 %2 v)) %1))
+   {}
+   vars))
+
+(defn- from-initial-context
+  "Config `vars` are read from the initial context, which (at least under Tomcat) 
+   are specific to the individual web app. Nevertheless the same names will 
+   be used as for environment variables, because it just makes life easier."
+  [vars]
+  (log/info "Seeking config in initial context")
+  (try
+    (reduce
+     #(try
+        (log/info "Seeking value for " %2 " in initial context")
+        (let [v (javax.naming.InitialContext/doLookup %2)]
+          (if v
+            (do
+              (log/info (str "Read value of " %2 " from initial context as " v))
+              (assoc %1 %2 v))
+            %1))
+        (catch Exception e
+          (log/warn (str "Error while seeking value for " %2 " in initial context: " (type e) "; " (.getMessage e)))
+          %1))
+     {}
+     (map #(str "java:comp/env/" (name %)) vars))
+    (catch javax.naming.NoInitialContextException _
+      ;; ignore: this only means we're not in a servlet context, 
+      ;; e.g unit tests. 
+      )
+    (catch Exception other
+      (log/warn (str "Error while seeking values in initial context: " (type other) "; " (.getMessage other))))))
 
 
 (defn to-keyword
@@ -106,6 +135,19 @@
      {:from :smeagol-site-title :to :site-title}))
 
 
+(def config-var-names
+  "Names of configuration variables which will be sought in the environment or
+   initial context"
+  '(:smeagol-config
+    :smeagol-content-dir
+    :smeagol-default-locale
+    :smeagol-formatters
+    :smeagol-js-from
+    :smeagol-log-level
+    :smeagol-passwd
+    :smeagol-site-title))
+
+
 (def build-config
   "The actual configuration, as a map. The idea here is that the config
   file is read (if it is specified and present), but that individual
@@ -128,14 +170,10 @@
                      config (merge
                               file-contents
                               (transform-map
-                                (from-env-vars
+                               (from-env-vars config-var-names)
-                                  :smeagol-content-dir
+                               config-env-transforms)
-                                  :smeagol-default-locale
+                              (transform-map
-                                  :smeagol-formatters
+                                (from-initial-context config-var-names)
-                                  :smeagol-js-from
-                                  :smeagol-log-level
-                                  :smeagol-passwd
-                                  :smeagol-site-title)
                                 config-env-transforms))]
                  (if (env :dev)
                    (log/debug

src/smeagol/diff2html.clj

@@ -1,7 +1,7 @@
 (ns ^{:doc "Format a diff as HTML."
       :author "Simon Brooke"}
   smeagol.diff2html
-  (:require [clojure.string :refer [join split split-lines]]))
+  (:require [clojure.string :refer [join split-lines]]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;
@@ -41,7 +41,7 @@
     (starts-with? line "-") (str "<p><del>" (subs line 1) "</del></p>")
     (starts-with? line "@@") "</div><div class='change'>"
     (starts-with? line "\\") (str "<p class='warn'>" (subs line 1) "</p>")
-    true (str "<p>" line "</p>")))
+    :else (str "<p>" line "</p>")))
 
 
 (defn diff2html

src/smeagol/extensions/geocsv.clj

@@ -2,7 +2,7 @@
       :author "Simon Brooke"}
   smeagol.extensions.geocsv
   (:require [smeagol.configuration :refer [config]]
-            [smeagol.extensions.utils :refer :all]
+            [smeagol.extensions.utils :refer [resource-url-or-data->data]]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

src/smeagol/extensions/mermaid.clj

@@ -1,7 +1,7 @@
 (ns ^{:doc "Mermaid formatter for Semagol's extendsible markdown format."
       :author "Simon Brooke"}
   smeagol.extensions.mermaid
-  (:require [smeagol.extensions.utils :refer :all]
+  (:require [smeagol.extensions.utils :refer [resource-url-or-data->data]]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

src/smeagol/extensions/photoswipe.clj

@@ -10,7 +10,7 @@
             [me.raynes.fs :as fs]
             [noir.io :as io]
             [smeagol.configuration :refer [config]]
-            [smeagol.extensions.utils :refer :all]
+            [smeagol.extensions.utils :refer [resource-url-or-data->data uploaded?]]
             [smeagol.util :refer [content-dir upload-dir]]
             [taoensso.timbre :as log]))
 
@@ -85,7 +85,7 @@
 (defn simplify
   "Simplify a parse-`tree` created by `simple-grammar`, q.v."
   [tree]
-  (if
+  (when
     (coll? tree)
     (case (first tree)
       :SLIDES (cons
@@ -106,7 +106,7 @@
   [slide]
   (let [url (:src slide)
         dimensions (try
-                     (if (uploaded? url)
+                     (when (uploaded? url)
                        (dimensions
                          (buffered-image
                            (cio/file upload-dir (fs/base-name url)))))
@@ -122,7 +122,7 @@
 
 (defn find-thumb
   [url thumbsize]
-  (if
+  (when
     (and
       (uploaded? url)
       thumbsize)

src/smeagol/extensions/test.clj

@@ -6,5 +6,5 @@
 (def process-test-return-value "<!-- The test extension has run and this is its output -->")
 
 (defn process-test
-    [^String fragment ^Integer index]
+    [^String _ ^Integer _]
     process-test-return-value)

src/smeagol/extensions/utils.clj

@@ -1,16 +1,15 @@
 (ns ^{:doc "Utility functions useful to extension processors."
       :author "Simon Brooke"}
   smeagol.extensions.utils
-  (:require [cemerick.url :refer (url url-encode url-decode)]
+  (:require [cemerick.url :refer (url)]
             [clj-yaml.core :as yaml]
             [clojure.data.json :as json]
             [clojure.java.io :as cjio]
             [clojure.string :as cs]
             [me.raynes.fs :as fs]
             [noir.io :as io]
-            [smeagol.configuration :refer [config]]
             [taoensso.timbre :as log]
-            [smeagol.util :refer [content-dir upload-dir]]))
+            [smeagol.util :refer [upload-dir]]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;

src/smeagol/extensions/vega.clj

@@ -1,7 +1,7 @@
 (ns ^{:doc "Format vega/vis extensions to Semagol's extended markdown format."
       :author "Simon Brooke"}
   smeagol.extensions.vega
-  (:require [smeagol.extensions.utils :refer :all]
+  (:require [smeagol.extensions.utils :refer [resource-url-or-data->data yaml->json]]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

src/smeagol/finder.clj

@@ -4,11 +4,9 @@
   smeagol.finder
   (:require [clojure.string :as cs]
             [me.raynes.fs :as fs]
-            [noir.io :as io]
             [ring.util.mime-type :refer [ext-mime-type]]
             [ring.util.response :as response]
-            [smeagol.configuration :refer [config]]
+            [smeagol.util :refer [local-url-base content-dir]]
-            [smeagol.util :refer [local-url-base content-dir upload-dir]]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

src/smeagol/formatting.clj

@@ -1,17 +1,10 @@
 (ns ^{:doc "Format Semagol's extended markdown format."
       :author "Simon Brooke"}
   smeagol.formatting
-  (:require [clojure.data.json :as json]
+  (:require [clojure.string :as cs]
-            [clojure.string :as cs]
-            [cemerick.url :refer (url url-encode url-decode)]
-            [clj-yaml.core :as yaml]
             [markdown.core :as md]
             [smeagol.configuration :refer [config]]
-            [smeagol.extensions.geocsv :refer [process-geocsv]]
+            [smeagol.local-links :refer [local-links]]
-            [smeagol.extensions.mermaid :refer [process-mermaid]]
-            [smeagol.extensions.photoswipe :refer [process-photoswipe]]
-            [smeagol.extensions.vega :refer [process-vega]]
-            [smeagol.local-links :refer :all]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -55,7 +48,7 @@
 
   **NOTE** that it is not expected that this function forms part of a stable
   API."
-  [^String text ^Integer index]
+  [^String text _]
   (str "<pre class=\"backticks\">```" (.trim text) "\n```</pre>"))
 
 
@@ -64,7 +57,7 @@
   or `nil` if there is none."
   [^String string]
   (try
-    (if string (first (cs/split (first (cs/split-lines string)) #"[^a-zA-Z0-9]+")))
+    (when string (first (cs/split (first (cs/split-lines string)) #"[^a-zA-Z0-9]+")))
     (catch NullPointerException _ nil)))
 
 
@@ -195,17 +188,16 @@
         ;; I need to put the backticks back in.
         remarked (if (odd? index) (str "```" fragment "\n```") fragment)
         first-token (get-first-token fragment)
-        kw (if-not (empty? first-token) (keyword first-token))
+        kw (when-not (empty? first-token) (keyword first-token))
-        formatter (if
+        formatter (when
                     kw
                     (try
                       (read-string (-> config :formatters kw :formatter))
                       (catch Exception _
-                        (do
+                        (log/info "No formatter found for extension `" kw "`")
-                          (log/info "No formatter found for extension `" kw "`")
                           ;; no extension registered - there sometimes won't be,
                           ;; and it doesn't matter
-                          nil))))]
+                          nil)))]
     (cond
       (empty? fragments)
       ;; We've come to the end of the list of fragments. Reassemble them into
@@ -213,7 +205,7 @@
       (reassemble-text result processed)
       formatter
       (apply-formatter index result fragments processed fragment first-token formatter)
-      true
+      :else
       (process-markdown-fragment index result remarked (rest fragments) processed))))
 
 (defn md->html

src/smeagol/handler.clj

@@ -1,9 +1,7 @@
 (ns ^{:doc "Set up, configure, and clean up after the wiki server."
       :author "Simon Brooke"}
   smeagol.handler
-  (:require [clojure.java.io :as cjio]
+  (:require [compojure.core :refer [defroutes]]
-            [clojure.string :refer [lower-case]]
-            [compojure.core :refer [defroutes]]
             [compojure.route :as route]
             [cronj.core :as cronj]
             [environ.core :refer [env]]
@@ -42,7 +40,7 @@
 ;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defn user-access [request]
+(defn user-access [_]
   (session/get :user))
 
 
@@ -75,10 +73,10 @@
                   :backlog 10})}
        :level (or
                 (:log-level config)
-                (if (env :dev) :debug)
+                (when (env :dev) :debug)
                 :info)})
     (cronj/start! session-manager/cleanup-job)
-    (if (env :dev) (parser/cache-off!))
+    (when (env :dev) (parser/cache-off!))
     ;;start the expired session cleanup job
     (log/info "\n-=[ smeagol started successfully"
                  (when (env :dev) "using the development profile") "]=-")

src/smeagol/history.clj

@@ -6,11 +6,10 @@
             [clj-jgit.querying :as q]
             [taoensso.timbre :as log])
   (:import  [org.eclipse.jgit.api Git]
-            [org.eclipse.jgit.lib Repository ObjectId]
+            [org.eclipse.jgit.lib ObjectId]
-            [org.eclipse.jgit.revwalk RevCommit RevTree RevWalk]
+            [org.eclipse.jgit.treewalk TreeWalk CanonicalTreeParser]
-            [org.eclipse.jgit.treewalk TreeWalk AbstractTreeIterator CanonicalTreeParser]
             [org.eclipse.jgit.treewalk.filter PathFilter]
-            [org.eclipse.jgit.diff DiffEntry DiffFormatter]))
+            [org.eclipse.jgit.diff DiffFormatter]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;
@@ -53,7 +52,7 @@
   [^String git-directory-path]
   (try
     (git/load-repo git-directory-path)
-    (catch java.io.FileNotFoundException fnf
+    (catch java.io.FileNotFoundException _
       (log/info "Initialising Git repository at" git-directory-path)
       (git/git-init git-directory-path)
       (let [repo (git/load-repo git-directory-path)]
@@ -137,7 +136,7 @@
     (.addTree tw tree)
     (.setRecursive tw true)
     (.setFilter tw (PathFilter/create file-path))
-    (if (not (.next tw))
+    (when-not (.next tw)
       (throw (IllegalStateException.
                (str "Did not find expected file '" file-path "'"))))
     (.copyTo (.open repo (.getObjectId tw 0)) out)

src/smeagol/include.clj

@@ -4,7 +4,6 @@
   (:require
     [clojure.string :as cs]
     [schema.core :as s]
-    [com.stuartsierra.component :as component]
     [smeagol.include.parse :as parse]
     [smeagol.include.resolve :as resolve]
     [smeagol.include.indent :as indent]))

src/smeagol/include/resolve.clj

@@ -4,8 +4,7 @@ smeagol.include and not inteded for direct usage."
       :author "Michael Jerger"}
   smeagol.include.resolve
   (:require
-    [schema.core :as s]
+    [schema.core :as s]))
-    [com.stuartsierra.component :as component]))
 
 (s/defrecord Resolver
   [type :- s/Keyword

src/smeagol/include/resolve_local_file.clj

@@ -6,7 +6,6 @@ smeagol.include and not inteded for direct usage."
   (:require
     [schema.core :as s]
     [smeagol.include.resolve :as resolve]
-    [com.stuartsierra.component :as component]
     [clojure.java.io :as cjio]
     [taoensso.timbre :as timbre]))
 

src/smeagol/layout.clj

@@ -2,16 +2,13 @@
 (ns ^{:doc "Render a page as HTML."
       :author "Simon Brooke"}
   smeagol.layout
-  (:require [clojure.java.io :as cjio]
+  (:require [clojure.string :as s]
-            [clojure.string :as s]
             [compojure.response :refer [Renderable]]
             [environ.core :refer [env]]
-            [hiccup.core :refer [html]]
             [ring.util.anti-forgery :refer [anti-forgery-field]]
             [ring.util.response :refer [content-type response]]
             [selmer.parser :as parser]
-            [smeagol.configuration :refer [config]]
+            [smeagol.sanity :refer [show-sanity-check-error]]
-            [smeagol.sanity :refer :all]
             [smeagol.util :as util]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -61,7 +58,7 @@
 ;;   be rendered.
   [template params]
   Renderable
-  (render [this request]
+  (render [_ request]
           (try
             (content-type
               (->> (assoc params
@@ -69,7 +66,7 @@
                      :i18n (util/get-messages request)
                      :dev (env :dev)
                      :servlet-context
-                     (if-let [context (:servlet-context request)]
+                     (when-let [context (:servlet-context request)]
                        ;; If we're not inside a serlvet environment (for
                        ;; example when using mock requests), then
                        ;; .getContextPath might not exist

src/smeagol/local_links.clj

@@ -1,9 +1,8 @@
 (ns ^{:doc "Format Semagol's local links."
       :author "Simon Brooke"}
   smeagol.local-links
-  (:require [clojure.data.json :as json]
+  (:require [clojure.string :as cs]
-            [clojure.string :as cs]
+            [cemerick.url :refer (url-encode)]))
-            [cemerick.url :refer (url url-encode url-decode)]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;

src/smeagol/middleware.clj

@@ -67,6 +67,7 @@
 
 (def production-middleware
   [#(wrap-internal-error % :log (fn [e] (log/error e)))
+   wrap-anti-forgery
    #(wrap-resource % "public")
    smeagol-wrap-content-type
    #(try

src/smeagol/repl.clj

@@ -1,9 +1,11 @@
 (ns ^{:doc "Functions to allow the wiki to be started and stopped from the REPL."
       :author "Simon Brooke"}
   smeagol.repl
-  (:use smeagol.handler
+  (:require 
-        ring.server.standalone
+   [ring.middleware.file :refer [wrap-file]]
-        [ring.middleware file-info file]))
+   [ring.middleware.file-info :refer [wrap-file-info]]
+   [ring.server.standalone :refer [app serve]]
+   [smeagol.handler :refer [destroy init]]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;

src/smeagol/routes/admin.clj

@@ -1,7 +1,7 @@
 (ns ^{:doc "Render all the main pages of a very simple Wiki engine."
       :author "Simon Brooke"}
   smeagol.routes.admin
-  (:require [clojure.walk :refer :all]
+  (:require [clojure.walk :refer [keywordize-keys]]
             [noir.session :as session]
             [taoensso.timbre :as timbre]
             [smeagol.authenticate :as auth]
@@ -35,12 +35,10 @@
 (defn edit-users
   "Render a page showing a list of users for editing."
   [request]
-  (let [params (keywordize-keys (:params request))
+  (layout/render "edit-users.html"
-        user (session/get :user)]
+                 (merge (util/standard-params request)
-    (layout/render "edit-users.html"
+                        {:title (:edit-users-title (util/get-messages request))
-                   (merge (util/standard-params request)
+                         :users (auth/list-users)})))
-                          {:title (:edit-users-title (util/get-messages request))
-                           :users (auth/list-users)}))))
 
 (defn delete-user
   "Render a form allowing a user to be deleted; and
@@ -49,8 +47,8 @@
   (let [params (keywordize-keys (:params request))
         target (:target params)
         deleted (auth/delete-user target)
-        message (if deleted (str (:del-user-success (util/get-messages request)) " " target "."))
+        message (when deleted (str (:del-user-success (util/get-messages request)) " " target "."))
-        error (if (not deleted) (str (:del-user-fail (util/get-messages request)) " " target "."))]
+        error (when-not deleted (str (:del-user-fail (util/get-messages request)) " " target "."))]
     (layout/render "edit-users.html"
                    (merge (util/standard-params request)
                           {:title (:edit-users-title (util/get-messages request))
@@ -69,8 +67,8 @@
             pass1 (:pass1 params)
             pass2 (:pass2 params)
             check-pass (auth/evaluate-password pass1 pass2)
-            password (if (and pass1 (true? check-pass)) pass1)
+            password (when (and pass1 (true? check-pass)) pass1)
-            stored (if
+            stored (when
                      (and
                       (:email params)
                       (or
@@ -78,18 +76,18 @@
                        (zero? (count pass1))
                        (true? check-pass)))
                      (auth/add-user target password (:email params) (:admin params)))
-            message (if stored (str (:save-user-success (util/get-messages request)) " " target "."))
+            message (when stored (str (:save-user-success (util/get-messages request)) " " target "."))
-            error (if
+            error (when
                     (and (:email params) (not stored))
                     (str
                       (:save-user-fail (util/get-messages request))
                       " " target ". "
-                      (if (keyword? check-pass) (check-pass (util/get-messages request)))))
+                      (when (keyword? check-pass) (check-pass (util/get-messages request)))))
             page (if stored "edit-users.html" "edit-user.html")
             details (auth/fetch-user-details target)]
-        (if message
+        (when message
           (timbre/info message))
-        (if error
+        (when error
           (timbre/warn error))
         (layout/render page
                        (merge (util/standard-params request)

src/smeagol/routes/wiki.clj

@@ -1,17 +1,16 @@
 (ns ^{:doc "Render all the main pages of a very simple Wiki engine."
       :author "Simon Brooke"}
   smeagol.routes.wiki
-  (:require [cemerick.url :refer (url url-encode url-decode)]
+  (:require [cemerick.url :refer (url-encode url-decode)]
             [clj-jgit.porcelain :as git]
             [clojure.java.io :as cjio]
             [clojure.pprint :refer [pprint]]
             [clojure.string :as cs]
-            [clojure.walk :refer :all]
+            [clojure.walk :refer [keywordize-keys]]
-            [compojure.core :refer :all]
+            [compojure.core :refer [defroutes GET POST]]
             [java-time :as jt]
             [markdown.core :as md]
             [me.raynes.fs :as fs]
-            [noir.io :as io]
             [noir.response :as response]
             [noir.util.route :as route]
             [noir.session :as session]
@@ -22,18 +21,17 @@
             [smeagol.formatting :refer [md->html]]
             [smeagol.history :as hist]
             [smeagol.layout :as layout]
-            [smeagol.local-links :refer :all]
+            [smeagol.local-links :refer [local-links]]
             [smeagol.routes.admin :as admin]
             [smeagol.sanity :refer [show-sanity-check-error]]
-            [smeagol.util :as util]
             [smeagol.uploads :as ul]
             [taoensso.timbre :as log]
             [com.stuartsierra.component :as component]
-            [smeagol.configuration :refer [config]]
             [smeagol.include.resolve-local-file :as resolve]
             [smeagol.include :as include]
-            [smeagol.util :refer [content-dir get-servlet-context-path
+            [smeagol.util :refer [content-dir get-message get-servlet-context-path
-                                  local-url local-url-base upload-dir]]))
+                                  local-url local-url-base standard-params 
+                                  start-page upload-dir]]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;
@@ -66,9 +64,8 @@
   (let [source-text (:src params)
         page (:page params)
         file-name (str page suffix)
-        file-path (cjio/file util/content-dir file-name)
+        file-path (cjio/file content-dir file-name)
-        exists? (.exists (cjio/as-file file-path))
+        git-repo (hist/load-or-init-repo content-dir)
-        git-repo (hist/load-or-init-repo util/content-dir)
         user (session/get :user)
         email (auth/get-email user)
         summary (format "%s: %s" user (or (:summary params) "no summary"))]
@@ -82,14 +79,14 @@
         (if
           (= suffix ".md")
           (url-encode page)
-          (util/get-message :default-page-title request))))))
+          (get-message :default-page-title request))))))
 
 
 (defn edit-page
   "Render a page in a text-area for editing. This could have been done in the same function as wiki-page,
   and that would have been neat, but I couldn't see how to establish security if that were done."
   ([request]
-   (edit-page request (util/get-message :default-page-title request) ".md" "edit.html" "_edit-side-bar.md"))
+   (edit-page request (get-message :default-page-title request) ".md" "edit.html" "_edit-side-bar.md"))
   ([request default suffix template side-bar]
    (or
      (show-sanity-check-error)
@@ -97,7 +94,7 @@
            src-text (:src params)
            page (or (:page params) default)
            file-name (str page suffix)
-           file-path (cjio/file util/content-dir file-name)
+           file-path (cjio/file content-dir file-name)
            exists? (.exists (cjio/as-file file-path))
            user (session/get :user)]
        (log/info
@@ -107,10 +104,10 @@
                    "User %s Opening '%s' for editing")
                  user file-path))
        (cond src-text (process-source params suffix request)
-             true
+             :else
              (layout/render template
-                            (merge (util/standard-params request)
+                            (merge (standard-params request)
-                                   {:title (str (util/get-message :edit-title-prefix request) " " page)
+                                   {:title (str (get-message :edit-title-prefix request) " " page)
                                     :page page
                                     :side-bar (md/md-to-html-string
                                                 (local-links
@@ -132,7 +129,7 @@
   investigate and document."
   (component/start
     (component/system-map
-      :resolver (resolve/new-resolver util/content-dir)
+      :resolver (resolve/new-resolver content-dir)
       :includer (component/using
                   (include/new-includer)
                   [:resolver]))))
@@ -180,7 +177,7 @@
                        (-> processed-text :extensions extension-key
                            resource-type requirement)
                        requirement)]
-               (if (empty? r)
+               (when (empty? r)
                  (log/warn "Found no valid URL for requirement"
                            requirement "of extension" extension-key))
                r))
@@ -204,9 +201,9 @@
   (or
     (show-sanity-check-error)
     (let [params (keywordize-keys (:params request))
-          page (or (:page params) util/start-page (util/get-message :default-page-title "Introduction" request))
+          page (or (:page params) start-page (get-message :default-page-title "Introduction" request))
           file-name (str page ".md")
-          file-path (cjio/file util/content-dir file-name)
+          file-path (cjio/file content-dir file-name)
           exists? (.exists (cjio/as-file file-path))]
       (if exists?
         (do
@@ -217,7 +214,7 @@
                                      (:includer md-include-system)
                                      (slurp file-path))))]
             (layout/render "wiki.html"
-                           (merge (util/standard-params request)
+                           (merge (standard-params request)
                                   processed-text
                                   {:title page
                                    :scripts (collect-preferred processed-text :scripts)
@@ -233,13 +230,13 @@
   if any. If none, error?"
   [request]
   (let [params (keywordize-keys (:params request))
-        page (url-decode (or (:page params) (util/get-message :default-page-title request)))
+        page (url-decode (or (:page params) (get-message :default-page-title request)))
         file-name (str page ".md")
-        repo-path util/content-dir]
+        repo-path content-dir]
     (log/info (format "Showing history of page '%s'" page))
     (layout/render "history.html"
-                   (merge (util/standard-params request)
+                   (merge (standard-params request)
-                          {:title (str (util/get-message :history-title-prefix request)
+                          {:title (str (get-message :history-title-prefix request)
                                        " " page)
                            :page page
                            :history (hist/find-history repo-path file-name)}))))
@@ -280,24 +277,24 @@
                (and (fs/extension %)
                     (image-extns (cs/lower-case (fs/extension %))))
                true false)
-             (if
+             (when
                (fs/mod-time %)
                (format-instant (fs/mod-time %)))
              (fs/name %)
-             (util/local-url %)])
+             (local-url %)])
          (remove
            #(or (cs/starts-with? (fs/name %) ".")
                 (fs/directory? %))
-           (file-seq (clojure.java.io/file util/upload-dir)))))]
+           (file-seq (clojure.java.io/file upload-dir)))))]
     (log/info (with-out-str (pprint files)))
     (layout/render
       "list-uploads.html"
-      (merge (util/standard-params request)
+      (merge (standard-params request)
              {:title (str
-                       (util/get-message :list-files request)
+                       (get-message :list-files request)
-                       (if
+                       (when
                          (:search params)
-                         (str " " (util/get-message :matching request))))
+                         (str " " (get-message :matching request))))
               :search (:search params)
               :files (if
                        (:search params)
@@ -317,14 +314,14 @@
   "Render a form to allow the upload of a file."
   [request]
   (let [params (keywordize-keys (:params request))
-        data-path (str util/content-dir "/uploads/")
+        data-path (str content-dir "/uploads/")
-        git-repo (hist/load-or-init-repo util/content-dir)
+        git-repo (hist/load-or-init-repo content-dir)
         upload (:upload params)
-        uploaded (if upload (ul/store-upload params data-path))
+        uploaded (when upload (ul/store-upload params data-path))
         user (session/get :user)
         summary (format "%s: %s" user (or (:summary params) "no summary"))]
     (log/info (session/get :user) "has uploaded" (cs/join "; " (map :resource uploaded)))
-    (if-not
+    (when-not
       (empty? uploaded)
       (do
         (doall (map
@@ -332,8 +329,8 @@
                  (remove nil? uploaded)))
         (git/git-commit git-repo summary {:name user :email (auth/get-email user)})))
     (layout/render "upload.html"
-                   (merge (util/standard-params request)
+                   (merge (standard-params request)
-                          {:title (util/get-message :file-upload-title request)
+                          {:title (get-message :file-upload-title request)
                            :uploaded uploaded}))))
 
 
@@ -341,14 +338,14 @@
   "Render a specific historical version of a page"
   [request]
   (let [params (keywordize-keys (:params request))
-        page (url-decode (or (:page params) (util/get-message :default-page-title request)))
+        page (url-decode (or (:page params) (get-message :default-page-title request)))
         version (:version params)
         file-name (str page ".md")
-        content (hist/fetch-version util/content-dir file-name version)]
+        content (hist/fetch-version content-dir file-name version)]
     (log/info (format "Showing version '%s' of page '%s'" version page))
     (layout/render "wiki.html"
-                   (merge (util/standard-params request)
+                   (merge (standard-params request)
-                          {:title (str (util/get-message :vers-col-hdr request) " " version " " (util/get-message :of request) " "  page)
+                          {:title (str (get-message :vers-col-hdr request) " " version " " (get-message :of request) " "  page)
                            :page page
                            :content (md->html content)}))))
 
@@ -357,24 +354,24 @@
   "Render a diff between two versions of a page"
   [request]
   (let [params (keywordize-keys (:params request))
-        page (url-decode (or (:page params) (util/get-message :default-page-title request)))
+        page (url-decode (or (:page params) (get-message :default-page-title request)))
         version (:version params)
         file-name (str page ".md")]
     (log/info (format "Showing diff between version '%s' of page '%s' and current" version page))
     (layout/render "wiki.html"
-                   (merge (util/standard-params request)
+                   (merge (standard-params request)
                           {:title
                            (str
-                             (util/get-message :diff-title-prefix request)
+                             (get-message :diff-title-prefix request)
                              " "
                              version
                              " "
-                             (util/get-message :of request)
+                             (get-message :of request)
                              " "
                              page)
                            :page page
                            :content (d2h/diff2html
-                                      (hist/diff util/content-dir file-name version))}))))
+                                      (hist/diff content-dir file-name version))}))))
 
 
 (defn auth-page
@@ -389,9 +386,9 @@
           action (:action form-params)
           user (session/get :user)
           redirect-to (:redirect-to params)]
-      (if redirect-to (log/info (str "After auth, redirect to: " redirect-to)))
+      (when redirect-to (log/info (str "After auth, redirect to: " redirect-to)))
       (cond
-        (= action (util/get-message :logout-label request))
+        (= action (get-message :logout-label request))
         (do
           (log/info (str "User " user " logging out"))
           (session/remove! :user)
@@ -403,12 +400,12 @@
             (or
               redirect-to
               (get-servlet-context-path request))))
-        true
+        :else
         (layout/render "auth.html"
-                       (merge (util/standard-params request)
+                       (merge (standard-params request)
                               {:title (if user
-                                        (str (util/get-message :logout-link request) " " user)
+                                        (str (get-message :logout-link request) " " user)
-                                        (util/get-message :login-link request))
+                                        (get-message :login-link request))
                                :redirect-to redirect-to}))))))
 
 (defn wrap-restricted-redirect
@@ -430,7 +427,7 @@
         request
         ;; else merge a redirect target into the params
         (let
-          [redirect-to (if (:uri request)
+          [redirect-to (when (:uri request)
                          (cs/join "?" [(:uri request) (:query-string request)]))]
           (assoc-in request [:params :redirect-to] redirect-to))))))
 
@@ -447,14 +444,14 @@
                    (true? check-pass)
                    (auth/change-pass user oldpass pass2))]
     (layout/render "passwd.html"
-                   (merge (util/standard-params request)
+                   (merge (standard-params request)
-                          {:title (str (util/get-message :chpass-title-prefix request) " " user)
+                          {:title (str (get-message :chpass-title-prefix request) " " user)
-                           :message (if changed? (util/get-message :chpass-success request))
+                           :message (when changed? (get-message :chpass-success request))
                            :error (cond
                                     (nil? oldpass) nil
                                     changed? nil
-                                    (keyword? check-pass) (util/get-message check-pass request)
+                                    (keyword? check-pass) (get-message check-pass request)
-                                    true (util/get-message :chpass-fail request))}))))
+                                    :else (get-message :chpass-fail request))}))))
 
 
 (defroutes wiki-routes

src/smeagol/uploads.clj

@@ -4,16 +4,13 @@
   (:require [clojure.string :as cs]
             [clojure.java.io :as io]
             [image-resizer.core :refer [resize]]
-            [image-resizer.scale-methods :as sm]
+            [image-resizer.util :refer [buffered-image dimensions]]
-            [image-resizer.util :refer :all]
             [me.raynes.fs :as fs]
-            [noir.io :as nio]
             [smeagol.configuration :refer [config]]
             [smeagol.util :as util]
             [taoensso.timbre :as log])
   (:import [java.io File]
-           [java.awt Image]
+           [java.awt.image RenderedImage]
-           [java.awt.image RenderedImage BufferedImageOp]
            [javax.imageio ImageIO ImageWriter ImageWriteParam IIOImage]
            [javax.imageio.stream FileImageOutputStream]))
 

src/smeagol/util.clj

@@ -3,7 +3,6 @@
   smeagol.util
   (:require [clojure.java.io :as cjio]
             [clojure.string :as cs]
-            [environ.core :refer [env]]
             [markdown.core :as md]
             [me.raynes.fs :as fs]
             [noir.io :as io]
@@ -11,7 +10,7 @@
             [scot.weft.i18n.core :as i18n]
             [smeagol.authenticate :as auth]
             [smeagol.configuration :refer [config]]
-            [smeagol.local-links :refer :all]
+            [smeagol.local-links :refer [local-links]]
             [taoensso.timbre :as log]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -79,15 +78,15 @@
                (cjio/file local-url-base file-path))]
     (cond
       (cs/includes? file-path "..")
-      (cs/join " " file-path
+      (cs/join " " [file-path
-               "Attempts to ascend the file hierarchy are disallowed.")
+               "Attempts to ascend the file hierarchy are disallowed."])
       (not (cs/starts-with? path local-url-base))
       (cs/join " " [path "is not servable"])
       (not (fs/exists? path))
       (cs/join " " [path "does not exist"])
       (not (fs/readable? path))
       (cs/join " " [path "is not readable"])))
-    (catch Exception any (cs/join " " file-path "is not servable because" (.getMessage any)))))
+    (catch Exception any (cs/join " " [file-path "is not servable because" (.getMessage any)]))))
 
 
 ;; (not-servable-reason "/home/simon/workspace/smeagol/resources/public/content/vendor/node_modules/photoswipe/dist/photoswipe.min.js")