NAME
   Jifty - an application framework

SYNOPSIS
    # Object containing lots of web related goodies...
    my $web      = Jifty->web;
    my $request  = Jifty->web->request;
    my $response = Jifty->web->response;
    my $link     = Jifty->web->link( label => _('W00t'), url => '/whatsit' );

    # Retrieve information from your application's etc/config.yml file.
    my $config   = Jifty->config;

    # Retrieve the Jifty::DBI handle
    my $handle   = Jifty->handle;

    # Load an application class, very handy in plugins
    my $class    = Jifty->app_class('Model', 'Foo');
    my $foo      = $class->new;
    $foo->create( frobnicate => 42 );

    # Configure information related to your application's actions
    my $api      = Jifty->api;

    # Make parts of your page "subscribe" to information in a fragment
    my $subs     = Jifty->subs;

    # Share information via IPC::PubSub in your application
    my $bus      = Jifty->bus;

    # Retrieve general information about Mason
    my $handler  = Jifty->handler;

DESCRIPTION
   Yet another web framework.

 What's cool about Jifty? (Buzzwords)
   DRY (Don't Repeat Yourself)
       Jifty tries not to make you say things more than once.

   Full-stack
       Out of the proverbial box, Jifty comes with one way to do everything
       you should need to do: One database mapper, one templating system,
       one web services layer, one AJAX toolkit, one set of handlers for
       standalone or FastCGI servers. We work hard to make all the bits
       play well together, so you don't have to.

   Continuations
       With Jifty, it's easy to let the user go off and do something else,
       like fill out a wizard, look something up in the help system or go
       twiddle their preferences and come right back to where they were.

   Form-based dispatch
       This is one of the things that Jifty does that we've not seen
       anywhere else. Jifty owns your form rendering and processing. This
       means you never need to write form handling logic. All you say is "I
       want an input for this argument here" and Jifty takes care of the
       rest. (Even autocomplete and validation)

   A Pony
       Jifty is the only web application framework that comes with a pony.

 Introduction
   If this is your first time using Jifty, Jifty::Manual::Tutorial is
   probably a better place to start.

METHODS
 new PARAMHASH
   This class method instantiates a new "Jifty" object. This object deals
   with configuration files, logging and database handles for the system.
   Before this method returns, it calls the application's "start" method
   (i.e. "MyApp->start") to handle any application-specific startup.

   Most of the time, the server will call this for you to set up your
   "Jifty" object. If you are writing command-line programs that want to
   use your libraries (as opposed to web services) you will need to call
   this yourself.

   See Jifty::Config for details on how to configure your Jifty
   application.

  Arguments
   no_handle
       If this is set to true, Jifty will not create a Jifty::Handle and
       connect to a database. Only use this if you're about to drop the
       database or do something extreme like that; most of Jifty expects
       the handle to exist. Defaults to false.

   logger_component
       The name that Jifty::Logger will log under. If you don't specify
       anything Jifty::Logger will log under the empty string. See
       Jifty::Logger for more information.

 config
   An accessor for the Jifty::Config object that stores the configuration
   for the Jifty application.

 logger
   An accessor for our Jifty::Logger object for the application.

   You probably aren't interested in this. See "log" for information on how
   to make log messages.

 handler
   An accessor for our Jifty::Handler object.

   This is another method that you usually don't want to mess with too
   much. Most of the interesting web bits are handled by "web".

 handle
   An accessor for the Jifty::Handle object that stores the database handle
   for the application.

 api
   An accessor for the Jifty::API object that publishes and controls
   information about the application's Jifty::Actions.

 app_class(@names)
   Return Class in application space. For example "app_class('Model',
   'Foo')" returns YourApp::Model::Foo.

   By the time you get it back, the class will have already been required

   Is you pass a hashref as the first argument, it will be treated as
   configuration parameters. The only existing parameter is "require",
   which defaults to true.

 web
   An accessor for the Jifty::Web object that the web interface uses.

 subs
   An accessor for the Jifty::Subs object that the subscription uses.

 bus
   Returns an IPC::PubSub object for the current application.

 plugins
   Returns a list of Jifty::Plugin objects for this Jifty application.

 find_plugin
   Find plugins by name.

 class_loader
   An accessor for the Jifty::ClassLoader object that stores the loaded
   classes for the application.

 setup_database_connection
   Set up our database connection. Optionally takes a paramhash with a
   single argument. This method is automatically called by "new".

   no_handle
       Defaults to false. If true, Jifty won't try to set up a database
       handle

   pre_init
       Defaults to false. If true, plugins are notified that this is a
       pre-init, any trigger registration in "init()" should not happen
       during this stage. Note that model mixins' "register_triggers" is
       unrelated to this.

   If "no_handle" is set or our application's config file is missing a
   "Database" configuration section or *has* a "SkipDatabase: 1" directive
   in its framework configuration, does nothing.

 app_instance_id
   Returns a globally unique id for this instance of this jifty
   application. This value is generated the first time it's accessed

 background SUB
   Forks a background process, and ensures that database connections and
   sockets are not shared with the parent process.

 admin_mode
   Returns true if the application is in admin mode. This should be used
   instead of "Jifty->config->framework('AdminMode')".

SEE ALSO
   <http://jifty.org>, Jifty::Manual::Tutorial, Jifty::Everything,
   Jifty::Config, Jifty::Handle, Jifty::Logger, Jifty::Handler, Jifty::Web,
   Jifty::API, Jifty::Subs, IPC::PubSub, Jifty::Plugin, Jifty::ClassLoader

AUTHORS
   Jesse Vincent, Alex Vandiver and David Glasser.

LICENSE
   Jifty is Copyright 2005-2010 Best Practical Solutions, LLC. Jifty is
   distributed under the same terms as Perl itself.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.