Class | Ramaze::App
In: | lib/ramaze/app.rb
Parent: | Object

App is the superclass for applications and acts as their prototype when it comes to configuration.

An application consists of options, a location, and a list of objects. The objects are usually {Controller}s.

The options are inherited, the basics are set in Ramaze.options, from there to Ramaze::App.options, and finally into every instance of App.

This allows to collect {Controller}s of your application into a common group that can easily be used in other applications, while retaining the original options.

Every instance of {App} is mapped in {AppMap}, which is the default location to call from Rack.

Additionally, every {App} can have custom locations for root/public/view/layout directories, which allows reuse beyond directory boundaries.

In contrast to Innate, where all Nodes share the same middleware, {App} also has a subset of middleware that handles serving static files, routes and rewrites.

To indicate that a {Controller} belongs to a specific application, you can pass a second argument to {Controller::map}

@example adding Controller to application

      class WikiController < Ramaze::Controller
        map '/', :wiki
      end

The App instance will be created for you and if you don‘t use any other applications in your code there is nothing else you have to do. Others can now come and simply reuse your code in their own applications.

There is some risk of name collisions if everybody calls their app `:wiki`, but given that you only use one foreign app of this kind might give less reason for concern.

If you still try to use two apps with the same name, you have to be careful, loading one first, renaming it, then loading the second one.

The naming of an App has no influence on any other aspects of dispatching or configuration.

### Methods

[] call find_or_create location= map new public_roots sync to to_app

### Included Modules

Innate::Optioned

### Constants

APP_LIST | = | {}

### Attributes

location | [R] |
name | [R] |
options | [R] |
url_map | [R] |

### Public Class methods

[](name)
find_or_create(name, location = nil)
new(name, location = nil)

### Public Instance methods

call(env)
location=(location)
map(location, object)
public_roots()
sync()
to(object)
to_app()

[Validate]