Module: Net::IMAP::NumValidator

Defined in:
lib/net/imap/data_encoding.rb

Overview

Common validators of number and nz_number types

Constant Summary collapse

NUMBER_RE =

:nodoc

/\A(?:0|[1-9]\d*)\z/

Class Method Summary collapse

Class Method Details

.coerce_mod_sequence_value(num) ⇒ Object

Like #ensure_mod_sequence_value, but usable with numeric String input.



291
292
293
294
295
296
297
298
 
# File 'lib/net/imap/data_encoding.rb', line 291

def coerce_mod_sequence_value(num)
  case num
  when Integer   then ensure_mod_sequence_value num
  when NUMBER_RE then ensure_mod_sequence_value Integer num
  else
    raise DataFormatError, "%p is not a valid mod-sequence-value" % [num]
  end
end

.coerce_mod_sequence_valzer(num) ⇒ Object

Like #ensure_mod_sequence_valzer, but usable with numeric String input.



301
302
303
304
305
306
307
308
 
# File 'lib/net/imap/data_encoding.rb', line 301

def coerce_mod_sequence_valzer(num)
  case num
  when Integer   then ensure_mod_sequence_valzer num
  when NUMBER_RE then ensure_mod_sequence_valzer Integer num
  else
    raise DataFormatError, "%p is not a valid mod-sequence-valzer" % [num]
  end
end

.coerce_number(num) ⇒ Object

Like #ensure_number, but usable with numeric String input.



251
252
253
254
255
256
257
258
 
# File 'lib/net/imap/data_encoding.rb', line 251

def coerce_number(num)
  case num
  when Integer   then ensure_number num
  when NUMBER_RE then ensure_number Integer num
  else
    raise DataFormatError, "%p is not a valid number" % [num]
  end
end

.coerce_number64(num) ⇒ Object

Like #ensure_number64, but usable with numeric String input.



271
272
273
274
275
276
277
278
 
# File 'lib/net/imap/data_encoding.rb', line 271

def coerce_number64(num)
  case num
  when Integer   then ensure_number64 num
  when NUMBER_RE then ensure_number64 Integer num
  else
    raise DataFormatError, "%p is not a valid number64" % [num]
  end
end

.coerce_nz_number(num) ⇒ Object

Like #ensure_nz_number, but usable with numeric String input.



261
262
263
264
265
266
267
268
 
# File 'lib/net/imap/data_encoding.rb', line 261

def coerce_nz_number(num)
  case num
  when Integer   then ensure_nz_number num
  when NUMBER_RE then ensure_nz_number Integer num
  else
    raise DataFormatError, "%p is not a valid nz-number" % [num]
  end
end

.coerce_nz_number64(num) ⇒ Object

Like #ensure_nz_number64, but usable with numeric String input.



281
282
283
284
285
286
287
288
 
# File 'lib/net/imap/data_encoding.rb', line 281

def coerce_nz_number64(num)
  case num
  when Integer   then ensure_nz_number64 num
  when NUMBER_RE then ensure_nz_number64 Integer num
  else
    raise DataFormatError, "%p is not a valid nz-number64" % [num]
  end
end

.ensure_mod_sequence_value(num) ⇒ Object

Ensure argument is ‘mod-sequence-value’ or raise DataFormatError

Raises:



237
238
239
240
241
 
# File 'lib/net/imap/data_encoding.rb', line 237

def ensure_mod_sequence_value(num)
  return num if valid_mod_sequence_value?(num)
  raise DataFormatError,
    "mod-sequence-value must be non-zero unsigned 64-bit integer: #{num}"
end

.ensure_mod_sequence_valzer(num) ⇒ Object

Ensure argument is ‘mod-sequence-valzer’ or raise DataFormatError

Raises:



244
245
246
247
248
 
# File 'lib/net/imap/data_encoding.rb', line 244

def ensure_mod_sequence_valzer(num)
  return num if valid_mod_sequence_valzer?(num)
  raise DataFormatError,
    "mod-sequence-valzer must be unsigned 64-bit integer: #{num}"
end

.ensure_number(num) ⇒ Object

Ensure argument is ‘number’ or raise DataFormatError

Raises:



209
210
211
212
213
 
# File 'lib/net/imap/data_encoding.rb', line 209

def ensure_number(num)
  return num if valid_number?(num)
  raise DataFormatError,
    "number must be unsigned 32-bit integer: #{num}"
end

.ensure_number64(num) ⇒ Object

Ensure argument is ‘number64’ or raise DataFormatError

Raises:



223
224
225
226
227
 
# File 'lib/net/imap/data_encoding.rb', line 223

def ensure_number64(num)
  return num if valid_number64?(num)
  raise DataFormatError,
    "number64 must be unsigned 63-bit integer: #{num}"
end

.ensure_nz_number(num) ⇒ Object

Ensure argument is ‘nz-number’ or raise DataFormatError

Raises:



216
217
218
219
220
 
# File 'lib/net/imap/data_encoding.rb', line 216

def ensure_nz_number(num)
  return num if valid_nz_number?(num)
  raise DataFormatError,
    "nz-number must be non-zero unsigned 32-bit integer: #{num}"
end

.ensure_nz_number64(num) ⇒ Object

Ensure argument is ‘nz-number64’ or raise DataFormatError

Raises:



230
231
232
233
234
 
# File 'lib/net/imap/data_encoding.rb', line 230

def ensure_nz_number64(num)
  return num if valid_nz_number64?(num)
  raise DataFormatError,
    "nz-number64 must be non-zero unsigned 63-bit integer: #{num}"
end

.valid_mod_sequence_value?(num) ⇒ Boolean

Check if argument is a valid ‘mod-sequence-value’ according to RFC 4551

mod-sequence-value  = 1*DIGIT
                       ; Positive unsigned 64-bit integer
                       ; (mod-sequence)
                       ; (1 <= n < 18,446,744,073,709,551,615)

Returns:

  • (Boolean) 


198
199
200
 
# File 'lib/net/imap/data_encoding.rb', line 198

def valid_mod_sequence_value?(num)
  1 <= num && num < 0xffff_ffff_ffff_ffff
end

.valid_mod_sequence_valzer?(num) ⇒ Boolean

Check if argument is a valid ‘mod-sequence-valzer’ according to RFC 4551

mod-sequence-valzer = "0" / mod-sequence-value

Returns:

  • (Boolean) 


204
205
206
 
# File 'lib/net/imap/data_encoding.rb', line 204

def valid_mod_sequence_valzer?(num)
  0 <= num && num < 0xffff_ffff_ffff_ffff
end

.valid_number64?(num) ⇒ Boolean

Check if argument is a valid ‘number64’ according to RFC 9051

number64        = 1*DIGIT
                   ; Unsigned 63-bit integer
                   ; (0 <= n <= 9,223,372,036,854,775,807)

Returns:

  • (Boolean) 


181
182
183
 
# File 'lib/net/imap/data_encoding.rb', line 181

def valid_number64?(num)
  0 <= num && num <= 0x7fff_ffff_ffff_ffff
end

.valid_number?(num) ⇒ Boolean

Check if argument is a valid ‘number’ according to RFC 3501

number          = 1*DIGIT
                   ; Unsigned 32-bit integer
                   ; (0 <= n < 4,294,967,296)

Returns:

  • (Boolean) 


165
166
167
 
# File 'lib/net/imap/data_encoding.rb', line 165

def valid_number?(num)
  0 <= num && num <= 0xffff_ffff
end

.valid_nz_number64?(num) ⇒ Boolean

Check if argument is a valid ‘number64’ according to RFC 9051

nz-number64     = digit-nz *DIGIT
                   ; Unsigned 63-bit integer
                   ; (0 < n <= 9,223,372,036,854,775,807)

Returns:

  • (Boolean) 


189
190
191
 
# File 'lib/net/imap/data_encoding.rb', line 189

def valid_nz_number64?(num)
  0 < num && num <= 0x7fff_ffff_ffff_ffff
end

.valid_nz_number?(num) ⇒ Boolean

Check if argument is a valid ‘nz-number’ according to RFC 3501

nz-number       = digit-nz *DIGIT
                   ; Non-zero unsigned 32-bit integer
                   ; (0 < n < 4,294,967,296)

Returns:

  • (Boolean) 


173
174
175
 
# File 'lib/net/imap/data_encoding.rb', line 173

def valid_nz_number?(num)
  0 < num && num <= 0xffff_ffff
end