Module: Camping::Base

Module | Camping::Base
In: | lib/camping-unabridged.rb

Camping::Base is built into each controller by way of the generic routing class Camping::R. In some ways, this class is trying to do too much, but it saves code for all the glue to stay in one place. Forgivable, considering that it‘s only really a handful of methods and accessors.

Everything in this module is accessable inside your controllers.

### Methods

lookup mab r r404 r500 r501 redirect render service table_name_prefix to_a

### Constants

T | = | {}
L | = | :layout

### Attributes

body | [RW] |
cookies | [RW] |
env | [RW] |
headers | [RW] |
input | [RW] |
request | [RW] |
root | [RW] |
state | [RW] |
status | [RW] |

### Public Class methods

table_name_prefix()

The default prefix for Camping model classes is the topmost module name lowercase and followed with an underscore.

      Tepee::Models::Page.table_name_prefix
        #=> "tepee_pages"

### Public Instance methods

lookup(n)

Finds a template, returning either:

      false             # => Could not find template
      true              # => Found template in Views
      instance of Tilt  # => Found template in a file

mab(&b)

You can directly return HTML form your controller for quick debugging by calling this method and pass some Markaby to it.

      module Nuts::Controllers
        class Info
          def get; mab{ code @headers.inspect } end
        end
      end

You can also pass true to use the :layout HTML wrapping method

r(s, b, h = {})

A quick means of setting this controller‘s status, body and headers based on a Rack response:

      r(302, 'Location' => self / "/view/12", '')
      r(*another_app.call(@env))

You can also switch the body and the header if you want:

      r(404, "Could not find page")

See also: r404, r500 and r501

r404(p)

Called when a controller was not found. You can override this if you want to customize the error page:

      module Nuts
        def r404(path)
          @path = path
          render :not_found
        end
      end

r500(k,m,e)

Called when an exception is raised. However, if there is a parse error in Camping or in your application‘s source code, it will not be caught.

`k` is the controller class, `m` is the request method (GET, POST, etc.) and `e` is the Exception which can be mined for useful info.

Be default this simply re-raises the error so a Rack middleware can handle it, but you are free to override it here:

      module Nuts
        def r500(klass, method, exception)
          send_email_alert(klass, method, exception)
          render :server_error
        end
      end

r501(m)

Called if an undefined method is called on a controller, along with the request method `m` (GET, POST, etc.)

redirect(*a)

Formulate a redirect response: a 302 status with `Location` header and a blank body. Uses Helpers#URL to build the location from a controller route or path.

So, given a root of `localhost:3301/articles`:

      redirect "view/12"  # redirects to "//localhost:3301/articles/view/12"
      redirect View, 12   # redirects to "//localhost:3301/articles/view/12"

NOTE: This method doesn‘t magically exit your methods and redirect. You‘ll need to `return redirect(…)` if this isn‘t the last statement in your code, or `throw :halt` if it‘s in a helper.

See: Controllers

render(v, o={}, &b)

Display a view, calling it by its method name `v`. If a `layout` method is found in Camping::Views, it will be used to wrap the HTML.

      module Nuts::Controllers
        class Show
          def get
            @posts = Post.find :all
            render :index
          end
        end
      end

service(*a)

All requests pass through this method before going to the controller. Some magic in Camping can be performed by overriding this method.

to_a()

Turn a controller into a Rack response. This is designed to be used to pipe controllers into the `r` method. A great way to forward your requests!

      class Read < '/(\d+)'
        def get(id)
          Post.find(id)
        rescue
          r *Blog.get(:NotFound, @headers.REQUEST_URI)
        end
      end

[Validate]