Class: Rack::Request

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/param.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.coercers ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/rack/param.rb', line 61

def self.coercers
  @coercers ||= {
    Date     => lambda { |t,v| Date.parse v },
    Time     => lambda { |t,v| Time.parse v },
    DateTime => lambda { |t,v| DateTime.parse v },
    Array    => lambda { |t,v| v.split(',') },
    Hash     => lambda { |t,v| Hash[v.split(',').map { |c| c.split ':', 2 }] },
    Boolean  => lambda { |t,v| v.falsey? ? false : (v.truthy? ? true : raise(StandardError)) }
  }
  @coercers.default_proc = lambda { |h, k| h[k] = lambda { |t,v| method(t.to_s.to_sym).call v } }
  @coercers
end

.rules ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/rack/param.rb', line 74

def self.rules
  @rules ||= {
    :blank        => Rule.rule("$ cannot be blank.")                   { |p,v| v == (p.empty? rescue false) },
    :greater_than => Rule.rule("$ can't be less than #.")              { |p,v| p > v },
    :less_than    => Rule.rule("$ can't be greater than #.")           { |p,v| p < v },
    :min          => Rule.rule("$ can't be less than #.")              { |p,v| p >= v },
    :max          => Rule.rule("$ can't be greater than #.")           { |p,v| p <= v },
    :length       => Rule.rule("$ can't be longer or shorter than #.") { |p,v| p.length == v },
    :min_length   => Rule.rule("$ must be longer than #.")             { |p,v| p.length >= v },
    :max_length   => Rule.rule("$ must be shorter than #.")            { |p,v| p.length <= v },
    :in           => Rule.rule("$ must be included in #.")             { |p,v| v.include? p },
    :contains     => Rule.rule("$ must include #")                     { |p,v| p.include? v },
    :regex        => Rule.rule("$ failed validation.")                 { |p,v| v.match(p) rescue false },
    :validator    => Rule.rule("$ failed validation.")                 { |p,v| v.call p }
  }
end

Instance Method Details

#param(name, type, opts = {}) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/rack/param.rb', line 34

def param name, type, opts={}
			name = name.to_s
  opts = Hash[opts.map { |k,v| [k.to_sym,v] }]

  if raw_params.member? name
    v = raw_params[name] || params[name]
    
    if !v.is_a?(type) && ((opts.member?(:coerce) && opts[:coerce]) || !opts.member?(:coerce))
      begin
        v = self.class.coercers[type].call type, v
      rescue StandardError
        raise ParameterError, "Parameter `#{name}` is not a valid #{type}."
      end
    end
    
    # will raise an error on an invalid param
    opts.select { |k,_| self.class.rules.member? k }
        .each { |k,arg| self.class.rules[k].validate! v, arg, opts[:error_message] }
    
    v = opts[:transform].to_proc.call v if opts.member?(:transform)
    params[name] = v
  else
    raise ParameterError, "Parameter #{name} is required." if opts.member?(:required) && opts[:required] && !opts.member?(:default)
    params[name] = opts[:default]
  end
end

#params ⇒ Object 



32
 
# File 'lib/rack/param.rb', line 32

def params; @processed_parameters ||= {}; end

#raw_params ⇒ Object 



31
 
# File 'lib/rack/param.rb', line 31

alias_method :raw_params, :params