Renamed namespace from rum to rum.core

Author: tonsky

README.md

@@ -35,14 +35,14 @@ Rum provides basic tools that every React app eventually need:
 
 ## Using Rum <a href="https://gitter.im/tonsky/rum?utm_source=badge&amp;utm_medium=badge&amp;utm_campaign=pr-badge&amp;utm_content=badge"><img src="https://camo.githubusercontent.com/da2edb525cde1455a622c58c0effc3a90b9a181c/68747470733a2f2f6261646765732e6769747465722e696d2f4a6f696e253230436861742e737667" alt="Gitter" data-canonical-src="https://badges.gitter.im/Join%20Chat.svg" style="max-width:100%;"></a>
 
-1. Add `[rum "0.3.0"]` to dependencies
-2. `(require 'rum)`.
+1. Add `[rum "0.4.0"]` to dependencies
+2. `(require '[rum.core :as rum])`.
 
 Simplest example defines component, instantiates it and mounts it on a page:
 
 ```clojure
 (ns example
-  (:require rum))
+  (:require [rum.core :as rum]))
 
 (rum/defc label [n text]
   [:.label (repeat n text)])
@@ -52,14 +52,6 @@ Simplest example defines component, instantiates it and mounts it on a page:
 
 For more examples, see [examples/examples.cljs](examples/examples.cljs). Live version of examples [is here](http://tonsky.me/rum/)
 
-Note: _To suppress warning about single-segmented namespace, add this:_
-
-```clojure
-:compiler {
-  {:warnings {:single-segment-namespace false}}
-}
-```
-
 ## Rum resources
 
 - [Norbert Wójtowicz talk at Lambda Days 2015](https://vimeo.com/122316380) where he explains benefits of web development with ClojureScript and React, and how Rum emulates all main ClojureScript frameworks
@@ -90,7 +82,7 @@ Behind the scenes, `defc` does couple of things:
 
 When called, `name` function will create new React element from built React class and pass through `argvec` so it’ll be available inside `render-body`
 
-To mount component, use `rum/mount`:
+To mount component, use `rum.core/mount`:
 
 ```clojure
 (rum/mount element dom-node)
@@ -121,7 +113,7 @@ or call `request-render` function:
 
 Rum comes with a couple of mixins which emulate behaviors known from `quiescent`, `om` and `reagent`. Developing your own mixin is also very simple.
 
-`rum/static` will check if arguments of a component constructor have changed (with Clojure’s `-equiv` semantic), and if they are the same, avoid re-rendering.
+`rum.core/static` will check if arguments of a component constructor have changed (with Clojure’s `-equiv` semantic), and if they are the same, avoid re-rendering.
 
 ```clojure
 (rum/defc label < rum/static [n text]
@@ -132,7 +124,7 @@ Rum comes with a couple of mixins which emulate behaviors known from `quiescent`
 (rum/mount (label 1 "xyz") body) ;; this will cause a re-render
 ```
 
-`rum/local` creates an atom that can be used as per-component local state. When you `swap!` or `reset!` this atom, component will be re-rendered automatically. Atom can be found in state under `:rum/local` key:
+`rum.core/local` creates an atom that can be used as per-component local state. When you `swap!` or `reset!` this atom, component will be re-rendered automatically. Atom can be found in state under `:rum/local` key:
 
 ```clojure
 (rum/defcs stateful < (rum/local 0) [state title]
@@ -144,9 +136,9 @@ Rum comes with a couple of mixins which emulate behaviors known from `quiescent`
 (rum/mount (stateful "Clicks count") js/document.body)
 ```
 
-Note that we used `defcs` instead of `defc` to get state as first argument to `render`. Also note that `rum/local` is not a mixin value, instead, it’s a function, generator-like: it takes initial value and returns mixin.
+Note that we used `defcs` instead of `defc` to get state as first argument to `render`. Also note that `rum.core/local` is not a mixin value, instead, it’s a function, generator-like: it takes initial value and returns mixin.
 
-`rum/reactive` will create “reactive” component that will track references used inside `render` function and auto-update when values of these references change.
+`rum.core/reactive` will create “reactive” component that will track references used inside `render` function and auto-update when values of these references change.
 
 ```clojure
 (def color (atom "#cc3333"))
@@ -161,16 +153,16 @@ Note that we used `defcs` instead of `defc` to get state as first argument to `r
 (reset! color "#000")    ;; and another one
 ```
 
-`rum/react` function used in this example works as `deref`, and additionally adds watch on that reference.
+`rum.core/react` function used in this example works as `deref`, and additionally adds watch on that reference.
 
-Finally, `rum/cursored` is a mixin that will track changes in references passed as arguments:
+Finally, `rum.core/cursored` is a mixin that will track changes in references passed as arguments:
 
 ```clojure
 (rum/defc label < rum/cursored [color text]
   [:.label {:style {:color @color}} @text])
 ```
 
-Note that `cursored` mixin creates passive component: it will not react to any changes in references by itself, and will only compare arguments when re-created by its parent. Additional `rum/cursored-watch` mixin will add watches on every `IWatchable` in arguments list:
+Note that `cursored` mixin creates passive component: it will not react to any changes in references by itself, and will only compare arguments when re-created by its parent. Additional `rum.core/cursored-watch` mixin will add watches on every `IWatchable` in arguments list:
 
 ```clojure
 (rum/defc body < rum/cursored rum/cursored-watch [color text]
@@ -328,6 +320,10 @@ This is a detailed breakdown of what happens inside of Rum. By using `rum/defc`,
 
 ## Changes
 
+### 0.4.0
+
+- [ BREAKING ] Core namespace was renamed from `rum` to `rum.core` to supress CLJS warnings
+
 ### 0.3.0
 
 - Upgraded to React 0.13.3, Sablono 0.3.6, ClojueScript 1.7.48

examples/examples.cljs

@@ -1,7 +1,7 @@
 (ns examples
   (:require
     [clojure.string :as str]
-    [rum]))
+    [rum.core :as rum]))
 
 (enable-console-print!)
 

project.clj

@@ -1,4 +1,4 @@
-(defproject rum "0.3.0"
+(defproject rum "0.4.0"
   :description "ClojureScript wrapper for React"
   :license     { :name "Eclipse"
                  :url  "http://www.eclipse.org/legal/epl-v10.html" }

src/rum.clj src/rum/core.cljsrc/rum.clj renamed to src/rum/core.clj

@@ -1,4 +1,4 @@
-(ns rum
+(ns rum.core
   (:require
     [sablono.compiler :as s]))
 
@@ -36,7 +36,7 @@
             ctor#         (fn [& args#]
                             (let [state# (args->state args#)]
                               (rum/element class# state# nil)))]
-        (with-meta ctor# {::class class#})))))
+        (with-meta ctor# {:rum/class class#})))))
 
 (defmacro defc
   "Defc does couple of things:
@@ -82,8 +82,8 @@
    Special properties goes at the end of arguments list and should be namespaced.
    For now only :rum/key and :rum/ref are supported"
   [ctor & args]
-  (let [props {::key "key"
-               ::ref "ref"}
+  (let [props {:rum/key "key"
+               :rum/ref "ref"}
         as (take-while #(not (props %)) args)
         ps (->> (drop-while #(not (props %)) args)
                 (partition 2)

src/rum.cljs src/rum/core.cljssrc/rum.cljs renamed to src/rum/core.cljs

@@ -1,11 +1,9 @@
-(ns rum
-  (:require-macros rum)
+(ns rum.core
+  (:require-macros rum.core)
   (:require
     [cljsjs.react]
     [sablono.core]))
 
-#_(enable-console-print!)
-
 (let [last-id (volatile! 0)]
   (defn next-id []
     (vswap! last-id inc)))
@@ -14,7 +12,7 @@
   (aget (.-state comp) ":rum/state"))
 
 (defn id [comp]
-  (::id @(state comp)))
+  (:rum/id @(state comp)))
 
 (defn- collect [fn-key classes]
   (->> classes
@@ -53,8 +51,8 @@
       (fn []
         (this-as this
           (let [props (.-props this)
-                state (-> { ::react-component this
-                            ::id (next-id) }            ;; assign id on mount?
+                state (-> { :rum/react-component this
+                            :rum/id (next-id) }            ;; assign id on mount?
                         (merge (props->state props)))]
             #js { ":rum/state" (volatile! state) })))
       :componentWillMount
@@ -71,8 +69,8 @@
       (fn [next-props]
         (this-as this
           (let [old-state @(state this)
-                next-state (-> { ::react-component this
-                                 ::id (::id old-state) }
+                next-state (-> { :rum/react-component this
+                                 :rum/id (:rum/id old-state) }
                              (merge (props->state next-props)))
                 next-state (reduce #(%2 old-state %1) next-state transfer-state)]
             (.setState this #js {":rum/state" (volatile! next-state)}))))
@@ -156,24 +154,24 @@
 ;; initialization
 
 (defn render->mixin [render-fn]
-  { :render (fn [state] [(apply render-fn (::args state)) state]) })
+  { :render (fn [state] [(apply render-fn (:rum/args state)) state]) })
 
 (defn render-state->mixin [render-fn]
-  { :render (fn [state] [(apply render-fn state (::args state)) state]) })
+  { :render (fn [state] [(apply render-fn state (:rum/args state)) state]) })
 
 (defn render-comp->mixin [render-fn]
-  { :render (fn [state] [(apply render-fn (:rum/react-component state) (::args state)) state]) })
+  { :render (fn [state] [(apply render-fn (:rum/react-component state) (:rum/args state)) state]) })
 
 (defn args->state [args]
-  {::args args})
+  {:rum/args args})
 
 (defn element [class state & [props]]
   (let [props (or props #js {})]
     (aset props ":rum/initial-state" state)
     (js/React.createElement class props)))
 
 (defn ctor->class [ctor]
-  (::class (meta ctor)))
+  (:rum/class (meta ctor)))
 
 (defn with-key [element key]
   (js/React.cloneElement element #js { "key" key } nil))
@@ -186,7 +184,7 @@
 (def static {
   :should-update
   (fn [old-state new-state]
-    (not= (::args old-state) (::args new-state)))
+    (not= (:rum/args old-state) (:rum/args new-state)))
 })
 
 ;; local mixin
@@ -215,18 +213,18 @@
 (def ^:dynamic *reactions*)
 
 (defn- reactive-key [state]
-  (str ":rum/reactive-" (::id state)))
+  (str ":rum/reactive-" (:rum/id state)))
 
 (def reactive {
   :transfer-state
   (fn [old new]
-    (assoc new ::refs (::refs old)))
+    (assoc new :rum/refs (:rum/refs old)))
   :wrap-render
   (fn [render-fn]
     (fn [state]
       (binding [*reactions* (volatile! #{})]
-        (let [comp             (::react-component state)
-              old-reactions    (::refs state #{})
+        (let [comp             (:rum/react-component state)
+              old-reactions    (:rum/refs state #{})
               [dom next-state] (render-fn state)
               new-reactions    @*reactions*
               key              (reactive-key state)]
@@ -238,13 +236,13 @@
               (add-watch ref key
                 (fn [_ _ _ _]
                   (request-render comp)))))
-          [dom (assoc next-state ::refs new-reactions)]))))
+          [dom (assoc next-state :rum/refs new-reactions)]))))
   :will-unmount
   (fn [state]
     (let [key (reactive-key state)]
-      (doseq [ref (::refs state)]
+      (doseq [ref (:rum/refs state)]
         (remove-watch ref key)))
-    (dissoc state ::refs))
+    (dissoc state :rum/refs))
 })
 
 (defn react [ref]
@@ -325,31 +323,31 @@
 (def cursored {
   :transfer-state
   (fn [old new]
-    (assoc new ::om-args (::om-args old)))
+    (assoc new :rum/om-args (:rum/om-args old)))
   :should-update
   (fn [old-state new-state]
-    (not= (::om-args old-state) (deref-args (::args new-state))))
+    (not= (:rum/om-args old-state) (deref-args (:rum/args new-state))))
   :wrap-render
   (fn [render-fn]
     (fn [state]
       (let [[dom next-state] (render-fn state)]
-        [dom (assoc next-state ::om-args (deref-args (::args state)))])))
+        [dom (assoc next-state :rum/om-args (deref-args (:rum/args state)))])))
 })
 
 (defn- cursored-key [state]
-  (str ":rum/cursored-" (::id state)))
+  (str ":rum/cursored-" (:rum/id state)))
 
 (def cursored-watch {
   :did-mount
     (fn [state]
-      (doseq [arg (::args state)
+      (doseq [arg (:rum/args state)
               :when (satisfies? IWatchable arg)]
         (add-watch arg (cursored-key state)
-          (fn [_ _ _ _] (request-render (::react-component state)))))
+          (fn [_ _ _ _] (request-render (:rum/react-component state)))))
       state)
   :will-unmount
     (fn [state]
-      (doseq [arg (::args state)
+      (doseq [arg (:rum/args state)
               :when (satisfies? IWatchable arg)]
         (remove-watch arg (cursored-key state)))
       state)