The cl-bloggy Reference Manual

Table of Contents

The cl-bloggy Reference Manual

This is the cl-bloggy Reference Manual, version 0.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 12:05:35 2020 GMT+0.

1 Introduction

cl-bloggy

This library implements a simple but highly extensible plugin blogging system for Hunchentoot.

It uses its own custom handler to add routes but but you can still use hunchentoots define-easy-handler.

Getting started

To get started you need to start up hunchentoot with a new acceptor called 'bloggy- acceptor'

(defparameter *server* (make-instance 'bloggy-acceptor
                                      :blog (make-instance 'blog
                                                           :title "Main")
                                      :document-root "./"
                                      :port 4203 :name 'main))
                                      

You can see a new initarg called :blog this must be an instance of 'blog or a subclass of blog.

Next add the main blog page and the main index page

(add-blog)
(add-index 'blog-index)

This will produce two pages, one at *blog-root-directory* (default "/blog/") and *blog-index-directory* (default "/blog/index") which you can browse but you will not see much (the argument 'blog-index is provided as it is the class being instantiated, this will come in handy later when learning how to customize the blog).

Next we must add a simple entry using easy-blog-entry This macro accepts 5 arguments, the first is the class of the blog-entry you want to create, the next the category, the next the title of the entry the fourth is the hunchentoot server, and the last and most important variable is a form that would be valid when passed to spinnerets 'with-html'. Here is an example:

(easy-blog-entry (blog-entry "general" "entry1" *server*)
  (:div :class "elp"
        (:h1 "A story to tell")
        (:p "once upon a time in a land far away")))

As you can see /blog/ and /blog/index have changed.

and the index:

Customizing

Because this library is built from top to bottom using generic functions it is very easy to modify the behaviour of this library, I will walk you through a few examples of how to do this.

First lets take a look at how we would customize an aspect of how a blog-entry is rendered; this is done by calling these methods in this specific order:

• to-html
• html-headers
  • global-css
  • global-fonts
  • specific-css
  • to-css
• html-body
• html-footer
  • global-footer
  • specific-footer

Each of these methods can be specialized for your own subclass in order to customize the behaviour of any of these aspects.

Say for example you wished to add a custom footer for an entry, to do this you would first create a subclass of blog-entry

(defclass new-blog-entry (blog-entry)
  ())

Then you simply create a new version of html-footer for your new class, specialize html-footer and create a new entry passing new-blog-entry as the first argument to easy-blog-entry.

(defmethod html-footer ((entry new-blog-entry))
  (spinneret:with-html
    (:p "i'm a different footer!!")))

(easy-blog-entry (new-blog-entry "general" "entryboof" *server*)
  (:p "im a new entry"))

You will notice that you have to use spinneret to modify the HTML, thats because at every step in the HTML rendering spinneret:with-html is called, so you must do the same for your variant. If we compile and browse to /blog/general/entryboof we will see:

If you wish to customize the default blog page then simply change the (make-instance ) when creating your hunchentoot server to a subclass of 'blog where you have created your own version of the methods in the HTML rendering pipeline.

Customizing the CSS

This is quite easy, the last method called in html-headers is a method called to-css this method adds inline CSS to the document to control the styling. It is quite easy to overwrite this using the same technique as above, simply create your own subclass of what you wish to modify and add your CSS like so:

(defclass new-blog-entry2 (blog-entry)
  ((css-rules
    :initform '(()))));; removing the default CSS rules

now the default version of to-css for blog-entry and blog (so subsequently blog-index as this is a subclass of blog) simply renders the contents of the slot css-rules and returns that:

(defmethod to-css ((entry blog-entry))
  (spinneret:with-html
    (:style :type "text/css"
            (apply #'lass:compile-and-write (css-rules entry)))))

Both blog, blog-entry and blog-index have default CSS which can be found in *blog-css-rules* *blog-entry-css* and *index-css-rules* respectively, these will serve as examples (see /src/generate-css.lisp) for you to follow on how to properly form the CSS; the CSS is all written using Shinmeras LASS, so you must make (css-rules ..) a list of lists. To understand which classes/id's are used when generating the HTML see /src/generate-html.lisp and browse through the spinneret forms to see what you can modify, *blog-entry-css-rules* also contains all the ids for each main part of an entry.

I will finish with one final example of how you would go about changing the default behaviour of the blog; by default entries are listed from newest to oldest, I will quickly show you how to list them from oldest to newest.

The functionality for controlling the listing of entries is within the method html-body the default is:

(defmethod html-body ((blog blog))
  (spinneret:with-html
    (:div :id "all-entries"
          (dolist (blog (sort (entries blog) #'> :key #'creation-date-universal))
            (:div :class "entry"
                  :id (id blog)
                  (html-body blog))))))

So we want to reverse the order of listing, this is very simple as you can see all we are doing is creating a div and within it listing all of the entries contained within the object 'blog', but we are sorting this list by the key #'creation-date-universal, so to modify this functionality we will create the following method on our own subclass of blog called new-blog here:

(defmethod html-body ((blog new-blog))
  (spinneret:with-html
    (:div :id "all-entries"
          (dolist (blog (sort (entries blog) #'< :key #'creation-date-universal))
            (:div :class "entry"
                  :id (id blog)
                  (html-body blog))))))

Now with the new blog you will have to modify the 'blog within your *server* instance to a new instance using new-blog instead of the default blog.

I hope this helps.

Extra

Take a look at /src/test-server.lisp for a few examples.

Take a look at /src/generate-html.lisp to see how the default behaviour is implemented.

To modify the index page, subclass blog-index and call (make-index ..) with your version of blog-index.

License

MIT

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 cl-bloggy

Author

K1D77A

License

MIT

Description

A simple extendable blogging system to use with Hunchentoot

Version

0.0.1

Dependencies

• hunchentoot
• spinneret
• alexandria
• lass
• str
• local-time
• lorem-ipsum

Source

cl-bloggy.asd (file)

Components

• package.lisp (file)
• classes&conditions.lisp (file)
• hunchentoot-handler.lisp (file)
• generate-css.lisp (file)
• generate-html.lisp (file)
• cl-bloggy.lisp (file)

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.

3.1 Lisp

3.1.1 cl-bloggy.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/cl-bloggy-20201220-git/cl-bloggy.asd

Systems

cl-bloggy (system)

3.1.2 cl-bloggy/package.lisp

Parent

cl-bloggy (system)

Location

package.lisp

Packages

cl-bloggy

3.1.3 cl-bloggy/classes&conditions.lisp

Dependency

package.lisp (file)

Parent

cl-bloggy (system)

Location

classes&conditions.lisp

Exported Definitions

• blog (method)
• (setf blog) (method)
• blog (class)
• blog-entry (class)
• blog-index (class)
• category (method)
• (setf category) (method)
• content (method)
• (setf content) (method)
• creation-date (method)
• creation-date-universal (method)
• (setf creation-date-universal) (method)
• css-rules (method)
• (setf css-rules) (method)
• css-rules (method)
• (setf css-rules) (method)
• css-rules (method)
• (setf css-rules) (method)
• entries (method)
• (setf entries) (method)
• id (method)
• title (method)
• (setf title) (method)
• title (method)
• (setf title) (method)

Internal Definitions

• *blog-index-directory* (special variable)
• *blog-root-directory* (special variable)
• add-new-blog (method)
• clean-string (function)
• make-blog (function)
• make-id (function)
• minute-day-month-year-now (function)
• new-blog-entry (method)

3.1.4 cl-bloggy/hunchentoot-handler.lisp

Dependency

classes&conditions.lisp (file)

Parent

cl-bloggy (system)

Location

hunchentoot-handler.lisp

Exported Definitions

• blog (method)
• (setf blog) (method)
• bloggy-acceptor (class)

Internal Definitions

• add-route (method)
• make-route (function)
• remove-route (method)
• route (type)
• routep (function)
• routes (method)
• (setf routes) (method)

3.1.5 cl-bloggy/generate-css.lisp

Dependency

hunchentoot-handler.lisp (file)

Parent

cl-bloggy (system)

Location

generate-css.lisp

Exported Definitions

• *blog-css-rules* (special variable)
• *blog-entry-css-rules* (special variable)
• *index-css-rules* (special variable)
• to-css (generic function)
• to-css (method)
• to-css (method)

3.1.6 cl-bloggy/generate-html.lisp

Dependency

generate-css.lisp (file)

Parent

cl-bloggy (system)

Location

generate-html.lisp

Exported Definitions

• global-css (generic function)
• global-css (method)
• global-fonts (generic function)
• global-fonts (method)
• html-body (method)
• html-body (method)
• html-body (method)
• html-headers (method)
• html-headers (method)
• specific-css (generic function)
• specific-css (method)
• specific-css (method)
• specific-css (method)
• specific-footer (generic function)
• specific-footer (method)
• specific-footer (method)
• to-html (generic function)
• to-html (method)
• to-html (method)

Internal Definitions

• global-footer (method)
• html-footer (method)
• html-footer (method)

3.1.7 cl-bloggy/cl-bloggy.lisp

Dependency

generate-html.lisp (file)

Parent

cl-bloggy (system)

Location

cl-bloggy.lisp

Internal Definitions

• add-blog (function)
• add-index (function)
• easy-blog-entry (macro)
• normalize-category-and-title (generic function)
• normalize-category-and-title (method)

4 Packages

Packages are listed by definition order.

4.1 cl-bloggy

Source

package.lisp (file)

Nickname

bloggy

Use List

common-lisp

Exported Definitions

• *blog-css-rules* (special variable)
• *blog-entry-css-rules* (special variable)
• *index-css-rules* (special variable)
• blog (generic function)
• blog (method)
• (setf blog) (method)
• blog (method)
• (setf blog) (method)
• (setf blog) (generic function)
• blog (class)
• blog-entry (class)
• blog-index (class)
• bloggy-acceptor (class)
• category (generic function)
• category (method)
• (setf category) (method)
• (setf category) (generic function)
• content (generic function)
• content (method)
• (setf content) (method)
• (setf content) (generic function)
• creation-date (generic function)
• creation-date (method)
• creation-date-universal (generic function)
• creation-date-universal (method)
• (setf creation-date-universal) (method)
• (setf creation-date-universal) (generic function)
• css-rules (generic function)
• css-rules (method)
• (setf css-rules) (method)
• css-rules (method)
• (setf css-rules) (method)
• css-rules (method)
• (setf css-rules) (method)
• (setf css-rules) (generic function)
• entries (generic function)
• entries (method)
• (setf entries) (method)
• (setf entries) (generic function)
• global-css (generic function)
• global-css (method)
• global-fonts (generic function)
• global-fonts (method)
• html-body (generic function)
• html-body (method)
• html-body (method)
• html-body (method)
• html-headers (generic function)
• html-headers (method)
• html-headers (method)
• id (generic function)
• id (method)
• specific-css (generic function)
• specific-css (method)
• specific-css (method)
• specific-css (method)
• specific-footer (generic function)
• specific-footer (method)
• specific-footer (method)
• title (generic function)
• title (method)
• (setf title) (method)
• title (method)
• (setf title) (method)
• (setf title) (generic function)
• to-css (generic function)
• to-css (method)
• to-css (method)
• to-html (generic function)
• to-html (method)
• to-html (method)

Internal Definitions

• *blog-index-directory* (special variable)
• *blog-root-directory* (special variable)
• add-blog (function)
• add-index (function)
• add-new-blog (generic function)
• add-new-blog (method)
• add-route (generic function)
• add-route (method)
• clean-string (function)
• easy-blog-entry (macro)
• global-footer (generic function)
• global-footer (method)
• html-footer (generic function)
• html-footer (method)
• html-footer (method)
• make-blog (function)
• make-id (function)
• make-route (function)
• minute-day-month-year-now (function)
• new-blog-entry (generic function)
• new-blog-entry (method)
• normalize-category-and-title (generic function)
• normalize-category-and-title (method)
• remove-route (generic function)
• remove-route (method)
• route (type)
• routep (function)
• routes (generic function)
• routes (method)
• (setf routes) (method)
• (setf routes) (generic function)

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

5.1 Exported definitions

5.1.1 Special variables

Special Variable: *blog-css-rules*

The default LASS used to render the main blog page

Package

cl-bloggy

Source

generate-css.lisp (file)

Special Variable: *blog-entry-css-rules*

The default LASS used by each the class ’blog-entry’

Package

cl-bloggy

Source

generate-css.lisp (file)

Special Variable: *index-css-rules*

The default LASS used to render the main blog index.

Package

cl-bloggy

Source

generate-css.lisp (file)

5.1.2 Generic functions

Generic Function: blog OBJECT

Generic Function: (setf blog) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: blog (BLOGGY-ACCEPTOR bloggy-acceptor)

automatically generated reader method

Source

hunchentoot-handler.lisp (file)

Method: (setf blog) NEW-VALUE (BLOGGY-ACCEPTOR bloggy-acceptor)

automatically generated writer method

Source

hunchentoot-handler.lisp (file)

Method: blog (BLOG-INDEX blog-index)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf blog) NEW-VALUE (BLOG-INDEX blog-index)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: category OBJECT

Generic Function: (setf category) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: category (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf category) NEW-VALUE (BLOG-ENTRY blog-entry)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: content OBJECT

Generic Function: (setf content) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: content (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf content) NEW-VALUE (BLOG-ENTRY blog-entry)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: creation-date OBJECT

Package

cl-bloggy

Methods

Method: creation-date (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Generic Function: creation-date-universal OBJECT

Generic Function: (setf creation-date-universal) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: creation-date-universal (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf creation-date-universal) NEW-VALUE (BLOG-ENTRY blog-entry)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: css-rules OBJECT

Generic Function: (setf css-rules) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: css-rules (BLOG-INDEX blog-index)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf css-rules) NEW-VALUE (BLOG-INDEX blog-index)

automatically generated writer method

Source

classes&conditions.lisp (file)

Method: css-rules (BLOG blog)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf css-rules) NEW-VALUE (BLOG blog)

automatically generated writer method

Source

classes&conditions.lisp (file)

Method: css-rules (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf css-rules) NEW-VALUE (BLOG-ENTRY blog-entry)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: entries OBJECT

Generic Function: (setf entries) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: entries (BLOG blog)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf entries) NEW-VALUE (BLOG blog)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: global-css I

Appends a few CSS links to the render pipeline

Package

cl-bloggy

Source

generate-html.lisp (file)

Methods

Method: global-css ITEM

Generic Function: global-fonts I

Appends a font to the render pipeline

Package

cl-bloggy

Source

generate-html.lisp (file)

Methods

Method: global-fonts ITEM

Generic Function: html-body ENTRY

Package

cl-bloggy

Methods

Method: html-body (BLOG blog)

Source

generate-html.lisp (file)

Method: html-body (INDEX blog-index)

Source

generate-html.lisp (file)

Method: html-body (ENTRY blog-entry)

Source

generate-html.lisp (file)

Generic Function: html-headers ENTRY

Package

cl-bloggy

Methods

Method: html-headers (BLOG blog)

Source

generate-html.lisp (file)

Method: html-headers (ENTRY blog-entry)

Source

generate-html.lisp (file)

Generic Function: id OBJECT

Package

cl-bloggy

Methods

Method: id (BLOG-ENTRY blog-entry)

An amalgamation of title and category

Source

classes&conditions.lisp (file)

Generic Function: specific-css E

Adds specific CSS to the render pipeline. Create your own version of this method for your own subclass to append stylesheets

Package

cl-bloggy

Source

generate-html.lisp (file)

Methods

Method: specific-css ITEM

Method: specific-css (BLOG blog)

Method: specific-css (ENTRY blog-entry)

Generic Function: specific-footer E

Adds specific footer to the render pipeline. Create your own version of this method for your own subclass to modify the footer

Package

cl-bloggy

Source

generate-html.lisp (file)

Methods

Method: specific-footer (BLOG blog)

Method: specific-footer (ENTRY blog-entry)

Generic Function: title OBJECT

Generic Function: (setf title) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: title (BLOG blog)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf title) NEW-VALUE (BLOG blog)

automatically generated writer method

Source

classes&conditions.lisp (file)

Method: title (BLOG-ENTRY blog-entry)

automatically generated reader method

Source

classes&conditions.lisp (file)

Method: (setf title) NEW-VALUE (BLOG-ENTRY blog-entry)

automatically generated writer method

Source

classes&conditions.lisp (file)

Generic Function: to-css E

to-css simply appends a the CSS as an inline style tag. See (css-rules e) for the list of CSS, the CSS is infact a list of LASS rules

Package

cl-bloggy

Source

generate-css.lisp (file)

Methods

Method: to-css (BLOG blog)

Method: to-css (ENTRY blog-entry)

Generic Function: to-html E

The entry function used to create HTML pages. This method calls ’html-headers’ html-body’ and ’html-footer’ in that order in order to render a page. You can create your own version of this method to modify the functionality for your own subclasses the same goes for the three methods it calls.

Package

cl-bloggy

Source

generate-html.lisp (file)

Methods

Method: to-html (BLOG blog)

Method: to-html (ENTRY blog-entry)

5.1.3 Classes

Class: blog ()

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

blog-index (class)

Direct methods

• html-footer (method)
• html-body (method)
• html-headers (method)
• to-html (method)
• specific-footer (method)
• specific-css (method)
• to-css (method)
• new-blog-entry (method)
• add-new-blog (method)
• title (method)
• title (method)
• css-rules (method)
• css-rules (method)
• entries (method)
• entries (method)

Direct slots

Slot: entries

Type

list

Readers

entries (generic function)

Writers

(setf entries) (generic function)

Slot: css-rules

Initform

cl-bloggy:*blog-css-rules*

Readers

css-rules (generic function)

Writers

(setf css-rules) (generic function)

Slot: title

Type

string

Initargs

:title

Initform

"main page"

Readers

title (generic function)

Writers

(setf title) (generic function)

Class: blog-entry ()

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• normalize-category-and-title (method)
• html-footer (method)
• html-body (method)
• html-headers (method)
• to-html (method)
• specific-footer (method)
• specific-css (method)
• to-css (method)
• add-new-blog (method)
• content (method)
• content (method)
• id (method)
• title (method)
• title (method)
• css-rules (method)
• css-rules (method)
• creation-date-universal (method)
• creation-date-universal (method)
• creation-date (method)
• category (method)
• category (method)

Direct slots

Slot: category

Type

string

Initargs

:category

Readers

category (generic function)

Writers

(setf category) (generic function)

Slot: creation-date

Initform

(cl-bloggy::minute-day-month-year-now nil)

Readers

creation-date (generic function)

Slot: creation-date-universal

Initform

(get-universal-time)

Readers

creation-date-universal (generic function)

Writers

(setf creation-date-universal) (generic function)

Slot: css-rules

Initform

cl-bloggy:*blog-entry-css-rules*

Readers

css-rules (generic function)

Writers

(setf css-rules) (generic function)

Slot: title

Type

string

Initargs

:title

Readers

title (generic function)

Writers

(setf title) (generic function)

Slot: id

An amalgamation of title and category

Type

string

Initargs

:id

Readers

id (generic function)

Slot: content

Type

function

Initargs

:content

Readers

content (generic function)

Writers

(setf content) (generic function)

Class: blog-index ()

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Direct superclasses

blog (class)

Direct methods

• html-body (method)
• css-rules (method)
• css-rules (method)
• blog (method)
• blog (method)

Direct slots

Slot: blog

Type

cl-bloggy:blog

Initargs

:blog

Readers

blog (generic function)

Writers

(setf blog) (generic function)

Slot: css-rules

Initform

cl-bloggy:*index-css-rules*

Readers

css-rules (generic function)

Writers

(setf css-rules) (generic function)

Class: bloggy-acceptor ()

Package

cl-bloggy

Source

hunchentoot-handler.lisp (file)

Direct superclasses

easy-acceptor (class)

Direct methods

• acceptor-dispatch-request (method)
• remove-route (method)
• add-route (method)
• blog (method)
• blog (method)
• routes (method)
• routes (method)

Direct slots

Slot: routes

Readers

routes (generic function)

Writers

(setf routes) (generic function)

Slot: blog

Initargs

:blog

Readers

blog (generic function)

Writers

(setf blog) (generic function)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *blog-index-directory*

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Special Variable: *blog-root-directory*

Package

cl-bloggy

Source

classes&conditions.lisp (file)

5.2.2 Macros

Macro: easy-blog-entry (BLOG-CLASS CATEGORY TITLE ACCEPTOR &optional LET-BINDINGS-TO-OVERRIDE-GLOBAL-VARS) &body BODY

Takes BLOG-CLASS (a subclass of ’blog-entry’ or an instance of blog-entry)
and creates a new page at the url ’*blog-root-directory*/CATEGORY/TITLE’.
You can add this to any arbitrary running instance of hunchentoot as long as it was initiated using a subclass of the acceptor bloggy-acceptor. You can use the variable ’let-bindings-to-override-global-vars’ to modify any global variable used in the render pipeline however I recommend you simply create subclass and specialize methods on that subclass instead. BODY must be valid spinneret code, it is an implicit (spinneret:with-html ,@body ) so you can enter any arbitrary HTML using spinneret, use wisely.

Package

cl-bloggy

Source

cl-bloggy.lisp (file)

5.2.3 Functions

Function: add-blog &optional PATH

Initializes the main blog page at PATH

Package

cl-bloggy

Source

cl-bloggy.lisp (file)

Function: add-index INDEX-CLASS &optional PATH

Initializes the main blog index at PATH

Package

cl-bloggy

Source

cl-bloggy.lisp (file)

Function: clean-string STRING

downcases, replaces spaces with hyphens and removes white space

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Function: make-blog MAIN-TITLE

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Function: make-id CATEGORY TITLE

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Function: make-route METHOD URL HANDLER

Package

cl-bloggy

Source

hunchentoot-handler.lisp (file)

Function: minute-day-month-year-now STREAM

Package

cl-bloggy

Source

classes&conditions.lisp (file)

Function: routep X

Package

cl-bloggy

Source

hunchentoot-handler.lisp (file)

5.2.4 Generic functions

Generic Function: add-new-blog BLOG ENTRY

Package

cl-bloggy

Methods

Method: add-new-blog (BLOG blog) (ENTRY blog-entry)

Source

classes&conditions.lisp (file)

Generic Function: add-route ROUTE ACCEPTOR

Package

cl-bloggy

Methods

Method: add-route ROUTE (ACCEPTOR bloggy-acceptor)

Adds a route to your acceptor, the acceptor is what you used to start hunchentoot

Source

hunchentoot-handler.lisp (file)

Generic Function: global-footer ITEM

Package

cl-bloggy

Methods

Method: global-footer ITEM

Source

generate-html.lisp (file)

Generic Function: html-footer ENTRY

Package

cl-bloggy

Methods

Method: html-footer (BLOG blog)

Source

generate-html.lisp (file)

Method: html-footer (ENTRY blog-entry)

Source

generate-html.lisp (file)

Generic Function: new-blog-entry BLOG-ENTRIES BLOG-CLASS TITLE CATEGORY CONTENT

Package

cl-bloggy

Methods

Method: new-blog-entry (BLOG-ENTRIES blog) BLOG-CLASS TITLE CATEGORY CONTENT

Source

classes&conditions.lisp (file)

Generic Function: normalize-category-and-title E

This method produces a URL used to refer to a blog entry

Package

cl-bloggy

Source

cl-bloggy.lisp (file)

Methods

Method: normalize-category-and-title (ENTRY blog-entry)

Generic Function: remove-route ROUTE ACCEPTOR

Package

cl-bloggy

Methods

Method: remove-route ROUTE (ACCEPTOR bloggy-acceptor)

Source

hunchentoot-handler.lisp (file)

Generic Function: routes OBJECT

Generic Function: (setf routes) NEW-VALUE OBJECT

Package

cl-bloggy

Methods

Method: routes (BLOGGY-ACCEPTOR bloggy-acceptor)

automatically generated reader method

Source

hunchentoot-handler.lisp (file)

Method: (setf routes) NEW-VALUE (BLOGGY-ACCEPTOR bloggy-acceptor)

automatically generated writer method

Source

hunchentoot-handler.lisp (file)

5.2.5 Types

Type: route ()

Package

cl-bloggy

Source

hunchentoot-handler.lisp (file)

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types