Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the ningle Reference Manual, version 0.3.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:20:01 2018 GMT+0.
| • Introduction: | What ningle is all about | |
| • Systems: | The systems documentation | |
| • Modules: | The modules documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
"ningle" is a lightweight web application framework for Common Lisp.
(defvar *app* (make-instance 'ningle:<app>))
(setf (ningle:route *app* "/")
"Welcome to ningle!")
(setf (ningle:route *app* "/login" :method :POST)
#'(lambda (params)
(if (authorize (cdr (assoc "username" params :test #'string=))
(cdr (assoc "password" params :test #'string=)))
"Authorized!"
"Failed...Try again.")))
(clack:clackup *app*)
Now you can access to http://localhost:5000/ and then ningle should show you "Welcome to ningle!".
(ql:quickload :ningle)
ningle is a fork project of Caveman. ningle doesn't require you to generate a project skeleton.
As this is a thin framework, you need to have subtle knowledge about Clack. It is a server interface ningle bases on.
ningle has the Sinatra-like routing system.
;; GET request (default)
(setf (ningle:route *app* "/" :method :GET) ...)
;; POST request
(setf (ningle:route *app* "/" :method :POST) ...)
;; PUT request
(setf (ningle:route *app* "/" :method :PUT) ...)
;; DELETE request
(setf (ningle:route *app* "/" :method :DELETE) ...)
;; OPTIONS request
(setf (ningle:route *app* "/" :method :OPTIONS) ...)
Route pattern may contain "keyword" to put the value into the argument.
(setf (ningle:route *app* "/hello/:name")
#'(lambda (params)
(format nil "Hello, ~A" (cdr (assoc :name params)))))
The above controller will be invoked when you access to "/hello/Eitaro" or "/hello/Tomohiro", and then (cdr (assoc :name params)) will be "Eitaro" and "Tomohiro".
Route patterns may also contain "wildcard" parameters. They are accessible by (assoc :splat params).
(setf (ningle:route *app* "/say/*/to/*")
#'(lambda (params)
; matches /say/hello/to/world
(cdr (assoc :splat params)) ;=> ("hello" "world")
))
(setf (ningle:route *app* "/download/*.*")
#'(lambda (params)
; matches /download/path/to/file.xml
(cdr (assoc :splat params)) ;=> ("path/to/file" "xml")
))
Route matching with Regular Expressions:
(setf (ningle:route *app* "/hello/([\\w]+)" :regexp t)
#'(lambda (params)
(format nil "Hello, ~A!" (first (cdr (assoc :captures params))))))
Routes may include a variety of matching conditions, such as the Accept:
(setf (ningle:route *app* "/" :accept '("text/html" "text/xml"))
#'(lambda (params)
(declare (ignore params))
"<html><body>Hello, World!</body></html>"))
(setf (ningle:route *app* "/" :accept "text/plain")
#'(lambda (params)
(declare (ignore params))
"Hello, World!"))
You can easily define your own conditions:
(setf (ningle:requirement *app* :probability)
#'(lambda (value)
(<= (random 100) value)))
(setf (ningle:route *app* "/win_a_car" :probability 10)
#'(lambda (params)
(declare (ignore params))
"You won!"))
(setf (ningle:route *app* "/win_a_car")
#'(lambda (params)
(declare (ignore params))
"Sorry, you lost."))
ningle provides two special variables named *request* and *response*. They will be bound to an instance Lack.Request and Lack.Response for each request.
For example, by using them, you can change the response status code, Content-Type or something like that in each controllers.
(setf (lack.response:response-headers *response*)
(append (lack.response:response-headers *response*)
(list :content-type "application/json")))
(setf (lack.response:response-headers *response*)
(append (lack.response:response-headers *response*)
(list :access-control-allow-origin "*")))
(setf (lack.response:response-status *response*) 201)
ningle provides an useful function named context. It is an accessor to an internal hash table.
(setf (context :database)
(dbi:connect :mysql
:database-name "test-db"
:username "nobody"
:password "nobody"))
(context :database)
;;=> #<DBD.MYSQL:<DBD-MYSQL-CONNECTION> #x3020013D1C6D>
ningle doesn't provide Session system in the core, but recommends to use Lack.Middleware.Session with Lack.Builder.
(import 'lack.builder:builder)
(clack:clackup
(builder
:session
*app*))
Of course, you can use other Lack Middlewares with ningle.
Copyright (c) 2012-2014 Eitaro Fukamachi (e.arrows@gmail.com)
Licensed under the LLGPL License.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The ningle system: |
Eitaro Fukamachi
LLGPL
Super micro framework for Common Lisp.
# ningle
[](https://travis-ci.org/fukamachi/ningle)
"ningle" is a lightweight web application framework for Common Lisp.
## Usage
“‘common-lisp
(defvar *app* (make-instance ’ningle:<app>))
(setf (ningle:route *app* "/")
"Welcome to ningle!")
(setf (ningle:route *app* "/login" :method :POST)
#’(lambda (params)
(if (authorize (cdr (assoc "username" params :test #’string=))
(cdr (assoc "password" params :test #’string=)))
"Authorized!"
"Failed...Try again.")))
(clack:clackup *app*)
“‘
Now you can access to http://localhost:5000/ and then ningle should show you "Welcome to ningle!".
## Installation
(ql:quickload :ningle)
## Description
ningle is a fork project of [Caveman](http://fukamachi.github.com/caveman/). ningle doesn’t require you to generate a project skeleton.
As this is a thin framework, you need to have subtle knowledge about [Clack](http://clacklisp.org). It is a server interface ningle bases on.
## Getting started
### Routing
ningle has the [Sinatra](http://www.sinatrarb.com/)-like routing system.
“‘common-lisp
;; GET request (default)
(setf (ningle:route *app* "/" :method :GET) ...)
;; POST request
(setf (ningle:route *app* "/" :method :POST) ...)
;; PUT request
(setf (ningle:route *app* "/" :method :PUT) ...)
;; DELETE request
(setf (ningle:route *app* "/" :method :DELETE) ...)
;; OPTIONS request
(setf (ningle:route *app* "/" :method :OPTIONS) ...)
“‘
Route pattern may contain "keyword" to put the value into the argument.
“‘common-lisp
(setf (ningle:route *app* "/hello/:name")
#’(lambda (params)
(format nil "Hello, ~A" (cdr (assoc :name params)))))
“‘
The above controller will be invoked when you access to "/hello/Eitaro" or "/hello/Tomohiro", and then ‘(cdr (assoc :name params))‘ will be "Eitaro" and "Tomohiro".
Route patterns may also contain "wildcard" parameters. They are accessible by ‘(assoc :splat params)‘.
“‘common-lisp
(setf (ningle:route *app* "/say/*/to/*")
#’(lambda (params)
; matches /say/hello/to/world
(cdr (assoc :splat params)) ;=> ("hello" "world")
))
(setf (ningle:route *app* "/download/*.*")
#’(lambda (params)
; matches /download/path/to/file.xml
(cdr (assoc :splat params)) ;=> ("path/to/file" "xml")
))
“‘
Route matching with Regular Expressions:
“‘common-lisp
(setf (ningle:route *app* "/hello/([\\w]+)" :regexp t)
#’(lambda (params)
(format nil "Hello, ~A!" (first (cdr (assoc :captures params))))))
“‘
### Requirements
Routes may include a variety of matching conditions, such as the Accept:
“‘common-lisp
(setf (ningle:route *app* "/" :accept ’("text/html" "text/xml"))
#’(lambda (params)
(declare (ignore params))
"<html><body>Hello, World!</body></html>"))
(setf (ningle:route *app* "/" :accept "text/plain")
#’(lambda (params)
(declare (ignore params))
"Hello, World!"))
“‘
You can easily define your own conditions:
“‘common-lisp
(setf (ningle:requirement *app* :probability)
#’(lambda (value)
(<= (random 100) value)))
(setf (ningle:route *app* "/win_a_car" :probability 10)
#’(lambda (params)
(declare (ignore params))
"You won!"))
(setf (ningle:route *app* "/win_a_car")
#’(lambda (params)
(declare (ignore params))
"Sorry, you lost."))
“‘
### Request & Response
ningle provides two special variables named ‘*request*‘ and ‘*response*‘. They will be bound to an instance [Lack.Request](https://github.com/fukamachi/lack/blob/master/src/request.lisp#L33) and [Lack.Response](https://github.com/fukamachi/lack/blob/master/src/response.lisp#L19) for each request.
For example, by using them, you can change the response status code, Content-Type or something like that in each controllers.
“‘common-lisp
(setf (lack.response:response-headers *response*)
(append (lack.response:response-headers *response*)
(list :content-type "application/json")))
(setf (lack.response:response-headers *response*)
(append (lack.response:response-headers *response*)
(list :access-control-allow-origin "*")))
(setf (lack.response:response-status *response*) 201)
“‘
### Context
ningle provides an useful function named ‘context‘. It is an accessor to an internal hash table.
“‘common-lisp
(setf (context :database)
(dbi:connect :mysql
:database-name "test-db"
:username "nobody"
:password "nobody"))
(context :database)
;;=> #<DBD.MYSQL:<DBD-MYSQL-CONNECTION> #x3020013D1C6D>
“‘
### Using Session
ningle doesn’t provide Session system in the core, but recommends to use [Lack.Middleware.Session](https://github.com/fukamachi/lack/blob/master/src/middleware/session.lisp#L20) with [Lack.Builder](https://github.com/fukamachi/lack/blob/master/src/builder.lisp#L62).
“‘common-lisp
(import ’lack.builder:builder)
(clack:clackup
(builder
:session
*app*))
“‘
Of course, you can use other Lack Middlewares with ningle.
## See Also
* [Clack](http://clacklisp.org/)
* [Lack](https://github.com/fukamachi/lack)
## Author
* Eitaro Fukamachi (e.arrows@gmail.com)
## Copyright
Copyright (c) 2012-2014 Eitaro Fukamachi (e.arrows@gmail.com)
## License
Licensed under the LLGPL License.
0.3.0
ningle.asd (file)
src (module)
Modules are listed depth-first from the system components tree.
| • The ningle/src module: |
ningle (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files: |
| • The ningle.asd file: | ||
| • The ningle/src/ningle.lisp file: | ||
| • The ningle/src/app.lisp file: | ||
| • The ningle/src/route.lisp file: | ||
| • The ningle/src/context.lisp file: |
Next: The ningle/src/ningle<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
ningle.asd
ningle (system)
Next: The ningle/src/app<dot>lisp file, Previous: The ningle<dot>asd file, Up: Lisp files [Contents][Index]
Next: The ningle/src/route<dot>lisp file, Previous: The ningle/src/ningle<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/app.lisp
Next: The ningle/src/context<dot>lisp file, Previous: The ningle/src/app<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/route.lisp
Previous: The ningle/src/route<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/context.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The ningle-asd package: | ||
| • The ningle package: | ||
| • The ningle.app package: | ||
| • The ningle.route package: | ||
| • The ningle.context package: |
Next: The ningle package, Previous: Packages, Up: Packages [Contents][Index]
ningle.asd
Next: The ningle<dot>app package, Previous: The ningle-asd package, Up: Packages [Contents][Index]
ningle.lisp (file)
common-lisp
Next: The ningle<dot>route package, Previous: The ningle package, Up: Packages [Contents][Index]
app.lisp (file)
common-lisp
Next: The ningle<dot>context package, Previous: The ningle<dot>app package, Up: Packages [Contents][Index]
route.lisp (file)
common-lisp
Previous: The ningle<dot>route package, Up: Packages [Contents][Index]
context.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions: | ||
| • Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported special variables: | ||
| • Exported macros: | ||
| • Exported functions: | ||
| • Exported generic functions: | ||
| • Exported classes: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Special variable to store Ningle Context, a hash table.
Don’t set to this variable directly. This is designed to be bound in lexical let.
context.lisp (file)
Special variable to store Ningle Request, a instance of ‘<request>’ in Ningle.Request package. Don’t set to this variable directly. This is designed to be bound in lexical let.
context.lisp (file)
Special variable to store Ningle Response, a instance of ‘<response>’ in Ningle.Response package. Don’t set to this variable directly. This is designed to be bound in lexical let.
context.lisp (file)
Special variable to store session.
Don’t set to this variable directly. This is designed to be bound in lexical let.
context.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
context.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
app.lisp (file)
Access to current context. If key is specified, return the value in current context.
If not, just return a current context.
Example:
(context)
;=> #<HASH-TABLE :TEST EQL size 0/60 #x3020025FF5FD>
(context :request)
;=> #<CAVEMAN.REQUEST:<REQUEST> #x3020024FCCFD>
context.lisp (file)
(setf context) (function)
context.lisp (file)
context (function)
Create a new Context.
context.lisp (file)
app.lisp (file)
Next: Exported classes, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Make a request object. See ningle.app for the default behavior.
context.lisp (file)
Make a request object. A class of the request object can be changed by overwriting this.
app.lisp (file)
Make a response object. See ningle.app for the default behavior.
context.lisp (file)
Make a response object. A class of the response object can be changed by overwriting this.
app.lisp (file)
An action when no routing rules are found.
app.lisp (file)
app.lisp (file)
automatically generated reader method
route.lisp (file)
automatically generated writer method
route.lisp (file)
Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
Base class for Ningle Application. All Ningle Application must inherit this class.
app.lisp (file)
lack-component (class)
(myway.mapper:make-mapper)
mapper (generic function)
(setf mapper) (generic function)
hash-table
(ningle.app::default-requirements-map)
app-requirements (generic function)
(setf app-requirements) (generic function)
route.lisp (file)
route (class)
:requirements
(quote nil)
route-requirements (generic function)
(setf route-requirements) (generic function)
:compiled-requirements
route-compiled-requirements (generic function)
(setf route-compiled-requirements) (generic function)
:controller
route-controller (generic function)
(setf route-controller) (generic function)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal macros: | ||
| • Internal functions: | ||
| • Internal generic functions: |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
app.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
route.lisp (file)
app.lisp (file)
Previous: Internal functions, Up: Internal definitions [Contents][Index]
automatically generated reader method
route.lisp (file)
automatically generated writer method
route.lisp (file)
automatically generated reader method
route.lisp (file)
automatically generated writer method
route.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index: | ||
| • Function index: | ||
| • Variable index: | ||
| • Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | F L M N |
|---|
| Jump to: | F L M N |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
A C D F G M N R W |
|---|
| Jump to: | (
A C D F G M N R W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
C M R S |
|---|
| Jump to: | *
C M R S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | <
C N P S |
|---|
| Jump to: | <
C N P S |
|---|