Class: Ramaze::App

Inherits:
Object show all
Includes:
Innate::Optioned
Defined in:
lib/ramaze/app.rb

Overview

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

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 Controllers 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

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.

Examples:

adding Controller to application


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

Constant Summary collapse

APP_LIST = 
{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, location = nil) ⇒ App

Returns a new instance of App.



73
74
75
76
77
78
79
80
81
 
# File 'lib/ramaze/app.rb', line 73

def initialize(name, location = nil)
  @name = name.to_sym
  @url_map = Innate::URLMap.new
  self.location = location if location

  APP_LIST[@name] = self

  @options = self.class.options.sub(@name)
end

Instance Attribute Details

#location ⇒ Object

Returns the value of attribute location.



71
72
73
 
# File 'lib/ramaze/app.rb', line 71

def location
  @location
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



71
72
73
 
# File 'lib/ramaze/app.rb', line 71

def name
  @name
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



71
72
73
 
# File 'lib/ramaze/app.rb', line 71

def options
  @options
end

#url_map ⇒ Object (readonly)

Returns the value of attribute url_map.



71
72
73
 
# File 'lib/ramaze/app.rb', line 71

def url_map
  @url_map
end

Class Method Details

.[](name) ⇒ Object 



121
122
123
 
# File 'lib/ramaze/app.rb', line 121

def self.[](name)
  APP_LIST[name.to_sym]
end

.find_or_create(name, location = nil) ⇒ Object 



116
117
118
119
 
# File 'lib/ramaze/app.rb', line 116

def self.find_or_create(name, location = nil)
  location = '/' if location.nil? && name == :pristine
  self[name] || new(name, location)
end

Instance Method Details

#call(env) ⇒ Object 



92
93
94
 
# File 'lib/ramaze/app.rb', line 92

def call(env)
  to_app.call(env)
end

#map(location, object) ⇒ Object 



102
103
104
 
# File 'lib/ramaze/app.rb', line 102

def map(location, object)
  url_map.map(location, object)
end

#public_roots ⇒ Object 



111
112
113
114
 
# File 'lib/ramaze/app.rb', line 111

def public_roots
  roots, publics = [*options.roots], [*options.publics]
  roots.map{|root| publics.map{|public| ::File.join(root, public) }}.flatten
end

#sync ⇒ Object 



83
84
85
 
# File 'lib/ramaze/app.rb', line 83

def sync
  AppMap.map(location, self)
end

#to(object) ⇒ Object 



106
107
108
109
 
# File 'lib/ramaze/app.rb', line 106

def to(object)
  return unless mapped = url_map.to(object)
  [location, mapped].join('/').squeeze('/')
end

#to_app ⇒ Object 



96
97
98
99
100
 
# File 'lib/ramaze/app.rb', line 96

def to_app
  files = Ramaze::Files.new(*public_roots)
  app = Current.new(Route.new(url_map), Rewrite.new(url_map))
  Rack::Cascade.new([files, app])
end