NAME

       Jifty::Manual::Glossary - The Jifty dictionary

GLOSSARY

       We use words.  This is what they mean.

       action
           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.

       active
           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.

       AJAX
           An acronym standing for Asynchronous Javascript And XML.  Though technically
           incorrect, it is the buzzword that describes doing asynchronous requests to the server
           while the user waits.  This can lead to very "dynamic" pages, as the browser does not
           need to refresh the entire page to update a small section of the screen.  In Jifty,
           the sections of the screen are called "region"s.  See Jifty::Web::PageRegion.

       argument
           An argument is a user-supplied input to fill in a "parameter" in an "action".  See
           Jifty::Action.

       canonicalize
           To turn an "argument" into a more standard form.  For instance, a canonicalizer could
           translate a user-typed date into a date object or a SQL-formatted date string.  See
           Jifty::Action.

       collection
           A /collection is a class representing all or a subset of the records stored in the
           database regarding a particular "model". See Jifty::Collection.

       constructor
           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.  For instance, the "id" of a
           Jifty::Action::Record::Update is a constructor.  See Jifty::Action.

       continuation
           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.

       database version
           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.

       form field
           A widget which the browser renders.  These are generally useful to ask the user for a
           value for an "argument" to an "action".  See Jifty::Web::Form::Field.

       fragment
           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!

       element
           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'. This, and the whole idea of an element is strictly
           convention, but Jifty contains elements for things like page headers, menus, and
           showing keybindings out of the box to make your life easier.

       mandatory
           A property of a "parameter"; the user must enter a value for the action to validate.
           This is the simplest level of validation.

       model
           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".

       moniker
           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.

       parameter
           A parameter is a named parameter to an "action".  Jifty generally renders these on the
           screen as "form field"s.  See Jifty::Param and Jifty::Param::Schema.

       region
           An area of the page which JavaScript can replace.  The content in the region is a
           "fragment".  Think of the region as the box and the fragment as the content in the
           box.  See Jifty::PageRegion.

       request
           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.

       response
           The answer to a "request", it contains a "result" for every action that ran.  See
           Jifty::Response.

       result
           The answer to a "action", it contains information about if the action was a success or
           failure, and further detail about why or how.  It can also contain arbitrary
           "content".  See Jifty::Result.

       return
           After performing a "tangent" a user may perform a "return" to invoke the
           "continuation" created by the original tangent.

       schema
           The schema for a "model" represents the structure of the data stored in an individual
           item in that model's "collection". See Jifty::DBI::Schema.

       schema version
           The schema version is a number in version object used to determine which "database
           version" your application code is expecting to use. There are three places where the
           schema version is important:

           1.  Jifty application version. The Jifty application stores some details in the
               database.

           2.  Your database version. Your application keeps a database version recorded in the
               configuration. See Jifty::Config.

           3.  Plugin versions. Each plugin has a version associated with it affecting whatever
               "/model"s it uses.

           If any of these versions differs from their respective "database version"s, then you
           need to run the Jifty::Script::Schema to "upgrade" to the latest schema version.

           Contrast with "database version".

       sticky
           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.

       tangent
           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.

       upgrade
           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.

       validate
           To check that the provided value of an "argument" is a possible value for it to have.
           See Jifty::Web::Form::Field.