marcuskammer/coleslaw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

New pass at "incremental" compilation. See now, isn't that better?

Browse source
This commit is contained in:
Brit Butler 2014-06-03 16:37:56 -04:00
parent 3467157805
commit bed63d2156
2 changed files with 23 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
docs/hacking.md
View file

@ -134,7 +134,7 @@ be seamlessly picked up by *coleslaw* and included on the rendered site.
All current Content Types and Indexes implement the protocol faithfully.
It consists of 2 "class" methods, 2 instance methods, and an invariant.
There are also 4 helper functions provided that should prove useful in
There are also 5 helper functions provided that should prove useful in
implementing new content types.
@ -191,6 +191,10 @@ eql-specializing on the class, e.g.
unique. Such a hash collision represents content on the site being
shadowed/overwritten. This should be used in your `discover` method.
- `delete-document`: Remove a document from *coleslaw*'s in-memory
database. This is currently only used by the incremental compilation
plugin.
- `write-document`: Write the document out to disk as HTML. It takes
an optional template name and render-args to pass to the template.
This should be used in your `publish` method.

104
plugins/incremental.lisp
View file

@ -8,49 +8,38 @@
#:discover
#:get-updated-files
#:find-content-by-path
#:find-all
#:add-document
#:write-document
#:delete-document
;; Private
#:all-subclasses
#:do-subclasses
#:construct
#:rel-path
#:index-content
#:content-date
#:content-tags
#:tag-slug
)
#:rel-path)
(:export #:enable))
(in-package :coleslaw-incremental)
;; KLUDGE: We currently never update the site for config changes.
;; Examples to consider include changing the theme or domain of the site.
;; Both would require full site recompiles. Consequently, it seems reasonable
;; to expect that incremental plugin users:
;; A) have done a full build of their site
;; B) have a cl-store dump of the database at ~/.coleslaw.db
;; ^ we should provide a script or plugin just for this
;; C) move the original deployment to a location of their choice and set it
;; as staging-dir in coleslaw's config prior to enabling incremental builds
;; D) to further simplify *my* life, we assume the date of a piece of content
;; will never be changed retroactively, only its tags
;; In contrast to the original incremental plans, full of shoving state into
;; the right place by hand and avoiding writing pages to disk that hadn't
;; changed, the new plan is to only avoid redundant parsing of content in
;; the git repo. The rest of coleslaw's operation is "fast enough".
;;
;; Prior to enabling the plugin a user must have a cl-store dump of the
;; database at ~/.coleslaw.db. We should provide a script to generate it.
;;
;; We're gonna be a bit dirty here and monkey patch. The compilation model
;; still isn't an "exposed" part of Coleslaw. After some experimentation maybe
;; we'll settle on an interface.
(defvar *transients* '(coleslaw::numeric-index coleslaw::feed coleslaw::tag-feed)
"A list of document types that should be regenerated on any change to the blog.")
(defun coleslaw::load-content ()
(let ((db-file (rel-path (user-homedir-pathname) ".coleslaw.db")))
(setf coleslaw::*site* (cl-store:restore db-file))
(loop for (status path) in (get-updated-files)
do (update-content status path))
(coleslaw::update-content-metadata)
(dolist (doc-type *transients*)
(discover (find-class doc-type)))
(do-subclasses (itype index)
;; Discover's before method will delete the possibly outdated indexes.
(discover itype))
(cl-store:store coleslaw::*site* db-file)))
(defun update-content (status path)
@ -72,75 +61,18 @@
(when-let (ctype (find extension ctypes :test #'class-name-p))
(call-next-method status path :ctype ctype))))))
;; TODO: If the last content from a given month or with a given tag
;; is deleted, delete the index. Unfortunately, the tag/month links
;; won't be updated on all indexes since we only regenerate them for new posts.
(defmethod process-change ((status (eql :deleted)) path &key)
(let* ((old (find-content-by-path path))
(month-index (find-month-index (content-date old))))
(delete old (index-content month-index))
(dolist (tag (content-tags old))
(let ((tag-index (find-tag-index tag)))
(delete old (index-content tag-index))))
(let ((old (find-content-by-path path)))
(delete-document old)))
(defmethod process-change ((status (eql :modified)) path &key)
(defmethod process-change ((status (eql :modified)) path &key ctype)
(let ((old (find-content-by-path path))
(new (construct ctype (read-content path))))
(delete-document old)
;; TODO:
;; Iterate over tags in new, replacing old with new in each tag index's content.
;; If there are new tags/date, add it to relevant indices (or create them).
;; If tags/date are removed, remove from relevant indices (or delete them).
(add-document new)
(write-document new)))
(add-document new)))
(defmethod process-change ((status (eql :added)) path &key ctype)
(let* ((new (construct ctype (read-content path)))
(tags (content-tags new))
(month (subseq (content-date new) 0 7)))
(maybe-add-month-index new month)
(dolist (tag tags)
(maybe-add-tag-index new tag))
(add-document new)
;; FIXME: New posts won't have prev/next links populated.
(write-document new)))
(defun coleslaw::compile-blog (staging)
"lulz. Do it live. DO IT ALL LIVE."
(dolist (doc-type *transients*)
(publish (find-class doc-type))))
;; No-op. We'll be updating in place instead.
(defmethod coleslaw:deploy (staging))
(let ((new (construct ctype (read-content path))))
(add-document new)))
(defun enable ())
;;;; Utils
(defun delete-document (document)
"Given a DOCUMENT, delete it from the staging directory and in-memory DB."
(let ((url (page-url document)))
(delete-file (rel-path (staging-dir *config*) (namestring url)))
(remhash (page-url document) coleslaw::*site*)))
(defun maybe-add-month-index (content month)
"Add a month index for MONTH containing CONTENT if one does not exist."
(unless (find-month-index month)
(let ((month-index (coleslaw::index-by-month month (list content))))
(add-document month-index)
(write-document month-index))))
(defun maybe-add-tag-index (content tag)
"Add a tag index for TAG containing CONTENT if one does not exist."
(unless (find-tag-index tag)
(let ((tag-index (coleslaw::index-by-tag tag (list content))))
(add-document tag-index)
(write-document tag-index))))
(defun find-tag-index (tag)
(find (tag-slug tag) (find-all 'tag-index) :key #'index-slug :test #'equal))
(defun find-month-index (date)
(find (subseq date 0 7) (find-all 'month-index) :key #'index-slug :test #'equal))