Geddy

architecture
router
controllers
models
templates
helpers
CLI
sessions
deployment
- Nodejitsu
- Heroku
i18n
- Setting a locale for your app
- Using i18n text
utilities
authentication

Architecture

Geddy is built on the same MVC principles that many popular frameworks are based on. Every Geddy app has its models, controllers, and views as well as config files and routes.

structure

├── app
│   ├── controllers
│   │   ├── application.js
│   │   └── main.js
│   ├── helpers
│   ├── models
│   └── views
│       ├── layouts
│       │   └── application.html.ejs
│       └── main
│           └── index.html.ejs
├── config
    ├── development.js
    ├── environment.js
    ├── init.js
    ├── production.js
    └── router.js
├── lib
├── log
├── node_modules
└── public

config

geddy.config

Geddy has built in configuration management. Global config options should go in your 'config/environments.js` file. Likewise, your production and development config options should go in their respective files

If you want to start up your app in a specific environment, use the -e option:

$ geddy -e production

logger

geddy.log[level]

Geddy automatically logs requests to an access log, and you can log anything you'd like to stdout or a file. It supports 9 different log levels from debug to emergency.

levels

access: outputs to the access log and stdout
debug: debug level logging
info: info level logging
notice: notice level logging
warning: warning level logging
error: error level logging, prints to stdout and stderr
critical: critical level logging
alert: alert level logging
emergency: emergency level logging

examples

geddy.log.debug('someting to debug')
// prints `something to debug` to the console


geddy.log.error('something went wrong')
// prints 'something went wrong' to stderr and the console

Router

Geddy uses Barista as its router. Its API is very similar to rails routes. Both general-purpose resource-based routes and individually defined routes are possible.

.match

router.match(path [, method])

defines the url to match to a controller action.

path

path [string]: the url to match to an action

method

method [string]: the http method to match

examples

router.match('/').to('Main.index');
// will route any request to '/' to the Main controller's index action


router.match('/products/:id', 'GET').to('products.show')
// will route '/products/5' to Products.show()
// and set the id paramer to be 5


router.match('/profiles/:username', 'GET').to('users.show')
// will route '/products/dan' to Users.show()
// and set the username paramer to be dan


router.match('/products/:id(.:format)', 'GET').to('products.show')
// things enclosed in parentheses are optional

.to

router.match(path).to(action)

defines the action to map the path to.

action

action [string]: a controller name plus an action name as a string
action [object]: an object that defines a controller and action property

examples

router.match('/').to('Main.index');
// will route any request to '/' to the Main controller's index action


router.match('/').to({controller: 'Main', action: 'index'});
// will route any request to '/' to the Main controller's index action

.get

router.get(path)

Equivalent to router.match(path, 'GET')

.post

router.post(path)

Equivalent to router.match(path, 'POST')

.put

router.put(path)

Equivalent to router.match(path, 'PUT')

.del

router.del(path)

Equivalent to router.match(path, 'DELETE')

.resource

router.resource(controller)

generates standard resource routes for a controller name

controller

controller [string]: the camelCased controller name that needs resourceful routes

examples

router.resource('products')

// is equivalent to:

router.get('/products(.:format)').to('products.index')
router.get('/products/add(.:format)').to('products.add')
router.get('/products/:id(.:format)').to('products.show')
router.get('/products/:id/edit(.:format)').to('products.edit')
router.post('/products(.:format)').to('products.create')
router.put('/products/:id(.:format)').to('products.update')
router.del('/products/:id(.:format)').to('products.destroy')

Controllers

Controllers define the different actions that your users can interact with.

.request

this.request

The raw http.ServerRequest object for this request/response cycle.

.response

this.response

The raw http.ServerResponse object for this request/response cycle.

.params

this.params

The parsed params for the request. params is also passed as an argument to the action, it was added as an instance field for convenience.

.cookies

this.cookies

Cookies collection from the request

.name

this.name

The name of the controller constructor function, in CamelCase with uppercase initial letter.

.respondsWith

this.respondsWith

Content-type the controller can respond with.

example

this.respondsWith = ['txt','json','html'];

.before

before(filter, [options])

Adds an action to be performed before a response is rendered.

filter

filter [function] Action to add to the beforeFilter list. If the action is asynchronous, takes a single callback parameter to call when the action is finished.

options

except [array] List of actions where the before-filter should not be performed.
only [array] List of actions where the before-filter should only be performed.
async [boolean] When set to true, the before-filter is asynchronous, and requires a callback

examples

this.before(someFunction);
// runs someFunction before the response is rendered


this.before(someFunction, {except: ['index', 'home']});
// won't run someFunction if this is the index or home action


this.before(someFunction, {only: ['add', 'update', 'remove']}
// will only run someFunction if this is the add, update, or remove action

.after

after(filter, [options])

Adds an action to be performed after a response is rendered.

filter

filter [function] Action to add to the afterFilter list. If the action is asynchronous, takes a single callback parameter to call when the action is finished.

options

except [array] List of actions where the after-filter should not be performed.
only [array] List of actions where the after-filter should only be performed.
async [boolean] When set to true, the after-filter is asynchronous, and requires a callback

examples

this.after(someFunction);
// runs someFunction after the response is rendered


this.after(someFunction, {except: ['index', 'home']});
// won't run someFunction if this is the index or home action


this.after(someFunction, {only: ['add', 'update', 'remove']}
// will only run someFunction if this is the add, update, or remove action

.protectFromForgery

protectFromForgery()

Prevents cross-site requests by requiring a same-origin token for destructive HTTP methods (PUT, POST, DELETE)

.redirect

redirect(to)

to [string]

if to is a string, it will redirect to the url in that string

to [object]

controller [string]: a controller name
action [string]: an action name
format [string]: the file extension

Sends a 302 redirect to the client, based on either a simple string-URL, or a controller/action/format combination.

examples

this.redirect('/users/1');
// will redirect the browser to /users/1


this.redirect({controller: 'users', action: 'show', id: 1});
// will redirect the browser to /users/1

.error

error(err)

Respond to a request with an appropriate HTTP error-code. If a status-code is set on the error object, uses that as the error's status-code. Otherwise, responds with a 500 for the status-code.

err [error]

statusCode [number] optional HTTP status code to send to the client, defaults to 500
message [string] the error message text to send to the client

examples

this.error();
// sends a 500

var err = new Error('Whoopsy daisy');
this.error(err);
// sends a 500 with a specific message

var err = new Error();
err.statusCode = 420;
this.error(err);
// sends a 420

.transfer

transfer(action)

Transfer a request from its original action to a new one. The entire request cycle is repeated, including before-filters.

action

action [string]: name of the new action designated to handle the request.
action [object]: The new action designated to handle the request.

.respond

respond(data, options)

Performs content-negotiation, and renders a response.

data

data [object]: an object with properties to send to the view

options

layout [string]: the path to the layout file to use
layout [false]: a flag to not use a layout file
format [string]: the format to render
template [string]: The path (without file extensions) to the template to use to render this response
statusCode [number]: The HTTP status-code to use with this response

examples

this.respond(params);
// send the params object to the view, then send the response


this.respond({posts: posts});
// send the passed in object to the view, then send the response


this.respond(params, {template: 'path/to/template'});
// send params to path/to/template, render it, then send the response


this.respond(null, {statusCode: 201});
// send the params object as the response in json format

this.respond(params, {format: 'json'});
// send a 201/created with no body

.flash

The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request. This is useful for storing error messages, etc. It is accessed in much the same way as the session, like a hash.

It also includes a few convenience methods for getting/setting commonly used types of flash-messages.

.flash.alert

flash.alert([message])

Gets or sets the alert flash-messages for a session. If the 'message' (value) parameter is included it sets the value. If the 'message' paramter is not included, it retrieves the value and returns it.

message

message [string|object]: The contents of the flash-message

examples

this.flash.alert('Check it out!');
// Sets the 'alert' flash-message to 'Check it out!'

this.flash.alert();
// Returns 'This is fantastic!'

.flash.error

flash.error([message])

Gets or sets the error flash-messages for a session. If the 'message' (value) parameter is included it sets the value. If the 'message' paramter is not included, it retrieves the value and returns it.

message

message [string|object]: The contents of the flash-message

examples

this.flash.error('Yikes! Something wrong wrong.');
// Sets the 'error' flash-message to 'Yikes! Something wrong wrong.'

this.flash.error();
// Returns 'This is fantastic!'

.flash.success

flash.success([message])

Gets or sets the success flash-messages for a session. If the 'message' (value) parameter is included it sets the value. If the 'message' paramter is not included, it retrieves the value and returns it.

message

message [string|object]: The contents of the flash-message

examples

this.flash.success('Whoa! It worked.');
// Sets the 'success' flash-message to 'Whoa! It worked.'

this.flash.success();
// Returns 'This is fantastic!'

.flash.info

flash.info([message])

Gets or sets the info flash-messages for a session. If the 'message' (value) parameter is included it sets the value. If the 'message' paramter is not included, it retrieves the value and returns it.

message

message [string|object]: The contents of the flash-message

examples

this.flash.info('FYI. Just sayin.');
// Sets the 'info' flash-message to 'FYI. Just sayin.'

this.flash.info();
// Returns 'This is fantastic!'

.flash.set

flash.set([type], message)

Sets the flash-messages for a session, for a custom type, or the entire flash-message object

type

type [string]: The flash-message type. If not included, this call sets the entire flash-message object

message

message [string|object]: The contents of the flash-message

examples

this.flash.set('foo', 'Foo bar baz');
// Sets the 'foo' flash-message to 'Foo bar baz'

this.flash.set({bar: 'Baz bar qux});
// Sets the entire flash-message object

.flash.get

flash.get([type])

Retrieves the flash-messages for a session, for a custom type, or the entire flash-message object

type

type [string]: The flash-message type. If not included, this call retrieves the entire flash-message object

examples

this.flash.set('foo', 'Foo bar baz');
this.flash.get('foo');
// Returns 'Foo bar baz'

this.flash.get();
// Returns an object: {foo: 'Foo bar baz'}

.flash.keep

flash.keep([type])

Normally flash-message are wiped out when they are used in the current request. keep makes them persist and be available to the next request.

type

type [string]: The type of message to preserve until the next request. If the type param is not included, preserves the entire flash-message object

examples

this.flash.keep('error');
// Keep the error flash around after a redirect

.flash.discard

flash.discard([type])

Mark a particular flash-message entry (or the entire object) to be discarded at the end of the current request.

type

type [string]: The type of message to discard at the end of the current request. If the type param is not included, discards the entire flash-message object

examples

this.flash.discard('error');
// Discard the current error flash-message

Models

Geddy uses the Model module for its model layer. Model is an abstract ORM that is compatible with many different types of databases, including Postgres, in-memory, MongoDB and Riak.

summary

Model uses a pretty simple syntax for defining a model. (It should look familiar to anyone who has used an ORM like ActiveRecord, DataMapper, Django's models, or SQLAlchemy.)

.defineProperties

defineProperties(properties)

defines the properties for your model.

properties

properties [object]: an object keyed by name of properties to define

example

var User = function () {
  this.defineProperties({
    login: {type: 'string', required: true}
  , password: {type: 'string', required: true}
  , lastName: {type: 'string'}
  , firstName: {type: 'string'}
  });
}

.property

property(name, type, options)

defines a single property

name

name [string]: the name of the property

type

type [string]: the type of the property
- 'string'
- 'text'
- 'number'
- 'int'
- 'boolean'
- 'object'
- 'datetime'
- 'date'
- 'time'

options

required [boolean]: sets the property to be required

examples

this.property('login', 'string', {required: true});
this.property('password', 'string', {required: true});
this.property('joined', 'datetime');
this.property('premium', 'boolean');

.validatesPresent

validatesPresent(property, options)

Sets up a validation to make sure that the property is present.

property

property [string]: the name of the property to validate

options

message [string]: a message to give the user if the validation fails

example

this.validatesPresent('login');
// makes sure that the login property is present

.validatesFormat

validatesFormat(property, regex, options)

Sets up a validation to make sure that the property is formatted correctly.

property

property [string]: the name of the property to validate

regex

regex [regex]: a regular expression that the property value must pass

options

message [string]: a message to give the user if the validation fails

example

this.validatesFormat('login', /[a-z]+/, {message: 'cannot contain numbers'});
// makes sure that the login property does not contain numbers

.validatesLength

validatesLength(property, qualifier, options)

Sets up a validation to make sure that the property meets certain length requirements.

property

property [string]: the name of the property to validate

qualifier

min [number]: the minimum length of the property
max [number]: the maximum length of the property
[number]: the exact length of the property

options

message [string]: a message to give the user if the validation fails

example

this.validatesLength('login', {min: 3});
// makes sure that the login property is at least 3 characters long


this.validatesLength('login', {max: 20});
// makes sure that the login property is not longer than 20 characters

this.validatesLength('login', 3)
// makes sure that the login property is exactly 3 characters long

.validatesConfirmed

validatesConfirmed(property, param, options)

Sets up a validation to make sure that the property has been confirmed.

property

property [string]: the name of the property to validate

param

param [string]: the param required to match

options

message [string]: a message to give the user if the validation fails

example

this.validatesConfirmed('password', 'confirmPassword');
// confirms that password and confirmPassword are equal

.validatesWithFunction

validatesWithFunction(property, fn, options)

Sets up a validation to make sure that the property has been confirmed.

property

property [string]: the name of the property to validate

fn

fn [function]: a function which, when passed the value of the property, will return true or false

options

message [string]: a message to give the user if the validation fails

example

this.validatesWithFunction('password', function (val) {
      // Something that returns true or false
      return val.length > 0;
});
// uses the function to see if th length of password is greater than 0

.hasOne

hasOne(model)

Sets up a has-one relationship between this model and another.

model

model [string]: the name of the model that this model has one of.

example

this.hasOne('Profile');
// sets up a has one relationship
// (something) -> has one -> profile

.hasMany

hasMany(model)

Sets up a has-many relationship between this model and another.

model

model [string]: the pluralized name of the model that this model has many of.

example

this.hasMany('Friends');
// sets up a has many relationship
// (something) -> has many -> friends

.belongsTo

belongsTo(model)

Sets up a belongs-to relationship between this model and another. A belongs-to is often used as the inverse of a has-many or has-one. Note however that this is not required -- associations are unidirectional.

model

model [string]: the singular name of the model that this model belongs to.

example

this.belongsTo('User');
// sets up a belongs-to relationship
// (something) -> belongs to -> a user

.adapter

this.adapter

Defines the database adapter for this model

examples

this.adapter = 'mongo';
// makes this model use mongo for it's database


this.adapter = 'riak'


this.adapter = 'postgres'


this.adapter = 'memory'

instance

Instance methods can be defined in the model definition as well.

example

var User = function () {
...
  this.someMethod = function () {
    // Do some stuff
  };
  // sets up a someMethod method on each instance of this model
...
};

.isValid

isValid()

Returns true if the model instance passes all validations, otherwise it returns false.

example

user.isValid()

.save

save(fn)

Saves the instance to the database.

fn

fn [function]: the function to be called when saving is complete

example

user.save(function (err, data) {
// do things
});
// saves the user then calls the callback function

.updateProperties

updateProperties(properties)

Updates the properties of a model and asserts that they are valid; This method will not call save on the instance.

properties

properties [object]: an object who's keys are property names and its values are the values to change the property to.

example

user.updateProperties({
  login: 'alerxst'
});
// updates the login property and validates it

.add

.add{target_model_name}( instance )

If a model has a hasMany relationship established with another model, you can use this method to add instaces of one model to it’s “parent” model.

target_model_name

The name of the model you’d like to add

instance

instace [modelInstance]: The instance to add

example

var user = geddy.model.User.create(userParams);
var post = geddy.model.Post.create(postParams);
user.addPost(post);

.set

.set{target_model_name}( instance )

If a model has a hasOne relationship established with another model, you can use this method to add an instace of one model to it’s “parent” model.

target_model_name

The name of the model you’d like to set

instance

instace [modelInstance]: The instance to set

example

var user = geddy.model.User.create(userParams);
var account = geddy.model.Account.create(accountParams);
user.setAccount(account);

.get

.get{target_model_name}( fn )

If a model has a hasOne relationship established with another model, you can use this method to add an instace of one model to it’s “parent” model.

target_model_name

hasMany: the plural name of the model you’d like to get a collection of
hasOne: the singular name of the model you like to get an instance of

fn

fn [function]: The function to call once the models are retrieved.

example

var user = geddy.model.User.create(params);

// hasOne
user.getAccount(function (err, account) {
  // do stuff with the user’s account
});

// hasMany
user.getPosts(function (err, posts) {
  // do stuff with the user’s posts
});

static

Static methods can be added by creating a method on the model definition object.

var User = function () {
  this.property('login', 'string', {required: true});
  this.property('password', 'string', {required: true});
};

User.findByLogin = function (login, callback) {
  User.all({login: login}, callback);
}

.create

create(params)

Creates a new model instance and returns it.

params

params [object]: an object whos keys are model properties

example

var params = {
  login: 'alex'
, password: 'lerxst'
, lastName: 'Lifeson'
, firstName: 'Alex'
};
var user = User.create(params);

.first

first(query, options, fn)

Use the first method to find a single item. You can pass it an id, or a set of query parameters in the form of an object-literal. In the case of a query, it will return the first item that matches, according to whatever sort you've specified.

query [string]

query [string]: if the query is a string, it will be assumed that it's an id

query [object]

query [object]: if the query is an object, it will be interpreted as a Query object

example

User.first('sdfs-asd-1', function (err, user) {
  // do stuff with user
});


User.first({login: 'alerxst'}, function (err, user) {
  // do stuff with user
});

.all

all(query, options, fn)

Use the all method to find lots of items. Pass it a set of query parameters in the form of an object-literal, where each key is a field to compare, and the value is either a simple value for comparison (equal to), or another object-literal where the key is the comparison-operator, and the value is the value to use for the comparison.

query [object]

query [object]: if the query is an object, it will be interpreted as a Query object

options

sort [object]: each key is a property name, each value can either be asc or desc

example

User.all({location: 'san francisco'}, function (err, users) {
  // do stuff with users
});


User.all({location: 'san francisco'}, {sort: {createdAt: 'desc'}}, function (err, users) {
  // do stuff with users
});

.remove

remove(id, fn)

Remove an instance from the database by id.

id

id [string]: the id of the instance to be removed

examples

User.remove('abc-123', function (err, data) {
  // do something now that it's removed.
});

queries

Model uses a simple API for finding and sorting items. Again, it should look familiar to anyone who has used a similar ORM for looking up records. The only wrinkle with Model is that the API is (as you might expect for a NodeJS library) asynchronous.

comparison operators

eql: equal to
ne: not equal to
gt: greater than
lt: less than
gte: greater than or equal
lte: less than or equal
like: like

A simple string-value for a query parameter is the same as 'eql'. {foo: 'bar'} is the same as {foo: {eql: 'bar'}}.

combining queries

Model supports combining queries with OR and negating queries with NOT.

To perform an 'or' query, use an object-literal with a key of 'or', and an array of query-objects to represent each set of alternative conditions.

To negate a query with 'not', simply use a query-object where 'not' is the key, and the value is the set of conditions to negate.

examples

{foo: 'BAR', bar: {ne: null}}
// Where "foo" is 'BAR' and "bar" is not null

{foo: {'like': 'B'}}
// Where "foo" begins with 'B'

{foo: {lt: 2112}, bar: 'BAZ'}
// Where foo is less than 2112, and bar is 'BAZ'

{or: [{foo: 'BAR'}, {bar: 'BAZ'}]}
// Where "foo" is 'BAR' OR "bar" is 'BAZ'

{or: [{foo {ne: 'BAR'}}, {bar: null}, {baz: {lt: 2112}}]}
// Where "foo" is not 'BAR' OR "bar" is null OR "baz" is less than 2112

{not: {foo: 'BAR', bar: 'BAZ'}}
// Where NOT ("foo" is 'BAR' and "bar" is 'BAZ')

{not: {foo: 'BAZ', bar: {lt: 1001}}}
// Where NOT ("foo" is 'BAZ' and "bar" is less than 1001)

{or: [{foo: {'like': 'b'}}, {foo: 'foo'}], not: {foo: 'baz'}}
// Where ("foo" is like 'b' OR "foo" is 'foo') and NOT "foo" is 'baz'

events

Both the base model 'constructors,' and model instances are EventEmitters. The emit events during the create/update/remove lifecycle of model instances. In all cases, the plain-named event is fired after the event in question, and the 'before'-prefixed event, of course happens before.

The 'constructor' for a model emits the following events:

beforeCreate
create
beforeValidate
validate
beforeUpdateProperties
updateProperties
beforeSave (new instances, single and bulk)
save (new instances, single and bulk)
beforeUpdate (existing single instances, bulk updates)
update (existing single instances, bulk updates)
beforeRemove
remove

Model-item instances emit these events:

beforeUpdateProperties
updateProperties
beforeSave
save
beforeUpdate
update

Templates

Geddy's view layer provides a versatile set of templating languages and helpers to get you started quickly.

engines

The view layer supports these four templating engines:

EJS(.ejs)
Jade(.jade)
Mustache(.mu, .ms, .mustache)
Handlebars(.hbs, .handlebars)
Swig(.swig)

To use a certain template engine just give the view a corresponding extension listed above.

When using the Geddy CLI to generate parts of your application you can use different template languages by giving an argument to the command, here are some examples:

$ geddy app --mustache my_app
$ geddy scaffold -m user


$ geddy app --jade my_app
$ geddy scaffold -j user


$ geddy app --handle my_app
$ geddy scaffold -H user

$ geddy app --swig my_app
$ geddy scaffold --swig user

urlFor

urlFor(options<String/Object>)

Returns a URL based on the options provided

Options [String]:

'back' [String] The 'back' string will return a URL that points to the last URL in history

Options [Object]:

relPath [Boolean] If true, the relative URL is returned(Default: false)
protocol [String] The protocol to use(Default: What your Geddy instance is using('http' default))
username [String] Includes a username in the path. Requires password or it'll be ignored
password [String] Includes a username in the path. Requires password or it'll be ignored
subdomain [String] Specifies the subdomain to prepend to domain
domain [String] Specifies the domain to point to. Required if relPath is false
host [String] Alias for host
port [Integer] Specify the port to connect to
controller [String] Specifies the controller to use for the path
action [String] Specifies the action to use for the path
id [String] Specifies an ID to use for displaying specific items
trailingSlash [Boolean] If true, adds a trailing slash to the end of the path/domain
fragment [String] Appends a fragment to the end of the path/domain
anchor [String] Alias for fragment

Notes:

If options is a String it will just be returned, unless the String is equal to 'back'
Any other options added will be considered as a query to be appended to the URL

Examples:

urlFor('http://google.com')
// => 'http://google.com'


urlFor({controller: 'tasks', action: 'new', host: 'somehost.com'})
// => 'http://somehost.com/tasks/new'


urlFor({controller: 'tasks', action: 'new', relPath: true})
// => '/tasks/new'


urlFor({controller: 'tasks', action: 'new', relPath: true, trailingSlash: true})
// => '/tasks/new/'


urlFor({host: 'somehost.com', protocol: 'https', username: 'username', password: 'password'})
// => 'https://username:password@somehost.com'


urlFor({controller: 'tasks', action: 'new', host: 'somehost.com', protocol: 'https'})
// => 'https://somehost.com/tasks/new'


urlFor({controller: 'tasks', action: 'edit', id: 'IwTEf55ivH', host: 'somehost.com'})
//  => 'http://somehost.com/tasks/IwTEf55ivH/edit'


urlFor({controller: 'tasks', action: 'new', host: 'somehost.com', anchor: 'submit'})
// => 'http://somehost.com/tasks/new#submit'


urlFor({controller: 'tasks', action: 'new', host: 'somehost.com', authToken: 'some_token'})
// => 'http://somehost.com/tasks/new?authToken=some_token'

contentTag

contentTag(tag<String>, content<String>, htmlOptions<Object>)

Returns an HTML element from a given tag and includes the content and all htmlOptions

Custom HTML options:

data[Array] The data attribute takes an Array containing data attributes you want, when parsed they each get parsed as a full data attribute(e,g: data: {goTo: 'google.com'} will be data-go-to="google.com").

Examples:

contentTag('p', 'this is some content')
// => '<p>this is some content</p>'


contentTag('input', 'sample value')
// => '<input value="sample value" />'


contentTag('input', 'sample value', {value: 'override sample value'})
// => '<input autofocus="autofocus" type="text" value="sample value" />'


contentTag('input', 'sample value', {type: 'text', autofocus: true})
// => '<input autofocus="autofocus" type="text" value="sample value" />'


contentTag('a', 'http://google.com')
// => '<a href="http://google.com">http://google.com</a>'


contentTag('a', 'hey there', {href: 'http://google.com'})
// => '<a href="http://google.com">hey there</a>'


contentTag('a', 'hey there', {href: 'http://google.com', data: { goTo: 'http://google.com'} })
// => '<a data-go-to="http://google.com" href="http://google.com">hey there</a>'


contentTag('a', 'hey there', {href: 'http://google.com', data_go_to: 'http://google.com'})
// => '<a data-go-to="http://google.com" href="http://google.com">hey there</a>'

selectTag

`selectTagString(optionsArray, selectedOption, htmlOptions

Framework documentation

Architecture

structure

config

logger

levels

examples

Router

.match

path

method

examples

.to

action

examples

.get

.post

.put

.del

.resource

controller

examples

Controllers

.request

.response

.params

.cookies

.name

.respondsWith

example

.before

filter

options

examples

.after

filter

options

examples

.protectFromForgery

.redirect

to [string]

to [object]

examples

.error

err [error]

examples

.transfer

action

.respond

data

options

examples

.flash

.flash.alert

message

examples

.flash.error

message

examples

.flash.success

message

examples

.flash.info

message

examples

.flash.set

type

message

examples

.flash.get

type

examples

.flash.keep

type

examples

.flash.discard

type

examples

Models