fix bad rule id/indexing

- turns out the env* atom was abused harder than we thought
- to be functional we have to pass the rule-index all around

... i see now why they used an atom.

Author: lwhorton

src/cljss/builder.clj

@@ -8,29 +8,30 @@
        (map? value)))
 
 (defn build-styles [cls styles]
-  (let [pseudo  (filterv utils/pseudo? styles)
-        nested  (->> styles
-                     (filterv (comp not utils/pseudo?))
-                     (filterv utils/nested?))
-        [mstatic mvals] (some-> styles :cljss.core/media ((partial build-media cls)))
-        styles  (dissoc styles :cljss.core/media)
-        styles  (filterv #(and (not (utils/pseudo? %)) (not (utils/nested? %))) styles)
-        [static vals] (c/collect-styles cls styles)
-        pstyles (->> pseudo
-                     (reduce
-                       (fn [coll [rule styles]]
-                         (conj coll (c/collect-styles (str cls (subs (name rule) 1)) styles)))
-                       []))
-        nstyles (->> nested
-                     (reduce
-                       (fn [coll [rule styles]]
-                         (conj coll (c/collect-styles (str cls " " rule) styles)))
-                       []))
-        vals    (->> pstyles
-                     (mapcat second)
-                     (into vals)
-                     (concat mvals)
-                     (into []))
+  (let [rule-index 0
+        pseudo (filterv utils/pseudo? styles)
+        nested (->> styles
+                    (filterv (comp not utils/pseudo?))
+                    (filterv utils/nested?))
+        [mstatic mvals rule-index] (some-> styles :cljss.core/media ((partial build-media cls rule-index)))
+        styles (dissoc styles :cljss.core/media)
+        styles (filterv #(and (not (utils/pseudo? %)) (not (utils/nested? %))) styles)
+
+        [static vals rule-index] (c/collect-styles cls styles rule-index)
+        [pstyles rule-index] (c/collect-dynamic-styles
+                               rule-index
+                               pseudo
+                               (fn [rule] (str cls (subs (name rule) 1))))
+        [nstyles rule-index] (c/collect-dynamic-styles
+                               rule-index
+                               nested
+                               (fn [rule] (str cls " " rule)))
+
+        vals (->> pstyles
+                  (mapcat second)
+                  (into vals)
+                  (concat mvals)
+                  (into []))
         vals (->> nstyles
                   (mapcat second)
                   (into vals))

src/cljss/collect.clj

@@ -8,19 +8,35 @@
 (defn varid [cls idx [rule]]
   [rule (str "--var-" cls "-" idx)])
 
-(defn collect-styles [cls styles]
+(defn collect-styles [cls styles rule-index]
   (let [dynamic (filterv dynamic? styles)
         static  (filterv (comp not dynamic?) styles)
-        [vars _]
-                (reduce
-                  (fn [[vars idx] ds]
-                    (let [ret (conj vars (varid cls idx ds))]
-                      [ret (inc idx)]))
-                  [[] 0]
-                  dynamic)
+        [vars rule-index] (reduce
+                            (fn [[vars idx] ds]
+                              (let [ret (conj vars (varid cls idx ds))]
+                                [ret (inc idx)]))
+                            [[] rule-index]
+                            dynamic)
+        _ (println "static" static)
+        _ (println "vars" vars)
+        _ (println "dynamic" dynamic)
         vals    (mapv (fn [[_ var] [_ exp]] [var exp]) vars dynamic)
+        _ (println "vals" vals)
         static  (->> vars
                      (map (fn [[rule var]] [rule (str "var(" var ")")]))
                      (concat static)
                      (build-css cls))]
-    [static vals]))
+    [static vals rule-index]))
+
+(defn collect-dynamic-styles [rule-index rules class-generator]
+  (loop
+    [idx rule-index
+     acc []
+     coll rules]
+    (if (not (seq coll))
+      [acc idx]
+      (let [[rule styles] (first coll)
+            [static vals nxt-idx] (collect-styles (class-generator rule) styles idx)]
+        (recur nxt-idx
+               (conj acc [static vals])
+               (rest coll))))))

src/cljss/media.clj

@@ -234,39 +234,37 @@
          (clojure.string/join " ")
          (str "@media "))))
 
-(defn compile-media-dispatch [styles _]
+(defn compile-media-dispatch [styles _ _]
   (cond
     (contains? styles :media) :media
     (contains? styles :styles) :styles))
 
 (defmulti compile-media #'compile-media-dispatch)
 
-(defmethod compile-media :media [{media :media} cls]
+(defmethod compile-media :media [{media :media} cls rule-index]
   (->> (seq media)
        (reduce
-         (fn [[sstyles svalues] [query styles]]
-           (let [[static values] (compile-media {:styles styles} cls)
+         (fn [[sstyles svalues nxt-idx] [query styles]]
+           (let [[static values nxt-idx] (compile-media {:styles styles} cls nxt-idx)
                  query (-compile-media-query query)]
-             [(str sstyles query static) (concat svalues values)]))
-         ["" []])))
+             [(str sstyles query static) (concat svalues values) nxt-idx]))
+         ["" [] rule-index])))
 
-(defmethod compile-media :styles [{styles :styles} cls]
+(defmethod compile-media :styles [{styles :styles} cls rule-index]
   (let [pseudo (filterv utils/pseudo? styles)
-        pstyles (->> pseudo
-                     (reduce
-                       (fn [coll [rule styles]]
-                         (conj coll (c/collect-styles (str cls (subs (name rule) 1)) styles)))
-                       []))
+        [pstyles rule-index] (c/collect-dynamic-styles rule-index pseudo (fn [rule] (str cls (subs (name rule) 1))))
+
         styles (filterv (comp not utils/pseudo?) styles)
-        [static values] (c/collect-styles cls styles)
+        [static values rule-index] (c/collect-styles cls styles rule-index)
         values (->> pstyles
                     (mapcat second)
                     (into values))]
     [(str "{" (apply str static (map first pstyles)) "}")
-     values]))
+     values
+     rule-index]))
 
-(defn build-media [cls styles]
-  (compile-media {:media styles} cls))
+(defn build-media [cls rule-index styles]
+  (compile-media {:media styles} cls rule-index))
 
 (comment
   (build-media