Module: Datacaster::Predefined

Extended by:
Predefined
Included in:
DefinitionDSL, Predefined
Defined in:
lib/datacaster/predefined.rb

Instance Method Summary collapse

Instance Method Details

#absent(error_key = nil, on: nil) ⇒ Object

'Meta' types



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/datacaster/predefined.rb', line 96

def absent(error_key = nil, on: nil)
  error_keys = ['.absent', 'datacaster.errors.absent']
  error_keys.unshift(error_key) if error_key

  cast do |x|
    if x == Datacaster.absent ||
      (!on.nil? && x.respond_to?(on) && x.public_send(on))
      Datacaster.ValidResult(Datacaster.absent)
    else
      Datacaster.ErrorResult(
        I18nValues::Key.new(error_keys, value: x)
      )
    end
  end.json_schema_attributes(required: false)
end

#any(error_key = nil) ⇒ Object 



112
113
114
115
116
 
# File 'lib/datacaster/predefined.rb', line 112

def any(error_key = nil)
  error_keys = ['.any', 'datacaster.errors.any']
  error_keys.unshift(error_key) if error_key
  check { |x| x != Datacaster.absent }.i18n_key(*error_keys)
end

#array(error_key = nil) ⇒ Object 



349
350
351
352
353
354
355
356
 
# File 'lib/datacaster/predefined.rb', line 349

def array(error_key = nil)
  error_keys = ['.array', 'datacaster.errors.array']
  error_keys.unshift(error_key) if error_key

  check { |x| x.is_a?(Array) }.
    i18n_key(*error_keys).
    json_schema(type: 'array')
end

#array_schema(element_caster, error_keys = {}, allow_empty: true) ⇒ Object Also known as: array_of 



45
46
47
 
# File 'lib/datacaster/predefined.rb', line 45

def array_schema(element_caster, error_keys = {}, allow_empty: true)
  ArraySchema.new(DefinitionDSL.expand(element_caster), error_keys, allow_empty:)
end

#attribute(*keys) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/datacaster/predefined.rb', line 118

def attribute(*keys)
  if keys.empty? || keys.any? { |k| !Datacaster::Utils.pickable?(k) }
    raise RuntimeError, "each argument should be String, Symbol, Integer or an array thereof", caller
  end

  transform do |input|
    result =
      keys.map do |key|
        Array(key).reduce(input) do |result, k|
          if result.respond_to?(k)
            result.public_send(k)
          else
            break Datacaster.absent
          end
        end
      end
    keys.length == 1 ? result.first : result
  end
end

#boolean(error_key = nil) ⇒ Object 



502
503
504
505
506
507
508
509
510
511
512
513
 
# File 'lib/datacaster/predefined.rb', line 502

def boolean(error_key = nil)
  error_keys = ['.boolean', 'datacaster.errors.boolean']
  error_keys.unshift(error_key) if error_key

  cast do |x|
    if [false, true].include?(x)
      Datacaster.ValidResult(x)
    else
      Datacaster.ErrorResult(I18nValues::Key.new(error_keys, value: x))
    end
  end.json_schema(type:'boolean')
end

#cast(&block) ⇒ Object

Base types



9
10
11
 
# File 'lib/datacaster/predefined.rb', line 9

def cast(&block)
  Caster.new(&block)
end

#cast_around(&block) ⇒ Object

'Around' types



90
91
92
 
# File 'lib/datacaster/predefined.rb', line 90

def cast_around(&block)
  AroundNodes::Caster.new(&block)
end

#check(error_key = nil, &block) ⇒ Object 



13
14
15
 
# File 'lib/datacaster/predefined.rb', line 13

def check(error_key = nil, &block)
  Checker.new(error_key, &block)
end

#choosy_hash_schema(fields, error_key = nil) ⇒ Object 



64
65
66
 
# File 'lib/datacaster/predefined.rb', line 64

def choosy_hash_schema(fields, error_key = nil)
  choosy_schema(hash_schema(fields, error_key))
end

#choosy_schema(base) ⇒ Object 



80
81
82
 
# File 'lib/datacaster/predefined.rb', line 80

def choosy_schema(base)
  ContextNodes::StructureCleaner.new(base, :remove)
end

#compare(value, error_key = nil) ⇒ Object 



17
18
19
20
21
22
23
24
25
 
# File 'lib/datacaster/predefined.rb', line 17

def compare(value, error_key = nil)
  comparator = Comparator.new(value, error_key)

  if value.nil?
    comparator.json_schema(type: 'null')
  else
    comparator.json_schema(enum: [value])
  end
end

#decimal(digits = 8, error_key = nil) ⇒ Object 



337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/datacaster/predefined.rb', line 337

def decimal(digits = 8, error_key = nil)
  error_keys = ['.decimal', 'datacaster.errors.decimal']
  error_keys.unshift(error_key) if error_key

  Trier.new([ArgumentError, TypeError]) do |x|
    # strictly validate format of string, BigDecimal() doesn't do that
    Float(x)

    BigDecimal(x, digits)
  end.i18n_key(*error_keys).json_schema(type: 'string')
end

#default(value, on: nil) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
 
# File 'lib/datacaster/predefined.rb', line 138

def default(value, on: nil)
  transform do |x|
    if x == Datacaster.absent ||
      (!on.nil? && x.respond_to?(on) && x.public_send(on))
      Datacaster::Utils.deep_freeze(value)
    else
      x
    end
  end.json_schema_attributes(required: false)
end

#float(error_key = nil) ⇒ Object 



358
359
360
361
362
363
 
# File 'lib/datacaster/predefined.rb', line 358

def float(error_key = nil)
  error_keys = ['.float', 'datacaster.errors.float']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(Float) }.i18n_key(*error_keys).
    json_schema(type: 'number', format: 'float')
end

#hash_schema(fields, error_key = nil) ⇒ Object 



50
51
52
53
54
55
56
57
58
 
# File 'lib/datacaster/predefined.rb', line 50

def hash_schema(fields, error_key = nil)
  unless fields.is_a?(Hash)
    raise "Expected field definitions in a form of Hash for hash_schema, got #{fields.inspect} instead"
  end
  HashSchema.new(
    fields.transform_values { |f| DefinitionDSL.expand(f) },
    error_key
  )
end

#hash_value(error_key = nil) ⇒ Object

'hash' would be a bad method name, because it would override built in Object#hash



377
378
379
380
381
382
383
 
# File 'lib/datacaster/predefined.rb', line 377

def hash_value(error_key = nil)
  error_keys = ['.hash_value', 'datacaster.errors.hash_value']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(Hash) }.
    i18n_key(*error_keys).
    json_schema(type: 'object', additionalProperties: true)
end

#hash_with_symbolized_keys(error_key = nil) ⇒ Object 



385
386
387
 
# File 'lib/datacaster/predefined.rb', line 385

def hash_with_symbolized_keys(error_key = nil)
  hash_value(error_key) & transform { |x| x.symbolize_keys }
end

#included_in(values, error_key: nil) ⇒ Object 



389
390
391
392
393
394
395
 
# File 'lib/datacaster/predefined.rb', line 389

def included_in(values, error_key: nil)
  error_keys = ['.included_in', 'datacaster.errors.included_in']
  error_keys.unshift(error_key) if error_key
  check { |x| values.include?(x) }.
    i18n_key(*error_keys, reference: values.map(&:to_s).join(', ')).
    json_schema(enum: values)
end

#integer(error_key = nil) ⇒ Object 



397
398
399
400
401
402
 
# File 'lib/datacaster/predefined.rb', line 397

def integer(error_key = nil)
  error_keys = ['.integer', 'datacaster.errors.integer']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(Integer) }.i18n_key(*error_keys).
    json_schema(type: 'integer')
end

#integer32(error_key = nil) ⇒ Object 



404
405
406
407
408
409
 
# File 'lib/datacaster/predefined.rb', line 404

def integer32(error_key = nil)
  error_keys = ['.integer32', 'datacaster.errors.integer32']
  error_keys.unshift(error_key) if error_key
  integer(error_key) & check { |x| x.abs <= 2_147_483_647 }.i18n_key(*error_keys).
    json_schema(format: 'int32')
end

#iso8601(error_key = nil) ⇒ Object

Form request types



474
475
476
477
478
479
480
481
482
 
# File 'lib/datacaster/predefined.rb', line 474

def iso8601(error_key = nil)
  error_keys = ['.iso8601', 'datacaster.errors.iso8601']
  error_keys.unshift(error_key) if error_key

  string(error_key) &
    try(catched_exception: [ArgumentError, TypeError]) { |x| DateTime.iso8601(x) }.
      i18n_key(*error_keys).
      json_schema(type: 'string', format: 'date-time')
end

#maximum(max, error_key = nil, inclusive: true) ⇒ Object 



411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/datacaster/predefined.rb', line 411

def maximum(max, error_key = nil, inclusive: true)
  subkey = 'lt'
  subkey += 'eq' if inclusive

  error_keys = [".maximum.#{subkey}", "datacaster.errors.maximum.#{subkey}"]

  error_keys.unshift(error_key) if error_key

  caster =
    if inclusive
      check { |x| x <= max }
    else
      check { |x| x < max }
    end

  numeric(error_key) & caster.i18n_key(*error_keys, max:)
end

#merge_message_keys(*keys) ⇒ Object 



149
150
151
 
# File 'lib/datacaster/predefined.rb', line 149

def merge_message_keys(*keys)
  MessageKeysMerger.new(keys)
end

#minimum(min, error_key = nil, inclusive: true) ⇒ Object 



429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/datacaster/predefined.rb', line 429

def minimum(min, error_key = nil, inclusive: true)
  subkey = 'gt'
  subkey += 'eq' if inclusive

  error_keys = [".minimum.#{subkey}", "datacaster.errors.minimum.#{subkey}"]

  error_keys.unshift(error_key) if error_key

  caster =
    if inclusive
      check { |x| x >= min }
    else
      check { |x| x > min }
    end

  numeric(error_key) & caster.i18n_key(*error_keys, min:)
end

#must_be(klass, error_key = nil) ⇒ Object 



153
154
155
156
157
 
# File 'lib/datacaster/predefined.rb', line 153

def must_be(klass, error_key = nil)
  error_keys = ['.must_be', 'datacaster.errors.must_be']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(klass) }.i18n_key(*error_keys, reference: klass.name)
end

#non_empty_array(error_keys = {}) ⇒ Object 



460
461
462
 
# File 'lib/datacaster/predefined.rb', line 460

def non_empty_array(error_keys = {})
  array_of(any, error_keys, allow_empty: false)
end

#non_empty_string(error_key = nil) ⇒ Object 



454
455
456
457
458
 
# File 'lib/datacaster/predefined.rb', line 454

def non_empty_string(error_key = nil)
  error_keys = ['.non_empty_string', 'datacaster.errors.non_empty_string']
  error_keys.unshift(error_key) if error_key
  string(error_key) & check { |x| !x.empty? }.i18n_key(*error_keys)
end

#numeric(error_key = nil) ⇒ Object

Strict types



329
330
331
332
333
334
335
 
# File 'lib/datacaster/predefined.rb', line 329

def numeric(error_key = nil)
  error_keys = ['.numeric', 'datacaster.errors.numeric']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(Numeric) }.
    i18n_key(*error_keys).
    json_schema(oneOf: [{ 'type' => 'string' }, { 'type' => 'number' }])
end

#optional(base, on: nil) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/datacaster/predefined.rb', line 159

def optional(base, on: nil)
  if on == nil
    return (absent | base).json_schema { base.to_json_schema }.json_schema_attributes(required: false)
  end

  unless on.is_a?(Symbol)
    raise RuntimeError, "`on` should be a Symbol"
  end

  caster =
    absent |
      (check { |x| x.respond_to?(on) && x.public_send(on) } & transform { Datacaster.absent }) |
      base

  caster
    .json_schema(base.to_json_schema)
    .json_schema_attributes(required: false)
end

#optional_param(base) ⇒ Object 



533
534
535
 
# File 'lib/datacaster/predefined.rb', line 533

def optional_param(base)
  transform_if_present { |x| x == '' ? Datacaster::Absent.instance : x } & (absent | base)
end

#partial_schema(base) ⇒ Object 



84
85
86
 
# File 'lib/datacaster/predefined.rb', line 84

def partial_schema(base)
  ContextNodes::StructureCleaner.new(base, :pass)
end

#pass ⇒ Object 



178
179
180
181
 
# File 'lib/datacaster/predefined.rb', line 178

def pass
  cast { |v| Datacaster::ValidResult(v) }
    .json_schema_attributes(required: false)
end

#pass_if(base) ⇒ Object 



183
184
185
 
# File 'lib/datacaster/predefined.rb', line 183

def pass_if(base)
  ContextNodes::PassIf.new(base)
end

#pattern(regexp, error_key = nil) ⇒ Object 



365
366
367
368
369
370
371
372
373
374
 
# File 'lib/datacaster/predefined.rb', line 365

def pattern(regexp, error_key = nil)
  error_keys = ['.pattern', 'datacaster.errors.pattern']
  error_keys.unshift(error_key) if error_key

  ecma_regexp = JsRegex.new(regexp).to_s

  string(error_key) & check { |x| x.match?(regexp) }.
    i18n_key(*error_keys, reference: ecma_regexp).
    json_schema(pattern: ecma_regexp)
end

#pick(*keys) ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/datacaster/predefined.rb', line 187

def pick(*keys)
  if keys.empty?
    raise RuntimeError, "pick(key, ...) accepts at least one argument", caller
  end

  if wrong = keys.find { |k| !Datacaster::Utils.pickable?(k) }
    raise RuntimeError, "each argument should be String, Symbol, Integer or an array thereof, instead got #{wrong.inspect}", caller
  end

  retrieve_key = -> (from, key) do
    if from.respond_to?(:key?) && !from.key?(key)
      Datacaster.absent
    elsif from.respond_to?(:length) && key.is_a?(Integer) && key > 0 && key >= from.length
      Datacaster.absent
    elsif !from.respond_to?(:[])
      Datacaster.absent
    else
      from[key]
    end
  end

  json_schema = -> (previous) do
    previous = previous.apply({
      'type' => 'object',
      'properties' => keys.map { |k, v| [k.to_s, JsonSchemaResult.new] }.to_h
    })

    if keys.length == 1
      previous.with_focus_key(keys[0].to_s)
    else
      previous.with_focus_key(false)
    end
  end

  must_be(Enumerable) & cast { |input|
    result =
      keys.map do |key|
        Array(key).reduce(input) do |result, k|
          result = retrieve_key.(result, k)
          break result if result == Datacaster.absent
          result
        end
      end
    result = keys.length == 1 ? result.first : result
    Datacaster::ValidResult(result)
  }.json_schema(&json_schema).json_schema_attributes(picked: keys)
end

#relate(left, op, right, error_key: nil) ⇒ Object 



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/datacaster/predefined.rb', line 235

def relate(left, op, right, error_key: nil)
  error_keys = ['.relate', 'datacaster.errors.relate']
  additional_vars = {}

  left_caster = left
  if Datacaster::Utils.pickable?(left)
    left_caster = pick(left)
  elsif !Datacaster.instance?(left)
    raise RuntimeError, "provide String, Symbol, Integer or array thereof instead of #{left.inspect}", caller
  end

  right_caster = right
  if Datacaster::Utils.pickable?(right)
    right_caster = pick(right)
  elsif !Datacaster.instance?(right)
    raise RuntimeError, "provide String, Symbol, Integer or array thereof instead of #{right.inspect}", caller
  end

  op_caster = op
  if op.is_a?(String) || op.is_a?(Symbol)
    op_caster = check { |(l, r)| l.respond_to?(op) && l.public_send(op, r) }
  elsif !Datacaster.instance?(left)
    raise RuntimeError, "provide String or Symbol instead of #{op.inspect}", caller
  end

  {left: left, op: op, right: right}.each do |k, v|
    if [String, Symbol, Integer].any? { |c| v.is_a?(c) }
      additional_vars[k] = v
    end
  end

  if additional_vars.length == 3
    error_keys.unshift(".#{left}.#{op}.#{right}")
  end
  error_keys.unshift(error_key) if error_key

  cast do |value|
    left_result = left_caster.(value)
    next left_result unless left_result.valid?
    i18n_var!(:left, left_result.value) unless additional_vars.key?(:left)

    right_result = right_caster.(value)
    next right_result unless right_result.valid?
    i18n_var!(:right, right_result.value) unless additional_vars.key?(:right)

    result = op_caster.([left_result.value, right_result.value])
    next Datacaster.ErrorResult([I18nValues::Key.new(error_keys)]) unless result.valid?

    Datacaster.ValidResult(value)
  end.i18n_vars(additional_vars)
end

#remove ⇒ Object 



287
288
289
 
# File 'lib/datacaster/predefined.rb', line 287

def remove
  transform { Datacaster.absent }
end

#responds_to(method, error_key = nil) ⇒ Object 



291
292
293
294
295
 
# File 'lib/datacaster/predefined.rb', line 291

def responds_to(method, error_key = nil)
  error_keys = ['.responds_to', 'datacaster.errors.responds_to']
  error_keys.unshift(error_key) if error_key
  check { |x| x.respond_to?(method) }.i18n_key(*error_keys, reference: method.to_s)
end

#run(&block) ⇒ Object 



27
28
29
 
# File 'lib/datacaster/predefined.rb', line 27

def run(&block)
  Runner.new(&block)
end

#schema(base) ⇒ Object 



76
77
78
 
# File 'lib/datacaster/predefined.rb', line 76

def schema(base)
  ContextNodes::StructureCleaner.new(base, :fail)
end

#steps(*casters) ⇒ Object 



297
298
299
 
# File 'lib/datacaster/predefined.rb', line 297

def steps(*casters)
  AndNode.new(*casters)
end

#strict_hash_schema(fields, error_key = nil) ⇒ Object 



60
61
62
 
# File 'lib/datacaster/predefined.rb', line 60

def strict_hash_schema(fields, error_key = nil)
  schema(hash_schema(fields, error_key))
end

#string(error_key = nil) ⇒ Object 



447
448
449
450
451
452
 
# File 'lib/datacaster/predefined.rb', line 447

def string(error_key = nil)
  error_keys = ['.string', 'datacaster.errors.string']
  error_keys.unshift(error_key) if error_key
  check { |x| x.is_a?(String) }.i18n_key(*error_keys).
    json_schema(type: 'string')
end

#switch(base = nil, **on_clauses) ⇒ Object 



301
302
303
304
305
306
 
# File 'lib/datacaster/predefined.rb', line 301

def switch(base = nil, **on_clauses)
  switch = SwitchNode.new(base)
  on_clauses.reduce(switch) do |result, (k, v)|
    result.on(k, v)
  end
end

#to_boolean(error_key = nil) ⇒ Object 



484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
 
# File 'lib/datacaster/predefined.rb', line 484

def to_boolean(error_key = nil)
  error_keys = ['.to_boolean', 'datacaster.errors.to_boolean']
  error_keys.unshift(error_key) if error_key

  cast do |x|
    if ['true', '1', true].include?(x)
      Datacaster.ValidResult(true)
    elsif ['false', '0', false].include?(x)
      Datacaster.ValidResult(false)
    else
      Datacaster.ErrorResult(I18nValues::Key.new(error_keys, value: x))
    end
  end.json_schema(oneOf: [
    { 'type' => 'string', 'enum' => ['true', 'false', '1', '0'] },
    { 'type' => 'boolean' },
  ])
end

#to_float(error_key = nil) ⇒ Object 



515
516
517
518
519
520
521
522
 
# File 'lib/datacaster/predefined.rb', line 515

def to_float(error_key = nil)
  error_keys = ['.to_float', 'datacaster.errors.to_float']
  error_keys.unshift(error_key) if error_key

  Trier.new([ArgumentError, TypeError]) do |x|
    Float(x)
  end.i18n_key(*error_keys).json_schema(type: 'number', format: 'float')
end

#to_integer(error_key = nil) ⇒ Object 



524
525
526
527
528
529
530
531
 
# File 'lib/datacaster/predefined.rb', line 524

def to_integer(error_key = nil)
  error_keys = ['.to_integer', 'datacaster.errors.to_integer']
  error_keys.unshift(error_key) if error_key

  Trier.new([ArgumentError, TypeError]) do |x|
    Integer(x)
  end.i18n_key(*error_keys).json_schema(oneOf: [{ 'type' => 'string' }, { 'type' => 'number' }])
end

#transform(&block) ⇒ Object 



31
32
33
 
# File 'lib/datacaster/predefined.rb', line 31

def transform(&block)
  Transformer.new(&block)
end

#transform_if_present(&block) ⇒ Object 



35
36
37
38
39
 
# File 'lib/datacaster/predefined.rb', line 35

def transform_if_present(&block)
  raise 'Expected block' unless block_given?

  Transformer.new { |v| v == Datacaster.absent ? v : block.(v) }
end

#transform_to_hash(fields) ⇒ Object 



68
69
70
 
# File 'lib/datacaster/predefined.rb', line 68

def transform_to_hash(fields)
  HashMapper.new(fields.transform_values { |x| DefinitionDSL.expand(x) })
end

#transform_to_value(value) ⇒ Object 



308
309
310
311
 
# File 'lib/datacaster/predefined.rb', line 308

def transform_to_value(value)
  value = Datacaster::Utils.deep_freeze(value)
  transform { value }
end

#try(error_key = nil, catched_exception:, &block) ⇒ Object 



41
42
43
 
# File 'lib/datacaster/predefined.rb', line 41

def try(error_key = nil, catched_exception:, &block)
  Trier.new(catched_exception, error_key, &block)
end

#uuid(error_key = nil) ⇒ Object 



464
465
466
467
468
469
470
 
# File 'lib/datacaster/predefined.rb', line 464

def uuid(error_key = nil)
  error_keys = ['.uuid', 'datacaster.errors.uuid']
  error_keys.unshift(error_key) if error_key
  pattern(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/, error_key).
    i18n_key(*error_keys).
    json_schema { { 'type' => 'string', 'format' => 'uuid' } }
end

#validate(active_model_validations) ⇒ Object 



72
73
74
 
# File 'lib/datacaster/predefined.rb', line 72

def validate(active_model_validations)
  Validator.new(active_model_validations)
end

#with(keys, caster) ⇒ Object 



313
314
315
316
317
318
319
320
321
322
323
324
325
 
# File 'lib/datacaster/predefined.rb', line 313

def with(keys, caster)
  keys = Array(keys)

  unless Datacaster::Utils.pickable?(keys)
    raise RuntimeError, "provide String, Symbol, Integer or an array thereof instead of #{keys.inspect}", caller
  end

  if keys.length == 1
    return transform_to_hash(keys[0] => pick(keys[0]) & caster)
  end

  with(keys[0], must_be(Enumerable) & with(keys[1..-1], caster))
end