Generation pipeline

To actually generate anything with λ-blog we need to define a computation that will successively transform your content through different states into a bunch of static pages. We need a pipeline, if you will.

The generation pipline is quite literarily whatever you want it to be. Its purpose is to take your content and generate your static site with a bunch of magic happening inbetween over which you have total control. In fact, this the guiding principle behind λ-blog - it is optimized for customizability, so you can build a static blog generator tailored specifically to your needs.

The magic

λ-blog comes with a few useful functions that simplify generation pipeline creation. These can be divided into three categories:

  • Filesystem related functions, for example:
    • read-dir
    • copy-dir!
  • Entity manipulation functions, for example:
    • update
    • whenever
  • Site generation functions, for example:
    • generate!

Detailed descriptions of these functions can be found in the lambda-blog.generator namespace.

Building a pipeline

A sensible way to start building your generation pipeline is to define some sort of configuration entity (let's assume for a moment that we have data/js and data/style directories populated):

(def config {:author "Idorobots"
             :title "My kickass blog!"
             :scripts ["js/script.js"]
             :stylesheets ["style/style.css"
                           "style/theme.css"]
             :output-dir "out"})

Next, we need a convenient way to repeatably generate the static site. A Clojure function is the way to go:

(defn generate []
  (-> config
      ;; The pipeline goes here.
      ))

Lastly, we need to build the actual pipeline. Let's start by adding an entity representing the page index:

(-> config
    (assoc :index {:title "Index"})
    ;; ...
    )

Next, read & parse some entries (again, assume that we have data/entries handy). Note, that we want the entries to appear in a sorted orded, hence the update call:

(-> config
    (assoc :index {:title "Index"})
    (read-dir :entries "data/entries" hello-parser)
    (update :entries
            #(sort-by (comp :timestamp :metadata) %))
    ;; ...
    )

And finally, generate the site:

(-> config
    (assoc :index {:title "Index"})
    (read-dir :entries "data/entries" hello-parser)
    (update :entries
            #(sort-by (comp :timestamp :metadata) %))
    clean-dir!
    (generate! :index some-index-template)
    (generate-all! :entries some-entry-template)
    (copy-dir! "data/js" "js")
    (copy-dir! "data/style" "style"))

Now, whenever generate is evaluated a fresh and (hopefully) repeatable instance of My kickass blog! will be generated.


All writing licensed under Creative Commons License. All code released to the Public Domain unless otherwise specified.

Powered by λ-blog.