Module: Renee::Core::Routing

Includes:
Chaining
Included in:
Renee::Core
Defined in:
lib/renee_core/routing.rb

Overview

Collection of useful methods for routing within a Renee::Core app.

Instance Method Summary collapse

Instance Method Details

#complete(&blk) ⇒ Object

Match only when the path is either '' or '/'.

Examples:

complete { halt [200, {}, "hello world"] }


193
194
195
196
197
 
# File 'lib/renee_core/routing.rb', line 193

def complete(&blk)
  if env['PATH_INFO'] == '/' or env['PATH_INFO'] == ''
    with_path_part(env['PATH_INFO']) { blk.call }
  end
end

#delete(path = nil, &blk) ⇒ Object

Respond to a DELETE request and yield the block.

Examples:

delete { halt [200, {}, "hello world"] }


182
183
184
 
# File 'lib/renee_core/routing.rb', line 182

def delete(path = nil, &blk)
  request_method('DELETE', path, &blk)
end

#empty(&blk) ⇒ Object

Match only when the path is ''.

Examples:

empty { halt [200, {}, "hello world"] }


206
207
208
209
210
 
# File 'lib/renee_core/routing.rb', line 206

def empty(&blk)
  if env['PATH_INFO'] == ''
    with_path_part(env['PATH_INFO']) { blk.call }
  end
end

#extension(ext, &blk) ⇒ Object Also known as: ext

Match an extension.

Examples:

extension('html') { |path| halt [200, {}, path] }


109
110
111
112
113
114
115
116
 
# File 'lib/renee_core/routing.rb', line 109

def extension(ext, &blk)
  if detected_extension && match = detected_extension[ext]
    if match == detected_extension
      (ext_match = env['PATH_INFO'][/\/?\.#{match}/]) ?
        with_path_part(ext_match, &blk) : blk.call
    end
  end
end

#get(path = nil, &blk) ⇒ Object

Respond to a GET request and yield the block.

Examples:

get { halt [200, {}, "hello world"] }


149
150
151
 
# File 'lib/renee_core/routing.rb', line 149

def get(path = nil, &blk)
  request_method('GET', path, &blk)
end

#multi_variable(count, type = nil, &blk) ⇒ Object Also known as: multi_var, mvar

Same as variable except you can match multiple variables with the same type.

Parameters:

  • count (Range, Integer) —

    The number of parameters to capture.

  • type (Symbol) (defaults to: nil) —

    The type to use for match.



79
80
81
 
# File 'lib/renee_core/routing.rb', line 79

def multi_variable(count, type = nil, &blk)
  complex_variable(type, '/', count, &blk)
end

#no_extension(&blk) ⇒ Object

Match no extension.

Examples:

no_extension { |path| halt [200, {}, path] }


126
127
128
 
# File 'lib/renee_core/routing.rb', line 126

def no_extension(&blk)
  blk.call if detected_extension.nil?
end

#part(p, &blk) ⇒ Object

Like #path, but doesn't look for leading slashes.



38
39
40
41
42
43
 
# File 'lib/renee_core/routing.rb', line 38

def part(p, &blk)
  p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
  if match = env['PATH_INFO'][p]
    with_path_part(match) { blk.call }
  end
end

#partial_variable(type = nil, &blk) ⇒ Object Also known as: part_var

Match parts off the path as variables without a leading slash.

See Also:



97
98
99
 
# File 'lib/renee_core/routing.rb', line 97

def partial_variable(type = nil, &blk)
  complex_variable(type, nil, 1, &blk)
end

#path(p, &blk) ⇒ Object

Match a path to respond to.

Examples:

path('/')    { ... } #=> '/'
path('test') { ... } #=> '/test'

path 'foo' do
  path('bar') { ... } #=> '/foo/bar'
end

Parameters:

  • p (String) —

    path to match.

  • blk (Proc) —

    block to yield



23
24
25
26
27
 
# File 'lib/renee_core/routing.rb', line 23

def path(p, &blk)
  p = p[1, p.size] if p[0] == ?/
  extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
  part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
end

#post(path = nil, &blk) ⇒ Object

Respond to a POST request and yield the block.

Examples:

post { halt [200, {}, "hello world"] }


160
161
162
 
# File 'lib/renee_core/routing.rb', line 160

def post(path = nil, &blk)
  request_method('POST', path, &blk)
end

#put(path = nil, &blk) ⇒ Object

Respond to a PUT request and yield the block.

Examples:

put { halt [200, {}, "hello world"] }


171
172
173
 
# File 'lib/renee_core/routing.rb', line 171

def put(path = nil, &blk)
  request_method('PUT', path, &blk)
end

#query(q, &blk) ⇒ Object

Match variables within the query string.

Examples:

query(:key => :integer) { |h| halt [200, {}, "hello world #{h[:key]}"] }
query(:key) { |val| halt [200, {}, "key is #{val}"] }

Parameters:

  • q (Array, Hash) —

    Either an array or hash of things to match query string variables. If given an array, if you pass the values for each key as parameters to the block given. If given a hash, then every value must be able to be matched by a registered type.



227
228
229
230
231
232
233
 
# File 'lib/renee_core/routing.rb', line 227

def query(q, &blk)
  case q
  when Hash  then blk.call(Hash[q.map{|(k, v)| [k, transform(v, request[k.to_s]) || return]}])
  when Array then blk.call(*q.map{|qk| request[qk.to_s] or return })
  else            query([q], &blk)
  end
end

#query_string(qs, &blk) ⇒ Object

Yield block if the query string matches.

Examples:

path 'test' do
  query_string 'foo=bar' do
    halt [200, {}, 'matched']
  end
end
GET /test?foo=bar #=> 'matched'

Parameters:

  • qs (String) —

    The query string to match.



250
251
252
 
# File 'lib/renee_core/routing.rb', line 250

def query_string(qs, &blk)
  blk.call if qs === env['QUERY_STRING']
end

#remainder(&blk) ⇒ Object Also known as: catchall

Match any remaining path.

Examples:

remainder { |path| halt [200, {}, path] }


137
138
139
 
# File 'lib/renee_core/routing.rb', line 137

def remainder(&blk)
  with_path_part(env['PATH_INFO']) { |var| blk.call(var) }
end

#repeating_variable(type = nil, &blk) ⇒ Object Also known as: glob

Same as variable except it matches indefinitely.

Parameters:

  • type (Symbol) (defaults to: nil) —

    The type to use for match.



88
89
90
 
# File 'lib/renee_core/routing.rb', line 88

def repeating_variable(type = nil, &blk)
  complex_variable(type, '/', nil, &blk)
end

#variable(type = nil, &blk) ⇒ Object Also known as: var

Match parts off the path as variables. The parts matcher can conform to either a regular expression, or be an Integer, or simply a String. @param[Object] type the type of object to match for. If you supply Integer, this will only match integers in addition to casting your variable for you. @param[Object] default the default value to use if your param cannot be successfully matched.

Examples:

path '/' do
  variable { |id| halt [200, {}, id] }
end
GET /hey  #=> [200, {}, 'hey']
path '/' do
  variable(:integer) { |id| halt [200, {}, "This is a numeric id: #{id}"] }
end
GET /123  #=> [200, {}, 'This is a numeric id: 123']
path '/test' do
  variable { |foo, bar| halt [200, {}, "#{foo}-#{bar}"] }
end
GET /test/hey/there  #=> [200, {}, 'hey-there']


70
71
72
 
# File 'lib/renee_core/routing.rb', line 70

def variable(type = nil, &blk)
  complex_variable(type, '/', 1, &blk)
end

#whole_path(p, &blk) ⇒ Object

Like #path, but requires the entire path to be consumed.

See Also:



32
33
34
 
# File 'lib/renee_core/routing.rb', line 32

def whole_path(p, &blk)
  path(p) { complete(&blk) }
end