We now have a new super-generalized and minimal abstraction for collections – a collection is some set of things that, when given a function to apply to its contents, can do so and give you the result, i.e. a collection is (at minimum) reducible. In other words, you can call reduce on it.

via Clojure/core — Reducers – A Library and Model for Collection Processing.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive
• Part 4: Adding CSS, Post detail page and Simple Authentication
• Part 5: Blog Administration Area

Introduction

Over that past 4 parts you have seen how to start with creating a simple blog using Clojure, render the posts and finally how to add a simple login page that will check the username and password and redirect to “admin” page. In this part we’ll finish the administration area of the blog that will help us create new blog posts.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part5

Sessions

When a user logs into the “admin” area using our login form, we need to keep track of her session and allow them to perform administrative operations such as managing posts or setting their password etc. Ring library provides a simple session middleware that uses various session storage options – cookie, in-memory and database backed session stores. You can create your own session implementations by implementing the SessionStore protocol. For our application we’ll just use the cookie-store to store the session information.

First step in creating the session is using the wrap-session function. We’ll add this to our routes and make sure that the session is wrapped for all the starting with “/admin”. Update your routes definition in core.clj as follows:

;; Routes definition
(def routes
  (app
   (wrap-file "resources/public")
   (wrap-params)
   (wrap-session {:cookie-name "clog-session" :store (cookie-store)})
   ["login"] (delegate login)
   ["admin"] (delegate admin)
   [""] (delegate index)
   [id] (delegate post id)))

Also make sure that you add the necessary namespaces to the core.clj namespace.

(ns clog.core                           
  (:use ring.adapter.jetty 
        ring.middleware.resource
        ring.middleware.reload
        ring.util.response
        ring.middleware.file
        ring.middleware.params
        ring.middleware.session
        ring.middleware.session.cookie
        net.cgrand.moustache
        clog.controller))

When a user logs in, we can use the session to store the username, and in subsequent requests to admin pages, we’ll verify if the session contains the username otherwise we send the user back to login page. First let us update the login method in the controller to make sure that we set the “username” on the session cookie.

(defn login
  "Login Handler"
  [req]
  (let [params (:params req)]
    (if (empty? params)
      (response (login-page))
      (if (= (get params "username") (get params "password"))
        (assoc (redirect "/admin") :session {:username (get params "username")})
        (response (login-page "Invalid username or password"))))))

When the username is valid according to our logic – we set the session map during redirect. This will set a cookie with the name “clog-session” when the user is logged in. You can check the cookie in your browser’s inspector.

Now we’ll tweak the admin handler to check whether the username is set on the session cookie, if not, we’ll redirect the user to the login page.

(defn admin
  "Admin handler"
  [req]
  (let [username (:username (:session req))]
    (if (nil? username)
      (redirect "/login")
      (response "Admin Page"))))

The next step is to add a logout function that will clear the session to make sure the username key is removed from the session.

defn logout
  "Logout handler"
  [req]
  (assoc (redirect "/") :session nil))

We also need to update our routes to make sure that”/logout” works as expected. Just add the new logout handler to the routes in core.clj as follows:

(def routes
  (app
   (wrap-file "resources/public")
   (wrap-params)
   (wrap-session {:cookie-name "clog-session" :store (cookie-store)})
   ["login"] (delegate login)
   ["logout"] (delegate logout)
   ["admin"] (delegate admin)
   [""] (delegate index)
   [id] (delegate post id)))

After these changes, when you try to access “/admin” without logging in you’ll be redirected to the login page as expected. Browsing to “/logout” page will “clear” your session redirecting you back to the home page of the blog.

Since we are now having only one “secure” page, we just added the session check to the admin handler function itself. Clearly this isn’t a nice way, since in a production version of your blog, you might have many more admin pages such as user settings, post settings etc. This approach of verifying the session in every function look pretty stupid in that case.

You can move the session checking logic to a different security wrapper handler which will check the request before forwarding to the next handler. If this security wrapper handler sees that the url is one of the “secure” urls, it will verify the session. When the session doesn’t contain the username key, it can redirect to the login page.

Blog post admin page

Now we have our simple security in place, let us finish our blog posting function that will allow us to create a new post. First create the admin html page which contains the form for the blog post.

<!DOCTYPE html>
<html>
<head>
    <title>Clog - Admin</title>
    <script type="text/javascript" src="/bootstrap/js/html5.js"></script>
    <link rel="stylesheet" type="text/css" href="/bootstrap/bootstrap.css"/>
    <style type="text/css">
        body {
            padding-top: 80px;
        }
    </style>
</head>
<body>
 
<div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
        <div class="container">
            <span><a class="brand"><b>Clog - The clojure Blog</b></a></span>
            <span class="pull-right"><a href="/logout">Logout</a></span>
        </div>
    </div>
</div>
<div class="container">
      <h2>New Post</h2>
 
    <div class="span8">
        <form class="form" method="POST" action="/admin">
            <div class="control-group">
                <label class="control-label" for="title">Title</label>
                <input type="text" id="title" name="title"
                class="span8 input-xlarge"/>
            </div>
            <div class="control-group">
                <label class="control-label" for="password">Content</label>
                <textarea name="content" class="span8 input-xlarge" rows="20"></text>
            </div>
            <div class="form-actions">
                <button type="submit" class="btn btn-primary">Save</button>
            </div>
        </form>
    </div>
</div>
</body>
</html>

The admin page contains a simple form with title field and a text area for the post content. We also added a logout link in case the user wants to logout of the admin area. The above html should be placed into clog/resources/admin.html along with other templates.

Update the templates.clj and create a oneliner that will use this template.

(deftemplate admin-page "admin.html" [])

Now replace the admin handler in controller.clj so that it will render the admin template as response.

(defn admin
  "Admin handler"
  [req]
  (let [username (:username (:session req))]
    (if (nil? username)
      (redirect "/login")
      (response (admin-page)))))

As you can see in the admin html, the form is posting the content to the same admin URL. So we need to capture that form parameters and update the database with the post details.

(defn admin
  "Admin handler"
  [req]
  (let [username (:username (:session req))
        params (:params req)]
    (if (nil? username)
      (redirect "/login")
      (do
        (if-not (empty? params)
          (let [id (inc (count (select posts)))
                author-id (:id (first (select authors (fields :id) (where {:username username}))))]
            (insert posts (values (assoc params
                                    :id id
                                    :author author-id)))))
        (response (admin-page))))))

Once this function is in, you can now login to the blog admin area using jane or john and add a new post to the blog.

Conclusion

This concludes the part 5 of this series. In the next and final part, I’ll discuss what sort of deployment options available and how you can deploy your Clog engine to “production”. As you can see the webapp we built so far is no where near to a production standard application, but this should help you get started with developing your own apps. You can now enhance clog with list of posts, deleting posts, adding comments etc. by just using the conceptual framework presented in this series. If you have any questions, feel free to ask in the comments of this post.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixtures with clj-yaml and HTML Templating with Enlive
• Part 4: Adding CSS, Post detail page and Simple Authentication
• Part 5: Blog Administration Area

Introduction

The story so far – In the last 3 parts, we completed setting up the project for a simple blog engine, loading the test data and finally displaying the blog posts on the “home” page. In this post first we’ll first add some nice CSS to make it look a bit better and finish the blog post detail page. Next we’ll add an authentication page for the blog.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part4

Static Resources

To make our blog look a bit more nice, we need some CSS and styling. We’ll use twitter’s bootstrap CSS for styling. To serve the css files from the root path, we can use ring middleware file provides a function wrap-files which will serve the static resources. First create a folder called public in the resources folder. This will contain all the static stuff like images, CSS etc. Now download and copy the bootstrap folder to the newly created public folder. The folder structure in IntelliJ should look like the following:

Update the code in core.clj‘s routes and add the wrap-file as shown below:

(def routes
  (app
   (wrap-file "resources/public")
    [""] (delegate index)))

Now update your HTML for the home page with the following code. The changes I made are adding the CSS declaration to the top, and restructuring HTML a bit.

<!DOCTYPE html>
<html>
<head>
    <title>Clog - The clojure Blog</title>
    <link rel="stylesheet" type="text/css" href="/bootstrap/css/bootstrap.css"/>
    <style type="text/css">
         body {
             padding-top: 80px;
         }
     </style>    
</head>
<body>
 
<div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
        <div class="container">
            <span><a class="brand"><b>Clog - The clojure Blog</b></a></span>
        </div>
    </div>
</div>
<div class="container">
    <div class="post row">
        <div class="page-header"><h1><span class="title">Title of the Post</span></h1></div>
        <div class="content">Post Content</div>
    </div>
</div>
</body>
</html>

(use 'clog.templates :reload)

Here’s how the home page looks now.

Hacking LESS (Optional)

If you are feeling adventurous, you can try editing the Bootstrap LESS and change the styling to your liking. I use less.js and the .less files directly, and experiment with changing the styles. Just download the latest less.js and keep it under bootstrap/js and replace the stylesheet link in the html’s head element to the following:

<link rel="stylesheet/less" type="text/css" href="/bootstrap/less/bootstrap.less"/>
<script src="/bootstrap/js/less-1.2.1.min.js" type="text/javascript"></script>

Here’s how the blog looks like with Clojure Colors

Post Detail Page

Now we just have the home page, but it would be better if we show the single blog post page when someone clicks on the post title. So let us add that functionality. First we need a new route that will handle the post detail URLs. Whenever someone goes to http://host/{post_id} we’ll show the detail page of that post. So we repeat pretty much the same exercise we did for rendering the home page, i.e., creating a template (both html and a new deftemplate in templates.clj ), adding a controller function, and finally calling that function in updated routes.

Here’s the updated version of the routes declaration which adds a new handler to the route as shown below.

;; Routes definition
(def routes
  (app
   (wrap-file "resources/public")
    [""] (delegate index)
    [id] (delegate post id)))

For the HTML of the post detail page, we’ll just reuse the home page, copy the html from home.html to post.html. Update the templates.clj with the deftemplate macro, the code is also similar to the home-page template macro.

(deftemplate post-page "post.html" [post]
  [:title] (content (str "Clog - " (:title post)))
  [:span.title] (content (:title post))
  [:div.content] (html-content (:content post)))

And finally the controller method

(defn post
  "Post details page handler"
  [req id]
  (let [postId (Integer/parseInt id)]
    (->> (first (select posts (where {:id postId})))
      post-page response)))

After these changes you should be able to see the post detail page by going to http://host:port/1 or http://host:port/2

Link to the Post pages

We’ll now modify the home page template and link the title of the post to the corresponding detail page. First modify the home.html and change the title span to an anchor. Here’s the relevant part of the modified html:

  <h1><a class="title">Title of the Post</a></h1></div>

Now edit the templates.clj to add the href attribute to the post detail page. Since we need to add the href and modify the content of the a tag, we use the do-> function to add the transformations. Here’s the updated home-page macro in templates.clj:

(deftemplate home-page  "home.html" [posts]
  [:title] (content "Clog - the clojure blog engine!")
  [:div.post] (clone-for [post posts]
                [:a.title] (do->
                             (set-attr :href (str "/" (:id post)))
                             (content (:title post)))
                [:div.content (html-content (:content post))]))

If everything went well, once you reload the templates namespace using (use ‘clog.templates :reload) you should see the home page with titles of the posts linking to the post detail pages.

Authentication

The next step is to create an administration area which is only accessible after login, and will be used to create the blog posts. First we need to create our login.html which will contain a form that will allow users to login. Notice that there’s an error div, which we will use to show the error message when the user enters invalid username and password. Take the following code and put it in a file login.html under resources

<!DOCTYPE html>
<html>
<head>
    <title>Clog - Login</title>
     <link rel="stylesheet" type="text/css" href="/bootstrap/css/bootstrap.css"/>
     <style type="text/css">
         body {
             padding-top: 80px;
         }
     </style> 
</head>
<body>
 
<div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
        <div class="container">
            <span><a class="brand"><b>Clog - The clojure Blog</b></a></span>
        </div>
    </div>
</div>
<div class="container">
    <div class="span8">
        <div id="error" class="alert alert-error"></div>
        <form class="form" method="POST" action="/login">
            <div class="control-group">
                <label class="control-label" for="username">Username</label>
                <input type="text" id="username" name="username" class="input-xlarge"/>
            </div>
            <div class="control-group">
                <label class="control-label" for="password">Password</label>
                <input id="password" type="password" name="password" class="input-xlarge"/>
            </div>
            <div class="form-actions">
                <button type="submit" class="btn btn-primary">Login</button>
                <a class="btn" href="/">Cancel</a>
            </div>
        </form>
    </div>
</div>
</body>
</html>

Now let us add a macro to our templates.clj to render the login page. In this macro, we are checking if any message is passed to the template method, we’ll set the appropriate message in the error div. We are also using the set-attr and remove-attr functions from enlive.

(deftemplate login-page "login.html" [& msg]
  [:div#error] (if (nil? msg)
                  (set-attr :style "display:none")
                  (do->
                    (remove-attr :style)
                    (content msg))))

Now let us update the routes, so when someone goes to /login we’ll render the login page. We need to also add a POST handler that will process the login form’s post request. We’ll also use the ring’s params middleware function wrap-params that will wrap the request parameters and pass it on along with request. So update the clog.core namespace to include the ring.middleware.param:

(ns clog.core
  (:use ring.adapter.jetty
        ring.middleware.resource
        ring.middleware.reload
        ring.util.response
        ring.middleware.file
        ring.middleware.params
        net.cgrand.moustache
        clog.controller))

Now update the routes var with wrap-params and handler for the login page and login action as shown below:

(def routes
  (app
   (wrap-params)
   (wrap-file "resources/public")
    ["login"]  (delegate login)
    [""] (delegate index)
    [id] (delegate post id)))

The login route will handle both POST and GET, since we haven’t specified any request method. The function login is in the controller.clj which is shown below.

(defn login
  "Login Handler"
  [req]
  (let [params (:params req)]
    (if (empty? params)
      (response (login-page))
      (if (= (get params "username") (get params "password"))
        (redirect "/admin")
        (response (login-page "Invalid username or password"))))))

This is a bit “crude” way of handling login, but we are trying to keep this as simple as possible. What the above function is doing is checking if the params are empty, they’ll be empty when there’s a GET request on the /login URL, then just render the login-page with no parameters. When the params are not empty, check if username is equal to password, then redirect to the /admin url (which doesn’t exist yet, but we will add it soon). And finally, if the username isn’t equal to password, then render the same login-page but with a message “Invalid username or password”.

Now that all the required pieces are in place, when you start the server (with port 8080), you should be able to see the login page at http://localhost:8080/login and when you enter two different strings for username and password, you should see an error message. You’ll get a redirect to /admin when you enter same string for username and password.

Conclusion

In this part we finished the “front-end” of the blog and started working on the admin area. In the Part 5of this series, we’ll wrap up the blog engine by completing the administration area that allows you to create the blog posts. In sixth and final part of this series we’ll see what deployment options are available and how to deploy the blog engine on Heroku.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixtures with clj-yaml and HTML Templating with Enlive
• Part 4: Adding CSS, Post detail page and Simple Authentication
• Part 5: Blog Administration Area

Introduction

In the previous part of this tutorial we created a couple of tables using migrations – authors table and posts table. In this part first I’ll describe how to load some test data (a.k.a ‘fixtures‘) into our database tables. We’ll use YAML to define a couple of authors and 3 blog posts and we’ll parse the YAML file and load the data using the clj-yaml library.

Also we’ll create our first template and render the blog’s home page with the sample data from the database.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part3

A quick note for PostgreSQL users

In the previous while creating the tables using migrations, I overlooked and made a mistake in naming the tables. If you are using PostgreSQL then the word “user” is a reserved word, so you should rename the table to authors – I’ve updated the code accordingly.

Loading Fixtures

Fixtures are used to populate the database with some initial data. Though fixtures are mostly used for loading test data we can also use fixtures to bootstrap the content. First let us create a file called fixtures.yml under resources folder. If you don’t have a resources folder in your project, create it under the root directory so that will be at the same level as src folder.

Edit the fixtures.yml and add the following:

authors:
    - id: 1
      username:     "john"
      password:     "clojure-blogger"
      email:        "john@clojure-blog.org"
    - id: 2
      username:     "jane"
      password:     "clojure-blogher"
      email:        "jane@clojure-blog.org"
 
posts:
    - title: "Hello World!"
      text: "<em>Welcome to Clog, the World's most advanced Clojure Blog Engine!</em>"
      status: true
      author: 1
    - title: "Hello World!, again!"
      text: "Sayin 't 'gain! <em>Welcome to Clog, the World's most advanced Clojure Blog Engine!</em>"
      status: true
      author: 2

Now, fire up the Clojure REPL in IntelliJ IDE using Tools -> Start Clojure Console. We’ll load the clj-yaml library and parse the yaml file.

;; load clj-yaml
(use 'clj-yaml.core)
(parse-string (slurp "./resources/fixtures.yml"))

If everything went well, you should see the map with keys :authors and :posts in the console as shown below:

{:authors 
  ({:id 1, :username "john", :password "clojure-blogger", :email "john@clojure-blog.org"} 
   {:id 2, :username "jane", :password "clojure-blogher", :email "jane@clojure-blog.org"}), 
 :posts 
  ({:title "Hello World!", 
    :text "<i>Welcome to Clog, the World's most advanced Clojure Blog Engine!</i>", 
    :status true, :author 1} 
   {:title "Hello World!, again!", 
     :text "Sayin 't 'gain! <i>Welcome to Clog, the World's most advanced Clojure Blog Engine!</i>", 
    :status true, :author 2})}

Now to add the authors to the database all you need is the following couple of lines:

;;load korma library and models
(use 'korma.db 'korma.core 'clog.models)
(insert authors (values (:authors (parse-string (slurp "./resources/fixtures.yml")))))

The second line in the above code snippet reads the fixtures file using slurp, parses the yaml using parse-string which returns a map with keys :authors and :posts. We use clojure’s maps-as-functions-of-keys features to get the list of authors and pass them to Korma’s insert function. Once this is executed you can see the data is now inserted into the Users table.

(select authors)
;;output
[{:id 1, :username "john", :password "clojure-blogger", :email "john@clojure-blog.org"} 
 {:id 2, :username "jane", :password "clojure-blogher", :email "jane@clojure-blog.org"}]
(select posts)
....

Templates using Enlive

Now that we have our sample data populated in the database, it is time to get started with our first template. Clojure has a couple of libraries that can help you with dealing with HTML viz, Hiccup and Enlive. Hiccup is a DSL for generating HTML and Enlive is a selector based templating engine. I’m a bit biased towards Enlive – since I have more freedom of styling and HTML stays HTML. So in this tutorial I’m using Enlive.

Defining Home Page Template

Enlive provides a macro called deftemplate to define template functions. The macro is defined as follows:

(defmacro deftemplate
 "Defines a template as a function that returns a seq of strings." 
 [name source args & forms] 
  `(def ~name (template ~source ~args ~@forms)))

The forms you pass in are actually used to transform the html. I think it will be easier to understand with an example that you can follow along. First let us create the home.html under resources folder. By convention the templates are loaded from the resources directory.

<!DOCTYPE html>
<html>
<head>
    <title>Title Here</title>
</head>
<body>
Clog - Home Page!
</body>
</html>

We will place all our template definitions in clog.templates namespace which lives in cleverly named templates.clj

(ns clog.templates
  (:use [net.cgrand.enlive-html]))
 
(deftemplate home-page "home.html" []
  [:title] (content "Clog - the clojure blog engine!"))

In the above snippet we are using deftemplate macro to create a template function called home-page which takes the file home.html and transforms the file using the forms, in our case only one which is:

[:title] (content "Clog - the clojure blog engine!")

This says find out the tag :title in the home.html and replace its contents with “Clog – the clojure blog engine!”. To test this out you can load the namespace in repl and run the home-page function. That will print out the transformed template as shown below.

(use 'clog.templates)
nil
user=> (home-page)
("<!DOCTYPE html>\n" "<html>" "\n" "<head>" "\n    " "<title>" "Clog - the clojure blog engine!" "</title>" "\n" "</head>" "\n" "<body>\nClog - Home Page!\n</body>" "\n\n\n" "</html>")

Now this template function can be used to generate the transformed html we need to send to the client. To connect the these views to the requests, we will use simple controller functions. These functions/handlers are then used to transform the templates using the request parameter and data from the database. For example we want our blog to respond to something like http://host:port/posts/1 by sending out the html for the post with id 1. This logic is wrapped inside a controller function.

A simple Controller

We’ll put our controller functions in the clog.controller namespace. Here’s the initial version of the controller which has handler for the index page.

(ns clog.controller
  (:use clog.templates
         clog.models
         ring.util.response))
 
(defn index
  "Index page handler"
  [req]
  (->> (home-page) response)) ;; A sexier way to write (response (home-page))

Now to see this function in action, we need to update the routes of the application in core.clj to call clog.controller/index. Here’s the complete core.clj after the required modifications:

(ns clog.core
  (:use ring.adapter.jetty
        ring.middleware.resource
        ring.middleware.reload
        ring.util.response
        net.cgrand.moustache
        clog.controller))
 
;; Routes definition
(def routes
  (app
    [""] (delegate index)))
 
;;; start function for starting jetty
(defn start [port]
  (run-jetty #'routes {:port (or port 8080) :join? false}))
 
(defn -main []
  (let [port (Integer/parseInt (System/getenv "PORT"))]
    (start port)))

Start the server as shown below, and you should see the home page with title in the window title bar “Clog – the clojure blog engine!”.

(use 'clog.core)
(start 9000)

List of Posts

The home is working, but it is rather boring and doesn’t show any real data. Let us try to show the two posts we added in the database. First we need to update the home.html to create a place holder for a post.

<!DOCTYPE html>
<html>
<head>
    <title>Title Here</title>
</head>
<body>
<div class="post">
    <div class="title">Title of the Post</div>
    <div class="content">Post Content</div>
</div>
</body>
</html>

Now let us update the template and add another transformation. In this case we want to “clone” the div with class post and replace the content of divs with classes title and content. Here’s the updated deftemplate’s code that does exactly the same. We are using clone-for macro and using the forms to transform the sub elements.

(deftemplate home-page  "home.html" [posts]
  [:title] (content "Clog - the clojure blog engine!")
  [:div.post] (clone-for [post posts]
                [:div.title] (content (:title post))
                [:div.content (content (:content post))]))

Now we need to make sure that our controller function sends the required data to the template.

(ns clog.controller
  (:use  clog.templates
         clog.models
         ring.util.response
         korma.core))
 
(defn index
  "Index page handler"
  [req]
  (->> (select posts) home-page response)) ;; Equivalent to  (response (home-page (select posts))

We are selecting all the posts using Korma select function and passing it on to home-page function. The result of the home-page template function – which is the html with posts populated is passed on to response.

After making these changes, you should see the list of posts in the home page.

Conclusion

In this part we saw how to glue things together and get the content from database, render it in a page using templates. In the next part we’ll finish by updating the home template and adding another template to display the post. Also, in the next part we’ll start working in creating an admin area with authentication.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

1. Herman Miller Aeron: Ultimate Programmer’s Chair
2. Nerf Recon CS-6 with N-Strike Darts: For fun times.
3. 17″ Mac Book Pro with 8GB RAM, SSD running Emacs in Full Screen: Ultimate Programmer’s Computer
4. The Joy of Clojure: The book for Ultimate programming language
5. mStand for MBP: For enhanced ergonomics and coolness factor

Not shown in the photo:

• Super Awesome Colleagues
• Projects using cutting-edge tech including: Scala, Play! Framework.
• No Managers
• No Managers, Seriously.
• WORK-ON-YOUR-OWN-COOL-PROJECT-EVERY-FRIDAY – Yeah, EVERY Friday.

Like what you see and curious about what we do ? Come and talk to us at Play!ground on February 3rd at Paddy Murphy’s Irish Pub, Rotterdam.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive
• Part 4: Adding CSS, Post detail page and Simple Authentication
• Part 5: Blog Administration Area

Updated: 31st January, 2012 – Renamed all ‘users’ to ‘authors’ to prevent problems with PostgreSQL

Introduction

In part 1 of this series, we learnt how to setup a Clojure web application project – Clog a blogging engine. In this second part of the tutorial we will start working on the application’s database layer – setting up the schema, creating migrations and finally creating the entities for the model. This terminology should be familiar for people who already worked with other web application frameworks such as Ruby on Rails or Play! framework. If you have never used these frameworks, do not worry no knowledge of those is assumed in this tutorial.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part1

Database Schema Setup

Normally when you want to work with a database, you will create a schema using DDL (Data Definition Language). DDL contains SQL statements like “CREATE TABLE AUTHOR …” etc. This will define the schema objects you need to store your application’s data. In this post however, I’d like to show you how you can create and manage the schema using a Clojure library called Lobos.

Lobos library provides a DSL (Domain Specific Language) that helps you in defining the database schema and migrations in a Database-agnostic way. By that I mean you can define your schema in Clojure and you can use Lobos to create the schema on any database e.g. PostgreSQL, MySQL or HSQL.

Before we begin, we need to create a database. As you might have seen in part 1‘s dependency listing, for this tutorial we will use PostgreSQL as the database.

Database Setup

First install PostgreSQL for your platform by downloading it from here. Create a user with login clog and your choice of password. Create a database named clogdb and make sure that the user has permissions on the database. To perform these steps you can either use the pgAdmin GUI tool to manage the database or you can use psql command line tool. If you prefer the latter, you can use the following commands to create the database and user:

CREATE USER clog WITH PASSWORD 'Your_Choice_Of_Password';
 
CREATE DATABASE clogdb;
 
GRANT ALL PRIVILEGES ON DATABASE clogdb TO clog;

Schema Creation using Lobos

Before we start writing code in Clojure with Lobos, let us take a quick look at the terminology.

Migrations

Migrations are incremental steps that you have taken to evolve your database schema. Let me explain what a migration means with a concrete example. When you are creating the tables for our blog engine, you will create a table called Posts to store our blog posts. The Posts table might contain the following columns: id, publishedDate, status, content, title. To create a table with these fields you’ll use the following SQL DDL:

CREATE TABLE posts ( id INTEGER UNIQUE, 
                     title text NOT NULL,
                     content text,
                     published_date DATETIME NOT NULL,
                     STATUS text NOT NULL, 
                     CONSTRAINT posts_id_key PRIMARY KEY (id));

Now at a later point of time you want to add rating to all the blog posts, that means you need to alter the schema to add a new column to the Posts table. This can be done using following Alter table statement.

ALTER TABLE posts
      ADD rating INTEGER;

In the above scenario, your database schema on the whole, has two versions or revisions. Version one that resulted when you executed the CREATE table statement and Version one when you executed the Alter table version. You can treat the two statements you used to modify the database as two migrations. Initially your database schema is at Version 0, once the first migration is executed, you have updated your database to version 1. After second statement, the ALTER TABLE one, is executed your database will be at version 2.

To “rollback” the schema you need a statement which will drop the added rating column, and another to drop the table completely which will result in database resulting in Version 0. When all these SQL statements are combined we get what we call “migrations”. Migrations help you “migrate” and “rollback” the database. Think of the migrations as a version control mechanism for your database.

Now that we know what migrations mean, let us see how to create the schema and migrations using Lobos.

Schema Definition using Lobos migrations

We will define all the schema related operations and migrations in a Clojure namespace called migrations. First create a new directory called lobos under src. If you are using IntelliJ IDEA, then right click the src directory and select New > Package and create a package named lobos. Inside the src/lobos create a file called migrations.clj. Add the following code to the file:

(ns lobos.migrations
  ;; exclude some clojure built-in symbols so we can use the lobos' symbols
  (:refer-clojure :exclude [alter drop
                            bigint boolean char double float time])
  ;; use only defmigration macro from lobos
  (:use (lobos [migration :only [defmigration]]
          core
          schema)))
 
;;; Defines the database for lobos migrations
(def clogdb
  {:classname "org.postgresql.Driver"
   :subprotocol "postgresql"
   :subname "clogdb"
   :user "clog"
   :password "clog"})

The code snippet above defines a namespace migration with one var clogdb which is a map of database connection information. You may need to change the database password with the one you used while creating the database user.

We create our first migration that will add the users table:

(defmigration add-authors-table
  ;; code be executed when migrating the schema "up" using "migrate"
  (up [] (create clogdb
           (table :authors (integer :id :primary-key )
             (varchar :username 100 :unique )
             (varchar :password 100 :not-null )
             (varchar :email 255))))
  ;; Code to be executed when migrating schema "down" using "rollback"
  (down [] (drop (table :authors ))))

Next we define the migration that will create the posts table as shown below:

(defmigration add-posts-table
  (up [] (create clogdb
           (table :posts (integer :id :primary-key )
             (varchar :title 250)
             (text :content )
             (boolean :status (default false))
             (timestamp :created (default (now)))
             (timestamp :published )
             (integer :author [:refer :authors :id] :not-null))))
  (down [] (drop (table :posts ))))

The above code is pretty much similar to the authors table migration – a title column, text column and a couple of timestamp columns to store the created and published date and times. Also, every post belongs to an author, so we create a foreign key to the authors table using :refer. Here we are referring to the :authors table’s :id column.

To run the above code, start a REPL console if it isn’t already running. Type the following commands into the console:

(use 'lobos.core 'lobos.connectivity 'lobos.migration 'lobos.migrations)
(open-global clogdb)
(migrate)

You should see the following output in the console:

WARNING: alter already refers to: #'clojure.core/alter in namespace: user, being replaced by: #'lobos.core/alter
WARNING: drop already refers to: #'clojure.core/drop in namespace: user, being replaced by: #'lobos.core/drop
WARNING: complement already refers to: #'clojure.core/complement in namespace: user, being replaced by: #'lobos.migration/complement
nil
{:default-connection {:connection #, :db-spec {:subprotocol "postgresql", :classname "org.postgresql.Driver", :subname "clogdb", :user "clog", :password "clog"}}}
add-authors-table
add-posts-table
nil

To cross check what relations are created in the database, you can use psql and try the following commands:

clogdb=# \d
\d         
             List OF relations              
 Schema |       Name       | TYPE  | Owner  
--------+------------------+-------+------- 
 public | lobos_migrations | TABLE | clog   
 public | posts            | TABLE | clog   
 public | authors            | TABLE | clog   
(3 ROWS)                                    
 
clogdb=# \d authors                                                                           
\d authors                                                                                    
             TABLE "public.authors"                                                           
  COLUMN  |          TYPE          | Modifiers                                              
----------+------------------------+-----------                                             
 id       | INTEGER                | NOT NULL                                               
 username | CHARACTER VARYING(100) |                                                        
 password | CHARACTER VARYING(100) | NOT NULL                                               
 email    | CHARACTER VARYING(255) |                                                        
Indexes:                                                                                    
    "authors_primary_key_id" PRIMARY KEY, btree (id)                                          
    "authors_unique_username" UNIQUE, btree (username)                                        
Referenced BY:                                                                              
    TABLE "posts" CONSTRAINT "posts_fkey_user" FOREIGN KEY ("author") REFERENCES authors(id)    
 
clogdb=# \d posts                                                                           
\d posts                                                                                    
                  TABLE "public.posts"                                                      
  COLUMN   |            TYPE             |   Modifiers                                      
-----------+-----------------------------+---------------                                   
 id        | INTEGER                     | NOT NULL                                         
 title     | CHARACTER VARYING(250)      |                                                  
 content   | text                        |                                                  
 STATUS    | BOOLEAN                     | DEFAULT FALSE                                    
 created   | TIMESTAMP WITHOUT TIME zone | DEFAULT now()                                    
 published | TIMESTAMP WITHOUT TIME zone |                                                  
 author    | INTEGER                     | NOT NULL                                         
Indexes:                                                                                    
    "posts_primary_key_id" PRIMARY KEY, btree (id)                                          
Foreign-KEY constraints:                                                                    
    "posts_fkey_author" FOREIGN KEY ("author") REFERENCES authors(id)

Lobos keeps track of which migrations are run using the lobos_migrations table. As you can see below our current lobos_migrations contains two migrations we have written and executed.

clogdb=# SELECT * FROM lobos_migrations;  
SELECT * FROM lobos_migrations;           
      name                                
-----------------                         
 add-authors-TABLE                          
 add-posts-TABLE                          
(2 ROWS)

Entity Definition

After creating the database, now we’ll define our entities using the SQL library Korma. What is Korma ?

Korma is a domain specific language for Clojure that takes the pain out of working with your favorite RDBMS. Built for speed and designed for flexibility, Korma provides a simple and intuitive interface to your data that won’t leave a bad taste in your mouth.

Korma makes it easier to deal with the database. Instead of using SQL queries, you can use Clojure to access the database. To get the data from the tables, first we need to define entities using the Korma’s defnentity macro. First create a file called models.clj in your src/clog folder. And add the following code to the file:

(ns clog.models
  (:use korma.db
        korma.core))
 
(defdb clogdb
  {:classname "org.postgresql.Driver"
   :subprotocol "postgresql"
   :subname "clogdb"
   :user "clog"
   :password "clog"})
 
(defentity authors)
(defentity posts)

The above code defines two entities authors and posts. Let me show you how we can insert an author record into the database and select the list of authors from the database. Start Clojure REPL, if it isn’t running already. Type the following code into REPL:

(use 'korma.db 'korma.core 'clog.models)
(insert  authors (values {:id 1, :username "vijay", :password "password", :email "mail AT vijaykiran.com"}) )

This will insert a new record into the database. You can use the select function to get the list of authors from the authors table.

(select authors)
[{:id 1, :username "vijay", :password "password", :email "mail AT vijaykiran.com"}]

Source Code

If you are stuck at any point and want to directly checkout the code, you can use the following commands to get the code that is tagged with part2

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part2

Conclusion

This concludes the part 2 of this series. In this part of the tutorial we saw how to create a simple schema using Lobos library, also we defined the entities for the tables we created using the Korma library. In the next part I’ll show you how to populate sample data into the database and we’ll create our first template to display the data in the browser.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

If you have any feedback on this article and its content, you can contact me via Twitter.

via The Rise of the New Groupthink – NYTimes.com.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive
• Part 4: Adding CSS, Post detail page and Simple Authentication
• Part 5: Blog Administration Area

Introduction

Clojure is general-purpose compiled, dynamic, Lisp-dialect language that targets JVM (also .Net CLR and JavaScript). There are many ways you can build a Web application using Clojure. You can use a simple framework like Noir or you can pick and choose libraries you like and build your own web stack along the way. I assume that you already started learning Clojure using some tutorial or a good Clojure book.

In this blog post series I’ll explain how to build a web application using Clojure. Creating a blogging engine seems to be the equivalent “hello world” for Web application development, so let us build a blog engine in Clojure: Clog.

Clojure Web Application Toolkit

There are many fantastic libraries available for Clojure for any type of task you can imagine and superior Java Interoperability of Clojure gives you seamless access to innumerable Java libraries and API that you can benefit from. To build a database backed web application you might need some standard libraries to perform HTTP Routing, Database connectivity and migrations, HTML Templates etc.

We’ll use the following libraries to build our web application:

• Clojure – 1.3.0 – The language.
• ring –  1.0.1 – The HTTP Abstraction API and Middleware.
• moustache  - 1.1.0 – HTTP Routes DSL
• lobos –  1.0.0-SNAPSHOT – Database Schema Manipulation and Migrations
• korma – 0.2.1 – DSL for Database Connectivity and Interaction.
• enlive – 1.0.0 – Selector based HTML library.
• postgresql - 9.1-901.jdbc4 – PostgreSQL JDBC4 driver.
• clj-yaml – 0.3.1 – A snakeyaml wrapper for YAML file parsing and generation.

The above list is just for your information. You don’t need to individually download those libraries. For those of you who are familiar with Java dependency management tools like Apache Maven or Apache Ivy, Clojure ecosystem has similar build tool called Leineingen which helps you configure your project, manage dependencies etc.

Leiningen is for automating Clojure projects without setting your hair on fire.Working on Clojure projects with tools designed for Java can be an exercise in frustration. With Leiningen, you just write Clojure.

Using Leiningen you can configure your project settings using Clojure. Leiningen uses Apache Maven for dependency resolution. So you can add any library from a maven repository as a dependency to your Clojure project. Installing Leiningen is very straight forward, which is left as an exercise to the reader.

Project Setup

After you have installed leiningen you can create a project by typing the following command in your terminal (or command) window.

lein new clog

If leiningen is installed properly you should see an output of the command similar to the following

→ ~$ lein new clog
Created new project in: /Users/vijaykiran/clog
Look over project.clj and start coding in clog/core.clj

When you run the above command, leiningen will create a simple Clojure project named “clog” for you. If you look into the clog folder, you see there are several files and folders created. Again, if you are familiar with Apache Maven, you can see the structure is pretty similar to standard Maven project. Anyway, let us take a quick look at the generated files and folders:

• README – A simple README file
• project.clj – The Clojure project configuration file – written in Clojure.
• src – Folder for your source code
• test – Folder for your tests
• src/clog/core.clj – The “core” Clojure file for your project (You can change it to whatever you want, but for simplicity, we’ll leave it as it is).

Create a directory called resources inside the clog directory. This directory will be used to store and serve the static resources like images, CSS files etc. of our web application.

There are many configuration options available to set up your project via the project.clj file. But for now we’ll just focus on simple things like adding dependencies.

Adding Dependencies

If you open the project.clj file under your clog folder, you can already see that there are a couple of dependencies configured using defproject macro.

(defproject clog "1.0.0-SNAPSHOT"
  :description "FIXME: write description"
  :dependencies [[org.clojure/clojure "1.3.0"]])

Let us update the file to add the required libraries (as shown above). Use your favorite editor to edit the project.clj, we’ll later setup an IDE for editing our source code. While we are there, we’ll also fix the version and description of the project and set them to 0.0.1-SNAPSHOT and A Clojure Blogging Engine.

(defproject clog "0.0.1-SNAPSHOT"
  :description "Clog: A Blog engine written in Clojure"
  :dependencies [[org.clojure/clojure "1.3.0"]
                 [ring "1.0.1" ;;; Exclude the clojure, clj-stacktrace from ring dependency
                   :exclusions [org.clojure/clojure
                               clj-stacktrace]]
                 [net.cgrand/moustache "1.1.0"]
                 [lobos "1.0.0-SNAPSHOT"]
                 [korma "0.2.1"]
                 [enlive "1.0.0"]
                 [postgresql "9.1-901.jdbc4"]
                 [clj-yaml "0.3.1"]])

After you edit the project.clj, run the lein deps command to download the required dependencies. You should see output similar to this:

~/clog $ lein deps
...
Copying 32 files to /Users/vijaykiran/clog/lib

That is all you need to do to configure and setup your project. Of course, we still need to set up the database, which we will come back to at a later stage. Next step is configure a development environment a.k.a an IDE.

IDE Configuration

All major IDEs (Eclipse with Couter-ClockWise plugin, IntelliJ IDEA with La Clojure plugin and Netbeans with Enclojure plugin) have Clojure support via Plugins. Many Clojure developers seem to prefer Emacs instead of using IDEs.

Emacs with SLIME

Emacs seems to be the favorite editor of most people in Clojure community. Emacs has several “plugins” that help with editing Clojure files. Learning & using Emacs can be intimidating at first but personally I find it very rewarding experience. If you are an Emacs user you can use clojure-mode, slime, swank and paredit as your development environment. There are several tutorials available on how to configure Emacs for clojure development. I encourage you to check them out if you want to use Emacs as your “IDE”. I use Emacs with lein swank, clojure-mode and slime-connect. I configured emacs with emacs starter kit and other plugins, FWIW, this is how it looks:

IntelliJ IDEA

For this tutorial I will use IntelliJ Community Edition with La Clojure and Leiningen Plugins. After downloading the IDE make sure you install and enable the plugins.

After you have installed both plugins, select Open Project .. option in IntelliJ and choose the project.clj from clog folder. Leiningen plugin will detect the project.clj and open the clog project as an IntelliJ project as shown below.

Make sure that you add Clojure facet to the module, which will allow you start the Clojure console for the project. Also, add the clojure 1.3 library for project if you have another version of clojure installed globally. This will make sure that when you start the Clojure console, it will use the correct Clojure version.

Startup code for Jetty Server

First step in developing a web application is to startup the jetty server. We will use the ring-jetty adapter to start-up the Jetty server. Edit the core.clj file and add the following code to it:

(ns clog.core
  (:use ring.adapter.jetty
        ring.middleware.resource
        ring.util.response
        net.cgrand.moustache))
 
;;; A simple handler to show send some response to the client.
(defn index
  [req]
  (response "Welcome, to Clog - A Blog Engine written in Clojure"))
 
;; Routes definition
(def routes
  (app
    [""] index))
 
;;; start function for starting jetty
(defn start [port]
  (run-jetty #'routes {:port (or port 8080) :join? false}))

Let us take a closer look on the code we added to the core.clj. First we defined the namespace clog.core and imported the namespaces via :use. Then we defined a simple function called index that uses the ring response method to send some text as response.

We used the moustache macro app to define the routes that we want to handle. In our case, we want the route that matches the url segment with parts [""] to the function index, which is another way saying when a client sends a request with no url segments or parameters, let the function index handle it.

Next we defined a function start that will help us to start a jetty server. It takes a port parameter, if it isn’t supplied, the run-jetty function from ring-jetty adapter will start the jetty server on port 8080.

Running the program in lein REPL

You can run this program using REPL in command line. Open a terminal window, and change to the clog directory. Then type lein repl, which will start a new Clojure REPL with the class path setup to include our project’s libraries. In the REPL, first import the clog.core namespace by typing use ‘clog.core. Now you can use the start function to start jetty on your port of choice. Here’s the transcript of the commands and their results:

→ ~$ cd clog
→ clog[master]/$ lein repl
REPL started; server listening on localhost port 53791
user=> (use 'clog.core)
nil
user=> (start 8888)
2012-01-11 16:10:41.640:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
#
2012-01-11 16:10:41.642:INFO::jetty-6.1.25
2012-01-11 16:10:41.654:INFO::Started SocketConnector@0.0.0.0:8888
user=>

Open a browser window and open the URL http://localhost:8888. You should see the message Welcome, to Clog – A Blog Engine written in Clojure.

Running the program in IntelliJ IDE

To run this program in IntelliJ, start the Clojure console by clicking on the Tools -> Start Clojure Console. This will start a console in your IDE with the your module’s class path. Now type (use ‘clog.core) and (start 8888) in your clojure console. You should see the output as shown below:

You can now browse to the URL: http://localhost:8888 to see the response.

Conclusion

This concludes the part 1 of this series. In part 2 I’ll show you how to create the database schema and migrations using Clojure and lobos. Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

If you have any feedback on this article and its content, you can contact me via Twitter.

• Chana : Chickpeas
• Methi :Fenugreek Leaves
• Matki : Earthen Pot
• Basmati Rice: Basmati Rice

The main ingredients

• Tomatoes – Deseeded, diced
• Red onion
• Methi Leaves
• Mint leaves
• Chana – soaked overnight and boiled
• Saffron – soaked in warm water
• Briyani Rice – washed and soaked in warm water
• Yogurt

Spices:

• Cloves
• Bay leaves
• Black Cardamom
• Cinnamon Sticks
• Green Cardamom
• Black Cumin Seeds
• Raisins
• Green Chili – Sliced vertically
• Star Anise
• Chopped Ginger and Garlic

Making the Chana “Masala”
Heat some ghee, add the spices (Cloves, Bay leaves, Black and green cardamom, cumin seeds and star anise). After a couple of minutes add chopped onions, chili, chopped ginger and garlic. Sauté for a 3-4 minutes. Add Chopped tomatoes. Once onion and tomato become soft add Chickpeas and Methi leaves. Keep stirring and keep cooking on medium heat.

After 4-5 minutes of cooking add yogurt and mix thoroughly. Reduce the heat and cook for a couple of more minutes. You don’t need to cook it all the way, since it will be put into the oven in a Matki.

Spread the chana masala as a thick layer in a Matki (Earthen Pot), and spread soaked rice on top of it as a second layer. On the rice sprinkle saffron water, a pinch of gram masala and some mint leaves. Add another layer of Chana Masala and Rice continue till you fill up the Matki.

Place the pot in the oven pre-heated to 200° Celsius – cook for 1.5 hours. Enjoy with Raita.

I’ve been hugely impressed with the Nokia Lumia 800 running Windows Phone 7.5. I’ve had an iPhone since day one, and every model since, but I really like the new path Microsoft is cutting with WP7 so I decided to give it an extended try. It’s been a bit over a week, and so far I don’t miss my iPhone at all. In fact, going back to the iPhone feels like going back in time. It’s rough around the edges in a few spots, but I think Microsoft is up to something good here. More on this in a future post after I’ve spent some more quality time with the phone/platform.

via Some great stuff Ive tried recently – 37signals.

0 vs. nothing is one of those abstract distinctions that’s almost impossible to talk about directly; you more have to do it with examples. Imagine there’s a certain math class, and in this class there’s a fiendishly difficult 100-point midterm, and imagine that neither you nor I get even one point out of 100 on this exam. Except there’s a difference: you are not in the class and didn’t even take the exam, where as I am, and did. The fact that you received 0 points on the exam is thus irrelevant — your 0 means N/A, nothing — where are my 0 is an actual zero. Or if you don’t like that one, imagine that you and I are respectively female and male, both healthy and 20—40 years of age, and we’re both at the doctor’s, and neither of us has had a menstrual period in the past ten weeks, in which case my total number of periods is nothing, whereas yours here is 0 — and significant.

- From Everything and More: A Compact History of Infinity (Great Discoveries)

… consider for a moment how many levels of abstraction are involved in math itself. In arithmetic there’s the abstraction of number; and then there’s algebra, with a variable being a further-abstracted symbol for some number(s) and a function being a precise but abstract relation between domains of variables; and then of course there’s college math’s derivatives and integrals of functions, and then integral equations involving unknown functions, and differential equations’ families of functions, and complex functions (which are functions of functions), and definite integrals calculated as the difference between two integrals; and so on up through topology and tensor analysis and complex numbers and the complex plane and complex conjugates of matrices, etc. etc., the whole enterprise becoming such a towering baklava of abstractions and abstractions of abstractions that you pretty much have to pretend that everything you’re manipulating is an actual, tangible thing or else you get so abstracted that you can’t even sharpen your pencil, much less do any math.

- From “Everything and More – A Compact History of ∞” by David Foster Wallace

##########################################################################################
#                                 Magic Date
#
# Author: Vijay Kiran<mail@vijaykiran.com>
#
# Allows conversion of natural date string to real date object.
# e.g. tomorrow, today, 2w etc.
#
#
# Implementation is shame-lessly based on MagicDate in Python. 
##########################################################################################
##                        Requirements/Specs                                            ##
##                                                                                      ##
#
# One liner - should work like OmniFocus date field
## 
#
# Details:
# • 2d, -3w, 1h, 1y1m, and so on — Relative dates and times put the date at
# a certain amount of time from right now. Negative numbers represent times in the past.
# 
# • 2 days, -3 weeks, 1 hour, 1 year 1 month, and so on — 
# You can use the full names of units too.
# 
# • yesterday, tomorrow, next thursday, last month, this friday, and so on — 
#   You can refer to relative dates using common words. 
#   “This”, “next”, and “last” have specific meanings: this friday always means 
#   the Friday in this week, next friday always means 
#   the Friday in the next week, and last friday always means 
#   the Friday in last week, regardless of what day today is. 
#   Other units work in the same way.
# 
# • september, thurs, 2019, and so on — If you enter the name of a specific time period, 
#   the date will be at its beginning. So september means September first.
# 
# • 5/23/08 10a, 9.30.09 2:00 PM, and so on — You can use the short date format as 
#   defined in your International system preferences. 
# 
# • 2w sat, 4d @ 5p, tues 6a, aug 6 tues 5p, and so on —
#    Mix the available formats however you like.
# 
# • now, 9, 14:00, tom, and so on — OmniFocus makes its best guess 
#   at things like bare numbers, times, and word fragments. 
#   If you think something might work, give it a try.
 
weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
 
magicDate = (str) ->
 d = new Date
 regs = [
   # Today
   [ /^tod/i, Date ],
   # Tomorrow
   [ /^tom/i, -> d.setDate(d.getDate() + 1) ;  d ],
   # Now
   [ /^now/i, Date],
   # Yesterday
   [ /^yes/i, -> d.setDate(d.getDate() - 1) ; d ],
   [ /^(last|next|this)\s(week)/, 
     (result) ->
       switch result[1].toLowerCase()
         when "last" then d.setDate(d.getDate() - 7)
         when "this" then d.setDate(d.getDate() + 1)
         when "next" then d.setDate(d.getDate() + 7)
       d
   ],
    # <last> <this>/<next> <weekday>
    [
      /^(last|this|next)\s(\S+)/i,
      (result) ->
        rel = result[1].toLowerCase()
        weekday = result[2].toLowerCase()
        today = d.getDay()
        # Pick index + 1 because getDay is 1 = Monday, 2 = Tuesday and so on
        index = (i + 1 for item, i in weekdays when new RegExp(weekday).test(item))
 
        switch result[1].toLowerCase()
          when "last" then d.setDate(d.getDate() - (today - index + (if (index < today ) then 0 else 7)) )
          when "this" then  d.setDate(d.getDate() + index - today)
          when "next" then  d.setDate(d.getDate() + index + today - 1 )
        d
    ]
   ]
# 
 for x in regs
     re  = x[0] 
     fn  = x[1]
     if re.test str then return fn(str.match re)

And here’s how you can use it:

testStrings = [ "yes", "yesterda", "Yes", "ye", "-"
                "tod", "todd", "today", "TodaY", "-"
                "now", "nowww", "Now", "ANDNOW","-"
                "tom", "tomorrow", "Tomorrow", "to", "-"  
                "last mon", "last tuesday", "last wed", "last thurs",  "last fri", "last sat" , "LAst Sunda", "-"
                "last week", "tHIS Week", "next week", "-"
                "this mon", "this tuesday", "this weDNE", "this thursday", "THIS FRIDAY", "this sat", "this sun", "-"
                "next mon", "NExt tue", "nex wednesday", "next thursday", "Next Friday", "Next Satur", "next sun", "-"]
 
for str in testStrings
  if str is "-" 
    console.log "---------------------------------------------------"
  else
    console.log "#{str}           =     #{magicDate str}"

Here are some photos I took at the event.

Also, yesterday – the iKiva app that I built crossed 6000 Downloads! I’m working on the next version which will be an universal app that will work on both iPad and iPhone/iPod touch. And Hopefully I’ll get enough free time to complete it in the next couple of months.

In 1909, after missing his train due to an ultimately disastrous trip to the lavatory at Ahmedpur station, an embarrassed, angry young man named Okhil Chandra Sen sent an unintentionally amusing letter of complaint to the Sahibganj divisional railway office in West Bengal. The letter proved to be an important one as, according to the Railway Museum in New Delhi, the subsequent investigation into the affair by the British Raj resulted in the introduction of toilets to all trains in the country; something that had been absent since the formation of Indian Railways in 1857.

via Letters of Note: My belly is too much swelling with jackfruit.