This is the API documentation for Aurita’s core implementation.

In total, there are the following API documentations:

Core

Aurita’s core (this API): intra.wortundform.de/doc/aurita/

Main

Aurita’s core application logic API: intra.wortundform.de/doc/aurita-main/

GUI

Object-oriented GUI API: intra.wortundform.de/doc/aurita-gui/

Plugins

Aurita’s vendor plugins: intra.wortundform.de/doc/aurita-plugins/

Lore

Aurita’s ORM: intra.wortundform.de/doc/lore/

All

All APIs in one (big!): intra.wortundform.de/doc/all

We are a small software company in Munich, Germany. We develop web applications of any flavor since 2000. We develop custom-fitted applications for mostly medium-sized companies (200-500 employees or so). As we are small, we need tools that support fast and agile development cycles. That’s why i (fuchsto) started Aurita about three years ago (There is a whole bunch of reasons why we didn’t just go for Rails, especially back then, when Rails was 0.9). Our products are open source, and so is our framework.

A typical Aurita application consists of the following layers:

1. Web server (usually nginx)

2. Proxies (thin, mongrel, webrick, …)

3. Middleware (rack or custom handler)

4. Aurita’s dispatcher applications

5. The app’s Model / View / Controller / Modules, usually some of Aurita’s plug-ins combined with app-specific code.

Aurita itself implements layers 2 to 4. Layer 5 (the actual application) usually consists of plug-in code. For a simple plug-in example, see the aurita-mailing-plugin here:

github.com/fuchsto/aurita-mailing-plugin

Middleware tasks are implemented by a Aurita-specific Rack middleware (Aurita::Handler::Aurita_Application), so it is compatible with web servers like Thin, Mongrel, Lighttpd, Apache and many more. There are specific adapters for Thin (Aurita::Thin_Daemon) and Mongrel (Aurita::Mongrel_Daemon). Thin is recommended and used by default. Of course, Aurita + Thin can be used behind HAProxy and Unicorn, which is recommended for enterprisey production environments.

The most interesting part. Controllers implement pure business logic and client / server interaction. Controllers use models to retreive and modify data, and views to display them.

See

• Aurita::Base_Controller

• Aurita::Base_Controller_Methods

Lore ORM is used for defining and working with models and DB abstraction. Aurita extends Lore::Model by several behaviours, like Categorized_Behaviour and Taggable_Behaviour.

See Aurita::Model

There are two ways how user interfaces can be generated: Templates and GUI elements.

Templates are the a well-known standard: Write an interface skeleton with close to no intelligence, fill in values, and print it. Templates are ERB files residing in folders named “views” (in Aurita itself, in plugins, or in the project).

Aurita also offers GUI elements, which are real Ruby objects, This concept is comparable to e.g. Qt: Define a class derived from Aurita::GUI::Element or Aurita::GUI::Widget, create instances of it, and render them at the very end. This way, a GUI element class can be derived from an existing one. This is especially needed for rich internet application toolkits.

The advantage of GUI objects over templates is flexibility and reuse of interface logic - ever tried to reuse an HTML template but with slight changes? This is where they come to play.

In general, both are necessary. Use templates for interface parts that do not offer complex functionality but are quickly written in HTML. However, you should consider using a GUI object for a table that is sortable by columns, for instance.

A controller that responds with an interface may either render a template or return an Aurita::GUI::Element instance.

See documentation on Aurita::GUI

• Aurita::View_Helpers

• Aurita::GUI::Element

• Aurita::GUI::HTML

• Aurita::GUI::Widget

Aurita is a plugin-based application framework. That is to say, it offers basic application logic that is supposed to be useful in all applications based on it, but without plugins, it would just be a blank page.

Aurita::Main - which includes core models / views / controllers - is treated as a plugin, too, but it is loaded automatically in every Aurita project.

Aurita::Main also includes lots of GUI modules. Context menus, tables and much more can be used easily for every business object right away, for instance.

By using Aurita::Main and adding existing plugins, you can write your own application without having to reinvent tagging, user management, versioning, digital asset management, form generation … for every project.

If your project needs a wiki, add the Wiki plugin. If you need todo lists, add the Todo plugin, and so on. Plugins do not have to be stand-alone: The Todo plugin can hook into the Wiki plugin so todo lists can be added to an article. Of course it’s possible to just use parts of a plugin’s functions.

See documentation on Aurita::Plugins

• Aurita::Plugin::Manifest

• Aurita::Plugin_Register

Aurita has been developed by Tobias Fuchs and released under the liberal MIT licence (See LICENSE file in your distribution).