spire¶ ↑

Light controller-only rack framework with a dash of views.

Installation¶ ↑

gem install spire
spire -c project_name
cd !$ && rackup

This will install spire, create a project called 'project_name' in the same directory it's run in, and then start the site.

Usage ¶ ↑

Creating a project¶ ↑

To create a new project you simply use the spire executable like so:

spire -c my_project

and it will make a template app in ./my_project in the folder it was executed.

Routes¶ ↑

Routes are used in the config.ru, they work like the old-style Rails routes:

run Spire::Router.new(path, {
  "default" => "index#index", # the default route!
  "/index" => "index#index",
})

The “default” route is what is opened when someone goes to '/' on your address.

"/index" => "index#index",

This would match the '/index' request to the IndexController (in app/controllers) and execute the index method in that controller.

"/foo/bar" => "foo#bar"

That would when '/foo/bar' is requested return the response found in the FooController and the value in Bar that's returned.

Controllers¶ ↑

Controllers are named to tie with the routes (read above). They are stored in:

project_name/app/controllers/

With the naming scheme like so:

FooController.rb

Where Foo is the name of the controller. The name must be camel-cased. All classes must be defined like so:

class Foo < Spire::MainController

end

as a skeleton controller for the framework to use. An example response would look like this:

class Index < Spire::MainController
  def index
    "This is just a response"
  end
end

This would display a html page with that text. The Response.new initiator could be used like so:

def index
  @status = 200
  @content_type = "text/html;"
  return "Hi, I'm a test page!"
end

Where the first instance variable @status is the HTTP status to show, the second being the content type, and the last being the returned value as a string.

Controller generator¶ ↑

You can generate controllers using the spire executable. To do this you can simply run:

spire -g foo

Which will generate the FooController in the app/controllers directory with all the necessary code for you.

Views¶ ↑

RHTML¶ ↑

RHTML templates are executed using erubis due to its speed. To create a erb view, you must create a view in:

/app/views/

With the naming scheme of:

template.rhtml

The .rhtml is important so Spire knows what file it is. To pass data to a view, you simply define an instance variable before you render the template and it will automatically be accessible in your view template. To render a template, you simply use:

render :view => "index.rhtml"

HAML¶ ↑

HAML templates can be rendered like so:

render :view => "index.haml"

This would load the index.haml view in:

/app/views/index.haml

To pass data to the view, define and fill an instance variable with content or an object, and you can use it inside your HAML view.

HTML¶ ↑

HTML are static templates to be used in your project/app, they can't use variables, nor can they execute ruby code. They can be rendered using:

render :view => "index.html"

Which would load the 'index.html' file from:

project_name/app/views/index.html

The first argument is the file name, the second being the extension. You could also use:

render :file => "index.html"

if the html file is in:

/public/index.html

Files¶ ↑

To return a file from a method, you can use the render method for this task:

render :file => "test.pdf"

This will give the browser the file 'test.pdf' from the /public directory. This method will also match the content-type of this automatically using magic and will give the browser the correct content type and response automatically. This will also give a HTML 404 error page if the file does not exist.

Dependencies ¶ ↑

You will need 'git', 'wget' and 'ruby' and 'rubygems' to get started.