Post Processing

Post Processing

There are many situations where we want to apply some transformation to data that cuts across many different parts of the data model or application model. For example, we may want to format some output as currency or convert some input from a string to a number.

In our current application we would like to round a number to two decimal places. We will do this with a post processor just to show how they work.

Since we will be writing ClojureScript code to do this formatting we do not want to include it in the behavior namespace. Instead, we will add the post processor to our dataflow definition just before we create the application. We do this in the tutorial-client.start namespace.

First we create a function which will round a number to the desired number of decimal places.

(defn round [n places]
  (let [p (Math.pow 10 places)]
    (/ (Math.round (* p n)) p)))

Next we create the post processing function. A post processing function takes a message and returns a sequence of messages. Post processing functions can filter, transform and expand messages.

(defn round-number-post [[op path n]]
  [[op path (round n 2)]])

Next we create a function which will add a :post key to the dataflow definition.

(defn add-post-processors [dataflow]
  (assoc dataflow
    :post {:app-model [[:value [:tutorial :average-count] round-number-post]]}))

Finally we update the call to app/build so that it will first add the post processor.

app (app/build (add-post-processors behavior/example-app))

The final version of the create-app function looks like this.

(defn create-app [render-config]
  (let [app (app/build (add-post-processors behavior/example-app))
        render-fn (push-render/renderer "content" render-config render/log-fn)
        app-model (render/consume-app-model app render-fn)]
    (app/begin app)
    (p/put-message (:input app) {msg/type :inc msg/topic [:my-counter]})
    {:app app :app-model app-model}))

In the browser we should now see a rounded value for :average-count.

Next steps

The application's behavior is now complete. Notice that we have written all of our behavior code as Clojure code. If we were writing tests first, or as we go, we could have arrived at this point without ever opening a browser. Had we done that, we could now open a browser and see everything work in the Data UI.

It is also important to point out what we have not done. We have got the core behavior of our application working without thinking about rendering or the complexities of the browser or working on our service. This has allowed us to focus all of our attention on what we actually cared about at this stage of development. Begin able to focus in this way is very helpful when our applications become more complex.

In the next few sections we will focus on rendering.

The tag for this step is step5.

Home | Making an HTML Template