Jifty::Manual::Glossary - The Jifty dictionary
We use words. This is what they mean.
An action is a specifically designed RPC call that can do something to the system, with any number of declared "parameter"s. At runtime, an action can take "argument"s, which it "canonicalize"s, "validate"s, and then uses to do something useful. Each action has a "result". See Jifty::Action and Jifty::Manual::Actions.
For an "action" to run, it needs to be active. Most of the time, all actions submitted are active, but it is possible to specify only a specific action as active; any non-active actions are ignored. See Jifty::Request.
A property of a "parameter"; the action must have an argument value for this parameter in order to be constructed.
This is different from "mandatory",
in that the user can leave mandatory fields empty.
id of a Jifty::Action::Record::Update is a constructor.
A concept stolen from Lisp, Scheme, Smalltalk, and Perl 6. The continuation of any particular piece of code is the deferred operations that care about the return value at that point. In the context of Jifty, a continuation is a deferred "request" that may pull "argument"s and the like from the "result"s of the current request. Continuations can be arbitrarily nested, so they are often useful to keep track of tangents that the user went on. See Jifty::Continuation.
The database version is the "schema version" last installed or updated in the application's database. In general, the database version will always match the schema version. The exception is when Jifty is updated to a new schema version, your application updates to a new schema version, or a plugin updates to a new schema version. When this happens, you must "update" your database so that the database versions and schema versions match before running your application.
A section of HTML (at present, a Mason component) contained in a "region". Fragments are a kind of standalone Mason component which the browser can request individually. Because of this, they can only take strings and scalars as arguments, not references or objects!
A Mason component used by one or more other pages,
which is not a whole page of itself.
As opposed to fragments
elements are strictly internal,
and never visible to the outside world by themselves.
Elements typically live under a path beginning with or containing '/_elements'.
and the whole idea of an element is strictly convention,
but Jifty contains elements for things like page headers,
and showing keybindings out of the box to make your life easier.
Jifty uses Jifty::DBI to store its data (though might use other storage tools at some later time). The model defines the "schema" and provides a package for creating, reading, updating, and deleting records stored in the database. The model is generally a subclass of Jifty::Record. Access multiple items from a model is performed through a "collection".
Every instance of a Jifty::Action has a moniker. Monikers serve as identifiers for actions, to associate arguments with actions and to access specific actions "by name". Monikers need not be globally unique, but they must be unique within a single request. Monikers have no semantic meaning. See "monikers" in Jifty::Action
A moniker is an arbitrary-length nonempty string containing no semicolons. It may not begin with a digit.
A single query which lists "action"s to run, together with a page or list of "fragment"s to return. This most often comes from the browser as query parameters, but may come from other sources as a JSON or YAML POST request. The answer to a request is a "response". See Jifty::Request.
/models it uses.
Contrast with "database version".
A property of "form field"s. If a field is "sticky," values that the user entered appear there again when the page is rendered again, avoiding making the user type them again. Most "action"s have form fields which are sticky on failure, so the user can update the information and try again.
A tangent is a link or redirect that causes Jifty to save the current state into a "continuation" for a later "return". This operation is handy for situations when you want to jump to another page or form, but return to this page when the user is done with the "tangent" page. Because of the use of continuations, this can be especially handy because a user could go on multiple tangents and eventually return to the start.
Generally, your Jifty application will change over time. Most of these changes will be simple changes to behavior or appearance. When changes are made to the "schema" structure of your database, you may need to perform an upgrade. An upgrade is the process by which you rename columns, initialize data, or otherwise update information that needs to be updated when a change to the database needs to be made. See Jifty::Upgrade, Jifty::Manual::Upgrading, and Jifty::Script::Schema.