Sammy (also aliased as $.sammy) is not only the namespace for a\n number of prototypes, its also a top level method that allows for easy\n creation/management of Sammy.Application instances. There are a\n number of different forms for Sammy() but each returns an instance\n of Sammy.Application. When a new instance is created using\n Sammy it is added to an Object called Sammy.apps. This\n provides for an easy way to get at existing Sammy applications. Only one\n instance is allowed per element_selector so when calling\n Sammy('selector') multiple times, the first time will create\n the application and the following times will extend the application\n already added to that selector.
// returns the app at #main or a new app\n Sammy('#main')\n\n // equivilent to \"new Sammy.Application\", except appends to apps\n Sammy();\n Sammy(function() { ... });\n\n // extends the app at '#main' with function.\n Sammy('#main', function() { ... });\nAdd to the global logger pool. Takes a function that accepts an\n unknown number of arguments and should print them or send them somewhere\n The first argument is always a timestamp.
\n", "filename": "/lib/sammy.js", "lineno": 79 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.log", "args": [ ], "doc": "Sends a log message to each logger listed in the global\n loggers pool. Can take any number of arguments.\n Also prefixes the arguments with a timestamp.
\n", "filename": "/lib/sammy.js", "lineno": 86 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Object", "args": [ "obj" ], "doc": "Sammy.Object is the base for all other Sammy classes. It provides some useful\n functionality, including cloning, iterating, etc.
\n", "filename": "/lib/sammy.js", "lineno": 118 }, { "methods": [ { "klass": "Sammy.Object", "name": "has", "args": [ "key" ], "filename": "/lib/sammy.js", "lineno": 170, "doc": "Checks if the object has a value at key and that the value is not empty
convenience method to join as many arguments as you want\n by the first argument - useful for making paths
\n" }, { "klass": "Sammy.Object", "name": "keys", "args": [ "attributes_only" ], "filename": "/lib/sammy.js", "lineno": 159, "doc": "Returns an array of keys for this object. If attributes_only\n is true will not return keys that map to a function()
Shortcut to Sammy.log
\n" }, { "klass": "Sammy.Object", "name": "toHTML", "args": [ ], "filename": "/lib/sammy.js", "lineno": 147, "doc": "Renders a simple HTML version of this Objects attributes.\n Does not render functions.\n For example. Given this Sammy.Object:
\n\nvar s = new Sammy.Object({first_name: 'Sammy', last_name: 'Davis Jr.'});\ns.toHTML() //=> '<strong>first_name</strong> Sammy<br /><strong>last_name</strong> Davis Jr.<br />'\nReturns a copy of the object with Functions removed.
\n" }, { "klass": "Sammy.Object", "name": "toString", "args": [ "include_functions" ], "filename": "/lib/sammy.js", "lineno": 190, "doc": "Returns a string representation of this object.\n if include_functions is true, it will also toString() the\n methods of this object. By default only prints the attributes.
Escape HTML in string, use in templates to prevent script injection.\n Also aliased as h()
The HashLocationProxy is the default location proxy for all Sammy applications.\n A location proxy is a prototype that conforms to a simple interface. The purpose\n of a location proxy is to notify the Sammy.Application its bound to when the location\n or 'external state' changes. The HashLocationProxy considers the state to be\n changed when the 'hash' (window.location.hash / '#') changes. It does this in two\n different ways depending on what browser you are using. The newest browsers\n (IE, Safari > 4, FF >= 3.6) support a 'onhashchange' DOM event, thats fired whenever\n the location.hash changes. In this situation the HashLocationProxy just binds\n to this event and delegates it to the application. In the case of older browsers\n a poller is set up to track changes to the hash. Unlike Sammy 0.3 or earlier,\n the HashLocationProxy allows the poller to be a global object, eliminating the\n need for multiple pollers even when thier are multiple apps on the page.
\n", "filename": "/lib/sammy.js", "lineno": 213 }, { "methods": [ { "klass": "Sammy.HashLocationProxy", "name": "bind", "args": [ ], "filename": "/lib/sammy.js", "lineno": 223, "doc": "bind the proxy events to the current app.
\n" }, { "klass": "Sammy.HashLocationProxy", "name": "getLocation", "args": [ ], "filename": "/lib/sammy.js", "lineno": 251, "doc": "get the current location from the hash.
\n" }, { "klass": "Sammy.HashLocationProxy", "name": "setLocation", "args": [ "new_location" ], "filename": "/lib/sammy.js", "lineno": 260, "doc": "set the current location to new_location
unbind the proxy events from the current app
\n" } ], "attributes": [ ] } ], [ { "name": "Sammy.Application", "args": [ "app_function" ], "doc": "Sammy.Application is the Base prototype for defining 'applications'.\n An 'application' is a collection of 'routes' and bound events that is\n attached to an element when run() is called.\n The only argument an 'app_function' is evaluated within the context of the application.
returns a jQuery object of the Applications bound element.
\n" }, { "klass": "Sammy.Application", "name": "after", "args": [ "callback" ], "filename": "/lib/sammy.js", "lineno": 686, "doc": "A shortcut for binding a callback to be run after a route is executed.\n After callbacks have no guarunteed order.
\n" }, { "klass": "Sammy.Application", "name": "around", "args": [ "callback" ], "filename": "/lib/sammy.js", "lineno": 733, "doc": "Adds an around filter to the application. around filters are functions\n that take a single argument callback which is the entire route\n execution path wrapped up in a closure. This means you can decide whether\n or not to proceed with execution by not invoking callback or,\n more usefuly wrapping callback inside the result of an asynchronous execution.
The most common use case for around() is calling a possibly async function\n and executing the route within the functions callback:
\n\n var app = $.sammy(function() {\n\n var current_user = false;\n\n function checkLoggedIn(callback) {\n // /session returns a JSON representation of the logged in user\n // or an empty object\n if (!current_user) {\n $.getJSON('/session', function(json) {\n if (json.login) {\n // show the user as logged in\n current_user = json;\n // execute the route path\n callback();\n } else {\n // show the user as not logged in\n current_user = false;\n // the context of aroundFilters is an EventContext\n this.redirect('#/login');\n }\n });\n } else {\n // execute the route path\n callback();\n }\n };\n\n this.around(checkLoggedIn);\n\n });\nTakes a single callback that is pushed on to a stack.\n Before any route is run, the callbacks are evaluated in order within\n the current Sammy.EventContext
If any of the callbacks explicitly return false, execution of any\n further callbacks and the route itself is halted.
\n\nYou can also provide a set of options that will define when to run this\n before based on the route it proceeds.
\n\n var app = $.sammy(function() {\n\n // will run at #/route but not at #/\n this.before('#/route', function() {\n //...\n });\n\n // will run at #/ but not at #/route\n this.before({except: {path: '#/route'}}, function() {\n this.log('not before #/route');\n });\n\n this.get('#/', function() {});\n\n this.get('#/route', function() {});\n\n });\n See contextMatchesOptions() for a full list of supported options
Works just like jQuery.fn.bind() with a couple noteable differences.
eventNamespace()run()See http://code.quirkey.com/sammy/docs/events.html for more info.
\n" }, { "klass": "Sammy.Application", "name": "bindToAllEvents", "args": [ "callback" ], "filename": "/lib/sammy.js", "lineno": 884, "doc": "Will bind a single callback function to every event that is already\n being listened to in the app. This includes all the APP_EVENTS\n as well as any custom events defined with bind().
Used internally for debug logging.
\n" }, { "klass": "Sammy.Application", "name": "clearTemplateCache", "args": [ ], "filename": "/lib/sammy.js", "lineno": 1134, "doc": "clear the templateCache
\n" }, { "klass": "Sammy.Application", "name": "contextMatchesOptions", "args": [ "context", "match_options", "positive" ], "filename": "/lib/sammy.js", "lineno": 1048, "doc": "Matches an object of options against an EventContext like object that\n contains path and verb attributes. Internally Sammy uses this\n for matching before() filters against specific options. You can set the\n object to only match certain paths or verbs, or match all paths or verbs except\n those that match the options.
var app = $.sammy(),\n context = {verb: 'get', path: '#/mypath'};\n\n // match against a path string\n app.contextMatchesOptions(context, '#/mypath'); //=> true\n app.contextMatchesOptions(context, '#/otherpath'); //=> false\n // equivilent to\n app.contextMatchesOptions(context, {only: {path:'#/mypath'}}); //=> true\n app.contextMatchesOptions(context, {only: {path:'#/otherpath'}}); //=> false\n // match against a path regexp\n app.contextMatchesOptions(context, /path/); //=> true\n app.contextMatchesOptions(context, /^path/); //=> false\n // match only a verb\n app.contextMatchesOptions(context, {only: {verb:'get'}}); //=> true\n app.contextMatchesOptions(context, {only: {verb:'post'}}); //=> false\n // match all except a verb\n app.contextMatchesOptions(context, {except: {verb:'post'}}); //=> true\n app.contextMatchesOptions(context, {except: {verb:'get'}}); //=> false\n // match all except a path\n app.contextMatchesOptions(context, {except: {path:'#/otherpath'}}); //=> true\n app.contextMatchesOptions(context, {except: {path:'#/mypath'}}); //=> false\nThe base error handler takes a string message and an Error\n object. If raise_errors is set to true on the app level,\n this will re-throw the error to the browser. Otherwise it will send the error\n to log(). Override this method to provide custom error handling\n e.g logging to a server side component or displaying some feedback to the\n user.
A unique event namespace defined per application.\n All events bound with bind() are automatically bound within this space.
Delegates to the location_proxy to get the current location.\n See Sammy.HashLocationProxy for more info on location proxies.
Helper extends the event context just like helpers() but does it\n a single method at a time. This is especially useful for dynamically named\n helpers
// Trivial example that adds 3 helper methods to the context dynamically\n var app = $.sammy(function(app) {\n\n $.each([1,2,3], function(i, num) {\n app.helper('helper' + num, function() {\n this.log(\"I'm helper number \" + num);\n });\n });\n\n this.get('#/', function() {\n this.helper2(); //=> I'm helper number 2\n });\n });\nname The name of the methodmethod The function to be added to the prototype at nameHelpers extends the EventContext prototype specific to this app.\n This allows you to define app specific helper functions that can be used\n whenever you're inside of an event context (templates, routes, bind).
\n\nvar app = $.sammy(function() {\n\n helpers({\n upcase: function(text) {\n return text.toString().toUpperCase();\n }\n });\n\n get('#/', function() { with(this) {\n // inside of this context I can use the helpers\n $('#main').html(upcase($('#main').text());\n }});\n\n});\nextensions An object collection of functions to extend the context.Returns true if the current application is running.
Given a verb and a String path, will return either a route object or false\n if a matching route can be found within the current defined set.
\n" }, { "klass": "Sammy.Application", "name": "mapRoutes", "args": [ "route_array" ], "filename": "/lib/sammy.js", "lineno": 566, "doc": "mapRoutes takes an array of arrays, each array being passed to route()\n as arguments, this allows for mass definition of routes. Another benefit is\n this makes it possible/easier to load routes via remote JSON.
var app = $.sammy(function() {\n\n this.mapRoutes([\n ['get', '#/', function() { this.log('index'); }],\n // strings in callbacks are looked up as methods on the app\n ['post', '#/create', 'addUser'],\n // No verb assumes 'any' as the verb\n [/dowhatever/, function() { this.log(this.verb, this.path)}];\n ]);\n})\nThis thows a '404 Not Found' error by invoking error().\n Override this method or error() to provide custom\n 404 behavior (i.e redirecting to / or showing a warning)
Reruns the current route
\n" }, { "klass": "Sammy.Application", "name": "routablePath", "args": [ "path" ], "filename": "/lib/sammy.js", "lineno": 901, "doc": "Returns a copy of the given path with any query string after the hash\n removed.
\n" }, { "klass": "Sammy.Application", "name": "route", "args": [ "verb", "path", "callback" ], "filename": "/lib/sammy.js", "lineno": 483, "doc": "route() is the main method for defining routes within an application.\n For great detail on routes, check out: http://code.quirkey.com/sammy/doc/routes.html
This method also has aliases for each of the different verbs (eg. get(), post(), etc.)
verb A String in the set of ROUTE_VERBS or 'any'. 'any' will add routes for each\n of the ROUTE_VERBS. If only two arguments are passed,\n the first argument is the path, the second is the callback and the verb\n is assumed to be 'any'.path A Regexp or a String representing the path to match to invoke this verb.callback A Function that is called/evaluated whent the route is run see: runRoute().\n It is also possible to pass a string as the callback, which is looked up as the name\n of a method on the application.Actually starts the application's lifecycle. run() should be invoked\n within a document.ready block to ensure the DOM exists before binding events, etc.
var app = $.sammy(function() { ... }); // your application\n$(function() { // document.ready\n app.run();\n });\nstart_url Optionally, a String can be passed which the App will redirect to\nafter the events/routes have been bound.First, invokes lookupRoute() and if a route is found, parses the\n possible URL params and then invokes the route's callback within a new\n Sammy.EventContext. If the route can not be found, it calls\n notFound(). If raise_errors is set to true and\n the error() has not been overriden, it will throw an actual JS\n error.
You probably will never have to call this directly.
\n\nverb A String for the verb.path A String path to lookup.params An Object of Params pulled from the URI or passed directly.Either returns the value returned by the route callback or raises a 404 Not Found error.
\n" }, { "klass": "Sammy.Application", "name": "setLocation", "args": [ "new_location" ], "filename": "/lib/sammy.js", "lineno": 1095, "doc": "Delegates to the location_proxy to set the current location.\n See Sammy.HashLocationProxy for more info on location proxies.
new_location A new location string (e.g. '#/')Sets the location proxy for the current app. By default this is set to\n a new Sammy.HashLocationProxy on initialization. However, you can set\n the location_proxy inside you're app function to give your app a custom\n location mechanism. See Sammy.HashLocationProxy and Sammy.DataLocationProxy\n for examples.
setLocationProxy() takes an initialized location proxy.
// to bind to data instead of the default hash;\n var app = $.sammy(function() {\n this.setLocationProxy(new Sammy.DataLocationProxy(this));\n });\nSwaps the content of $element() with content\n You can override this method to provide an alternate swap behavior\n for EventContext.partial().
var app = $.sammy(function() {\n\n // implements a 'fade out'/'fade in'\n this.swap = function(content) {\n this.$element().hide('slow').html(content).show('slow');\n }\n\n get('#/', function() {\n this.partial('index.html.erb') // will fade out and in\n });\n\n});\na simple global cache for templates. Uses the same semantics as\n Sammy.Cache and Sammy.Storage so can easily be replaced with\n a persistant storage that lasts beyond the current request.
//=> Sammy.Application: body
\n" }, { "klass": "Sammy.Application", "name": "trigger", "args": [ "name", "data" ], "filename": "/lib/sammy.js", "lineno": 631, "doc": "Triggers custom events defined with bind()
name The name of the event. Automatically prefixed with the eventNamespace()data An optional Object that can be passed to the bound callback.context An optional context/Object in which to execute the bound callback.\nIf no context is supplied a the context is a new Sammy.EventContextThe opposite of run(), un-binds all event listeners and intervals\n run() Automaticaly binds a onunload event to run this when\n the document is closed.
use() is the entry point for including Sammy plugins.\n The first argument to use should be a function() that is evaluated\n in the context of the current application, just like the app_function\n argument to the Sammy.Application constructor.
Any additional arguments are passed to the app function sequentially.
\n\nFor much more detail about plugins, check out:\n http://code.quirkey.com/sammy/doc/plugins.html
\n\n var MyPlugin = function(app, prepend) {\n\n this.helpers({\n myhelper: function(text) {\n alert(prepend + \" \" + text);\n }\n });\n\n };\n\n var app = $.sammy(function() {\n\n this.use(MyPlugin, 'This is my plugin');\n\n this.get('#/', function() {\n this.myhelper('and dont you forget it!');\n //=> Alerts: This is my plugin and dont you forget it!\n });\n\n });\nIf plugin is passed as a string it assumes your are trying to load\n Sammy.\"Plugin\". This is the prefered way of loading core Sammy plugins\n as it allows for better error-messaging.
\n\n $.sammy(function() {\n this.use('Mustache'); //=> Sammy.Mustache\n this.use('Storage'); //=> Sammy.Storage\n });\nAn array of the default events triggered by the\n application during its lifecycle
\n" }, { "klass": "Sammy.Application", "name": "ROUTE_VERBS", "default": "['get','post','put','delete']", "filename": "/lib/sammy.js", "lineno": 318, "doc": "the four route verbs
\n" }, { "klass": "Sammy.Application", "name": "any", "default": "_routeWrapper('any')", "filename": "/lib/sammy.js", "lineno": 547, "doc": "Alias for route('any', ...)
\n" }, { "klass": "Sammy.Application", "name": "debug", "default": "false", "filename": "/lib/sammy.js", "lineno": 344, "doc": "When set to true, logs all of the default events using log()
Alias for route('delete', ...)
\n" }, { "klass": "Sammy.Application", "name": "element_selector", "default": "'body'", "filename": "/lib/sammy.js", "lineno": 341, "doc": "Defines what element the application is bound to. Provide a selector\n (parseable by jQuery()) and this will be used by $element()
Alias for route('get', ...)
\n" }, { "klass": "Sammy.Application", "name": "post", "default": "_routeWrapper('post')", "filename": "/lib/sammy.js", "lineno": 538, "doc": "Alias for route('post', ...)
\n" }, { "klass": "Sammy.Application", "name": "put", "default": "_routeWrapper('put')", "filename": "/lib/sammy.js", "lineno": 541, "doc": "Alias for route('put', ...)
\n" }, { "klass": "Sammy.Application", "name": "raise_errors", "default": "false", "filename": "/lib/sammy.js", "lineno": 348, "doc": "When set to true, and the error() handler is not overriden, will actually\n raise JS errors in routes (500) and when routes can't be found (404)
\n" }, { "klass": "Sammy.Application", "name": "run_interval_every", "default": "50", "filename": "/lib/sammy.js", "lineno": 351, "doc": "The time in milliseconds that the URL is queried for changes
\n" }, { "klass": "Sammy.Application", "name": "template_engine", "default": "null", "filename": "/lib/sammy.js", "lineno": 360, "doc": "The default template engine to use when using partial() in an\n EventContext. template_engine can either be a string that\n corresponds to the name of a method/helper on EventContext or it can be a function\n that takes two arguments, the content of the unrendered partial and an optional\n JS object that contains interpolation data. Template engine is only called/refered\n to if the extension of the partial is null or unknown. See partial()\n for more information
Sammy.RenderContext is an object that makes sequential template loading,\n rendering and interpolation seamless even when dealing with asyncronous\n operations.
RenderContext objects are not usually created directly, rather they are\n instatiated from an Sammy.EventContext by using render(), load() or\n partial() which all return RenderContext objects.
RenderContext methods always returns a modified RenderContext\n for chaining (like jQuery itself).
The core magic is in the then() method which puts the callback passed as\n an argument into a queue to be executed once the previous callback is complete.\n All the methods of RenderContext are wrapped in then() which allows you\n to queue up methods by chaining, but maintaing a guarunteed execution order\n even with remote calls to fetch templates.
Same usage as jQuery.fn.appendTo() but uses then() to ensure order
itterates over an array, applying the callback for each item item. the\n callback takes the same style of arguments as jQuery.each() (index, item).\n The return value of each callback is collected as a single string and stored\n as content to be used in the next iteration of the RenderContext.
uses the previous loaded content and the data object to interpolate\n a template. engine defines the templating/interpolation method/engine\n that should be used. If engine is not passed, the next_engine is\n used. If retain is true, the final interpolated data is appended to\n the previous_content instead of just replacing it.
Load a template into the context.\n The location can either be a string specifiying the remote path to the\n file, a jQuery object, or a DOM element.
No interpolation happens by default, the content is stored in\n content.
In the case of a path, unless the option {cache: false} is passed the\n data is stored in the app's templateCache().
If a jQuery or DOM object is passed the innerHTML of the node is pulled in.\n This is useful for nesting templates as part of the initial page load wrapped\n in invisible elements or <script> tags. With template paths, the template\n engine is looked up by the extension. For DOM/jQuery embedded templates,\n this isnt possible, so there are a couple of options:
{engine:} option.data-engine attribute of the passed node.interpolate() manually If a callback is passed it is executed after the template load.
Resume the queue, setting content to be used in the next operation.\n See wait() for an example.
render() the the location with data and then swap() the\n app's $element with the rendered content.
Same usage as jQuery.fn.prependTo() but uses then() to ensure order
load() a template and then interpolate() it with data.
this.get('#/', function() {\n this.render('mytemplate.template', {name: 'test'});\n });\nloads a template, and then interpolates it for each item in the data\n array. If a callback is passed, it will call the callback with each\n item in the array after interpolation
Replaces the $(selector) using html() with the previously loaded\n content
defers the call of function to occur in order of the render queue.\n The function can accept any number of arguments as long as the last\n argument is a callback function. This is useful for putting arbitrary\n asynchronous functions into the queue. The content passed to the\n callback is passed as content to the next item in the queue.
=== Example
\n\n this.send($.getJSON, '/app.json')\n .then(function(json) {\n $('#message).text(json['message']);\n });\nexecutes EventContext#swap() with the content
The \"core\" of the RenderContext object, adds the callback to the\n queue. If the context is waiting (meaning an async operation is happening)\n then the callback will be executed in order, once the other operations are\n complete. If there is no currently executing operation, the callback\n is executed immediately.
The value returned from the callback is stored in content for the\n subsiquent operation. If you return false, the queue will pause, and\n the next callback in the queue will not be executed until next() is\n called. This allows for the guarunteed order of execution while working\n with async operations.
If then() is passed a string instead of a function, the string is looked\n up as a helper method on the event context.
\n\n this.get('#/', function() {\n // initialize the RenderContext\n // Even though `load()` executes async, the next `then()`\n // wont execute until the load finishes\n this.load('myfile.txt')\n .then(function(content) {\n // the first argument to then is the content of the\n // prev operation\n $('#main').html(content);\n });\n });\ntrigger the event in the order of the event context. Same semantics\n as Sammy.EventContext#trigger(). If data is ommitted, content\n is sent as {content: content}
Pause the RenderContext queue. Combined with next() allows for async\n operations.
this.get('#/', function() {\n this.load('mytext.json')\n .then(function(content) {\n var context = this,\n data = JSON.parse(content);\n // pause execution\n context.wait();\n // post to a url\n $.post(data.url, {}, function(response) {\n context.next(JSON.parse(response));\n });\n })\n .then(function(data) {\n // data is json from the previous post\n $('#message').text(data.status);\n });\n });\nSammy.EventContext objects are created every time a route is run or a\n bound event is triggered. The callbacks for these events are evaluated within a Sammy.EventContext\n This within these callbacks the special methods of EventContext are available.
$.sammy(function() {
\n\n// The context here is this Sammy.Application\nthis.get('#/:name', function() {\n // The context here is a new Sammy.EventContext\n if (this.params['name'] == 'sammy') {\n this.partial('name.html.erb', {name: 'Sammy'});\n } else {\n this.redirect('#/somewhere-else')\n }\n});\n});
\n\nInitialize a new EventContext
\n\napp The Sammy.Application this event is called within.verb The verb invoked to run this context/route.path The string path invoked to run this context/route.params An Object of optional params to pass to the context. Is converted\nto a Sammy.Object.target a DOM element that the event that holds this context originates\nfrom. For post, put and del routes, this is the form element that triggered\nthe route.A shortcut to the app's $element()
Look up a templating engine within the current app and context.\n engine can be one of the following:
function(content, data) { return interploated; }ejs() helpermustache() If no engine is found, use the app's default template_engine
A shortcut to app's eventNamespace()
using the template engine found with engineFor(), interpolate the\n data into content
Default JSON parsing uses jQuery's parseJSON(). Include Sammy.JSON\n plugin for the more conformant \"crockford special\".
create a new Sammy.RenderContext calling load() with location and\n options. Called without interpolation or placement, this allows for\n preloading/caching the templates.
Raises a possible notFound() error for the current path.
render() the the location with data and then swap() the\n app's $element with the rendered content.
Changes the location of the current window. If to begins with\n '#' it only changes the document's hash. If passed more than 1 argument\n redirect will join them together with forward slashes.
redirect('#/other/route');\n // equivilent to\n redirect('#', 'other', 'route');\nCreate and return a Sammy.RenderContext calling render() on it.\n Loads the template and interpolate the data, however does not actual\n place it in the DOM.
// mytemplate.mustache <div class=\"name\">{{name}}</div>\n render('mytemplate.mustache', {name: 'quirkey'});\n // sets the `content` to <div class=\"name\">quirkey</div>\n render('mytemplate.mustache', {name: 'quirkey'})\n .appendTo('ul');\n // appends the rendered content to $('ul')\nCreate and return a Sammy.RenderContext calling renderEach() on it.\n Loads the template and interpolates the data for each item,\n however does not actual place it in the DOM.
// mytemplate.mustache <div class=\"name\">{{name}}</div>\n renderEach('mytemplate.mustache', [{name: 'quirkey'}, {name: 'endor'}])\n // sets the `content` to <div class=\"name\">quirkey</div><div class=\"name\">endor</div>\n renderEach('mytemplate.mustache', [{name: 'quirkey'}, {name: 'endor'}]).appendTo('ul');\n // appends the rendered content to $('ul')\ncreate a new Sammy.RenderContext calling send() with an arbitrary\n function
A shortcut to app's swap()
//=> Sammy.EventContext: get #/ {}
\n" }, { "klass": "Sammy.EventContext", "name": "trigger", "args": [ "name", "data" ], "filename": "/lib/sammy.js", "lineno": 1801, "doc": "Triggers events on app within the current context.
A simple cache strategy that stores key/values in memory.
\n", "filename": "/lib/plugins/sammy.cache.js", "lineno": 7 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.DataCacheProxy", "args": [ "initial", "$element" ], "doc": "A simple cache strategy that stores key/values $element.data() with a cache. prefix
\n", "filename": "/lib/plugins/sammy.cache.js", "lineno": 27 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Cache", "args": [ "app", "proxy" ], "doc": "Sammy.Cache provides helpers for caching data within the lifecycle of a\n Sammy app. The plugin provides two main methods on Sammy.Application,\n cache and clearCache. Each app has its own cache store so that\n you dont have to worry about collisions. There are currently two different 'cache proxies'\n that share the same API but store the data in different ways.
\n\nproxy decides which caching proxy to use, either 'memory'(default) or 'data'cache is the main method for interacting with the cache store. The same\n method is used for both setting and getting the value. The API is similar\n to jQuery.fn.attr()
\n\n // setting a value\n cache('key', 'value');\n\n // getting a value\n cache('key'); //=> 'value'\n\n // setting a value with a callback\n cache('key', function() {\n // this is the app\n return app.element_selector;\n });\na helper shortcut for use in Sammy.EventContext
\n" }, { "klass": "Sammy.Cache", "name": "clearCache", "args": [ "name" ], "filename": "/lib/plugins/sammy.cache.js", "lineno": 102, "doc": "clears the cached value for name
\n" } ], "attributes": [ ] } ], [ { "name": "Sammy.DataLocationProxy", "args": [ "app", "data_name", "href_attribute" ], "doc": "The DataLocationProxy is an optional location proxy prototype. As opposed to\n the HashLocationProxy it gets its location from a jQuery.data attribute\n tied to the application's element. You can set the name of the attribute by\n passing a string as the second argument to the constructor. The default attribute\n name is 'sammy-location'. To read more about location proxies, check out the\n documentation for Sammy.HashLocationProxy
An optional href_attribute can be passed, which specifies a DOM element\n attribute that holds \"links\" to different locations in the app. When the\n proxy is bound, clicks to element that have this attribute activate a\n setLocation() using the contents of the href_attribute.
var app = $.sammy(function() {\n // set up the location proxy\n this.setLocationProxy(new Sammy.DataLocationProxy(this, 'location', 'rel'));\n\n this.get('about', function() {\n this.partial('about.html');\n });\n\n });\nIn this scenario, if an element existed within the template:
\n\n <a href=\"/about\" rel=\"about\">About Us</a>\nClicking on that link would not go to /about, but would set the apps location\n to 'about' and trigger the route.
\n", "filename": "/lib/plugins/sammy.data_location_proxy.js", "lineno": 35 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.FormBuilder", "args": [ "name", "object" ], "doc": "Sammy.FormBuilder is based very closely on the Rails FormBuilder classes.\n Its goal is to make it easy to create HTML forms for creating and editing\n JavaScript objects. It eases the process by auto-populating existing values\n into form inputs and creating input names suitable for parsing by\n Sammy.NestedParams and other backend frameworks.
\n\nYou initialize a Sammy.FormBuilder by passing the 'name' of the object and\n the object itself. Once initialized you create form elements with the object's\n prototype methods. Each of these methods returns a string of HTML suitable for\n appending through a template or directly with jQuery.
\n\n var item = {\n name: 'My Item',\n price: '$25.50',\n meta: {\n id: '123'\n }\n };\n var form = new Sammy.FormBuilder('item', item);\n form.text('name');\n //=> <input type='text' name='item[form]' value='My Item' />\nNested attributes can be accessed/referred to by a 'keypath' which is\n basically a string representation of the dot notation.
\n\n form.hidden('meta.id');\n //=> <input type='hidden' name='item[meta][id]' value='123' />\ncreates a checkbox input for keypath with the value value. Multiple\n checkboxes can be created with different value, if value equals the\n current value of the key of the form builder's object the attribute\n checked='checked' will be added.
By default checkbox() also generates a hidden element whose value is\n the inverse of the value given. This is known hack to get around a common\n gotcha where browsers and jQuery itself does not include 'unchecked'\n elements in the list of submittable inputs. This ensures that a value\n should always be passed to Sammy and hence the server. You can disable\n the creation of the hidden element by setting the hidden_element attribute\n to false
closes the form
\n" }, { "klass": "Sammy.FormBuilder", "name": "hidden", "args": [ "keypath", "attributes" ], "filename": "/lib/plugins/sammy.form.js", "lineno": 93, "doc": "creates a hidden input for keypath with an optional attributes object
creates a label for keypath with the text content\n with an optionalattributes` object
creates the open form tag with the object attributes
\n" }, { "klass": "Sammy.FormBuilder", "name": "password", "args": [ "keypath", "attributes" ], "filename": "/lib/plugins/sammy.form.js", "lineno": 114, "doc": "creates a password input for keypath with an optional attributes object
creates a radio input for keypath with the value value. Multiple\n radios can be created with different value, if value equals the\n current value of the key of the form builder's object the attribute\n checked='checked' will be added.
creates a select element for keypath with the option elements\n specified by an array in options. If options is an array of arrays,\n the first element in each subarray becomes the text of the option and the\n second becomes the value.
var options = [\n ['Small', 's'],\n ['Medium', 'm'],\n ['Large', 'l']\n ];\n form.select('size', options);\n //=> <select name='item[size]'><option value='s'>Small</option> ...\ncreates a submit input for keypath with an optional attributes object
creates a text input for keypath with an optional attributes object
creates a textarea for keypath with an optional attributes object
Sammy.Form is a Sammy plugin that adds form building helpers to a\n Sammy.Application
\n", "filename": "/lib/plugins/sammy.form.js", "lineno": 223 }, { "methods": [ { "klass": "Sammy.Form", "name": "formFor", "args": [ "name", "object", "content_callback" ], "filename": "/lib/plugins/sammy.form.js", "lineno": 259, "doc": "formFor creates a Sammy.Form builder object with the passed name\n and object and passes it as an argument to the content_callback.\n This is a shortcut for creating FormBuilder objects for use within\n templates.
// in item_form.template\n\n <% formFor('item', item, function(f) { %>\n <%= f.open({action: '#/items'}) %>\n <p>\n <%= f.label('name') %>\n <%= f.text('name') %>\n </p>\n <p>\n <%= f.submit() %>\n </p>\n <%= f.close() %>\n <% }); %>\nsimple_element is a simple helper for creating HTML tags.
\n\ntag the HTML tag to generate e.g. input, p, etc/attributes an object representing the attributes of the element as\nkey value pairs. e.g. {class: 'element-class'}content an optional string representing the content for the\nthe element. If ommited, the element becomes self closingA simple plugin that pings Google Analytics tracker\n every time a route is triggered. Originally by Brit Gardner (britg),\n with updates from Aaron Quint (quirkey).
\n\n=== Arguments
\n\n+tracker+:: the Google Analytics pageTracker object. Defaults to\n the default object defined by the GA snippet, or pass your own if you\n have a custom install
\n\n=== Example
\n\nInstall Google Analytics to your site as you normally would. Be sure that\n the 'pageTracker' global variable exists.
\n\nThen, simply add the plugin to your Sammy App and it will automatically\n track all of your routes in Google Analytics.\n They will appear as page views to the route's path.
\n\n $.sammy(function() {\n this.use('GoogleAnalytics');\n\n ...\n });\n If you have routes that you do not want to track, simply call noTrack\n within the route.
$.sammy(function() {\n this.use('GoogleAnalytics')\n\n get('#/dont/track/me', function() {\n this.noTrack(); // This route will not be tracked\n });\n });\nDisable tracking for the current route. Put at the begining of the\n route's callback
\n" }, { "klass": "Sammy.GoogleAnalytics", "name": "track", "args": [ "path" ], "filename": "/lib/plugins/sammy.googleanalytics.js", "lineno": 60, "doc": "send a page view to the tracker with path
Sammy.Haml provides a quick way of using haml style templates in your app.\n The plugin itself includes the haml-js library created by Tim Caswell at\n at http://github.com/creationix/haml-js
\n\nHaml is an alternative HTML syntax that is really great for describing\n the structure of HTML documents.
\n\nBy default using Sammy.Haml in your app adds the haml() method to the EventContext\n prototype. However, just like Sammy.Template you can change the default name of the method\n by passing a second argument (e.g. you could use the hml() as the method alias so that all the template\n files could be in the form file.hml instead of file.haml)
\n\nThe template (mytemplate.haml):
\n\n %h1&= title\n\n Hey, #{name}! Welcome to Haml!\nThe app:
\n\n var $.app = $.sammy(function() {\n // include the plugin\n this.use(Sammy.Haml);\n\n this.get('#/hello/:name', function() {\n // set local vars\n this.title = 'Hello!'\n this.name = this.params.name;\n // render the template and pass it through haml\n this.partial('mytemplate.haml');\n });\n\n });\nIf I go to #/hello/AQ in the browser, Sammy will render this to the body:
\n\n <h1>Hello!</h1>\n\n Hey, AQ! Welcome to HAML!\nNote: You dont have to include the haml.js file on top of the plugin as the plugin\n includes the full source.
\n", "filename": "/lib/plugins/sammy.haml.js", "lineno": 548 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Handlebars.SafeString", "args": [ "string" ], "doc": "Build out our basic SafeString type
\n", "filename": "/lib/plugins/sammy.handlebars.js", "lineno": 243 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Handlebars", "args": [ "app", "method_alias" ], "doc": "Sammy.Handlebars provides a quick way of using Handlebars templates in your app.\n The plugin itself includes the handlebars.js library created by Yehuda Katz at\n at http://github.com/wycats/handlebars.js
\n\nHandlebars.js is an extension to the Mustache templating language created by Chris Wanstrath. Handlebars.js\n and Mustache are both logicless templating languages that keep the view and the code separated like\n we all know they should be.
\n\nBy default using Sammy.Handlbars in your app adds the handlebars() method to the EventContext\n prototype. However, just like Sammy.Template you can change the default name of the method\n by passing a second argument (e.g. you could use the hbr() as the method alias so that all the template\n files could be in the form file.hbr instead of file.handlebars)
\n\nThe template (mytemplate.hb):
\n\n <h1>\\{\\{title\\}\\}<h1>\n\n Hey, {{name}}! Welcome to Handlebars!\nThe app:
\n\n var $.app = $.sammy(function() {\n // include the plugin and alias handlebars() to hb()\n this.use(Sammy.Handlebars, 'hb');\n\n this.get('#/hello/:name', function() {\n // set local vars\n this.title = 'Hello!'\n this.name = this.params.name;\n // render the template and pass it through handlebars\n this.partial('mytemplate.hb');\n });\n\n });\nIf I go to #/hello/AQ in the browser, Sammy will render this to the body:
\n\n <h1>Hello!</h1>\n\n Hey, AQ! Welcome to Handlebars!\nThe template (mytemplate.hb)
\n\n Hey, {{name}}! {{>hello_friend}}\nThe partial (mypartial.hb)
\n\n Say hello to your friend {{friend}}!\nThe app:
\n\n var $.app = $.sammy(function() {\n // include the plugin and alias handlebars() to hb()\n this.use(Sammy.Handlebars, 'hb');\n\n this.get('#/hello/:name/to/:friend', function() {\n var context = this;\n\n // fetch handlebars-partial first\n $.get('mypartial.hb', function(response){\n context.partials = response;\n\n // set local vars\n context.name = this.params.name;\n context.hello_friend = {name: this.params.friend};\n\n // render the template and pass it through handlebars\n context.partial('mytemplate.hb');\n });\n });\n\n });\nIf I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body:
\n\n Hey, AQ! Say hello to your friend dP!\nNote: You dont have to include the handlebars.js file on top of the plugin as the plugin\n includes the full source.
\n", "filename": "/lib/plugins/sammy.handlebars.js", "lineno": 582 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.JSON", "args": [ "app" ], "doc": "Sammy.JSON is a simple wrapper around Douglas Crockford's ever-useful json2.js\n (http://www.json.org/js.html]) Sammy.JSON includes the top level JSON object if\n it doesn't already exist (a.k.a. does not override the native implementation that\n some browsers include). It also adds a json() helper to a Sammy app when\n included.
\n", "filename": "/lib/plugins/sammy.json.js", "lineno": 331 }, { "methods": [ { "klass": "Sammy.JSON", "name": "json", "args": [ "object" ], "filename": "/lib/plugins/sammy.json.js", "lineno": 351, "doc": "json is a polymorphic function that translates objects aback and forth\n from JSON to JS. If given a string, it will parse into JS, if given a JS\n object it will stringify into JSON.
\n\n var app = $.sammy(function() {\n this.use(Sammy.JSON);\n\n this.get('#/', function() {\n this.json({user_id: 123}); //=> \"{\\\"user_id\\\":\\\"123\\\"}\"\n this.json(\"{\\\"user_id\\\":\\\"123\\\"}\"); //=> [object Object]\n this.json(\"{\\\"user_id\\\":\\\"123\\\"}\").user_id; //=> \"123\"\n });\n })\nSammy.Meld is a simple templating engine that uses the power of jQuery's\n DOM manipulation to easily meld JSON data and HTML templates very quickly.
The template can either be a string (i.e. loaded from a remote template)\n or a DOM Element/jQuery object. This allows you to have templates be DOM\n elements as the initial document load.
\n\n The simplest case is a nested <div> whose class name is tied to a\n property of a JS object.
Template:
\n\n <div class=\"post\">\n <div class=\"title\"></div>\n <div class=\"entry\"></div>\n <div class=\"author\">\n <span class=\"name\"></span>\n </div>\n </div>\nData:
\n\n {\n \"post\": {\n \"title\": \"My Post\",\n \"entry\": \"My Entry\",\n \"author\": {\n \"name\": \"@aq\"\n }\n }\n }\nResult:
\n\n <div class=\"post\">\n <div class=\"title\">My Post</div>\n <div class=\"entry\">My Entry</div>\n <div class=\"author\">\n <span class=\"name\">@aq</span>\n </div>\n </div>\n Templates can be much more complex, and more deeply nested.\n More examples can be found in test/fixtures/meld/
If you don't think the lookup by classes is semantic for you, you can easily\n switch the method of lookup by defining a selector function in the options
\n\nFor example:
\n\n meld($('.post'), post_data, {\n selector: function(k) {\n return '[data-key=' + k + ']';\n }\n });\n Would look for template nodes like <div data-key='entry'>
Sammy.Mustache provides a quick way of using mustache style templates in your app.\n The plugin itself includes the awesome mustache.js lib created and maintained by Jan Lehnardt\n at http://github.com/janl/mustache.js
\n\nMustache is a clever templating system that relys on double brackets {{}} for interpolation.\n For full details on syntax check out the original Ruby implementation created by Chris Wanstrath at\n http://github.com/defunkt/mustache
\n\nBy default using Sammy.Mustache in your app adds the mustache() method to the EventContext\n prototype. However, just like Sammy.Template you can change the default name of the method\n by passing a second argument (e.g. you could use the ms() as the method alias so that all the template\n files could be in the form file.ms instead of file.mustache)
\n\nThe template (mytemplate.ms):
\n\n <h1>\\{\\{title\\}\\}<h1>\n\n Hey, {{name}}! Welcome to Mustache!\nThe app:
\n\n var $.app = $.sammy(function() {\n // include the plugin and alias mustache() to ms()\n this.use(Sammy.Mustache, 'ms');\n\n this.get('#/hello/:name', function() {\n // set local vars\n this.title = 'Hello!'\n this.name = this.params.name;\n // render the template and pass it through mustache\n this.partial('mytemplate.ms');\n });\n\n });\nIf I go to #/hello/AQ in the browser, Sammy will render this to the body:
\n\n <h1>Hello!</h1>\n\n Hey, AQ! Welcome to Mustache!\nThe template (mytemplate.ms)
\n\n Hey, {{name}}! {{>hello_friend}}\nThe partial (mypartial.ms)
\n\n Say hello to your friend {{friend}}!\nThe app:
\n\n var $.app = $.sammy(function() {\n // include the plugin and alias mustache() to ms()\n this.use(Sammy.Mustache, 'ms');\n\n this.get('#/hello/:name/to/:friend', function() {\n var context = this;\n\n // fetch mustache-partial first\n $.get('mypartial.ms', function(response){\n context.partials = response;\n\n // set local vars\n context.name = this.params.name;\n context.hello_friend = {name: this.params.friend};\n\n // render the template and pass it through mustache\n context.partial('mytemplate.ms');\n });\n });\n\n });\nIf I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body:
\n\n Hey, AQ! Say hello to your friend dP!\nNote: You dont have to include the mustache.js file on top of the plugin as the plugin\n includes the full source.
\n", "filename": "/lib/plugins/sammy.mustache.js", "lineno": 420 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.NestedParams", "args": [ "app" ], "doc": "Sammy.NestedParams overrides the default form parsing behavior to provide\n extended functionality for parsing Rack/Rails style form name/value pairs into JS\n Objects. In fact it passes the same suite of tests as Rack's nested query parsing.\n The code and tests were ported to JavaScript/Sammy by http://github.com/endor
\n\nThis allows you to translate a form with properly named inputs into a JSON object.
\n\nGiven an HTML form like so:
\n\n <form action=\"#/parse_me\" method=\"post\">\n <input type=\"text\" name=\"obj[first]\" />\n <input type=\"text\" name=\"obj[second]\" />\n <input type=\"text\" name=\"obj[hash][first]\" />\n <input type=\"text\" name=\"obj[hash][second]\" />\n </form>\nAnd a Sammy app like:
\n\n var app = $.sammy(function(app) {\n this.use(Sammy.NestedParams);\n\n this.post('#/parse_me', function(context) {\n $.log(this.params);\n });\n });\nIf you filled out the form with some values and submitted it, you would see something\n like this in your log:
\n\n {\n 'obj': {\n 'first': 'value',\n 'second': 'value',\n 'hash': {\n 'first': 'value',\n 'second': 'value'\n }\n }\n }\nIt supports creating arrays with [] and other niceities. Check out the tests for\n full specs.
\n", "filename": "/lib/plugins/sammy.nested_params.js", "lineno": 112 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.OAuth2", "args": [ "app" ], "doc": "Sammy.OAuth2 is a plugin for using OAuth 2.0 to authenticate users and\n access your application's API. Requires Sammy.Session.
\n\nTriggers the following events:\n - oauth.connected -- Access token set and ready to use. Triggered when new\n access token acquired, of when application starts and already has access\n token.\n - oauth.disconnected -- Access token reset. Triggered by\n loseAccessToken().\n - oauth.denied -- Authorization attempt rejected.
\n\nthis.use(Sammy.Storage);\n this.use(Sammy.OAuth2);\n this.oauthorize = \"/oauth/authorize\";
\n\n// The quick & easy way\n this.requireOAuth();\n // Specific path\n this.requireOAuth(\"/private\");\n // Filter you can apply to specific URLs\n this.before(function(context) { return context.requireOAuth(); })\n // Apply to specific request\n this.get(\"/private\", function(context) {\n this.requireOAuth(function() {
\n\n // Do something\n})\n })
\n\n// Sign in/sign out.\n this.bind(\"oauth.connected\", function() { $(\"#signin\").hide() });\n this.bind(\"oauth.disconnected\", function() { $(\"#signin\").show() });
\n\n// Handle access denied and other errors\n this.bind(\"oauth.denied\", function(evt, error) {\n this.partial(\"admin/views/no_access.tmpl\", { error: error.message });\n });
\n\n// Sign out.\n this.get(\"#/signout\", function(context) {\n context.loseAccessToken();\n context.redirect(\"#/\");\n });
\n", "filename": "/lib/plugins/sammy.oauth2.js", "lineno": 48 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.PathLocationProxy", "args": [ "app" ], "doc": "Sammy.PathLocationProxy is a simple Location Proxy that just\n gets and sets window.location. This allows you to use\n Sammy to route on the full URL path instead of just the hash. It\n will take a full refresh to get the app to change state.
To read more about location proxies, check out the\n documentation for Sammy.HashLocationProxy
Sammy.Pure is a simple wrapper around the pure.js templating engine for\n use in Sammy apps.
See http://beebole.com/pure/ for detailed documentation.
\n", "filename": "/lib/plugins/sammy.pure.js", "lineno": 744 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Store", "args": [ "options" ], "doc": "Sammy.Store is an abstract adapter class that wraps the multitude of in\n browser data storage into a single common set of methods for storing and\n retreiving data. The JSON library is used (through the inclusion of the\n Sammy.JSON) plugin, to automatically convert objects back and forth from\n stored strings.
\n\n Sammy.Store can be used directly, but within a Sammy.Application it is much\n easier to use the Sammy.Storage plugin and its helper methods.
Sammy.Store also supports the KVO pattern, by firing DOM/jQuery Events when\n a key is set.
\n\n // create a new store named 'mystore', tied to the #main element, using HTML5 localStorage\n // Note: localStorage only works on browsers that support it\n var store = new Sammy.Store({name: 'mystore', element: '#element', type: 'local'});\n store.set('foo', 'bar');\n store.get('foo'); //=> 'bar'\n store.set('json', {obj: 'this is an obj'});\n store.get('json'); //=> {obj: 'this is an obj'}\n store.keys(); //=> ['foo','json']\n store.clear('foo');\n store.keys(); //=> ['json']\n store.clearAll();\n store.keys(); //=> []\nThe constructor takes a single argument which is a Object containing these possible options.
\n\nname The name/namespace of this store. Stores are unique by name/type. (default 'store')element A selector for the element that the store is bound to. (default 'body')type The type of storage/proxy to use (default 'memory')Extra options are passed to the storage constructor.\n Sammy.Store supports the following methods of storage:
\n\nmemory Basic object storagedata jQuery.data DOM Storagecookie Access to document.cookie. Limited to 2Klocal HTML5 DOM localStorage, browswer support is currently limited.session HTML5 DOM sessionStorage, browswer support is currently limited.Removes the value at key from the current store
Clears all the values for the current store.
\n" }, { "klass": "Sammy.Store", "name": "each", "args": [ "callback" ], "filename": "/lib/plugins/sammy.storage.js", "lineno": 153, "doc": "Iterates over each key value pair passing them to the callback function
store.each(function(key, value) {\n Sammy.log('key', key, 'value', value);\n });\nChecks for the existance of key in the current store. Returns a boolean.
Returns the value at key if set, otherwise, runs the callback\n and sets the value to the value returned in the callback.
var store = new Sammy.Store;\nstore.exists('foo'); //=> false\nstore.fetch('foo', function() {\n return 'bar!';\n}); //=> 'bar!'\nstore.get('foo') //=> 'bar!'\nstore.fetch('foo', function() {\n return 'baz!';\n}); //=> 'bar!\nFilters the store by a filter function that takes a key value.\n Returns an array of arrays where the first element of each array\n is the key and the second is the value of that key.
\n\n var store = new Sammy.Store;\n store.set('one', 'two');\n store.set('two', 'three');\n store.set('1', 'two');\n var returned = store.filter(function(key, value) {\n // only return\n return value === 'two';\n });\n // returned => [['one', 'two'], ['1', 'two']];\nWorks exactly like filter except only returns the first matching key\n value pair instead of all of them
\n" }, { "klass": "Sammy.Store", "name": "get", "args": [ "key" ], "filename": "/lib/plugins/sammy.storage.js", "lineno": 117, "doc": "Returns the set value at key, parsing with JSON.parse and\n turning into an object if possible
Checks for the availability of the current storage type in the current browser/config.
\n" }, { "klass": "Sammy.Store", "name": "keys", "args": [ ], "filename": "/lib/plugins/sammy.storage.js", "lineno": 142, "doc": "Returns the all the keys set for the current store as an array.\n Internally Sammy.Store keeps this array in a 'meta_key' for easy access.
\n" }, { "klass": "Sammy.Store", "name": "load", "args": [ "key", "path", "callback" ], "filename": "/lib/plugins/sammy.storage.js", "lineno": 238, "doc": "loads the response of a request to path into key.
In /mytemplate.tpl:
\n\nMy Template\nIn app.js:
\n\nvar store = new Sammy.Store;\nstore.load('mytemplate', '/mytemplate.tpl', function() {\n s.get('mytemplate') //=> My Template\n});\nSets the value of key with value. If value is an\n object, it is turned to and stored as a string with JSON.stringify.\n It also tries to conform to the KVO pattern triggering jQuery events on the\n element that the store is bound to.
var store = new Sammy.Store({name: 'kvo'});\n $('body').bind('set-kvo-foo', function(e, data) {\n Sammy.log(data.key + ' changed to ' + data.value);\n });\n store.set('foo', 'bar'); // logged: foo changed to bar\nTests if the type of storage is available/works in the current browser/config.\n Especially useful for testing the availability of the awesome, but not widely\n supported HTML5 DOM storage
\n", "filename": "/lib/plugins/sammy.storage.js", "lineno": 262 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Store.Memory", "args": [ "name", "element" ], "doc": "Memory ('memory') is the basic/default store. It stores data in a global\n JS object. Data is lost on refresh.
\n", "filename": "/lib/plugins/sammy.storage.js", "lineno": 272 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Store.Data", "args": [ "name", "element" ], "doc": "Data ('data') stores objects using the jQuery.data() methods. This has the advantadge\n of scoping the data to the specific element. Like the 'memory' store its data\n will only last for the length of the current request (data is lost on refresh/etc).
\n", "filename": "/lib/plugins/sammy.storage.js", "lineno": 299 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Store.LocalStorage", "args": [ "name", "element" ], "doc": "LocalStorage ('local') makes use of HTML5 DOM Storage, and the window.localStorage\n object. The great advantage of this method is that data will persist beyond\n the current request. It can be considered a pretty awesome replacement for\n cookies accessed via JS. The great disadvantage, though, is its only available\n on the latest and greatest browsers.
\n\nFor more info on DOM Storage:\n [https://developer.mozilla.org/en/DOM/Storage]\n [http://www.w3.org/TR/2009/WD-webstorage-20091222/]
\n", "filename": "/lib/plugins/sammy.storage.js", "lineno": 333 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Store.SessionStorage", "args": [ "name", "element" ], "doc": ".SessionStorage ('session') is similar to LocalStorage (part of the same API)\n and shares similar browser support/availability. The difference is that\n SessionStorage is only persistant through the current 'session' which is defined\n as the length that the current window is open. This means that data will survive\n refreshes but not close/open or multiple windows/tabs. For more info, check out\n the LocalStorage documentation and links.
.Cookie ('cookie') storage uses browser cookies to store data. JavaScript\n has access to a single document.cookie variable, which is limited to 2Kb in\n size. Cookies are also considered 'unsecure' as the data can be read easily\n by other sites/JS. Cookies do have the advantage, though, of being widely\n supported and persistent through refresh and close/open. Where available,\n HTML5 DOM Storage like LocalStorage and SessionStorage should be used.
\n\n.Cookie can also take additional options:
\n\nexpires_in Number of seconds to keep the cookie alive (default 2 weeks).path The path to activate the current cookie for (default '/').For more information about document.cookie, check out the pre-eminint article\n by ppk: [http://www.quirksmode.org/js/cookies.html]
\n", "filename": "/lib/plugins/sammy.storage.js", "lineno": 408 }, { "methods": [ ], "attributes": [ ] } ], [ { "name": "Sammy.Storage", "args": [ "app" ], "doc": "Sammy.Storage is a plugin that provides shortcuts for creating and using\n Sammy.Store objects. Once included it provides the store() app level\n and helper methods. Depends on Sammy.JSON (or json2.js).
Sammy.Session is an additional plugin for creating a common 'session' store\n for the given app. It is a very simple wrapper around Sammy.Storage\n that provides a simple fallback mechanism for trying to provide the best\n possible storage type for the session. This means, LocalStorage\n if available, otherwise Cookie, otherwise Memory.\n It provides the session() helper through Sammy.Storage#store().
See the Sammy.Storage plugin for full documentation.
Sammy.Cache provides helpers for caching data within the lifecycle of a\n Sammy app. The plugin provides two main methods on Sammy.Application,\n cache and clearCache. Each app has its own cache store so that\n you dont have to worry about collisions. As of 0.5 the original Sammy.Cache module\n has been deprecated in favor of this one based on Sammy.Storage. The exposed\n API is almost identical, but Sammy.Storage provides additional backends including\n HTML5 Storage. Sammy.Cache will try to use these backends when available\n (in this order) LocalStorage, SessionStorage, and Memory
Sammy.Template is a simple plugin that provides a way to create\n and render client side templates. The rendering code is based on John Resig's\n quick templates and Greg Borenstien's srender plugin.\n This is also a great template/boilerplate for Sammy plugins.
\n\nTemplates use <% %> tags to denote embedded javascript.
\n\nHere is an example template (user.template):
\n\n <div class=\"user\">\n <div class=\"user-name\"><%= user.name %></div>\n <% if (user.photo_url) { %>\n <div class=\"photo\"><img src=\"<%= user.photo_url %>\" /></div>\n <% } %>\n </div>\nGiven that is a publicly accesible file, you would render it like:
\n\n $.sammy(function() {\n // include the plugin\n this.use(Sammy.Template);\n\n this.get('#/', function() {\n // the template is rendered in the current context.\n this.user = {name: 'Aaron Quint'};\n // partial calls template() because of the file extension\n this.partial('user.template');\n })\n });\nYou can also pass a second argument to use() that will alias the template\n method and therefore allow you to use a different extension for template files\n in partial()
\n\n // alias to 'tpl'\n this.use(Sammy.Template, 'tpl');\n\n // now .tpl files will be run through srender\n this.get('#/', function() {\n this.partial('myfile.tpl');\n });\nSammy.Title is a very simple plugin to easily set the document's title.\n It supplies a helper for setting the title (title()) within routes,\n and an app level method for setting the global title (setTitle())