GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  JIFTY::MANUAL::GLOSSARY (3)

.ds Aq ’

NAME

Jifty::Manual::Glossary - The Jifty dictionary

CONTENTS

GLOSSARY

We use words. This is what they mean.
action An <B>actionB> is a specifically designed RPC call that can do something to the system, with any number of declared parameters. At runtime, an action can take arguments, which it canonicalizes, validates, 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 <B>activeB>. 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 <B>Asynchronous Javascript And XMLB>. 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 regions. See Jifty::Web::PageRegion.
argument An <B>argumentB> 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 <B>/collectionB> 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 <B>mustB> 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 arguments and the like from the results 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 <B>database versionB> 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 <B>modelB> 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 <B>monikerB>. 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 <B>parameterB> is a named parameter to an action. Jifty generally renders these on the screen as form fields. 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 actions to run, together with a page or list of fragments 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 <B>schemaB> 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 <B>schema versionB> 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 /models it uses.

If any of these versions differs from their respective database versions, 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 fields. 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 actions 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 <B>upgradeB>. An <B>upgradeB> 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.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 JIFTY::MANUAL::GLOSSARY (3) 2010-12-08

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.