Module: Indexer::Valid

Extended by:
Valid
Included in:
Valid
Defined in:
lib/indexer/valid.rb

Overview

Validation functions.

Constant Summary collapse

TYPE =

Valid name regular expression.

/^[A-Za-z][\/:A-Za-z0-9_-]*[A-Za-z0-9]$/
NAME =

Valid name regular expression.

/^[A-Za-z][A-Za-z0-9_-]*[A-Za-z0-9]$/
URL =

Valid URL regular expression.

/^(\w+)\:\/\/\S+$/
IRC =

Valid IRC channel.

/^\#\w+$/
EMAIL =

Regular expression for matching valid email addresses.

/\b[A-Z0-9._%-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b/i
DATE =

FIXME: Regular expression to limit date-time fields to ISO 8601 (Zulu).

/^\d\d\d\d-\d\d-\d\d(\s+\d\d:\d\d:\d\d)?$/

Instance Method Summary collapse

Instance Method Details

#array!(array, field = nil) ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/indexer/valid.rb', line 127

def array!(array, field=nil)
  unless array?(array)
    raise_invalid("array", array, field)
  end
  return array
end

#array?(array) ⇒ Boolean

TODO: Should we bother with #to_ary?

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/indexer/valid.rb', line 122

def array?(array)
  Array === array || array.respond_to?(:to_ary)
end

#constant!(name, field = nil) ⇒ Object 



253
254
255
256
257
258
 
# File 'lib/indexer/valid.rb', line 253

def constant!(name, field=nil)
  unless constant?(name)
    raise_invalid("constant name", name, field)
  end
  return name
end

#constant?(name) ⇒ Boolean

TODO: Only allow double colons.

Returns:

  • (Boolean) 


247
248
249
250
 
# File 'lib/indexer/valid.rb', line 247

def constant?(name)
  name = name.to_s if Symbol === name
  /^[A-Z][A-Za-z0-9_:]*/ =~ name
end

#copyright_year!(year, field = nil) ⇒ Object

Four digit year.



204
205
206
207
208
209
 
# File 'lib/indexer/valid.rb', line 204

def copyright_year!(year, field=nil)
  unless copyright_year?(year)
    raise_invalid("copyright year", year, field)
  end
  return year
end

#copyright_year?(year) ⇒ Boolean

Four digit year.

Returns:

  • (Boolean) 


195
196
197
198
199
200
201
 
# File 'lib/indexer/valid.rb', line 195

def copyright_year?(year)
  year = year.to_s
  return true if /^\d\d\d\d$/ =~ year
  return true if /^\d\d\d\d\-\d\d\d\d$/ =~ year
  return true if /^\d\d\d\d(\,\d\d\d\d)+$/ =~ year
  false
end

#email!(email, field = nil) ⇒ Object 



88
89
90
91
92
93
 
# File 'lib/indexer/valid.rb', line 88

def email!(email, field=nil)
  unless email?(email)
    raise_invalid("email address", email, field)
  end
  return email
end

#email?(email) ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/indexer/valid.rb', line 83

def email?(email)
  EMAIL =~ email
end

#hash!(hash, field = nil) ⇒ Object 



140
141
142
143
144
145
 
# File 'lib/indexer/valid.rb', line 140

def hash!(hash, field=nil)
  unless hash?(hash)
    raise_invalid("hash", hash, field)
  end
  return hash
end

#hash?(hash) ⇒ Boolean

Returns:

  • (Boolean) 


135
136
137
 
# File 'lib/indexer/valid.rb', line 135

def hash?(hash)
  Hash === hash
end

#irc!(irc, field = nil) ⇒ Object 



66
67
68
69
 
# File 'lib/indexer/valid.rb', line 66

def irc!(irc, field=nil)
  raise_invalid("IRC", irc, field) unless irc?(irc)
  return irc
end

#irc?(irc) ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/indexer/valid.rb', line 61

def irc?(irc)
  IRC =~ irc
end

#name!(name, field = nil) ⇒ Object 



43
44
45
46
47
 
# File 'lib/indexer/valid.rb', line 43

def name!(name, field=nil)
  string!(name, field)
  raise_invalid("name", name, field) unless name?(name)
  return name
end

#name?(name) ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
 
# File 'lib/indexer/valid.rb', line 38

def name?(name)
  NAME =~ name
end

#oneline!(string, field = nil) ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/indexer/valid.rb', line 101

def oneline!(string, field=nil)
  unless oneline?(string)
    raise_invalid("one line string", string, field)
  end
  return string
end

#oneline?(string) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/indexer/valid.rb', line 96

def oneline?(string)
  string?(string) && !string.index("\n")
end

#path!(path, field = nil) ⇒ Object 



238
239
240
241
242
243
 
# File 'lib/indexer/valid.rb', line 238

def path!(path, field=nil)
  unless path?(path)
    raise_invalid("path", path, field)
  end
  return path
end

#path?(path) ⇒ Boolean

FIXME: better validation for path

Returns:

  • (Boolean) 


232
233
234
235
 
# File 'lib/indexer/valid.rb', line 232

def path?(path)
  return false unless string?(path)
  return true
end

#raise_invalid(type, value, field = nil) ⇒ Object 



261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/indexer/valid.rb', line 261

def raise_invalid(type, value, field=nil)
  case field
  when Exception
    raise(field)
  else
    if field
      message = "invalid %s for `%s' - %s" % [type, field, value.inspect]
    else
      message = "invalid %s - %s" % [type, value.inspect]
    end
    raise(ValidationError, message.strip)
  end
end

#raise_invalid_message(message) ⇒ Object

Raises:



276
277
278
 
# File 'lib/indexer/valid.rb', line 276

def raise_invalid_message(message)
  raise(ValidationError, message.strip)
end

#string!(string, field = nil) ⇒ Object 



114
115
116
117
118
119
 
# File 'lib/indexer/valid.rb', line 114

def string!(string, field=nil)
  unless string?(string)
    raise_invalid("string", string, field)
  end
  return string
end

#string?(string) ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/indexer/valid.rb', line 109

def string?(string)
  String === string
end

#type!(type, field = nil) ⇒ Object 



31
32
33
34
35
 
# File 'lib/indexer/valid.rb', line 31

def type!(type, field=nil)
  string!(type, field)
  raise_invalid("type", type, field) unless type?(name)
  return type
end

#type?(type) ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
 
# File 'lib/indexer/valid.rb', line 26

def type?(type)
  TYPE =~ type
end

#uri!(uri, field = nil) ⇒ Object 



77
78
79
80
 
# File 'lib/indexer/valid.rb', line 77

def uri!(uri, field=nil)
  raise_invalid("URI", uri, field) unless uri?(uri)
  return uri
end

#uri?(uri) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/indexer/valid.rb', line 72

def uri?(uri)
  url?(uri) || irc?(uri)
end

#url!(url, field = nil) ⇒ Object 



55
56
57
58
 
# File 'lib/indexer/valid.rb', line 55

def url!(url, field=nil)
  raise_invalid("URL", url, field) unless url?(url)
  return url
end

#url?(url) ⇒ Boolean

Returns:

  • (Boolean) 


50
51
52
 
# File 'lib/indexer/valid.rb', line 50

def url?(url)
  URL =~ url
end

#utc_date!(date, field = nil) ⇒ Object

TODO: This is probably the wrong name for iso8601



187
188
189
190
191
192
 
# File 'lib/indexer/valid.rb', line 187

def utc_date!(date, field=nil)
  unless utc_date?(date)
    raise_invalid("ISO 8601 formatted date", date, field)
  end
  return date
end

#utc_date?(date) ⇒ Boolean

TODO: This is probably the wrong name for iso8601

Returns:

  • (Boolean) 


175
176
177
178
179
180
181
182
183
184
 
# File 'lib/indexer/valid.rb', line 175

def utc_date?(date)
  return false unless string?(date)
  return false unless DATE =~ date
  begin
    Time.parse(date)
  rescue
    return false
  end
  true
end

#version_string!(value, field = nil) ⇒ Object 



220
221
222
223
224
225
226
227
228
229
 
# File 'lib/indexer/valid.rb', line 220

def version_string!(value, field=nil)
  string!(value, field)
  case value
  when /^\D/
    raise_invalid_message("#{field} must start with number - #{value.inspect}")
  when /[^.A-Za-z0-9]/
    raise_invalid_message("#{field} contains invalid characters - #{value.inspect}")
  end
  return value
end

#version_string?(string) ⇒ Boolean

Returns:

  • (Boolean) 


212
213
214
215
216
217
 
# File 'lib/indexer/valid.rb', line 212

def version_string?(string)
  return false unless string?(string)
  return false if /^\D/ =~ string
  return false if /[^.A-Za-z0-9]/ =~ string
  return true
end

#word!(word, field = nil) ⇒ Object

-- TODO: Do we really need to be so detailed about the error? Doing so prevent us from using #word? here. ++



161
162
163
164
165
166
167
 
# File 'lib/indexer/valid.rb', line 161

def word!(word, field=nil)
  string!(word, field)
  raise_invalid_message("#{field} must start with a letter -- #{word}") if /^[A-Za-z]/ !~ word
  raise_invalid_message("#{field} must end with a letter or number -- #{word}") if /[A-Za-z0-9]$/ !~ word
  raise_invalid_message("#{field} must be a word -- #{word}") if /[^A-Za-z0-9_-]/ =~ word
  return word
end

#word?(word, field = nil) ⇒ Boolean

Returns:

  • (Boolean) 


148
149
150
151
152
153
154
 
# File 'lib/indexer/valid.rb', line 148

def word?(word, field=nil)
  return false unless string?(word)
  return false if /^[A-Za-z]/ !~ word
  return false if /[A-Za-z0-9]$/ !~ word
  return false if /[^A-Za-z0-9_-]/ =~ word
  return true
end