Module: Camping::Base

### Home Classes Methods

### In Files

- lib/camping-unabridged.rb

### Methods

- #lookup
- #mab
- #r
- #r404
- #r500
- #r501
- #redirect
- #render
- #serve
- #service
- #to_a

### Files

- CHANGELOG
- COPYING

### Class/Module Index

Quicksearch

- Camping
- Camping::Base
- Camping::Controllers
- Camping::Cookies
- Camping::H
- Camping::Helpers
- Camping::Models
- Camping::Models::Base
- Camping::Reloader
- Camping::Server
- Camping::Server::Options
- Camping::Server::XSendfile
- Camping::Session
- Camping::Views
- Camping::X

No matching classes.

# Camping::Base

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 accessible inside your controllers.

### Constants

L
T

### Attributes

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

### Public Instance Methods

lookup(n) click to toggle source

Finds a template, returning either:

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

    # File lib/camping-unabridged.rb, line 269
    def lookup(n)
      T.fetch(n.to_sym) do |k|
        t = Views.method_defined?(k) ||
          (t = O[:_t].keys.grep(/^#{n}\./)[0]and Template[t].new{O[:_t][t]}) ||
          (f = Dir[[O[:views] || "views", "#{n}.*"]*'/'][0]) &&
          Template.new(f, O[f[/\.(\w+)$/, 1].to_sym] || {})

        O[:dynamic_templates] ? t : T[k] = t
      end
    end

mab(&b) click to toggle source

You can directly return HTML from your controller for quick debugging by calling this method and passing 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

    # File lib/camping-unabridged.rb, line 313
    def mab(&b)
      extend Mab
      mab(&b)
    end

r(s, b, h = {}) click to toggle source

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

    # File lib/camping-unabridged.rb, line 329
    def r(s, b, h = {})
      b, h = h, b if Hash === b
      @status = s
      @headers.merge!(h)
      @body = b
    end

r404(p) click to toggle source

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

    # File lib/camping-unabridged.rb, line 363
    def r404(p)
      P % "#{p} not found"
    end

r500(k,m,e) click to toggle source

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

    # File lib/camping-unabridged.rb, line 382
    def r500(k,m,e)
      raise e
    end

r501(m) click to toggle source

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

    # File lib/camping-unabridged.rb, line 388
    def r501(m)
      P % "#{m.upcase} not implemented"
    end

redirect(*a) click to toggle source

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 `http://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

    # File lib/camping-unabridged.rb, line 350
    def redirect(*a)
      r(302,'','Location'=>URL(*a).to_s)
    end

render(v, *a, &b) click to toggle source

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

    # File lib/camping-unabridged.rb, line 292
    def render(v, *a, &b)
      if t = lookup(v)
        r, @_r = @_r, o = Hash === a[-1] ? a.pop : {}
        s = (t == true) ? mab { send(v, *a, &b) } : t.render(self, o[:locals] || {}, &b)
        s = render(L, o.merge(L => false)) { s } if o[L] or o[L].nil? && lookup(L) && (!r && v.to_s[0] != __)
        s
      else
        raise "no template: #{v}"
      end
    end

serve(p, c) click to toggle source

Serves the string `c` with the MIME type of the filename `p`. Default text/html

    # File lib/camping-unabridged.rb, line 394
    def serve(p, c)
      t = Rack::Mime.mime_type(p[/\..*$/], "text/html") and @headers['Content-Type'] = t
      c
    end

service(*a) click to toggle source

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

    # File lib/camping-unabridged.rb, line 442
    def service(*a)
      r = catch(:halt){send(@method, *a)}
      @body ||= r
      self
    end

to_a() click to toggle source

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

    # File lib/camping-unabridged.rb, line 410
    def to_a
      @env['rack.session'][SK] = Hash[@state]
      r = Rack::Response.new(@body, @status, @headers)
      @cookies._n.each do |k, v|
        r.set_cookie(k, v)
      end
      r.to_a
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.