Module: Net::IMAP::NumValidator

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

Overview

Common validators of number and nz_number types

Constant Summary collapse

NUMBER_RE =

:nodoc

/\A\d+\z/
NZ_NUMBER_RE = 
/\A[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.



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

def coerce_mod_sequence_value(num)
  case num
  when Integer   then ensure_mod_sequence_value num
  when NUMBER_RE then ensure_mod_sequence_value num.to_i
  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.



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

def coerce_mod_sequence_valzer(num)
  case num
  when Integer   then ensure_mod_sequence_valzer num
  when NUMBER_RE then ensure_mod_sequence_valzer num.to_i
  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.



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

def coerce_number(num)
  case num
  when Integer   then ensure_number num
  when NUMBER_RE then ensure_number num.to_i
  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.



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

def coerce_number64(num)
  case num
  when Integer   then ensure_number64 num
  when NUMBER_RE then ensure_number64 num.to_i
  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.



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

def coerce_nz_number(num)
  case num
  when Integer      then ensure_nz_number num
  when NZ_NUMBER_RE then ensure_nz_number num.to_i
  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.



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

def coerce_nz_number64(num)
  case num
  when Integer      then ensure_nz_number64 num
  when NZ_NUMBER_RE then ensure_nz_number64 num.to_i
  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:



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

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:



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

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:



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

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:



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

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:



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

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:



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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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