Class: Rack::Parameter

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

Defined Under Namespace

Classes: Rule

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Parameter

Returns a new instance of Parameter.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/rack/param.rb', line 63

def initialize(opts={})
  opts[:value].inspect
			_opts = Hash[opts.dup.map { |k,v| [k.to_sym,v] }]
  _opts.merge! _opts.delete(:conditions)
  @error_message = _opts.delete :error_message
			@default = _opts.delete :default
			@required = _opts.delete :required
			@transform = _opts.delete :transform
			@delimiter = _opts.delete(:delimiter) || ","
			@separator = _opts.delete(:separator) || ":"
  @name = _opts.delete :name
  @type = _opts.delete :type
  @value = _opts.delete(:value) || @default
  @error = process(_opts) unless default?
end

Instance Attribute Details

#error ⇒ Object (readonly)

Returns the value of attribute error.



46
47
48
 
# File 'lib/rack/param.rb', line 46

def error
  @error
end

#value ⇒ Object (readonly)

Returns the value of attribute value.



46
47
48
 
# File 'lib/rack/param.rb', line 46

def value
  @value
end

Instance Method Details

#default? ⇒ Boolean

Returns:



83
84
85
 
# File 'lib/rack/param.rb', line 83

def default?
	@default == @value && !@value.nil?
end

#nil? ⇒ Boolean

Returns:



91
92
93
 
# File 'lib/rack/param.rb', line 91

def nil?
  @value.nil?
end

#process(opts) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/rack/param.rb', line 95

def process opts
  return "Parameter #{@name} is required." if @value.nil? && required?
  
  unless @value.class == @type || @value.nil?
    begin
      @value = case @type.to_s.downcase.to_sym
        when :date then Date.parse @value
        when :time then Time.parse @value
        when :datetime then DateTime.parse @value
        when :array then @value.split(@delimiter)
        when :hash then Hash[@value.split(@delimiter).map { |c| c.split @separator, 2 }]
        when :boolean then (@value.falsey? ? false : @value.truthy? ? true : raise(StandardError))
        else method(@type.to_s.to_sym).call @value end
    rescue StandardError => e
      return "Parameter `#{@name}` is not a valid #{@type.to_s}."
    end
  end
  
  validate_error = opts.detect { |k,v| break rules[k].validate @value, v, @error_message }
  return validate_error unless validate_error.nil?
  
  @value = @transform.to_proc.call @value if @transform
  nil
end

#required? ⇒ Boolean

Returns:



87
88
89
 
# File 'lib/rack/param.rb', line 87

def required?
	@required
end

#rules ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/rack/param.rb', line 120

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

#valid? ⇒ Boolean

Returns:



79
80
81
 
# File 'lib/rack/param.rb', line 79

def valid?
  @error.nil?
end