Fix combined dot-notation and non-literal classes

Generate the correct class attribute of an element when the class names
are both present as:

- part of the element keyword (using the dot notation)
- a non-literal value of the :class key in the attribute map
  (specifically when using a symbol as the value).

Fixes issue weavejester#143

src/hiccup/compiler.clj

@@ -73,37 +73,48 @@
   (or content
       (and (html-mode?) (not (void-tags tag)))))
 
-(defn- merge-classes [class classes]
+(defn- merge-classes [class classes compiling?]
   (cond
-    (nil? class)    classes
-    (string? class) (str classes " " class)
-    :else           (str classes " " (str/join " " class))))
-
-(defn- merge-attributes [map-attrs id classes]
+    (nil? class)                  classes
+    (string? class)               (str classes " " class)
+    (and compiling?
+         (symbol? class))         (list `str classes " " class)
+    (and (not compiling?)
+         (instance? Named class)) (str classes " " (name class))
+    :else                         (str classes " " (str/join " " class))))
+
+(defn- merge-attributes [map-attrs id classes compiling?]
   (-> map-attrs
       (cond-> id      (assoc :id (or (:id map-attrs) id)))
-      (cond-> classes (assoc :class (merge-classes (:class map-attrs) classes)))))
+      (cond-> classes (assoc :class (merge-classes (:class map-attrs) classes compiling?)))))
 
-(defn normalize-element
-  "Ensure an element vector is of the form [tag-name attrs content]."
-  [[tag & content]]
+(defn- normalize-element-with-compile-mode
+  "Ensure an element vector is of the form [tag-name attrs content], choosing
+   a different class merge strategy fi rendering or compiling."
+  [[tag & content] compiling?]
   (when (not (or (keyword? tag) (symbol? tag) (string? tag)))
     (throw (IllegalArgumentException. (str tag " is not a valid element name."))))
   (let [[_ tag id class] (re-matches re-tag (util/as-str tag))
         classes          (if class (str/replace class "." " "))
         map-attrs        (first content)]
     (if (map? map-attrs)
-      [tag (merge-attributes map-attrs id classes) (next content)]
+      [tag (merge-attributes map-attrs id classes compiling?) (next content)]
       [tag {:id id, :class classes} content])))
 
+(defn normalize-element
+  "Ensure an element vector is of the form [tag-name attrs content]. 
+   Assumes the element is being rendered, not compiled"
+  [[tag & content :as tag-content]]
+  (normalize-element-with-compile-mode tag-content false))
+
 (defprotocol HtmlRenderer
   (render-html [this]
     "Turn a Clojure data type into a string of HTML."))
 
 (defn render-element
   "Render an element vector as a HTML element."
   [element]
-  (let [[tag attrs content] (normalize-element element)]
+  (let [[tag attrs content] (normalize-element-with-compile-mode element false)]
     (if (container-tag? tag content)
       (str "<" tag (render-attr-map attrs) ">"
            (render-html content)
@@ -201,15 +212,15 @@
   [[tag attrs & content :as element]]
   (cond
     (every? literal? element)
-      ::all-literal                    ; e.g. [:span "foo"]
+    ::all-literal                    ; e.g. [:span "foo"]
     (and (literal? tag) (map? attrs))
-      ::literal-tag-and-attributes     ; e.g. [:span {} x]
+    ::literal-tag-and-attributes     ; e.g. [:span {} x]
     (and (literal? tag) (not-implicit-map? attrs))
-      ::literal-tag-and-no-attributes  ; e.g. [:span ^String x]
+    ::literal-tag-and-no-attributes  ; e.g. [:span ^String x]
     (literal? tag)
-      ::literal-tag                    ; e.g. [:span x]
+    ::literal-tag                    ; e.g. [:span x]
     :else
-      ::default))                      ; e.g. [x]
+    ::default))                      ; e.g. [x]
 
 (declare compile-seq)
 
@@ -221,11 +232,12 @@
 
 (defmethod compile-element ::all-literal
   [element]
+  (def test-v element)
   (render-element (eval element)))
 
 (defmethod compile-element ::literal-tag-and-attributes
   [[tag attrs & content]]
-  (let [[tag attrs _] (normalize-element [tag attrs])]
+  (let [[tag attrs _] (normalize-element-with-compile-mode [tag attrs] true)]
     (if (container-tag? tag content)
       `(str ~(str "<" tag) ~(compile-attr-map attrs) ">"
             ~@(compile-seq content)
@@ -238,7 +250,7 @@
 
 (defmethod compile-element ::literal-tag
   [[tag attrs & content]]
-  (let [[tag tag-attrs _] (normalize-element [tag])
+  (let [[tag tag-attrs _] (normalize-element-with-compile-mode [tag] true)
         attrs-sym         (gensym "attrs")]
     `(let [~attrs-sym ~attrs]
        (if (map? ~attrs-sym)

test/hiccup/compiler_test.clj

@@ -0,0 +1,13 @@
+(ns hiccup.compiler-test
+  (:require [hiccup.compiler :refer [render-element]]
+            [clojure.test :refer :all]))
+
+(deftest render-element-test
+  (testing "render non-literal class names when combined with tag classes"
+    (is (= (let [x "attr-class"]
+             (render-element [:a.tag-class {:class x}]))
+           "<a class=\"tag-class attr-class\"></a>"))
+    (is (= (render-element [:a.tag-class {:class 'x}])
+           "<a class=\"tag-class x\"></a>"))))
+
+

test/hiccup/core_test.clj

@@ -110,7 +110,11 @@
     (let [times-called (atom 0)
           foo #(swap! times-called inc)]
       (html [:div (foo)])
-      (is (= @times-called 1)))))
+      (is (= @times-called 1))))
+  (testing "defer evaluation of non-literal class names when combined with tag classes"
+    (let [x "attr-class"]
+      (is  (= (html [:div.tag-class {:class x}])
+              "<div class=\"tag-class attr-class\"></div>")))))
 
 (deftest render-modes
   (testing "closed tag"