on to 0.1.23

fix parameters of goog.log functions to prevent compiler warnings

.clj-kondo/config.edn

@@ -0,0 +1 @@
+{:config-paths ["../resources/clj-kondo.exports/mount/mount/"]}

.gitignore

@@ -1,7 +1,10 @@
 /target
 /classes
 /checkouts
-pom.xml
+.cpcache/
+.rebel_readline_history
+cljs-test-runner-out
+node_modules
 pom.xml.asc
 .repl*
 dev/resources/public/js/*
@@ -18,3 +21,4 @@ doo-index.html
 /.nrepl-history
 .cljs_rhino_repl/
 out/
+.clj-kondo/.cache

.travis.yml

@@ -0,0 +1,26 @@
+sudo: false
+language: java
+script:
+  - boot test
+  - boot test-cljs
+  - boot test-cljs-advanced
+install:
+  - mkdir -p ~/bin
+  - export PATH=~/bin:$PATH
+
+  - curl -L https://github.com/boot-clj/boot-bin/releases/download/latest/boot.sh -o ~/bin/boot
+  - chmod +x ~/bin/boot
+jdk: openjdk8
+env:
+  matrix:
+    - BOOT_CLOJURE_VERSION=1.8.0
+  global:
+    - JAVA_OPTS="-Xms512m -Xmx2048m"
+  jdk:
+    - openjdk8
+  cache:
+    directories:
+      - $HOME/.m2
+      - $HOME/.boot/cache/bin
+      - $HOME/.boot/cache/lib
+      - $HOME/bin

CHANGELOG.md

@@ -1,6 +1,60 @@
-## 0.1.9
+## 0.1.19
+###### Wed Aug 21 22:43:40 2024 -0400
 
-* `:on-reload` #{:noop :stop :restart} ([#36](https://github.com/tolitius/mount/issues/36)) 
+* add `clojure-kondo`
+
+## 0.1.17
+###### Mon Dec 19 15:17:21 2022 -0500
+
+* 2d050e9 fix: swap-states non string rollback (thanks to [egg-juxt](https://github.com/egg-juxt))
+
+## 0.1.16
+###### Mon Jan 28 10:34:26 2019 -0500
+
+* fb52f79 prevent reloading of mount.core ns ([106](https://github.com/tolitius/mount/issues/106))
+* c5f3e4c current-state should return Derefable on :cljc ([104](https://github.com/tolitius/mount/issues/104))
+* c2687d1 silent `*logger*` warning in latest ClojureScript([101](https://github.com/tolitius/mount/issues/101))
+* bb23747 switch form circle to travis
+
+## 0.1.14
+###### Thu Oct 25 18:34:22 2018 -0400
+
+* cljs: throw js/Error not just a string ([#100](https://github.com/tolitius/mount/issues/100))
+* add ^{:on-lazy-start :throw} ([#95](https://github.com/tolitius/mount/issues/95) and [#99](https://github.com/tolitius/mount/issues/99))
+* self hosted ClojureScript support ([#85](https://github.com/tolitius/mount/issues/85) and [#97](https://github.com/tolitius/mount/issues/97))
+
+## 0.1.12
+###### Sat Feb 10 14:53:04 2018 -0500
+
+* remove ref to old state alias in `swap-states` ([#89](https://github.com/tolitius/mount/issues/89))
+* `:on-reload :noop` should not leave stale references
+* `stop-except` & `start-without` to take all states ([#81](https://github.com/tolitius/mount/issues/81))
+* goog.log/error for logging cljs errors ([#63](https://github.com/tolitius/mount/issues/63))
+* on failure (down) reports and cleans up vs. just "throw" ([#63](https://github.com/tolitius/mount/issues/63))
+* do not start a `DerefableState` as a side-effect of printing ([#76](https://github.com/tolitius/mount/issues/76))
+
+## 0.1.11
+###### Fri Dec 2 18:09:51 2016 -0600
+
+* opening `(find-all-states)`
+* stop accepts a collection of states (in addition to varargs) ([#69](https://github.com/tolitius/mount/issues/69))
+* swap-states and start-with-states take values ([#68](https://github.com/tolitius/mount/issues/68))
+* adding `(running-states)` that returns a set
+* `(mount/start #{})` is a noop ([#65](https://github.com/tolitius/mount/issues/65))
+* removing log on state discovery
+* adding a restart listener with watchers
+
+## 0.1.10
+###### Sun Feb 28 18:20:52 2016 -0500
+
+* runtime args are now initialized to `{}` (rather than to `:no-args`)
+* composing states on mount start ([#47](https://github.com/tolitius/mount/issues/47))
+* removing `:suspend` and `:resume` ([#46](https://github.com/tolitius/mount/issues/46))
+
+## 0.1.9
+###### Sun Jan 31 15:47:19 2016 -0500
+
+* `:on-reload` #{:noop :stop :restart} ([#36](https://github.com/tolitius/mount/issues/36))
 * swapping states with values ([#45](https://github.com/tolitius/mount/issues/45))
 * `(mount.core/system)` experiment is refactored to [Yurt](https://github.com/tolitius/yurt)
 * cleaning up deleted states ([#42](https://github.com/tolitius/mount/issues/42))

Makefile

@@ -0,0 +1,31 @@
+.PHONY: clean test jar tag outdated install deploy tree repl
+
+clean:
+	rm -rf target
+	rm -rf classes
+
+jar: clean test tag
+	clojure -A:jar
+
+test: clean
+	clojure -X:test :patterns '[".*"]'            # clojure tests
+	# clojure -Atest-cljs -r ".*test.self.host.*"   # clojure script tests
+	# run "j8; boot test-cljs" until running cljs tests via deps.edn is fixed
+
+outdated:
+	clojure -M:outdated
+
+tag:
+	clojure -A:tag
+
+install: jar
+	clojure -A:install
+
+deploy: jar
+	clojure -A:deploy
+
+tree:
+	mvn dependency:tree
+
+repl:
+	clojure -A:dev -A:repl

README.md

@@ -1,22 +1,13 @@
 > I think that it's _extraordinarily important_ that we in computer science keep fun in computing
 
-_**Alan J. Perlis** from [Structure and Interpretation of Computer Programs](https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-3.html)_
+_**Alan J. Perlis** from [Structure and Interpretation of Computer Programs](https://web.mit.edu/6.001/6.037/sicp.pdf)_
 
-# mount
+# mount <img src="doc/img/mount-logo.png" width="70px">
+[![<! release](https://img.shields.io/badge/dynamic/json.svg?label=release&url=https%3A%2F%2Fclojars.org%2Fmount%2Flatest-version.json&query=version&colorB=blue)](https://github.com/tolitius/mount/releases)
+[![<! clojars](https://img.shields.io/clojars/v/mount.svg)](https://clojars.org/mount)
 
-  module  |  branch  |  status
-----------|----------|----------
-   mount  | `master` | [![Circle CI](https://circleci.com/gh/tolitius/mount/tree/master.png?style=svg)](https://circleci.com/gh/tolitius/mount/tree/master)
-   mount  | `0.1.9-SNAPSHOT` | [![Circle CI](https://circleci.com/gh/tolitius/mount/tree/0.1.9-SNAPSHOT.png?style=svg)](https://circleci.com/gh/tolitius/mount/tree/0.1.9-SNAPSHOT)
+###### _any_ questions or feedback: [`#mount`](https://clojurians.slack.com/messages/mount/) clojurians slack channel <img src="doc/img/slack-icon.png" width="15px"> (or just [open an issue](https://github.com/tolitius/mount/issues))
 
-[![Clojars Project](http://clojars.org/mount/latest-version.svg)](http://clojars.org/mount)
-
-> <img src="doc/img/slack-icon.png" width="30px"> _any_ questions or feedback: [`#mount`](https://clojurians.slack.com/messages/mount/) clojurians slack channel (or just [open an issue](https://github.com/tolitius/mount/issues))
-
--
-
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
 **Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
 
 - [Why?](#why)
@@ -29,23 +20,25 @@ _**Alan J. Perlis** from [Structure and Interpretation of Computer Programs](htt
 - [Value of Values](#value-of-values)
 - [The Importance of Being Reloadable](#the-importance-of-being-reloadable)
 - [Start and Stop Order](#start-and-stop-order)
+- [Composing States](#composing-states)
 - [Start and Stop Parts of Application](#start-and-stop-parts-of-application)
 - [Start an Application Without Certain States](#start-an-application-without-certain-states)
-- [Stop an Application Except Certain States](#stop-an-application-except-certain-states)
 - [Swapping Alternate Implementations](#swapping-alternate-implementations)
   - [Swapping States with Values](#swapping-states-with-values)
   - [Swapping States with States](#swapping-states-with-states)
-- [Suspending and Resuming](#suspending-and-resuming)
-  - [Suspendable Lifecycle](#suspendable-lifecycle)
-  - [Plugging into (reset)](#plugging-into-reset)
-  - [Suspendable Example Application](#suspendable-example-application)
+- [Stop an Application Except Certain States](#stop-an-application-except-certain-states)
 - [ClojureScript is Clojure](doc/clojurescript.md#managing-state-in-clojurescript)
+- [cljc mode](#cljc-mode)
+  - [Disable Lazy Start](#disable-lazy-start)
 - [Packaging](#packaging)
 - [Affected States](#affected-states)
 - [Recompiling Namespaces with Running States](#recompiling-namespaces-with-running-states)
   - [:on-reload](#on-reload)
 - [Cleaning up Deleted States](#cleaning-up-deleted-states)
 - [Logging](#logging)
+  - [mount-up](#mount-up)
+  - [Manual AOP](#manual-aop)
+- [Exception Handling](#exception-handling)
 - [Clojure Version](#clojure-version)
 - [Mount and Develop!](#mount-and-develop)
   - [Running New York Stock Exchange](#running-new-york-stock-exchange)
@@ -94,15 +87,15 @@ Pull request away, let's solve this thing!
 Creating state is easy:
 
 ```clojure
-(defstate conn :start create-conn)
+(defstate conn :start (create-conn))
 ```
 
-where the `create-conn` function is defined elsewhere, can be right above it.
+where the `create-conn` function creates a connection (for example to a database) and is defined elsewhere, can be right above it.
 
 In case this state needs to be cleaned / destroyed between reloads, there is also `:stop`
 
 ```clojure
-(defstate conn :start create-conn
+(defstate conn :start (create-conn)
                :stop (disconnect conn))
 ```
 
@@ -110,7 +103,7 @@ That is pretty much it. But wait, there is more.. this state is _a top level bei
 `required` by other namespaces or in REPL:
 
 ```clojure
-dev=> (require '[app.nyse :refer [conn]])
+dev=> (require '[app.db :refer [conn]])
 nil
 dev=> conn
 #object[datomic.peer.LocalConnection 0x1661a4eb "datomic.peer.LocalConnection@1661a4eb"]
@@ -127,6 +120,22 @@ For example let's say an `app` needs a connection above. No problem:
 
 where `above` is an arbitrary namespace that defines the above state / connection.
 
+### Documentation String
+
+As in any definition (i.e. `def`, `defn`) a documentation string can be added to better describe a state:
+
+```clojure
+(defstate answer
+  "answer to the ultimate question of life universe and everything"
+  :start (+ 1 41))
+```
+```clojure
+(doc answer)
+-------------------------
+dev/answer
+  answer to the ultimate question of life universe and everything
+```
+
 ## Dependencies
 
 If the whole app is one big application context (or `system`), cross dependencies with a solid dependency graph
@@ -163,12 +172,13 @@ this `config`, being top level, can be used in other namespaces, including the o
 (defstate conn :start (create-connection config))
 ```
 
-[here](dev/clj/app/www.clj#L30)
-is an example of a web server that "depends" on a similar `config`.
+[here](dev/clj/app/www.clj#L32) is an example of a web server that "depends" on a similar `config`.
+
+###### _(the example `load-config` function above comes from [cprop](https://github.com/tolitius/cprop), but could of course be a custom function that loads configuration from a file)_
 
 ## Value of values
 
-Lifecycle functions start/stop/suspend/resume can take both functions and values. This is "valuable" and also works:
+Lifecycle functions start/stop can take both functions and values. This is "valuable" and also works:
 
 ```clojure
 (defstate answer-to-the-ultimate-question-of-life-the-universe-and-everything :start 42)
@@ -259,11 +269,75 @@ dev=> (reset)
 
 You can see examples of start and stop flows in the [example app](README.md#mount-and-develop).
 
+## Composing States
+
+Besides calling `(mount/start)` there are other useful ways to start an application:
+
+* [starting parts of an application](README.md#start-and-stop-parts-of-application)
+* [starting an application without certain states](README.md#start-an-application-without-certain-states)
+* [swapping alternate implementations](README.md#swapping-alternate-implementations)
+* [passing runtime arguments](README.md#runtime-arguments)
+
+While all of these are great by themselves, sometimes it is really handy to compose these super powers. For example to start an application with _only_ certain states, _swapping_ a couple of them for new values, while passing runtime _arguments_.
+
+### Composer's Toolbox
+
+Each "tool" has a single responsibility and can be composed with other tools in _any_ combination and order.
+
+* `only` will return _only_ states that it is given + exist (seen by mount) in the application
+* `except` will return all the states that it is given _except_ a given set
+* `swap` will take a map with keys as states and values as their substitute values
+* `swap-states` will take a map with keys as states and values with `{:start fn :stop fn}` as their substitute states
+* `with-args` will take a map that could later be accessed by `(mount/args)`
+
+All these functions take one or two arguments. If called with two arguments, the first one will be treated as the universe of states to work with. If called with one argument, it will work with _all known_ to mount states.
+
+None of these functions start or stop the application states, they merely serve as transformations from the initial set of states to the one that will later be passed to `(mount/start)`.
+
+### Be Composing
+
+All of the above is much easier to understand by looking at examples:
+
+```clojure
+(-> (only #{#'foo/a
+            #'foo/b
+            #'foo/c
+            #'bar/d
+            #'baz/e})
+    (except [#'foo/c
+             #'bar/d])
+    (with-args {:a 42})
+    mount/start)
+```
+
+This would start off from 5 states, even though the whole application may have many more states available. It would then exclude two states (i.e. `#'foo/c` and `#'bar/d`), then it will pass runtime arguments `{:a 42}`, and finally it will start the remaining three states: `#'foo/a`, `#'foo/b`, `#'baz/e`.
+
+You may notice that `only` takes a set, while `except` takes a vector in this example. This is done intentionally to demonstrate that both these functions can take any collection of states. `set` would make more sense for most cases though.
+
+Here is a more "involved" example:
+
+```clojure
+(-> (only #{#'foo/a
+            #'foo/b
+            #'foo/c
+            #'bar/d
+            #'baz/e})
+    (with-args {:a 42})
+    (except [#'foo/c
+             #'bar/d])
+    (swap-states {#'foo/a {:start #(create-connection test-conf)
+                           :stop #(disconnect a)}})
+    (swap {#'baz/e {:datomic {:uri "datomic:mem://composable-mount"}}})
+    mount/start)
+```
+
+This will do the same thing as the previous example plus it would swap `#'foo/a` with alternative `:start` and `:stop` functions and `#'baz/e` with `{:datomic {:uri "datomic:mem://composable-mount"}}` value before starting the application.
+
 ## Start and Stop Parts of Application
 
 In REPL or during testing it is often very useful to work with / start / stop _only a part_ of an application, i.e. "only these two states".
 
-`mount`'s lifecycle functions, i.e. start/stop/suspend/resume, can _optionally_ take states as vars (i.e. prefixed with their namespaces):
+`mount`'s lifecycle functions, i.e. start/stop, can _optionally_ take states as vars (i.e. prefixed with their namespaces):
 
 ```clojure
 (mount/start #'app.config/config #'app.nyse/conn)
@@ -296,14 +370,14 @@ During testing it is often very useful to mock/stub certain states. For example
 
 ### Swapping States with Values
 
-The `start-with` function takes values as substitues.
+The `start-with` function takes values as substitutes.
 
 Say we have a `send-sms` state:
 
 ```clojure
 (ns app.sms)
 ;; ...
-(defstate send-sms :start (create-sms-sender 
+(defstate send-sms :start (create-sms-sender
                             (:sms config)))
 ```
 
@@ -321,14 +395,21 @@ When running tests it would be great _not_ to send the real text messages, but r
 
 ### Swapping States with States
 
-The `start-with-states` function takes other states as substitues:
+The `start-with-states` function takes values in a form of `{:start fn :stop fn}` as substitutes:
 
 ```clojure
-(mount/start-with {#'app.neo/db        #'app.test/test-db
-                   #'app.neo/publisher #'app.test/test-publisher})
+(mount/start-with-states {#'app.neo/db        {:start #(connect test-config)
+                                               :stop #(disconnect db)}
+                          #'app.neo/publisher {:start #(create-pub test-config)
+                                               :stop #(close-pub publisher)}})
 ```
 
-`start-with-states` takes a map of states with their substitutes. For example `#'app.nyse/db` here is the real deal (remote) DB that is being substituted with `#'app.test/test-db` state, which could be anything, a map, an in memory DB, etc.
+`start-with-states` takes a map of states with their substitutes. For example `#'app.nyse/db` here is the real deal (remote) DB that is being
+substituted with `#(connect test-config)` function, which could end up being anything, a map, an in memory DB, etc.
+
+The `:stop` functions of substitutes can be anything, and could refer to the original state references. As in the example above: `db` and `publisher`
+are real references. They would need to be accessible from the namespace of course, so you might need to `(:require [app.neo :refer [db]])`
+in order to use `db` in `:stop #(disconnect db)` example above.
 
 --
 
@@ -378,80 +459,6 @@ dev=> (mount/start)
 
 Notice that the `nyse-app` is not started the second time (hence no more accidental `java.net.BindException: Address already in use`). It is already up and running.
 
-## Suspending and Resuming
-
-Besides starting and stopping states can also be suspended and resumed. While this is not needed most of the time, it does comes really handy _when_ this need is there. For example:
-
-* while working in REPL, you only want to truly restart a web server/queue listener/db connection _iff_ something changed, all other times `(mount/stop)` / `(mount/start)` or `(reset)` is called, these states should not be restarted. This might have to do with time to connect / bound ports / connection timeouts, etc..
-
-* when taking an application out of rotation in a data center, and then phasing it back in, it might be handy to still keep it _up_, but suspend all the client / novelty facing components in between.
-
-and some other use cases.
-
-### Suspendable Lifecycle
-
-In addition to `start` / `stop` functions, a state can also have `resume` and, if needed, `suspend` ones:
-
-```clojure
-(defstate web-server :start start-server
-                     :resume resume-server
-                     :stop stop-server)
-
-```
-
-`suspend` function is optional. Combining this with [(mount/stop-except)](#stop-an-application-except-certain-states), can result in an interesting restart behavior where everything is restared, but this `web-server` is _resumed_ instead (in this case `#'app.www/nyse-app` is an example of the above `web-server`):
-
-```clojure
-dev=> (mount/stop-except #'app.www/nyse-app)
-14:44:33.991 [nREPL-worker-1] INFO  mount.core - << stopping..  nrepl
-14:44:33.992 [nREPL-worker-1] INFO  mount.core - << stopping..  conn
-14:44:33.992 [nREPL-worker-1] INFO  app.db - disconnecting from  datomic:mem://mount
-14:44:33.992 [nREPL-worker-1] INFO  mount.core - << stopping..  config
-:stopped
-dev=>
-
-dev=> (mount/suspend)
-14:44:52.467 [nREPL-worker-1] INFO  mount.core - >> suspending..  nyse-app
-:suspended
-dev=>
-
-dev=> (mount/start)
-14:45:00.297 [nREPL-worker-1] INFO  mount.core - >> starting..  config
-14:45:00.297 [nREPL-worker-1] INFO  mount.core - >> starting..  conn
-14:45:00.298 [nREPL-worker-1] INFO  app.db - creating a connection to datomic: datomic:mem://mount
-14:45:00.315 [nREPL-worker-1] INFO  mount.core - >> resuming..  nyse-app
-14:45:00.316 [nREPL-worker-1] INFO  mount.core - >> starting..  nrepl
-:started
-```
-
-Notice `>> resuming..  nyse-app`, which in [this case](https://github.com/tolitius/mount/blob/suspendable/test/app/www.clj#L32) just recreates Datomic schema vs. doing that _and_ starting the actual web server.
-
-### Plugging into (reset)
-
-In case `tools.namespace` is used, this lifecycle can be easily hooked up with `dev.clj`:
-
-```clojure
-(defn start []
-  (mount/start))
-
-(defn stop []
-  (mount/suspend)
-  (mount/stop-except #'app.www/nyse-app))
-
-(defn reset []
-  (stop)
-  (tn/refresh :after 'dev/start))
-```
-
-### Suspendable Example Application
-
-An [example application](https://github.com/tolitius/mount/tree/suspendable/test/app) with a suspendable web server and `dev.clj` lives in the `suspendable` branch. You can clone mount and try it out:
-
-```
-$ git checkout suspendable
-Switched to branch 'suspendable'
-```
-
 ## Recompiling Namespaces with Running States
 
 Mount will detect when a namespace with states (i.e. with `(defstate ...)`) was reloaded/recompiled,
@@ -473,28 +480,30 @@ Providing a `:stop` function _is_ optional, but in case a state needs to be clea
 
 ### :on-reload
 
-By default a state will be restarted on its redefenition or a namespace recompilation. However it is not always a desired behavior. Sometimes it's ok to have stale references during REPL sessions / development, other times all that is needed is not a "restart", but just a "stop".
+By default a state will be restarted on its redefinition or a namespace recompilation. However it is not always a desired behavior. Sometimes it's ok to have stale references during REPL sessions / development, other times all that is needed is not a "restart", but just a "stop".
 
-This behavior could be conrolled with an optional `:on-reload` meta attribute when defining a state. 
+This behavior could be controlled with an optional `:on-reload` meta attribute when defining a state.
 
 In case _nothing_ needs to be done to a running state on reload / recompile / redef, set `:on-reload` to `:noop`:
 
 ```clojure
-(defstate ^{:on-reload :noop} 
-          mem-db :start (connect config) 
+(defstate ^{:on-reload :noop}
+          mem-db :start (connect config)
                  :stop (disconnect mem-db))
 ```
 
 When a running state needs to be just "stopped" on reload, set `:on-reload` to `:stop`:
 
 ```clojure
-(defstate ^{:on-reload :stop} 
-          mem-db :start (connect config) 
+(defstate ^{:on-reload :stop}
+          mem-db :start (connect config)
                  :stop (disconnect mem-db))
 ```
 
 Again, by default, if no `:on-reload` meta is added, internally it would be set to `:restart`, in which case a running state will be restarted on a redef / a namespace reload.
 
+Note that `^{:on-reload :noop}` will disable stopping or starting the state on namespace recompilation but it will still obey `(mount/start)` / `(mount/stop)` calls. This means that if any of the namespaces with `(mount/start)` / `(mount/stop)` calls are reloaded or these calls are explicitely executed (i.e. somewhere in the `dev` namespace or in an `:after` clause), the state's start/stop functions will still be called.
+
 ## Cleaning up Deleted States
 
 Mount will detect when a state was renamed/deleted from a namespace, and will do two things:
@@ -505,7 +514,7 @@ Mount will detect when a state was renamed/deleted from a namespace, and will do
 Here is an example:
 
 ```clojure
-dev=> (defstate won't-be-here-long :start (println "I am starting... ") 
+dev=> (defstate won't-be-here-long :start (println "I am starting... ")
                                    :stop (println "I am stopping... "))
 #'dev/won't-be-here-long
 dev=>
@@ -539,6 +548,56 @@ Mount detected that `#'dev/won't-be-here-long` was deleted, hence:
 << stopping.. #'dev/won't-be-here-long (it was deleted)
 ```
 
+## `cljc` mode
+
+By default mount states are kept under var references. While it works for Clojure, it falls short in the land of ClojureScript since, especially during an `:advanced` compilation, var names get compressed + ClojureScript does not support reified vars.
+
+To support both Clojure and ClojureScript mount has a `cljc` mode which is well documented in [here](doc/clojurescript.md#managing-state-in-clojurescript), and can be enabled by `(mount/in-cljc-mode)`.
+
+### Disable Lazy Start
+
+When in `cljc` mode, mount states that are not started by `(mount/start a b c)`, or that are not transitive states: i.e. not `:require`d at the time `(mount/start)` is called, will start lazily whenever they are dereferenced:
+
+```clojure
+=> (mount/in-cljc-mode)
+:cljc
+
+=> (defstate db-connection :start (println "connecting")
+                           :stop (println "disconnecting..."))
+
+=> db-connection
+#object[mount.core.DerefableState 0x546b9d51 {:status :pending, :val nil}]
+
+dev=> (mount/running-states)
+#{}
+
+dev=> @db-connection   ;;   db-connection will start here when deref'ed even though it was not started explicitly
+connecting
+
+dev=> (mount/running-states)
+#{"#'dev/db-connection"}
+```
+
+This can be quite handy as it allows certain app states to start lazily.
+
+However there are cases when it is best to fail in case a certain state is deref'ed while it was not yet started. This is possible by marking such states with `^{:on-lazy-start :throw}` metadata:
+
+```clojure
+=> (defstate ^{:on-lazy-start :throw} db-connection :start (do (println "connecting") 42)
+                                                    :stop (println "disconnecting..."))
+
+=> @db-connection   ;;   this will throw since db connection is deref'ed before it was started
+
+java.lang.RuntimeException: :on-lazy-start is set to :throw i.e. (defstate {:on-lazy-start :throw} #'dev/db-connection...) and #'dev/db-connection state was not explicitly started before it was deref'ed (i.e. @#'dev/db-connection)
+
+=> (mount/start #'dev/db-connection)
+connecting
+{:started ["#'dev/db-connection"]}
+
+=> @db-connection
+42
+```
+
 ## Packaging
 
 Since `mount` relies on the Clojure/Script Compiler to learn about all the application states, before `mount/start` is called all the namespaces that have `defstate`s need to be compiled.
@@ -566,28 +625,22 @@ In practice only a few namespaces need to be `:require`d, since others will be b
 
 ## Affected States
 
-Every time a lifecycle function (start/stop/suspend/resume) is called mount will return all the states that were affected:
+Every time a lifecycle function (start/stop) is called mount will return all the states that were affected:
 
 ```clojure
 dev=> (mount/start)
 {:started [#'app.config/config
            #'app.nyse/conn
-           #'app/nrepl
-           #'check.suspend-resume-test/web-server
-           #'check.suspend-resume-test/q-listener]}
+           #'app/nrepl]}
 ```
 ```clojure
-dev=> (mount/suspend)
-{:suspended [#'check.suspend-resume-test/web-server
-             #'check.suspend-resume-test/q-listener]}
-```
-```clojure
-dev=> (mount/start)
-{:started [#'check.suspend-resume-test/web-server
-           #'check.suspend-resume-test/q-listener]}
+dev=> (mount/stop)
+{:stopped [#'app/nrepl
+           #'app.nyse/conn
+           #'app.config/config]}
 ```
 
-An interesting bit here is a vector vs. a set: all the states are returned _in the order they were changed_.
+An interesting bit here is a vector vs. a set: all the states are returned _in the order they were affected_.
 
 ## Logging
 
@@ -597,13 +650,39 @@ Valid question. It was a [conscious choice](https://github.com/tolitius/mount/is
 
 Since mount is a _library_ it should _not_ bring any dependencies unless its functionality directly depends on them.
 
-> But I still these logging statements in the examples.
+> _But I still these logging statements in the examples..._
 
-The way this is done is via an excellent [robert hooke](https://github.com/technomancy/robert-hooke/). Example applications live in `test`, so does the [utility](https://github.com/tolitius/mount/blob/75d7cdc610ce38623d4d3aea1da3170d1c9a3b4b/test/app/utils/logging.clj#L44) that adds logging to all the mount's lifecycle functions on start in [dev.clj](https://github.com/tolitius/mount/blob/75d7cdc610ce38623d4d3aea1da3170d1c9a3b4b/dev/dev.clj#L21).
+### mount-up
+
+One way to do that would be using "[mount-up](https://github.com/tolitius/mount-up)" that "watches mount's ups and downs":
+
+```clojure
+=> (require '[mount-up.core :as mu])
+
+=> (mu/on-upndown :info mu/log :before)
+
+=> (mount/start)
+INFO  mount-up.core - >> starting.. #'boot.user/server
+{:started ["#'boot.user/server"]}
+
+=> (mount/stop)
+INFO  mount-up.core - << stopping.. #'boot.user/server
+{:stopped ["#'boot.user/server"]}
+```
+
+### Manual AOP
+
+Another, a more manual way, would be to do it via an excellent [robert hooke](https://github.com/technomancy/robert-hooke/). Example applications live in `test`, so does the [utility](test/clj/tapp/utils/logging.clj#L42) that adds logging to all the mount's lifecycle functions on start in [dev.clj](https://github.com/tolitius/mount/blob/75d7cdc610ce38623d4d3aea1da3170d1c9a3b4b/dev/dev.clj#L21).
+
+## Exception Handling
+
+One way to handle exceptions on start/stop would be to simply wrap start/stop functions in `try/catch`.
+
+Another way would be to use a custom [mount-up](https://github.com/tolitius/mount-up/blob/master/README.md#wrapping) wrapper.
 
 ## Clojure Version
 
-Since mount [supports both](doc/clojurescript.md#managing-state-in-clojurescript) Clojure and CljoureScript, it relies on [Reader Conditionals](http://clojure.org/reader#The%20Reader--Reader%20Conditionals) that were introduced in `Clojure 1.7`. mount's code is not precompiled (i.e. AOT) and distributed in `.cljc` sources, hence it currently requires `Clojure 1.7` and above.
+Since mount [supports both](doc/clojurescript.md#managing-state-in-clojurescript) Clojure and ClojureScript, it relies on [Reader Conditionals](http://clojure.org/reader#The%20Reader--Reader%20Conditionals) that were introduced in `Clojure 1.7`. mount's code is not precompiled (i.e. AOT) and distributed in `.cljc` sources, hence it currently requires `Clojure 1.7` and above.
 
 ## Mount and Develop!
 
@@ -674,7 +753,7 @@ dev=> (find-orders conn "TSLA")
 ({:db/id 17592186045422, :order/symbol "TSLA", :order/bid 232.38M, :order/qty 100, :order/offer 232.43M})
 ```
 
-once something is changed in the code, or you just need to reload everything, do `(reset)`. 
+once something is changed in the code, or you just need to reload everything, do `(reset)`.
 
 _note: a simple `(mount/stop)` / `(mount/start)` will also work, `(reset)` is for "convenience + ns refresh":_
 
@@ -723,7 +802,7 @@ dev=> (find-orders conn "TSLA")
 
 ### New York Stock Exchange Maintenance
 
-Say we want to leave the exchange functioning, but would like to make sure that noone can hit it from the web. Easy, just stop the web server:
+Say we want to leave the exchange functioning, but would like to make sure that no one can hit it from the web. Easy, just stop the web server:
 
 ```clojure
 dev=> (mount/stop #'app.www/nyse-app)
@@ -782,7 +861,7 @@ The documentation is [here](doc/runtime-arguments.md#passing-runtime-arguments).
 
 ## License
 
-Copyright © 2015 tolitius
+Copyright © 2020 tolitius
 
 Distributed under the Eclipse Public License either version 1.0 or (at
 your option) any later version.

boot.properties

@@ -0,0 +1,2 @@
+BOOT_VERSION=2.7.1
+BOOT_CLOJURE_VERSION=1.10.1

build.boot

@@ -1,40 +1,56 @@
-(def +version+ "0.1.9")
+(def +version+ "0.1.18")
+
+;; -- since boot is no more, this file will go away
+;; -- once deps.edn "learns" how to run all cljs tests
+
+;; j8; boot test
+;; j8; boot test-cljs
+;; j8; boot test-cljs-advanced
+;; j8; boot -v build-jar push-snapshot
+;; j8; boot -v build-jar push-release
 
 (set-env!
   :source-paths #{"src"}
-  :dependencies '[;; mount brings _no dependencies_, everything here is for
+  :resource-paths #{"resources"}
+  :dependencies '[;; mount brings _NO DEPENDENCIES_, everything here is for
                   ;; mount dev, examples apps and tests
 
-                  [org.clojure/clojure "1.7.0"              :scope "provided"]
-                  [org.clojure/clojurescript "1.7.189"      :scope "provided" :classifier "aot"]
-                  [datascript "0.13.3"                      :scope "provided"]
-                  [compojure "1.4.0"                        :scope "provided"]
+                  [org.clojure/clojure "1.8.0"              :scope "provided"]
+                  [org.clojure/clojurescript "1.7.228"      :scope "provided" :classifier "aot"]
+                  [datascript "0.15.0"                      :scope "provided"]
+                  [compojure "1.5.0"                        :scope "provided"]
                   [ring/ring-jetty-adapter "1.1.0"          :scope "provided"]
                   [cheshire "5.5.0"                         :scope "provided"]
                   [hiccups "0.3.0"                          :scope "provided" :exclusions [org.clojure/clojurescript]]
                   [com.andrewmcveigh/cljs-time "0.3.14"     :scope "provided"]
+                  [tolitius/yang "0.1.9"                    :scope "provided"]
                   [ch.qos.logback/logback-classic "1.1.3"   :scope "provided"]
                   [org.clojure/tools.logging "0.3.1"        :scope "provided"]
                   [robert/hooke "1.3.0"                     :scope "provided"]
                   [org.clojure/tools.namespace "0.2.11"     :scope "provided"]
                   [org.clojure/tools.nrepl "0.2.12"         :scope "provided"]
-                  [com.datomic/datomic-free "0.9.5327"      :scope "provided" :exclusions [joda-time]]
+                  [com.datomic/datomic-free "0.9.5359"      :scope "provided" :exclusions [joda-time]]
+
+                  ;; proto repl for fun and joy
+                  [proto-repl               "0.3.1"         :scope "provided"]
+                  [proto-repl-charts        "0.3.2"         :scope "provided"]
 
                   ;; boot clj
-                  [boot/core              "2.5.1"           :scope "provided"]
+                  [boot/core              "2.7.1"           :scope "provided"]
                   [adzerk/bootlaces       "0.1.13"          :scope "test"]
-                  [adzerk/boot-logservice "1.0.1"           :scope "test"]
-                  [adzerk/boot-test       "1.0.6"           :scope "test"]
-                  [tolitius/boot-check    "0.1.1"           :scope "test"]
+                  [adzerk/boot-logservice "1.2.0"           :scope "test"]
+                  [adzerk/boot-test       "1.1.1"           :scope "test"]
+                  [tolitius/boot-check    "0.1.2"           :scope "test"]
 
                   ;; boot cljs
-                  [adzerk/boot-cljs            "1.7.170-3"       :scope "test"]
-                  [adzerk/boot-cljs-repl       "0.3.0"           :scope "test"]
+                  [adzerk/boot-cljs            "1.7.228-1"       :scope "test"]
+                  [adzerk/boot-cljs-repl       "0.4.0"           :scope "test"]
+                  [cider/piggieback            "0.3.9"           :scope "test" :exclusions [org.clojure/clojurescript]]
+                  [weasel                      "0.7.0"           :scope "test" :exclusions [org.clojure/clojurescript]]
+                  [nrepl                       "0.4.5"           :scope "test"]
                   [pandeiro/boot-http          "0.7.1-SNAPSHOT"  :scope "test"]
                   [tolitius/boot-stripper      "0.1.0-SNAPSHOT"  :scope "test"]
-                  [com.cemerick/piggieback     "0.2.1"           :scope "test" :exclusions [org.clojure/clojurescript]]
-                  [weasel                      "0.7.0"           :scope "test" :exclusions [org.clojure/clojurescript]]
-                  [adzerk/boot-reload          "0.4.2"           :scope "test"]
+                  [adzerk/boot-reload          "0.4.8"           :scope "test"]
                   [crisptrutski/boot-cljs-test "0.2.1-SNAPSHOT"  :scope "test"]])
 
 (require '[adzerk.bootlaces :refer :all]
@@ -62,7 +78,7 @@
 (deftask dev []
   (set-env! :source-paths #(conj % "dev/clj" "dev/cljs"))
 
-  (alter-var-root #'log/*logger-factory* 
+  (alter-var-root #'log/*logger-factory*
                   (constantly (log-service/make-factory log4b)))
   (apply set-refresh-dirs (get-env :directories))
   (load-data-readers!)
@@ -80,7 +96,7 @@
 
   (require '[mount.core])
 
-  (comp 
+  (comp
     (strip-deps-attr :attr :classifier :value "aot")
     (tcs/test-cljs ;; :optimizations :advanced
                    :out-file "mount.js")))
@@ -88,7 +104,7 @@
 (deftask test-cljs-advanced []
   (set-env! :source-paths #(conj % "dev/clj" "dev/cljs"))
   (set-env! :resource-paths #{"dev/resources"})
-  
+
   (comp
     (cljs :optimizations :advanced :ids #{"mount"})))
 
@@ -114,7 +130,7 @@
     (cljs-repl)
     (cljs :optimizations :none :ids #{"mount"})))
 
-(deftask cljs-example 
+(deftask cljs-example
   "mount cljs example"
   []
   (set-env! :source-paths #(conj % "dev/clj" "dev/cljs"))
@@ -127,7 +143,9 @@
     (cljs :optimizations :advanced :ids #{"mount"})))
 
 (task-options!
-  push {:ensure-branch nil}
+  tcs/test-cljs {:js-env :phantom}
+  push {; :ensure-clean nil
+        :ensure-branch nil}
   pom {:project     'mount
        :version     +version+
        :description "managing Clojure and ClojureScript app state since (reset)"

circle.yml

@@ -1,15 +0,0 @@
-machine:
-  java:
-    version: oraclejdk8
-
-dependencies:
-  pre:
-    - wget https://github.com/boot-clj/boot-bin/releases/download/2.5.2/boot.sh
-    - mv boot.sh boot && chmod a+x boot && sudo mv boot /usr/local/bin
-
-test:
-  override:
-    - boot test
-    - boot test-cljs
-    - boot test-cljs-advanced
-    - lein test2junit

deps.edn

@@ -0,0 +1,52 @@
+{:paths ["src" "resources"]
+
+ :deps {} ;; deps no deps
+
+ :aliases {:dev {:extra-deps {metosin/jsonista {:mvn/version "0.3.8"}
+                              com.datomic/datomic-free {:mvn/version "0.9.5359"
+                                                        :exclusions [joda-time/joda-time]}
+                              org.clojure/tools.nrepl {:mvn/version "0.2.12"}
+                              org.clojure/tools.namespace {:mvn/version "0.2.11"}
+                              cheshire/cheshire {:mvn/version "5.5.0"}
+                              compojure/compojure {:mvn/version "1.5.0"}
+                              ring/ring-jetty-adapter {:mvn/version "1.1.0"}
+                              robert/hooke {:mvn/version "1.3.0"}
+                              proto-repl/proto-repl {:mvn/version "0.3.1"}
+                              proto-repl-charts/proto-repl-charts {:mvn/version "0.3.2"}
+                              nrepl/nrepl {:mvn/version "0.7.0"}}}
+           :test {:extra-paths ["test/core" "test/clj" "test/cljs" "test/resources"]
+                  :extra-deps {com.datomic/datomic-free {:mvn/version "0.9.5359"
+                                                         :exclusions [joda-time/joda-time]}
+                               org.clojure/tools.nrepl {:mvn/version "0.2.12"}
+                               robert/hooke {:mvn/version "1.3.0"}
+                               org.clojure/tools.logging {:mvn/version "1.3.0"}
+                               io.github.cognitect-labs/test-runner {:git/url "https://github.com/cognitect-labs/test-runner.git"
+                                                                     :sha "e7660458ce25bc4acb4ccc3e2415aae0a4907198"}}
+                  :main-opts ["-m" "cognitect.test-runner"]
+                  :exec-fn cognitect.test-runner.api/test}
+           :test-cljs {:extra-paths ["test/core" "test/cljs" "test/resources"]
+                       :extra-deps {org.clojure/clojure {:mvn/version "1.8.0"}
+                                    org.clojure/clojurescript {:mvn/version "1.7.228"}
+                                    com.andrewmcveigh/cljs-time {:mvn/version "0.3.14"}
+                                    hiccups/hiccups {:mvn/version "0.3.0"}
+                                    datascript/datascript {:mvn/version "0.15.0"}
+                                    olical/cljs-test-runner {:mvn/version "3.8.1"}}
+                       :main-opts ["-m" "cljs-test-runner.main"]}
+           :repl {:extra-paths ["dev/clj"]
+                  :extra-deps {cider/cider-nrepl {:mvn/version "0.22.4"}
+                               org.clojure/tools.logging {:mvn/version "1.2.4"}
+                               com.bhauman/rebel-readline {:mvn/version "0.1.4"}}
+                  :main-opts ["-e" "(require 'dev)(in-ns 'dev)"
+                              "-m" "nrepl.cmdline" "--middleware" "[cider.nrepl/cider-middleware]"
+                              "-i" "-f" "rebel-readline.main/-main"]}
+           :outdated {:extra-deps {olical/depot {:mvn/version "2.0.1"}}
+                      :main-opts  ["-m" "depot.outdated.main" "-a" "outdated"]}
+           :tag {:extra-deps {tolitius/tag {:mvn/version "0.1.7"}}
+                 :main-opts ["-m" "tag.core" "tolitius/mount" "managing Clojure and ClojureScript app state since (reset)"]}
+           :jar {:extra-deps {seancorfield/depstar {:mvn/version "1.1.128"}}
+                 :extra-paths ["target/about"]
+                 :main-opts ["-m" "hf.depstar.jar" "target/mount.jar" "--exclude" "clojure/core/specs/alpha.*"]}
+           :deploy {:extra-deps {deps-deploy/deps-deploy {:mvn/version "RELEASE"}}
+                    :main-opts ["-m" "deps-deploy.deps-deploy" "deploy" "target/mount.jar"]}
+           :install {:extra-deps {deps-deploy/deps-deploy {:mvn/version "RELEASE"}}
+                     :main-opts ["-m" "deps-deploy.deps-deploy" "install" "target/mount.jar"]}}}

dev/clj/app/conf.clj

@@ -5,9 +5,9 @@
 
 (defn load-config [path]
   (info "loading config from" path)
-  (-> path 
-      slurp 
+  (-> path
+      slurp
       edn/read-string))
 
-(defstate config 
+(defstate config
   :start (load-config "dev/resources/config.edn"))

dev/clj/app/db.clj

@@ -1,4 +1,4 @@
-(ns app.db 
+(ns app.db
   (:require [mount.core :refer [defstate]]
             [datomic.api :as d]
             [clojure.tools.logging :refer [info]]
@@ -34,7 +34,7 @@
                  :db/valueType :db.type/bigdec
                  :db/cardinality :db.cardinality/one
                  :db.install/_attribute :db.part/db}
-                
+
                 {:db/id #db/id [:db.part/db]
                  :db/ident :order/qty
                  :db/valueType :db.type/long

dev/clj/app/nyse.clj

@@ -11,6 +11,6 @@
 
 (defn find-orders [conn ticker]
   (let [orders (d/q '[:find ?e :in $ ?ticker
-                      :where [?e :order/symbol ?ticker]] 
+                      :where [?e :order/symbol ?ticker]]
                     (d/db conn) ticker)]
     (touch conn orders)))

dev/clj/app/utils/logging.clj

@@ -1,4 +1,4 @@
-(ns app.utils.logging          ;; << change to your namespace/path 
+(ns app.utils.logging          ;; << change to your namespace/path
   (:require [mount.core]
             [robert.hooke :refer [add-hook clear-hooks]]
             [clojure.string :refer [split]]
@@ -6,41 +6,38 @@
 
 (alter-meta! *ns* assoc ::load false)
 
-(defn- f-to-action [f]
+(defn- f-to-action [f {:keys [status]}]
   (let [fname (-> (str f)
                   (split #"@")
                   first)]
     (case fname
-      "mount.core$up" :up
-      "mount.core$down" :down
-      "mount.core$sigstop" :suspend
-      "mount.core$sigcont" :resume
+      "mount.core$up" (when-not (:started status) :up)
+      "mount.core$down" (when-not (:stopped status) :down)
       :noop)))
 
-(defn whatcha-doing? [{:keys [status suspend]} action]
+(defn whatcha-doing? [action]
   (case action
-    :up (if (status :suspended) ">> resuming" 
-          (if-not (status :started) ">> starting"))
-    :down (if (or (status :started) (status :suspended)) "<< stopping")
-    :suspend (if (and (status :started) suspend) "<< suspending")
-    :resume (if (status :suspended) ">> resuming")))
+    :up ">> starting"
+    :down "<< stopping"
+    false))
 
-(defn log-status [f & args] 
-  (let [{:keys [var] :as state} (second args)
-        action (f-to-action f)] 
-    (when-let [taking-over-the-world (whatcha-doing? state action)]
-      (info (str taking-over-the-world "..  " var)))
+(defn log-status [f & args]
+  (let [[state-name state] args
+        action (f-to-action f state)]
+    (when-let [taking-over-the-world (whatcha-doing? action)]
+      (info (str taking-over-the-world ".. " state-name)))
     (apply f args)))
 
 (defonce lifecycle-fns
   #{#'mount.core/up
-    #'mount.core/down
-    #'mount.core/sigstop
-    #'mount.core/sigcont})
+    #'mount.core/down})
 
 (defn without-logging-status []
   (doall (map #(clear-hooks %) lifecycle-fns)))
 
+
+;; this is the one to use:
+
 (defn with-logging-status []
   (without-logging-status)
   (doall (map #(add-hook % log-status) lifecycle-fns)))

dev/clj/app/www.clj

@@ -14,10 +14,10 @@
   (GET "/nyse/orders/:ticker" [ticker]
        (generate-string (find-orders conn ticker)))
 
-  (POST "/nyse/orders" [ticker qty bid offer] 
-        (let [order {:ticker ticker 
-                     :bid (bigdec bid) 
-                     :offer (bigdec offer) 
+  (POST "/nyse/orders" [ticker qty bid offer]
+        (let [order {:ticker ticker
+                     :bid (bigdec bid)
+                     :offer (bigdec offer)
                      :qty (Integer/parseInt qty)}]
           (add-order conn order)
           (generate-string {:added order}))))

dev/clj/dev.clj

@@ -1,7 +1,6 @@
 (ns dev
   (:require [clojure.pprint :refer [pprint]]
             [clojure.tools.namespace.repl :as tn]
-            [boot.core :refer [load-data-readers!]]
             [mount.core :as mount :refer [defstate]]
             [mount.tools.graph :refer [states-with-deps]]
             [app.utils.logging :refer [with-logging-status]]
@@ -41,4 +40,11 @@
   (tn/refresh :after 'dev/go))
 
 (mount/in-clj-mode)
+
+(defn load-data-readers!
+  "Refresh *data-readers* with readers from newly acquired dependencies."
+  []
+  (#'clojure.core/load-data-readers)
+  (set! *data-readers* (.getRawRoot #'*data-readers*)))
+
 (load-data-readers!)

dev/clj/proto_play.clj

@@ -0,0 +1,15 @@
+(ns proto-play
+  (:require [mount.tools.graph :as mg]
+            [proto-repl-charts.graph :as proto]))
+
+(defn mount->proto [graph]
+  (reduce (fn [g {:keys [name deps]}]
+            (-> g
+                (update :nodes conj name)
+                (update :edges conj (-> deps (conj name) vec))))
+          {}
+          graph))
+
+(->> (mg/states-with-deps)
+     mount->proto
+     (proto/graph "a proto graph of mount states"))

dev/cljs/app/audit_log.cljs

@@ -13,13 +13,13 @@
 
 (defn find-source-logs [db source]
   (d/q '{:find [?t ?msg]
-         :in [$ ?s] 
+         :in [$ ?s]
          :where [[?e :source ?s]
                  [?e :timestamp ?t]
                  [?e :msg ?msg]]}
        @@db source))
 
 (defn find-all-logs [db]
-  (->> (map :e (d/datoms @@db :aevt :timestamp)) 
+  (->> (map :e (d/datoms @@db :aevt :timestamp))
        dedupe
        (d/pull-many @@db '[:timestamp :source :msg])))

dev/cljs/app/example.cljs

@@ -12,7 +12,7 @@
                 " → [" (name source) "]: " msg))
 
 (defn show-log []
-  (.write js/document 
+  (.write js/document
     (html [:ul (doall (for [e (find-all-logs log)]
                  [:li (format-log-event e)]))])))
 

dev/resources/config.edn

@@ -1,4 +1,4 @@
-{:datomic 
+{:datomic
  {:uri "datomic:mem://mount"}
 
  :www {:port 4242}

doc/clojurescript.md

@@ -8,7 +8,7 @@
   - [Using States](#using-states)
 - [Thanks](#thanks)
 
-In case you need to manage state in ClojureScript using mount, _all_ the mount Clojure features are supported in ClojureScript. 
+In case you need to manage state in ClojureScript using mount, _all_ the mount Clojure features are supported in ClojureScript.
 Which means all the mount Clojure [documentation](../README.md) is the mount ClojureScript documentation.
 
 With a slight change in [_mode_](clojurescript.md#mount-modes) ( no change in _mood_ though, just the _mode_ :)).
@@ -16,19 +16,19 @@ With a slight change in [_mode_](clojurescript.md#mount-modes) ( no change in _m
 ### The "Why"
 
 Since [reader conditionals](http://clojure.org/reader#The%20Reader--Reader%20Conditionals) were added in Clojure 1.7,
-it became a lot easier to target both platforms with lots of code reuse. You might have noticed 
+it became a lot easier to target both platforms with lots of code reuse. You might have noticed
 that most of mount code lives in `.cljc` files.
 
-The way mount is designed it "mounts" itself to a solid Clojure [namespace API](http://clojure.org/namespaces), 
+The way mount is designed it "mounts" itself to a solid Clojure [namespace API](http://clojure.org/namespaces),
 and while `.cljc` helps a lot with targeting Clojure and ClojureScript, JavaScript VM is vastly different from JVM.
-Since JavaScript mostly tagrets browsers, mobile devices and IoT, 
+Since JavaScript mostly tagrets browsers, mobile devices and IoT,
 it is quite important to [compress](https://github.com/clojure/clojurescript/wiki/Advanced-Compilation) the final result.
 
 Which means that Clojure namespaces API are not that well supported in ClojureScript, since they get renamed and optimized
-during compilation + of course no native namespace support on the JavaScript side 
+during compilation + of course no native namespace support on the JavaScript side
 (but that is somewhat solved with [Google Closure](https://closure-library.googlecode.com/git-history/docs/local_closure_goog_base.js.source.html#line428)).
 
-But. When developing an application in Clojure and ClojureScript, it would only make sense if the API for any library 
+But. When developing an application in Clojure and ClojureScript, it would only make sense if the API for any library
 would be _identical_ for both platforms. It should be transparent for developers whether they use a library in Clojure or ClojureScript.
 It is not possible for all libraries (i.e. concurrency, reified Vars, etc.), but we should try to make it possible for most.
 
@@ -42,7 +42,7 @@ Mount has two modes `clj` and `cljc`.
 
 #### Clojure _and_ ClojureScript Mode
 
-`cljc` mode is is not default, but it is easy to switch to:
+`cljc` is not a default mode, but it is easy to switch to:
 
 To switch Mount into this mode do:
 
@@ -52,7 +52,7 @@ To switch Mount into this mode do:
 
 anywhere before a call to `(mount/start)`, usually at the entry point of an app: in the `-main`, web handler, etc.
 
-This sets mount into the `cljc` mode. In this mode mount supports _both_: Clojure and ClojureScript with one difference 
+This sets mount into the `cljc` mode. In this mode mount supports _both_: Clojure and ClojureScript with one difference
 from the default `clj` mode:
 
 > all states are "_derefable_"
@@ -83,14 +83,16 @@ Let's look at the example [ClojureScript app](../dev/cljs/app) that uses mount t
 
 In order to run it, just compile `cljs` (in `:advanced` mode, because why not? :)) with:
 
-```clojure
-$ lein do clean, cljsbuild once prod
+```
+$ boot cljs-example
+Started Jetty on http://localhost:3000
+nREPL server started on port 64412 on host 127.0.0.1 - nrepl://127.0.0.1:64412
+Adding :require adzerk.boot-cljs-repl to mount.cljs.edn...
 Compiling ClojureScript...
-Compiling "dev/resources/public/js/compiled/mount.js" from ["src" "dev/cljs"]...
-Successfully compiled "dev/resources/public/js/compiled/mount.js" in 23.966 seconds.
+• mount.js
 ```
 
-And just open a browser at `file:///[path-to-mount]/mount/dev/resources/public/index.html`:
+And just open a browser at [http://localhost:3000](http://localhost:3000):
 
 <img src="img/mount.cljs.example.png" width="700">
 

doc/differences-from-component.md

@@ -31,9 +31,7 @@ The not so hidden benefit is REPL time reloadability that it brings to the table
   - [Boilerplate code](#boilerplate-code)
   - [Library vs. Framework](#library-vs-framework)
 - [What Component does better](#what-component-does-better)
-  - [Swapping alternate implementations](#swapping-alternate-implementations)
-  - [Uberjar / Packaging](#uberjar--packaging)
-  - [Multiple separate systems](#multiple-separate-systems)
+  - [Multiple separate systems within the same JVM](#multiple-separate-systems-within-the-same-jvm)
   - [Visualizing dependency graph](#visualizing-dependency-graph)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
@@ -57,7 +55,7 @@ Before moving on to differences, [here](https://news.ycombinator.com/item?id=246
 Component really only works if you build your entire app around its model: application is fully based on Components 
 where every Component is an Object.
 
-Mount does not require you to "buy anything at all", it is free :) Just create a `defstate` whenever/whereever 
+Mount does not require you to "buy anything at all", it is free :) Just create a `defstate` whenever/wherever 
 you need it and use it.
 
 This one was a big deal for all the projects we used Component with, "the whole app buy in" converts an "_open_" application 
@@ -96,7 +94,7 @@ the same with or without Mount: there are no extra mental steps.
 ### Objects vs. Namespaces
 
 One thing that feels a bit "unClojure" about Component is "Objects". Objects everywhere, and Objects for everything.
-This is how Component "separates explicit dependencies" and "clears the bounaries". 
+This is how Component "separates explicit dependencies" and "clears the boundaries". 
 
 This is also how an Object Oriented language does it, which does not leave a lot of room for functions: 
 with Component most of the functions are _methods_ which is an important distinction.
@@ -148,48 +146,23 @@ no "ceremony".
 
 Mount uses namespaces and vars where Component uses records and protocols.
 
-Component manages protocols and records, and in order to do that it requires a whole app buyin, which makes it a _framework_. 
+Component manages records and protocols, 
+and in order to do that it requires a whole app buy-in, 
+which makes it a _framework_. 
 
-Mount does not need to manage namespaces and vars, since it is very well managed by the Clojure Compiler, which makes it a _library_.
+Mount does not need to manage namespaces and vars, 
+since it is very well managed by the Clojure Compiler, 
+which makes it a _library_.
 
 ## What Component does better
 
-### Swapping alternate implementations
+### Multiple separate systems within the same JVM
 
-This is someting that is very useful for testing and is very easy to do in Component by simply assoc'ing onto a map.
+With Component multiple separate systems can be started _in the same Clojure runtime_ with different settings. Which _might_ be useful for testing, i.e. if you need to have `dev db` and `test db` started in the _same_ REPL, to _run tests within the same REPL you develop in_.
 
-Mount can do it too: https://github.com/tolitius/mount#swapping-alternate-implementations
+Development workflows vary and tend to be a subjective / preference based more than a true recipe, but I believe it is much cleaner to run tests in the _separate_ REPL / process. Moreover run them continuously: i.e. `boot watch speak test`: this way you don't event need to look at that other REPL / terminal, Boot will _tell_ you whether the tests pass or fail after any file is changed.
 
-The reason it is in "Component does it better" section is because, while result is the same, merging maps is a bit simpler than:
-
-```clojure
-(mount/start-with {#'app.nyse/db        #'app.test/test-db
-                   #'app.nyse/publisher #'app.test/test-publisher})
-```
-
-### Uberjar / Packaging
-
-Since Component fully controls the `system` where the whole application lives, it is quite simple 
-to start an application from anywhere including a `-main` function of the uberjar.
-
-In order to start the whole system in development, Mount just needs `(mount/start)` or `(reset)` 
-it's [simple](https://github.com/tolitius/mount#the-importance-of-being-reloadable).
-
-However there is no "tools.namespaces"/REPL at a "stand alone jar runtime" and in order for Mount to start / stop
-the app, states need to be `:require`/`:use`d, which is usually done within the same namespace as `-main`. 
-
-Depending on app dependencies, it could only require a few states to be `:require`/`:use`d, others 
-will be brought transitively. Here is more about mount [packaging](https://github.com/tolitius/mount#packaging) and an [example](uberjar.md#creating-reloadable-uberjarable-app) of building a wepapp uberjar with Mount.
-
-On the flip side, Component _system_ usually requires all the `:require`s, since in order to be built, it needs to "see" all the top level states.
-
-###### _conclusion: it's simple in Mount as well, but is left upto developer to require what's needed._
-
-### Multiple separate systems
-
-With Component multiple separate systems can be started _in the same Clojure runtime_ with different settings. Which might be useful for testing.
-
-Mount keeps states in namespaces, hence the app becomes "[The One](https://en.wikipedia.org/wiki/Neo_(The_Matrix))", and there can't be "multiples The Ones".
+Mount keeps states in namespaces, hence the app becomes "[The One](https://en.wikipedia.org/wiki/Neo_(The_Matrix))", and there can't be "multiples The Ones". In practice, if we are talking about stateful external resources, there is trully only _one_ of them with a given configuration. Different configuration => different state. It's that simple.
 
 Testing is not alien to Mount and it knows how to do a thing or two:
 
@@ -197,13 +170,13 @@ Testing is not alien to Mount and it knows how to do a thing or two:
 * [start an application without certain states](https://github.com/tolitius/mount#start-an-application-without-certain-states)
 * [swapping alternate implementations](https://github.com/tolitius/mount#swapping-alternate-implementations)
 * [stop an application except certain states](https://github.com/tolitius/mount#stop-an-application-except-certain-states)
-* [suspending and resuming](https://github.com/tolitius/mount#suspending-and-resuming)
+* [composing states](https://github.com/tolitius/mount#composing-states)
 
-But running two apps in the same JVM side by side with "same but different" states, is not something Mount can do at the moment.
+After [booting mount](http://www.dotkam.com/2015/12/22/the-story-of-booting-mount/) I was secretly thinking of achieving multiple separate systems by running them in different [Boot Pods](https://github.com/boot-clj/boot/wiki/Pods).
 
-After [booting mount](http://www.dotkam.com/2015/12/22/the-story-of-booting-mount/) I am secretly thinking of achieving multiple separate systems by running them in different [Boot Pods](https://github.com/boot-clj/boot/wiki/Pods), but for now it remains to be a secret hypothesis.
+But the more I think about it, the less it feels like a mount's core functionality. So I created [Yurt](https://github.com/tolitius/yurt) that can easily create and run multiple separate mount systems simultaniously.
 
-###### _conclusion: needs more thinking._
+###### _conclusion: can be done with mount as well, but via a different dependency._
 
 ### Visualizing dependency graph
 

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@tolitius/mount",
+  "version": "0.1.16",
+  "license": "EPL-1.0",
+  "homepage": "https://github.com/tolitius/mount",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tolitius/mount"
+  },
+  "author": {
+    "name": "tolitius",
+    "url": "http://www.dotkam.com"
+  },
+  "files": [
+    "src/*"
+  ],
+  "directories": {
+    "lib": "src"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}

pom.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <packaging>jar</packaging>
+  <groupId>mount</groupId>
+  <artifactId>mount</artifactId>
+  <version>0.1.23</version>
+  <name>mount</name>
+  <description>managing Clojure and ClojureScript app state since (reset)</description>
+  <url>https://github.com/tolitius/mount</url>
+  <licenses>
+    <license>
+      <name>Eclipse Public License</name>
+      <url>http://www.eclipse.org/legal/epl-v10.html</url>
+    </license>
+  </licenses>
+  <developers>
+    <developer>
+      <name>tolitius</name>
+    </developer>
+  </developers>
+  <scm>
+    <url>https://github.com/tolitius/mount</url>
+    <connection>scm:git:git://github.com/tolitius/mount.git</connection>
+    <developerConnection>scm:git:ssh://git@github.com/tolitius/mount.git</developerConnection>
+    <tag>HEAD</tag>
+  </scm>
+  <dependencies>
+    <dependency>
+      <groupId>org.clojure</groupId>
+      <artifactId>clojure</artifactId>
+      <version>1.11.2</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+  </build>
+  <repositories>
+    <repository>
+      <id>clojars</id>
+      <url>https://repo.clojars.org/</url>
+    </repository>
+  </repositories>
+</project>

project.clj

@@ -1,4 +1,4 @@
-(defproject mount "0.1.9-SNAPSHOT"
+(defproject mount "0.1.17"
   :description "managing Clojure and ClojureScript app state since (reset)"
   :url "https://github.com/tolitius/mount"
   :license {:name "Eclipse Public License"
@@ -7,10 +7,13 @@
   :source-paths ["src"]
 
   :dependencies [] ;; for visual clarity
-  
+
+  :tach {:test-runner-ns 'mount.test-self-host
+         :source-paths ["test/core"]}
+
   :profiles {:dev {:source-paths ["dev" "dev/clj" "test/clj"]
-                   :dependencies [[org.clojure/clojure "1.7.0"]
-                                  [org.clojure/clojurescript "1.7.170"]; :classifier "aot"]
+                   :dependencies [[org.clojure/clojure "1.8.0"]
+                                  [org.clojure/clojurescript "1.9.946"]; :classifier "aot"]
                                   [datascript "0.13.3"]
                                   [compojure "1.4.0"]
                                   [ring/ring-jetty-adapter "1.1.0"]
@@ -27,7 +30,8 @@
                    :plugins [[lein-cljsbuild "1.1.1"]
                              [lein-doo "0.1.6"]
                              [lein-figwheel "0.5.0-2"]
-                             [test2junit "1.1.3"]]
+                             [test2junit "1.1.3"]
+                             [lein-tach "1.0.0"]]
 
                    :test2junit-output-dir ~(or (System/getenv "CIRCLE_TEST_REPORTS") "target/test2junit")
 

resources/clj-kondo.exports/mount/mount/config.edn

@@ -0,0 +1,3 @@
+{:linters {:mount/defstate {:level :warning}}
+ :hooks {:analyze-call {mount.core/defstate hooks.defstate/defstate
+                        mount.core/defstate! hooks.defstate/defstate}}}

resources/clj-kondo.exports/mount/mount/hooks/defstate.clj

@@ -0,0 +1,39 @@
+(ns hooks.defstate
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn defstate [{:keys [node]}]
+  (let [[n & args] (next (:children node))
+        [docs args] (if (string? (api/sexpr (first args)))
+                      [(first args) (next args)]
+                      [nil args])
+        m (when-let [m (first (:meta n))]
+            (api/sexpr m))
+        m (if (map? m) m {})
+        ks (cond-> (take 1 args)
+                   (> (count args) 2) (conj (nth args 2)))
+        invalid-key (first (remove (comp (partial contains? #{:start :stop}) api/sexpr) ks))]
+    (cond
+      invalid-key
+      (api/reg-finding!
+        {:message (str "lifecycle functions can only contain `:start` and `:stop`. illegal function found: " (api/sexpr invalid-key))
+         :type    :mount/defstate
+         :row     (:row (meta invalid-key))
+         :col     (:col (meta invalid-key))})
+      (not (contains? (set (map api/sexpr ks)) :start))
+      (throw (ex-info "lifecycle functions must include `:start`" {}))
+      ((complement contains?) #{2 4} (count args))
+      (throw (ex-info "lifecycle functions must consist of no more than 2 pair forms: `:start` and `:stop`" {}))
+      (and (contains? m :on-reload) (not (contains? #{:noop :stop} (:on-reload m))))
+      (api/reg-finding!
+        {:message "metadata `:on-reload` key can only have value of `noop` or `stop`"
+         :type    :mount/defstate
+         :row     (:row (meta n))
+         :col     (:col (meta n))})
+      :else
+      {:node (api/list-node
+              (cond-> [(api/token-node 'def) n]
+                docs (conj docs)
+                true (conj (api/list-node
+                            (list*
+                             (api/token-node 'do)
+                             args)))))})))

src/mount/core.cljc

@@ -1,22 +1,23 @@
 (ns mount.core
+  #?(:clj {:clojure.tools.namespace.repl/load false}) ; prevent reloading of this ns
   #?(:clj (:require [mount.tools.macro :refer [on-error throw-runtime] :as macro]
+                    [mount.tools.macrovich :refer [deftime]]
                     [mount.tools.logger :refer [log]]
+                    [clojure.set :refer [intersection]]
                     [clojure.string :as s])
-     :cljs (:require [mount.tools.macro :as macro]
+     :cljs (:require [mount.tools.macro]
+                     [clojure.set :refer [intersection]]
                      [mount.tools.logger :refer [log]]))
   #?(:cljs (:require-macros [mount.core]
-                            [mount.tools.macro :refer [if-clj on-error throw-runtime]])))
+                            [mount.tools.macro :refer [on-error throw-runtime]]
+                            [mount.tools.macrovich :refer [deftime]])))
 
-(defonce ^:private -args (atom :no-args))                  ;; mostly for command line args and external files
+(defonce ^:private -args (atom {}))                        ;; mostly for command line args and external files
 (defonce ^:private state-seq (atom 0))
 (defonce ^:private mode (atom :clj))
 (defonce ^:private meta-state (atom {}))
 (defonce ^:private running (atom {}))                      ;; to clean dirty states on redefs
 
-;; supporting tools.namespace: (disable-reload!)
-#?(:clj
-    (alter-meta! *ns* assoc ::load false)) ;; to exclude the dependency
-
 (defn- make-state-seq [state]
   (or (:order (@meta-state state))
       (swap! state-seq inc)))
@@ -30,8 +31,7 @@
 (defn- validate [{:keys [start stop suspend resume] :as lifecycle}]
   (cond
     (not start) (throw-runtime "can't start a stateful thing without a start function. (i.e. missing :start fn)")
-    (and suspend
-         (not resume)) (throw-runtime "suspendable state should have a resume function (i.e. missing :resume fn)")))
+    (or suspend resume) (throw-runtime "suspend / resume lifecycle support was removed in \"0.1.10\" in favor of (mount/stop-except)")))
 
 (defn- with-ns [ns name]
   (str "#'" ns "/" name))
@@ -57,17 +57,6 @@
       (stop))
     (swap! running dissoc state)))
 
-#?(:clj
-    (defn current-state [state]
-      (let [{:keys [inst var]} (@meta-state state)]
-        (if (= @mode :cljc)
-          @inst
-          (var-get var))))
-
-   :cljs
-    (defn current-state [state]
-      (-> (@meta-state state) :inst deref)))
-
 #?(:clj
     (defn alter-state! [{:keys [var inst]} value]
       (if (= @mode :cljc)
@@ -86,39 +75,36 @@
     (swap! done conj state-name)
     state))
 
-(defn- up [state {:keys [start stop resume status] :as current} done]
+(defn- up [state {:keys [start stop status] :as current} done]
   (when-not (:started status)
     (let [s (on-error (str "could not start [" state "] due to")
-                      (if (:suspended status)
-                        (record! state resume done)
-                        (record! state start done)))]
+                      (record! state start done))]
       (alter-state! current s)
       (swap! running assoc state {:stop stop})
       (update-meta! [state :status] #{:started}))))
 
-(defn- down [state {:keys [stop status] :as current} done]
-  (when (some status #{:started :suspended})
-    (when stop
-      (on-error (str "could not stop [" state "] due to")
-                (record! state stop done)))
-    (alter-state! current (NotStartedState. state))   ;; (!) if a state does not have :stop when _should_ this might leak
+(defn- down
+  "brings a state down by
+    * calling its 'stop' function if it is defined
+      * if not defined, state will still become a 'NotStartedState'
+      * in case of a failure on 'stop', state is still marked as :stopped, and the error is logged / printed
+    * dissoc'ing it from the running states
+    * marking it as :stopped"
+  [state {:keys [stop status] :as current} done]
+  (when (some status #{:started})
+    (if stop
+      (if-let [cause (-> (on-error (str "could not stop [" state "] due to")
+                                   (record! state stop done)
+                                   :fail? false)
+                         :f-failed)]
+        (log cause :error)                                  ;; this would mostly be useful in REPL / browser console
+        (alter-state! current (->NotStartedState state)))
+        (alter-state! current (->NotStartedState state)))    ;; (!) if a state does not have :stop when _should_ this might leak
     (swap! running dissoc state)
     (update-meta! [state :status] #{:stopped})))
 
-(defn- sigstop [state {:keys [resume suspend status] :as current} done]
-  (when (and (:started status) resume)           ;; can't have suspend without resume, but the reverse is possible
-    (when suspend                                ;; don't suspend if there is only resume function (just mark it :suspended?)
-      (let [s (on-error (str "could not suspend [" state "] due to")
-                        (record! state suspend done))]
-        (alter-state! current s)))
-    (update-meta! [state :status] #{:suspended})))
-
-(defn- sigcont [state {:keys [resume status] :as current} done]
-  (when (:suspended status)
-    (let [s (on-error (str "could not resume [" state "] due to")
-                      (record! state resume done))]
-      (alter-state! current s)
-      (update-meta! [state :status] #{:started}))))
+(defn running-states []
+  (set (keys @running)))
 
 (deftype DerefableState [name]
   #?(:clj clojure.lang.IDeref
@@ -126,19 +112,46 @@
   (#?(:clj deref
       :cljs -deref)
     [_]
-    (let [{:keys [status inst] :as state} (@meta-state name)]
+    (let [{:keys [status var inst] :as state} (@meta-state name)]
       (when-not (:started status)
-        (up name state (atom #{})))
-      @inst)))
+        (if (= :throw (-> var meta :on-lazy-start))
+          (throw-runtime (str ":on-lazy-start is set to :throw i.e. (defstate {:on-lazy-start :throw} " name "...) "
+                              "and " name " state was not explicitly started before it was deref'ed (i.e. @" name ")"))
+          (up name state (atom #{}))))
+      @inst))
+  #?(:clj clojure.lang.IPending
+     :cljs IPending)
+  (#?(:clj isRealized
+      :cljs -realized?)
+    [_]
+    (boolean ((running-states) name))))
+
+#?(:clj
+    (defn current-state [state]
+      (let [{:keys [var]} (@meta-state state)]
+        (if (= @mode :cljc)
+          (->DerefableState state)
+          (var-get var))))
+
+   :cljs
+    (defn current-state [state]
+      (-> (@meta-state state) :inst deref)))
 
 (defn on-reload-meta [s-var]
   (or (-> s-var meta :on-reload)
       :restart))                      ;; restart by default on ns reload
 
-;;TODO: make private after figuring out the inconsistency betwen cljs compile stages 
+(defn running-noop? [s-name]
+  (let [{:keys [var status]} (@meta-state s-name)
+        on-reload (-> var meta :on-reload)]
+    (when status
+      (and (status :started)
+           (= :noop on-reload)))))
+
+;;TODO: make private after figuring out the inconsistency betwen cljs compile stages
 ;;      (i.e. _sometimes_ this, if private, is not seen by expanded "defmacro" on cljs side)
 (defn mount-it [s-var s-name s-meta]
-  (let [with-inst (assoc s-meta :inst (atom (NotStartedState. s-name))
+  (let [with-inst (assoc s-meta :inst (atom (->NotStartedState s-name))
                                 :var s-var)
         on-reload (on-reload-meta s-var)
         existing? (when-not (= :noop on-reload)
@@ -148,32 +161,42 @@
       (log (str ">> starting.. " s-name " (namespace was recompiled)"))
       (up s-name with-inst (atom #{})))))
 
-#?(:clj
-    (defmacro defstate [state & body]
-      (let [[state params] (macro/name-with-attributes state body)
-            {:keys [start stop suspend resume] :as lifecycle} (apply hash-map params)
-            state-name (with-ns *ns* state)
-            order (make-state-seq state-name)]
-        (validate lifecycle)
-        (let [s-meta (cond-> {:order order
-                              :start `(fn [] ~start)
-                              :status #{:stopped}}
-                       stop (assoc :stop `(fn [] ~stop))
-                       suspend (assoc :suspend `(fn [] ~suspend))
-                       resume (assoc :resume `(fn [] ~resume)))]                           
-          `(do
-             (~'defonce ~state (DerefableState. ~state-name))
-             (mount-it (~'var ~state) ~state-name ~s-meta)
-             (~'var ~state))))))
+(deftime
 
-#?(:clj
-    (defmacro defstate! [state & {:keys [start! stop!]}]
-      (let [state-name (with-ns *ns* state)]
-        `(defstate ~state
-           :start (~'let [~state (mount/current-state ~state-name)]
-                    ~start!)
-           :stop (~'let [~state (mount/current-state ~state-name)]
-                   ~stop!)))))
+(defmacro defstate
+  "defines a state (a.k.a. a stateful component).
+  restarts on recompilation.
+  pass ^{:on-reload :noop} to prevent auto-restart on ns recompilation,
+    or ^{:on-reload :stop} to stop on recompilation."
+  [state & body]
+  (let [[state params] (mount.tools.macro/name-with-attributes state body)
+        {:keys [start stop] :as lifecycle} (apply hash-map params)
+        state-name (with-ns *ns* state)
+        order (make-state-seq state-name)]
+      (validate lifecycle)
+      (let [s-meta (cond-> {:order order
+                            :start `(fn [] ~start)
+                            :status #{:stopped}}
+                     stop (assoc :stop `(fn [] ~stop)))]
+        `(do
+           ;; (log (str "|| mounting... " ~state-name))
+           ;; only create/redefine a new state iff this is not a running ^{:on-reload :noop}
+           (if-not (running-noop? ~state-name)
+             (do
+               (~'defonce ~state (->DerefableState ~state-name))
+               (mount-it (~'var ~state) ~state-name ~s-meta))
+             (~'defonce ~state (current-state ~state-name)))
+           (~'var ~state)))))
+
+(defmacro defstate! [state & {:keys [start! stop!]}]
+  (let [state-name (with-ns *ns* state)]
+    `(defstate ~state
+       :start (~'let [~state (mount.core/current-state ~state-name)]
+                ~start!)
+       :stop (~'let [~state (mount.core/current-state ~state-name)]
+               ~stop!))))
+
+)
 
 (defn in-cljc-mode []
   (reset! mode :cljc))
@@ -184,7 +207,7 @@
 ;;TODO args might need more thinking
 (defn args [] @-args)
 
-(defn- find-all-states []
+(defn find-all-states []
   (keys @meta-state))
 
 #?(:clj
@@ -226,14 +249,14 @@
 
 (defn- merge-lifecycles
   "merges with overriding _certain_ non existing keys.
-   i.e. :suspend is in a 'state', but not in a 'substitute': it should be overriden with nil
+   i.e. :stop is in a 'state', but not in a 'substitute': it should be overriden with nil
         however other keys of 'state' (such as :ns,:name,:order) should not be overriden"
   ([state sub]
     (merge-lifecycles state nil sub))
-  ([state origin {:keys [start stop suspend resume status]}]
+  ([state origin {:keys [start stop status]}]
     (assoc state :origin origin
                  :status status
-                 :start start :stop stop :suspend suspend :resume resume)))
+                 :start start :stop stop)))
 
 (defn- rollback! [state]
   (let [{:keys [origin] :as sub} (@meta-state state)]
@@ -241,13 +264,11 @@
       (update-meta! [state] (merge-lifecycles sub origin)))))
 
 (defn- substitute! [state with mode]
-  (let [lifecycle-fns #(select-keys % [:start :stop :suspend :resume :status])
+  (let [lifecycle-fns #(select-keys % [:start :stop :status])
         origin (@meta-state state)
         sub (if (= :value mode)
               {:start (fn [] with) :status :stopped}
-              (@meta-state with))]
-    (when (= :state mode)
-      (update-meta! [with :sub?] true))
+              (assoc with :status :stopped))]
     (update-meta! [state] (merge-lifecycles origin (lifecycle-fns origin) sub))))
 
 (defn- unsub [state]
@@ -258,21 +279,108 @@
   (remove (comp :sub? @meta-state) (find-all-states)))
 
 (defn start [& states]
-  (let [states (or (seq states) (all-without-subs))]
-    {:started (bring states up <)}))
+  (let [fs (-> states first)]
+    (if (coll? fs)
+      (if-not (empty? fs)                      ;; (mount/start) vs. (mount/start #{}) vs. (mount/start #{1 2 3})
+        (apply start fs)
+        {:started #{}})
+      (let [states (or (->> states (map var-to-str) seq)
+                       (all-without-subs))]
+        {:started (bring states up <)}))))
 
 (defn stop [& states]
-  (let [states (or states (find-all-states))
-        _ (dorun (map unsub states))     ;; unmark substitutions marked by "start-with"
-        stopped (bring states down >)]
-    (dorun (map rollback! states))       ;; restore to origin from "start-with"
-    {:stopped stopped}))
+  (let [fs (-> states first)]
+    (if (coll? fs)
+      (if-not (empty? fs)                      ;; (mount/stop) vs. (mount/stop #{}) vs. (mount/stop #{1 2 3})
+        (apply stop fs)
+        {:stopped #{}})
+      (let [states (or (->> states (map var-to-str) seq)
+                       (find-all-states))
+            _ (dorun (map unsub states))       ;; unmark substitutions marked by "start-with" / "swap-states"
+            stopped (bring states down >)]
+        (dorun (map rollback! states))         ;; restore to origin from "start-with" / "swap-states"
+        {:stopped stopped}))))
+
+;; composable set of states
+
+(defn- mapset [f xs]
+  (-> (map f xs)
+      set))
+
+(defn only
+  ([these]
+   (only (find-all-states) these))
+  ([states these]
+   (intersection (mapset var-to-str these)
+                 (mapset var-to-str states))))
+
+(defn with-args
+  ([args]
+   (with-args (find-all-states) args))
+  ([states args]
+    (reset! -args args)  ;; TODO localize
+    states))
+
+(defn except
+  ([these]
+   (except (find-all-states) these))
+  ([states these]
+   (remove (mapset var-to-str these)
+           (mapset var-to-str states))))
+
+(defn swap
+  ([with]
+   (swap (find-all-states) with))
+  ([states with]
+   (doseq [[from to] with]
+     (substitute! (var-to-str from)
+                  to :value))
+   states))
+
+(defn swap-states
+  ([with]
+   (swap-states (find-all-states) with))
+  ([states with]
+   (doseq [[from to] with]
+     (substitute! (var-to-str from)
+                  to :state))
+   states))
+
+;; restart on events
+
+(defprotocol ChangeListener
+  (add-watcher [this ks watcher])
+  (on-change [this k]))
+
+(deftype RestartListener [watchers]
+  ChangeListener
+
+  (add-watcher [_ ks state]
+    (doseq [k ks]
+      (swap! watchers update k (fn [v]
+                                 (-> (conj v state) vec)))))
+
+  (on-change [_ ks]
+    (doseq [k ks]
+      (when-let [states (seq (@watchers k))]
+        (apply stop states)
+        (apply start states)))))
+
+(defn restart-listener
+  ([]
+   (restart-listener {}))
+  ([watchers]
+   (RestartListener. (atom watchers))))
+
+;; explicit, not composable (subject to depreciate?)
 
 (defn stop-except [& states]
   (let [all (set (find-all-states))
         states (map var-to-str states)
         states (remove (set states) all)]
-    (apply stop states)))
+    (if-not (empty? states)
+      (apply stop states)
+      {:stopped #{}})))
 
 (defn start-with-args [xs & states]
   (reset! -args xs)
@@ -289,7 +397,7 @@
 (defn start-with-states [with]
   (doseq [[from to] with]
     (substitute! (var-to-str from)
-                 (var-to-str to) :state))
+                 to :state))
   (start))
 
 (defn start-without [& states]
@@ -297,13 +405,7 @@
     (let [app (set (all-without-subs))
           states (map var-to-str states)
           without (remove (set states) app)]
-      (apply start without))
+      (if-not (empty? without)
+        (apply start without)
+        {:started #{}}))
     (start)))
-
-(defn suspend [& states]
-  (let [states (or (seq states) (all-without-subs))]
-    {:suspended (bring states sigstop <)}))
-
-(defn resume [& states]
-  (let [states (or (seq states) (all-without-subs))]
-    {:resumed (bring states sigcont <)}))

src/mount/tools/graph.cljc

@@ -24,4 +24,3 @@
                         meta-with-ns)
                   states)
              (sort-by :order)))))
-

src/mount/tools/logger.cljc

@@ -3,16 +3,18 @@
              (:import [goog.debug Console])]))
 
 #?(:cljs
-    (defonce *logger*
+    (defonce ^:dynamic *logger*
       (do
         (.setCapturing (Console.) true)
-        (glog/getLogger "mount"))))
+        (glog/getLogger "mount" nil))))
 
 #?(:clj
-    (defn log [msg]
+    (defn log [msg & _]
       (prn msg)))
 
 #?(:cljs
-    (defn log [msg]
-      (glog/info *logger* msg)))
+    (defn log [msg & level]
+      (case (first level)
+        :error (glog/error *logger* msg nil)
+        (glog/info *logger* msg nil))))
 

src/mount/tools/macro.cljc

@@ -1,26 +1,28 @@
 (ns mount.tools.macro
-  #?(:cljs (:require-macros [mount.tools.macro])))
+  (:refer-clojure :exclude [case])
+  #?(:cljs (:require-macros [mount.tools.macrovich :refer [deftime]])
+     :clj (:require [mount.tools.macrovich :refer [deftime]])))
 
-#?(:clj
-    (defmacro if-clj [then else]
-      (if (-> &env :ns not)
-        then
-        else)))
+(deftime
 
-#?(:clj
-    (defmacro on-error [msg f]
-      `(if-clj
-         (try ~f
-              (catch Throwable t#
-                (throw (RuntimeException. ~msg t#))))
-         (try ~f
-              (catch :default t#
-                (throw (~'str ~msg " " t#)))))))
+  (defmacro on-error [msg f & {:keys [fail?]
+                               :or {fail? true}}]
+    `(mount.tools.macrovich/case
+      :clj  (try ~f
+                 (catch Throwable t#
+                   (if ~fail?
+                     (throw (RuntimeException. ~msg t#))
+                     {:f-failed (ex-info ~msg {} t#)})))
+      :cljs (try ~f
+                 (catch :default t#
+                   (if ~fail?
+                     (throw (js/Error (~'str ~msg " " t#)))
+                     {:f-failed (ex-info ~msg {} t#)})))))
 
-#?(:clj
-    (defmacro throw-runtime [msg]
-      `(throw (if-clj (RuntimeException. ~msg)
-                      (~'str ~msg)))))
+  (defmacro throw-runtime [msg]
+    `(throw (mount.tools.macrovich/case :clj (RuntimeException. ~msg) :cljs (~'str ~msg))))
+
+)
 
 ;; this is a one to one copy from https://github.com/clojure/tools.macro
 ;; to avoid a lib dependency for a single function

src/mount/tools/macrovich.cljc

@@ -0,0 +1,21 @@
+(ns ^{:doc "From https://github.com/cgrand/macrovich. Licensed under EPL v1.
+            Copyright Cristophe Grand." }
+    mount.tools.macrovich
+  (:refer-clojure :exclude [case]))
+
+(defmacro deftime
+  "This block will only be evaluated at the correct time for macro definition, at other times its content
+   are removed.
+   For Clojure it always behaves like a `do` block.
+   For Clojurescript/JVM the block is only visible to Clojure.
+   For self-hosted Clojurescript the block is only visible when defining macros in the pseudo-namespace."
+  [& body]
+  (when #?(:clj (not (:ns &env)) :cljs (re-matches #".*\$macros" (name (ns-name *ns*))))
+    `(do ~@body)))
+
+(defmacro case [& {:keys [cljs clj]}]
+  (if (contains? &env '&env)
+    `(if (:ns ~'&env) ~cljs ~clj)
+    (if #?(:clj (:ns &env) :cljs true)
+      cljs
+      clj)))

test/clj/tapp/conf.clj

@@ -7,9 +7,9 @@
 
 (defn load-config [path]
   (info "loading config from" path)
-  (-> path 
-      slurp 
+  (-> path
+      slurp
       edn/read-string))
 
-(defstate config 
+(defstate config
   :start (load-config "dev/resources/config.edn"))

test/clj/tapp/example.clj

@@ -30,7 +30,7 @@
                  :db/valueType :db.type/bigdec
                  :db/cardinality :db.cardinality/one
                  :db.install/_attribute :db.part/db}
-                
+
                 {:db/id #db/id [:db.part/db]
                  :db/ident :order/qty
                  :db/valueType :db.type/long
@@ -51,11 +51,11 @@
                             :order/bid bid
                             :order/offer offer
                             :order/qty qty}]))
- 
+
 
 (defn find-orders [ticker]                                   ;; can take connection as param
   (let [orders (d/q '[:find ?e :in $ ?ticker
-                      :where [?e :order/symbol ?ticker]] 
+                      :where [?e :order/symbol ?ticker]]
                     (d/db @nyse/conn) ticker)]
     (touch @nyse/conn orders)))
 

test/clj/tapp/utils/datomic.clj

@@ -6,8 +6,9 @@
 (defn entity [conn id]
   (d/entity (d/db conn) id))
 
-(defn touch [conn results]
+(defn touch
   "takes 'entity ids' results from a query
     e.g. '#{[272678883689461] [272678883689462] [272678883689459] [272678883689457]}'"
+  [conn results]
   (let [e (partial entity conn)]
     (map #(-> % first e d/touch) results)))

test/clj/tapp/utils/logging.clj

@@ -1,4 +1,4 @@
-(ns tapp.utils.logging          ;; << change to your namespace/path 
+(ns tapp.utils.logging          ;; << change to your namespace/path
   (:require [mount.core]
             [robert.hooke :refer [add-hook clear-hooks]]
             [clojure.string :refer [split]]
@@ -6,40 +6,37 @@
 
 (alter-meta! *ns* assoc ::load false)
 
-(defn- f-to-action [f]
+(defn- f-to-action [f {:keys [status]}]
   (let [fname (-> (str f)
                   (split #"@")
                   first)]
     (case fname
-      "mount.core$up" :up
-      "mount.core$down" :down
-      "mount.core$sigstop" :suspend
-      "mount.core$sigcont" :resume
+      "mount.core$up" (when-not (:started status) :up)
+      "mount.core$down" (when-not (:stopped status) :down)
       :noop)))
 
-(defn whatcha-doing? [{:keys [status suspend]} action]
+(defn whatcha-doing? [action]
   (case action
-    :up (if (status :suspended) ">> resuming" 
-          (if-not (status :started) ">> starting"))
-    :down (if (or (status :started) (status :suspended)) "<< stopping")
-    :suspend (if (and (status :started) suspend) "<< suspending")
-    :resume (if (status :suspended) ">> resuming")))
+    :up ">> starting"
+    :down "<< stopping"
+    false))
 
-(defn log-status [f & args] 
-  (let [{:keys [var] :as state} (second args)
-        action (f-to-action f)] 
-    (when-let [taking-over-the-world (whatcha-doing? state action)]
-      (info (str taking-over-the-world "..  " var)))
+(defn log-status [f & args]
+  (let [[state-name state] args
+        action (f-to-action f state)]
+    (when-let [taking-over-the-world (whatcha-doing? action)]
+      (info (str taking-over-the-world ".. " state-name)))
     (apply f args)))
 
 (defonce lifecycle-fns
   #{#'mount.core/up
-    #'mount.core/down
-    #'mount.core/sigstop
-    #'mount.core/sigcont})
+    #'mount.core/down})
 
 (defn without-logging-status []
-  (doall (map clear-hooks lifecycle-fns)))
+  (doall (map #(clear-hooks %) lifecycle-fns)))
+
+
+;; this is the one to use:
 
 (defn with-logging-status []
   (without-logging-status)

test/cljs/tapp/audit_log.cljs

@@ -13,13 +13,13 @@
 
 (defn find-source-logs [db source]
   (d/q '{:find [?t ?msg]
-         :in [$ ?s] 
+         :in [$ ?s]
          :where [[?e :source ?s]
                  [?e :timestamp ?t]
                  [?e :msg ?msg]]}
        @@db source))
 
 (defn find-all-logs [db]
-  (->> (map :e (d/datoms @@db :aevt :timestamp)) 
+  (->> (map :e (d/datoms @@db :aevt :timestamp))
        dedupe
        (d/pull-many @@db '[:timestamp :source :msg])))

test/cljs/tapp/example.cljs

@@ -12,7 +12,7 @@
                 " → [" (name source) "]: " msg))
 
 (defn show-log []
-  (.write js/document 
+  (.write js/document
     (html [:ul (doall (for [e (find-all-logs log)]
                  [:li (format-log-event e)]))])))
 

test/core/mount/test.cljc

@@ -13,7 +13,7 @@
     mount.test.start-without
     mount.test.start-with
     mount.test.start-with-states
-    mount.test.suspend-resume
+    mount.test.printing
     ))
 
 #?(:clj (alter-meta! *ns* assoc ::load false))
@@ -32,7 +32,7 @@
                'mount.test.start-without
                'mount.test.start-with
                'mount.test.start-with-states
-               'mount.test.suspend-resume
+               'mount.test.printing
                ))
 
 (defn run-tests []

test/core/mount/test/cleanup_deleted_states.cljc

@@ -11,7 +11,7 @@
    [mount.test.helper :refer [dval helper forty-two]]))
 
 (def status (atom :a-not-started))
-(defstate a :start (reset! status :a-started) 
+(defstate a :start (reset! status :a-started)
             :stop (reset! status :a-stopped))
 
 #?(:clj (alter-meta! *ns* assoc ::load false))
@@ -30,11 +30,11 @@
       (testing "should cleanup/stop a state after it was deleted from ns"
           (is (empty? (:started (mount/start)))) ;; on any mount op (not necessarily on "stop")
           (is (= :a-stopped @status))
-          (is (not (some #{"#'mount.test.cleanup-deleted-states/a"} 
+          (is (not (some #{"#'mount.test.cleanup-deleted-states/a"}
                          (keys @@#'mount.core/meta-state)))))
 
       (testing "should not stop it again on stop (should not be there by this point)")
-          (is (not (some #{"#'mount.test.cleanup-deleted-states/a"} 
+          (is (not (some #{"#'mount.test.cleanup-deleted-states/a"}
                          (-> (mount/stop) :stopped set))))))
 
 ;; (t/run-tests)

test/core/mount/test/cleanup_dirty_states.cljc

@@ -48,7 +48,7 @@
       (.require js/goog "mount.test.helper")                 ;; should have run :stop of `helper`
       ;; (is (= :cleaned @forty-two))                        ;; TODO: figure out how to reload a namespace properly
       ;; (is (instance? mount.core.NotStartedState (dval helper)))
-      (mount/start #'mount.test.helper/helper) 
+      (mount/start #'mount.test.helper/helper)
       (is (= :started (dval helper)))
       (mount/stop)
       (is (instance? mount.core.NotStartedState (dval helper))))))

test/core/mount/test/composable_fns.cljc

@@ -0,0 +1,190 @@
+(ns mount.test.composable-fns
+  (:require
+    #?@(:cljs [[cljs.test :as t :refer-macros [is are deftest testing use-fixtures]]
+               [clojure.set :refer [intersection]]
+               [mount.core :refer [only except swap swap-states with-args] :as mount :refer-macros [defstate]]
+               [tapp.websockets :refer [system-a]]
+               [tapp.conf :refer [config]]
+               [tapp.audit-log :refer [log]]]
+        :clj  [[clojure.test :as t :refer [is are deftest testing use-fixtures]]
+               [clojure.set :refer [intersection]]
+               [clojure.tools.nrepl.server :refer [start-server stop-server]]
+               [mount.core :as mount :refer [defstate only except swap swap-states with-args]]
+               [tapp.conf :refer [config]]
+               [tapp.nyse :refer [conn]]
+               [tapp.example :refer [nrepl]]])
+   [mount.test.helper :refer [dval helper]]))
+
+#?(:clj (alter-meta! *ns* assoc ::load false))
+
+(defstate test-conn :start 42
+                    :stop (constantly 0))
+
+(defstate test-nrepl :start [])
+
+(def swap-conn {:start (fn [] 42)
+                :stop #(println "stopping test-conn-state")})
+#?(:clj
+  (def swap-nrepl {:start #(start-server :bind "localhost" :port 3442)
+                   :stop #(stop-server @nrepl)}))
+
+#?(:clj
+  (deftest only-states
+
+    (testing "only should only return given states.
+              if source set of states is not provided, it should use all the states to select from"
+      (is (= #{"#'mount.test.composable-fns/test-conn" "#'tapp.example/nrepl" "#'tapp.nyse/conn"}
+             (only #{"#'is.not/here" #'mount.test.composable-fns/test-conn #'tapp.example/nrepl #'tapp.nyse/conn}))))
+
+    (testing "only should only return given states"
+      (is (= #{"#'mount.test.composable-fns/test-conn" "#'tapp.example/nrepl"}
+             (only [#'mount.test.composable-fns/test-conn #'tapp.example/nrepl #'tapp.nyse/conn]
+                   #{"#'is.not/here" #'mount.test.composable-fns/test-conn #'tapp.example/nrepl}))))))
+
+#?(:clj
+  (deftest except-states
+
+    (testing "except should exclude given states.
+              if source set of states is not provided, it should use all the states to exclude from"
+      (let [states (except #{"#'is.not/here" #'tapp.example/nrepl #'tapp.nyse/conn})]
+        (is (coll? states))
+        (is (pos? (count states)))
+        (is (zero? (count (intersection (set states)
+                                        #{"#'tapp.example/nrepl" "#'tapp.nyse/conn" "#'is.not/here"}))))))
+
+    (testing "except should exclude given states"
+      (is (= #{"#'tapp.conf/config" "#'mount.test.composable-fns/test-conn"}
+             (set (except #{#'tapp.example/nrepl #'tapp.conf/config #'mount.test.composable-fns/test-conn}
+                          #{"#'is.not/here" #'tapp.example/nrepl #'tapp.nyse/conn})))))))
+
+#?(:clj
+  (deftest states-with-args
+
+    (testing "with-args should set args and return all states if none provided"
+      (let [states (with-args {:a 42})]
+        (is (= {:a 42} (mount/args)))
+        (is (= states (#'mount.core/find-all-states)))))
+
+    (testing "with-args should set args and thread states if provided"
+      (let [t-states #{"#'is.not/here" #'mount.test.composable-fns/test-conn #'tapp.example/nrepl #'tapp.nyse/conn}
+            states (with-args t-states {:a 42})]
+        (is (= {:a 42} (mount/args)))
+        (is (= states t-states))))))
+
+#?(:clj
+  (deftest swap-states-with-values
+
+    (testing "swap should swap states with values and return all states if none is given"
+      (let [states (swap {#'tapp.nyse/conn "conn-sub"
+                          #'tapp.example/nrepl :nrepl-sub})]
+        (is (= states (#'mount.core/find-all-states)))
+        (mount/start)
+        (is (map? (dval config)))
+        (is (= :nrepl-sub (dval nrepl)))
+        (is (= "conn-sub" (dval conn)))
+        (mount/stop)))
+
+    (testing "swap should swap states with values and return only states that it is given"
+      (let [t-states #{"#'is.not/here" #'mount.test.composable-fns/test-conn #'tapp.example/nrepl #'tapp.nyse/conn}
+            states (swap t-states {#'tapp.nyse/conn "conn-sub"
+                                   #'tapp.example/nrepl :nrepl-sub})]
+        (is (= states t-states))
+        (mount/start)
+        (is (map? (dval config)))
+        (is (= :nrepl-sub (dval nrepl)))
+        (is (= "conn-sub" (dval conn)))
+        (is (= 42 (dval test-conn)))
+        (mount/stop)))))
+
+#?(:clj
+  (deftest swap-states-with-states
+
+    (testing "swap-states should swap states with states and return all mount states if none is given"
+      (let [states (swap-states {#'tapp.nyse/conn swap-conn
+                                 #'tapp.example/nrepl swap-nrepl})]
+        (is (= states (#'mount.core/find-all-states)))
+        (mount/start)
+        (is (map? (dval config)))
+        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
+        (is (= 42 (dval conn)))
+        (mount/stop)))
+
+    (testing "swap-states should swap states on start and rollback on stop"
+      (let [states (swap-states {#'tapp.nyse/conn swap-conn})]
+        (is (= states (#'mount.core/find-all-states)))
+        (mount/start #'tapp.nyse/conn)
+        (is (= 42 (dval conn)))
+        (mount/stop #'tapp.nyse/conn)
+        (mount/start #'tapp.nyse/conn)
+        (is (instance? datomic.peer.LocalConnection (dval conn)))
+        (mount/stop)))
+
+    (testing "swap-states should swap states with states and return only states that it is given"
+      (let [t-states #{"#'is.not/here" #'mount.test.composable-fns/test-conn #'tapp.nyse/conn}
+            states (swap-states t-states {#'tapp.nyse/conn swap-conn
+                                          #'tapp.example/nrepl swap-nrepl})]
+        (is (= states t-states))
+        (apply mount/start states)
+        (is (instance? mount.core.NotStartedState (dval config)))
+        (is (instance? mount.core.NotStartedState (dval nrepl)))
+        (is (= 42 (dval conn)))
+        (is (= 42 (dval test-conn))) ;; test-conn is explicitly started via "t-states"
+        (mount/stop)))))
+
+#?(:clj
+  (deftest composing
+
+    (testing "states provided to the top level should narrow down the scope for the whole composition"
+      (let [scope [#'tapp.conf/config
+                   #'tapp.example/nrepl
+                   #'tapp.nyse/conn
+                   #'mount.test.composable-fns/test-nrepl
+                   #'mount.test.composable-fns/test-conn]
+            states (-> (only scope)
+                       (with-args {:a 42})
+                       (except [#'mount.test.composable-fns/test-nrepl
+                                #'mount.test.composable-fns/test-conn])
+                       (swap-states {#'tapp.example/nrepl swap-nrepl})
+                       (swap {#'tapp.conf/config {:datomic {:uri "datomic:mem://composable-mount"}}}))]
+        (is (= #{"#'tapp.nyse/conn" "#'tapp.conf/config" "#'tapp.example/nrepl"} (set states)))
+        (mount/start states)
+        (is (= {:a 42} (mount/args)))
+        (is (= {:datomic {:uri "datomic:mem://composable-mount"}} (dval config)))
+        (is (instance? datomic.peer.LocalConnection (dval conn)))
+        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
+        (mount/stop)))
+
+    (testing "should compose and start in a single composition"
+      (let [scope [#'tapp.conf/config
+                   #'tapp.example/nrepl
+                   #'tapp.nyse/conn
+                   #'mount.test.composable-fns/test-nrepl
+                   #'mount.test.composable-fns/test-conn]]
+        (-> (only scope)
+            (with-args {:a 42})
+            (except [#'mount.test.composable-fns/test-nrepl
+                     #'mount.test.composable-fns/test-conn])
+            (swap-states {#'tapp.example/nrepl swap-nrepl})
+            (swap {#'tapp.conf/config {:datomic {:uri "datomic:mem://composable-mount"}}})
+            mount/start)
+        (is (= {:a 42} (mount/args)))
+        (is (= {:datomic {:uri "datomic:mem://composable-mount"}} (dval config)))
+        (is (instance? datomic.peer.LocalConnection (dval conn)))
+        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
+        (mount/stop)))
+
+    (testing "should not start anything on empty seq of states"
+      (let [scope #{}]
+        (is (= {:started #{}} (-> (only scope)
+                                  mount/start)))
+        (mount/stop)))
+
+    (testing "should not stop anything on empty seq of states"
+      (let [scope #{}]
+        (mount/start)
+        (is (instance? datomic.peer.LocalConnection (dval conn)))
+        (is (= {:stopped #{}} (-> (only scope)
+                                  mount/stop)))
+        (is (instance? datomic.peer.LocalConnection (dval conn)))
+        (mount/stop)
+        (is (instance? mount.core.NotStartedState (dval conn)))))))

test/core/mount/test/fun_with_values.cljc

@@ -43,7 +43,7 @@
                #'mount.test.fun-with-values/private-f
                #'mount.test.fun-with-values/f-value))
 
-(use-fixtures :once 
+(use-fixtures :once
               #?(:cljs {:before start-states
                         :after mount/stop}
                  :clj #((start-states) (%) (mount/stop))))

test/core/mount/test/helper.cljc

@@ -5,10 +5,10 @@
 
 #?(:clj (alter-meta! *ns* assoc ::load false))
 
-(defn dval 
+(defn dval
   "returns a value of DerefableState without deref'ing it"
   [d]
-  (-> (@@(var mount.core/meta-state) 
+  (-> (@@(var mount.core/meta-state)
                 #?(:clj (.name d)
                    :cljs (.-name d)))
              :inst

test/core/mount/test/on_reload.cljc

@@ -7,7 +7,7 @@
                [tapp.audit-log :refer [log]]]
         :clj  [[clojure.test :as t :refer [is are deftest testing use-fixtures]]
                [mount.core :as mount :refer [defstate]]
-               [tapp.example]]) 
+               [tapp.example]])
     [mount.test.helper :refer [dval helper forty-two counter inc-counter]]
     [mount.test.on-reload-helper :refer [a b c]]))
 
@@ -35,20 +35,21 @@
         (require 'mount.test.on-reload-helper :reload)
 
         ;; "a" is marked as :noop on reload
-        (is (instance? mount.core.NotStartedState (dval a))) ;; (!) stale reference of old a is still there somewhere
-        (is (= (-> pre-reload :a) 
+        ;; previous behavior left a stale reference =>>> ;; (is (instance? mount.core.NotStartedState (dval a))) ;; (!) stale reference of old a is still there somewhere
+        (is (= :started (dval a)))   ;; make sure a still has the same instance as before reload
+        (is (= (-> pre-reload :a)    ;; and the start was not called: the counter did not change
                (-> @counter :a)))
 
         ;; "b" is marked as :stop on reload
         (is (instance? mount.core.NotStartedState (dval b)))
-        (is (= (-> pre-reload :b :started) 
+        (is (= (-> pre-reload :b :started)
                (-> @counter :b :started)))
-        (is (= (inc (-> pre-reload :b :stopped)) 
+        (is (= (inc (-> pre-reload :b :stopped))
                (-> @counter :b :stopped)))
 
         ;; "c" is not marked on reload, using "restart" as default
         (is (= :started (dval c)))
         (is (= (inc (-> pre-reload :c :started))
                (-> @counter :c :started)))
-        (is (= (inc (-> pre-reload :c :stopped)) 
+        (is (= (inc (-> pre-reload :c :stopped))
                (-> @counter :c :stopped))))))

test/core/mount/test/parts.cljc

@@ -20,18 +20,18 @@
     (f)
     (mount/stop)))
 
-(use-fixtures :once 
+(use-fixtures :once
               #?(:cljs {:before #(mount/start #'tapp.conf/config #'tapp.audit-log/log)
                         :after mount/stop}
                  :clj with-parts))
 
 #?(:clj
-  (deftest start-only-parts 
+  (deftest start-only-parts
     (is (instance? datomic.peer.LocalConnection (dval conn)))
     (is (instance? mount.core.NotStartedState (dval should-not-start)))))
 
 #?(:cljs
-  (deftest start-only-parts 
+  (deftest start-only-parts
     (is (instance? datascript.db/DB @(dval log)))
     (is (map? (dval config)))
     (is (instance? mount.core.NotStartedState (dval should-not-start)))

test/core/mount/test/printing.cljc

@@ -0,0 +1,17 @@
+(ns mount.test.printing
+  (:require
+   #?@(:cljs [[cljs.test :as t :refer-macros [is are deftest testing use-fixtures]]
+              [mount.core :as mount :refer-macros [defstate]]]
+       :clj  [[clojure.test :as t :refer [is are deftest testing use-fixtures]]
+              [mount.core :as mount :refer [defstate]]])))
+
+#?(:clj (alter-meta! *ns* assoc ::load false))
+
+(defstate foo
+  :start (do (println "Starting!") 42))
+
+(deftest test-printing-has-no-side-effects
+  ;; Test that printing an unstarted DerefableState does not have the
+  ;; side-effect of starting it
+  (println foo)
+  (is (not= 42 foo)))

test/core/mount/test/private_fun.cljc

@@ -9,11 +9,11 @@
 
 #?(:clj (alter-meta! *ns* assoc ::load false))
 
-(use-fixtures :once 
+(use-fixtures :once
               #?(:cljs {:before #(mount/start #'mount.test.fun-with-values/private-f)
                         :after mount/stop}
-                 :clj #((mount/start #'mount.test.fun-with-values/private-f) 
-                        (%) 
+                 :clj #((mount/start #'mount.test.fun-with-values/private-f)
+                        (%)
                         (mount/stop))))
 
 (deftest fun-with-values

test/core/mount/test/start_with.cljc

@@ -51,7 +51,7 @@
         (is (instance? mount.core.NotStartedState (dval test-conn)))
         (is (instance? mount.core.NotStartedState (dval test-nrepl)))
         (mount/stop)))))
-    
+
 #?(:clj
   (deftest start-with
 
@@ -62,7 +62,7 @@
         (is (= :nrepl-sub (dval nrepl)))
         (is (= "conn-sub" (dval conn)))
         (mount/stop)))
-    
+
     (testing "should start normally after start-with"
       (let [_ (mount/start)]
         (is (map? (dval config)))

test/core/mount/test/start_with_states.cljc

@@ -7,6 +7,7 @@
                [tapp.audit-log :refer [log]]]
         :clj  [[clojure.test :as t :refer [is are deftest testing use-fixtures]]
                [mount.core :as mount :refer [defstate]]
+               [clojure.tools.nrepl.server :refer [start-server stop-server]]
                [tapp.conf :refer [config]]
                [tapp.nyse :refer [conn]]
                [tapp.example :refer [nrepl]]])
@@ -19,20 +20,29 @@
 
 (defstate test-nrepl :start [])
 
+(def swap-conn {:start (fn [] 42)
+                :stop #(println "stopping test-conn-state")})
+#?(:clj
+  (def swap-nrepl {:start #(start-server :bind "localhost" :port 3442)
+                   :stop #(stop-server @nrepl)})
+  :cljs
+  (def swap-nrepl {:start (fn [] :nrepl)
+                   :stop (fn [] :stopped-nrepl)}))
+
 #?(:cljs
   (deftest start-with-states
 
     (testing "should start with substitutes"
-      (let [_ (mount/start-with-states {#'tapp.websockets/system-a #'mount.test.start-with-states/test-conn
-                                        #'mount.test.helper/helper #'mount.test.start-with-states/test-nrepl})]
+      (let [_ (mount/start-with-states {#'tapp.websockets/system-a swap-conn
+                                        #'mount.test.helper/helper swap-nrepl})]
         (is (map? (dval config)))
-        (is (vector? (dval helper)))
+        (is (= (:nrepl (dval helper))))
         (is (= (dval system-a) 42))
         (is (instance? datascript.db/DB @(dval log)))
         (mount/stop)))
 
-    (testing "should not start the substitute itself"
-      (let [_ (mount/start-with-states {#'tapp.websockets/system-a #'mount.test.start-with-states/test-conn})]
+    #_(testing "should not start the substitute itself"                         ;; was true when subbing with exsiting states
+      (let [_ (mount/start-with-states {#'tapp.websockets/system-a swap-conn})]
         (is (instance? mount.core.NotStartedState (dval test-conn)))
         (is (= 42 (dval system-a)))
         (mount/stop)))
@@ -57,20 +67,20 @@
         (is (instance? mount.core.NotStartedState (dval test-conn)))
         (is (instance? mount.core.NotStartedState (dval test-nrepl)))
         (mount/stop)))))
-    
+
 #?(:clj
   (deftest start-with-states
 
     (testing "should start with substitutes"
-      (let [_ (mount/start-with-states {#'tapp.nyse/conn #'mount.test.start-with-states/test-conn
-                                        #'tapp.example/nrepl #'mount.test.start-with-states/test-nrepl})]
+      (let [_ (mount/start-with-states {#'tapp.nyse/conn swap-conn
+                                        #'tapp.example/nrepl swap-nrepl})]
         (is (map? (dval config)))
-        (is (vector? (dval nrepl)))
+        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
         (is (= (dval conn) 42))
         (mount/stop)))
-    
-    (testing "should not start the substitute itself"
-      (let [_ (mount/start-with-states {#'tapp.nyse/conn #'mount.test.start-with-states/test-conn})]
+
+    #_(testing "should not start the substitute itself"                         ;; was true when subbing with exsiting states
+      (let [_ (mount/start-with-states {#'tapp.nyse/conn swap-conn})]
         (is (instance? mount.core.NotStartedState (dval test-conn)))
         (is (= (dval conn) 42))
         (mount/stop)))

test/core/mount/test/start_without.cljc

@@ -20,7 +20,7 @@
     (f)
     (mount/stop)))
 
-  (use-fixtures :once 
+  (use-fixtures :once
                 #?(:cljs {:before #(mount/start-without #'mount.test.helper/helper #'tapp.websockets/system-a)
                           :after mount/stop}
                    :clj without))

test/core/mount/test/stop_except.cljc

@@ -25,7 +25,7 @@
         (is (instance? mount.core.NotStartedState (dval config)))
         (is (instance? mount.core.NotStartedState (dval system-a)))
         (mount/stop)))
-    
+
     (testing "should start normally after stop-except"
       (let [_ (mount/start)]
         (is (map? (dval config)))
@@ -51,7 +51,7 @@
         (is (instance? datomic.peer.LocalConnection (dval conn)))
         (is (instance? mount.core.NotStartedState (dval nrepl)))
         (mount/stop)))
-    
+
     (testing "should start normally after stop-except"
       (let [_ (mount/start)]
         (is (map? (dval config)))

test/core/mount/test/suspend_resume.cljc

@@ -1,212 +0,0 @@
-(ns mount.test.suspend-resume
-  (:require
-    #?@(:cljs [[cljs.test :as t :refer-macros [is are deftest testing use-fixtures]]
-               [mount.core :as mount :refer-macros [defstate]]
-               [tapp.websockets :refer [system-a]]
-               [tapp.conf :refer [config]]
-               [tapp.audit-log :refer [log]]]
-        :clj  [[clojure.test :as t :refer [is are deftest testing use-fixtures]]
-               [mount.core :as mount :refer [defstate]]
-               [tapp.conf :refer [config]]
-               [tapp.nyse :refer [conn]]
-               [tapp.example :refer [nrepl]]])
-   [mount.test.helper :refer [dval]]))
-
-#?(:clj (alter-meta! *ns* assoc ::load false))
-
-(defn koncat [k s]
-  (-> (name k)
-      (str "-" (name s))
-      keyword))
-
-(defn start [s] (koncat s :started))
-(defn stop [s] (koncat s :stopped))
-(defn suspend [s] (koncat s :suspended))
-(defn resume [s] (koncat s :resumed))
-
-(defstate web-server :start (start :w)
-                     :stop (stop :w)
-                     :suspend (suspend :w)
-                     :resume (resume :w))
-
-(defstate q-listener :start (start :q)
-                     :stop (stop :q)
-                     :suspend (suspend :q)
-                     :resume (resume :q))
-
-(defstate randomizer :start (rand-int 42))
-
-#?(:cljs
-  (deftest suspendable-lifecycle
-
-    (testing "should suspend _only suspendable_ states that are currently started"
-      (let [_ (mount/start)
-            _ (mount/suspend)]
-        (is (map? (dval config)))
-        (is (instance? datascript.db/DB @(dval log)))
-        (is (instance? js/WebSocket (dval system-a)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))
-
-    (testing "should resume _only suspendable_ states that are currently suspended"
-      (let [_ (mount/start)
-            _ (mount/stop #'tapp.websockets/system-a)
-            _ (mount/suspend)
-            _ (mount/resume)]
-        (is (map? (dval config)))
-        (is (instance? mount.core.NotStartedState (dval system-a)))
-        (is (instance? datascript.db/DB @(dval log)))
-        (is (= (dval web-server) :w-resumed))
-        (mount/stop)))
-
-    (testing "should start all the states, except the ones that are currently suspended, should resume them instead"
-      (let [_ (mount/start)
-            _ (mount/suspend)
-            _ (mount/start)]
-        (is (map? (dval config)))
-        (is (instance? js/WebSocket (dval system-a)))
-        (is (instance? datascript.db/DB @(dval log)))
-        (is (= (dval web-server) :w-resumed))
-        (mount/stop)))
-
-    (testing "should stop all: started and suspended"
-      (let [_ (mount/start)
-            _ (mount/suspend)
-            _ (mount/stop)]
-        (is (instance? mount.core.NotStartedState (dval config)))
-        (is (instance? mount.core.NotStartedState (dval system-a)))
-        (is (instance? mount.core.NotStartedState (dval log)))
-        (is (instance? mount.core.NotStartedState (dval web-server)))))))
-
-#?(:cljs 
-  (deftest suspendable-start-with-states
-
-    (testing "when replacing a non suspendable state with a suspendable one,
-              the later should be able to suspend/resume,
-              the original should not be suspendable after resume and preserve its lifecycle fns after rollback/stop"
-      (let [_ (mount/start-with-states {#'tapp.websockets/system-a #'mount.test.suspend-resume/web-server})
-            _ (mount/suspend)]
-        (is (= (dval system-a) :w-suspended))
-        (is (instance? mount.core.NotStartedState (dval web-server)))
-        (mount/stop)
-        (mount/start)
-        (mount/suspend)
-        (is (instance? js/WebSocket (dval system-a)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))))
-
-#?(:clj
-  (deftest suspendable-lifecycle
-
-    (testing "should suspend _only suspendable_ states that are currently started"
-      (let [_ (mount/start)
-            _ (mount/suspend)]
-        (is (map? (dval config)))
-        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
-        (is (instance? datomic.peer.LocalConnection (dval conn)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))
-    
-    (testing "should resume _only suspendable_ states that are currently suspended"
-      (let [_ (mount/start)
-            _ (mount/stop #'tapp.example/nrepl)
-            _ (mount/suspend)
-            _ (mount/resume)]
-        (is (map? (dval config)))
-        (is (instance? mount.core.NotStartedState (dval nrepl)))
-        (is (instance? datomic.peer.LocalConnection (dval conn)))
-        (is (= (dval web-server) :w-resumed))
-        (mount/stop)))
-
-    (testing "should start all the states, except the ones that are currently suspended, should resume them instead"
-      (let [_ (mount/start)
-            _ (mount/suspend)
-            _ (mount/start)]
-        (is (map? (dval config)))
-        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
-        (is (instance? datomic.peer.LocalConnection (dval conn)))
-        (is (= (dval web-server) :w-resumed))
-        (mount/stop)))
-
-    (testing "should stop all: started and suspended"
-      (let [_ (mount/start)
-            _ (mount/suspend)
-            _ (mount/stop)]
-        (is (instance? mount.core.NotStartedState (dval config)))
-        (is (instance? mount.core.NotStartedState (dval nrepl)))
-        (is (instance? mount.core.NotStartedState (dval conn)))
-        (is (instance? mount.core.NotStartedState (dval web-server)))))))
-
-
-#?(:clj 
-  (deftest suspendable-start-with-states
-
-    (testing "when replacing a non suspendable state with a suspendable one,
-              the later should be able to suspend/resume,
-              the original should not be suspendable after resume and preserve its lifecycle fns after rollback/stop"
-      (let [_ (mount/start-with-states {#'tapp.example/nrepl #'mount.test.suspend-resume/web-server})
-            _ (mount/suspend)]
-        (is (= (dval nrepl) :w-suspended))
-        (is (instance? mount.core.NotStartedState (dval web-server)))
-        (mount/stop)
-        (mount/start)
-        (mount/suspend)
-        (is (instance? clojure.tools.nrepl.server.Server (dval nrepl)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))
-
-    ;; this is a messy use case, but can still happen especially at REPL time
-    ;; it also messy, because usually :stop function refers the _original_ state by name (i.e. #(disconnect conn))
-    ;;    (unchanged/not substituted in its lexical scope), and original state won't be started
-    (testing "when replacing a suspendable state with a non suspendable one,
-              the later should not be suspendable,
-              the original should still be suspendable and preserve its lifecycle fns after the rollback/stop"
-      (let [_ (mount/start-with-states {#'mount.test.suspend-resume/web-server #'mount.test.suspend-resume/randomizer})
-            _ (mount/suspend)]
-        (is (integer? (dval web-server)))
-        (is (instance? mount.core.NotStartedState (dval randomizer)))
-        (mount/stop)
-        (mount/start)
-        (mount/suspend)
-        (is (integer? (dval randomizer)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))
-
-    ;; this is a messy use case, but can still happen especially at REPL time
-    (testing "when replacing a suspended state with a non suspendable started one,
-              the later should not be suspendable,
-              the original should still be suspended and preserve its lifecycle fns after the rollback/stop"
-      (let [_ (mount/start)
-            _ (mount/suspend) 
-            _ (mount/start-with-states {#'mount.test.suspend-resume/web-server #'tapp.nyse/conn})  ;; TODO: good to WARN on started states during "start-with-states"
-            _ (mount/suspend)]
-        (is (instance? datomic.peer.LocalConnection (dval conn)))
-        (is (= (dval web-server) :w-suspended)) ;; since the "conn" does not have a resume method, so web-server was not started
-        (mount/stop)
-        (mount/start)
-        (mount/suspend)
-        (is (instance? datomic.peer.LocalConnection (dval conn)))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))
-
-    ;; this is a messy use case, but can still happen especially at REPL time
-    (testing "when replacing a suspended state with a suspendable one,
-              the later should be suspendable,
-              the original should still be suspended and preserve its lifecycle fns after the rollback/stop"
-      (let [_ (mount/start)
-            _ (mount/suspend) 
-            _ (mount/start-with-states {#'mount.test.suspend-resume/web-server 
-                                        #'mount.test.suspend-resume/q-listener})]  ;; TODO: good to WARN on started states during "start-with-states"
-        (is (= (dval q-listener) :q-suspended))
-        (is (= (dval web-server) :q-resumed))
-        (mount/suspend)
-        (is (= (dval q-listener) :q-suspended))
-        (is (= (dval web-server) :q-suspended))
-        (mount/stop)
-        (is (instance? mount.core.NotStartedState (dval web-server)))
-        (is (instance? mount.core.NotStartedState (dval q-listener)))
-        (mount/start)
-        (mount/suspend)
-        (is (= (dval q-listener) :q-suspended))
-        (is (= (dval web-server) :w-suspended))
-        (mount/stop)))))

test/core/mount/test_self_host.cljs

@@ -0,0 +1,29 @@
+(ns mount.test-self-host
+  (:require
+    [cljs.test :as t]
+
+    mount.test.fun-with-values
+    mount.test.private-fun
+    mount.test.printing
+    mount.test.parts
+    mount.test.cleanup-dirty-states
+    mount.test.stop-except
+    mount.test.start-without
+    mount.test.start-with
+    mount.test.start-with-states
+    ))
+
+(t/run-tests
+ 'mount.test.fun-with-values
+ 'mount.test.private-fun
+ 'mount.test.printing
+ 'mount.test.parts
+ 'mount.test.cleanup-dirty-states
+ ;; 'mount.test.stop-except        ;; TODO: can't run with deps.edn (due to "WebSocket is not defined")
+ ;; 'mount.test.start-with         ;;       boot, lein have no problems
+ ;; 'mount.test.start-with-states  ;;       most likely somm misconfigured in node..
+ 'mount.test.start-without
+ )
+
+(defn run-tests []
+  (t/run-all-tests #"mount.test.*"))