Class: Dry::Validation::InputProcessorCompiler

Inherits:
Object
  • Object
show all
Defined in:
lib/dry/validation/input_processor_compiler.rb

Direct Known Subclasses

JSON, Params, Sanitizer, InputProcessorCompiler::Form

Defined Under Namespace

Classes: Form, JSON, Params, Sanitizer

Constant Summary collapse

DEFAULT_TYPE_NODE = 
[:definition, [String, {}]].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ InputProcessorCompiler

Returns a new instance of InputProcessorCompiler.



12
13
14
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 12

def initialize
  @type_compiler = Dry::Types::Compiler.new(Dry::Types)
end

Instance Attribute Details

#type_compiler ⇒ Object (readonly)

Returns the value of attribute type_compiler.



8
9
10
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 8

def type_compiler
  @type_compiler
end

Instance Method Details

#call(ast) ⇒ Object 



16
17
18
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 16

def call(ast)
  type_compiler.(hash_node(schema_ast(ast)))
end

#constructor(type) ⇒ Object 



41
42
43
44
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 41

def constructor(type)
  fn_id = type.__send__(:register_fn, type.fn)
  [:constructor, [[:definition, [type.primitive, {}]], fn_id, {}]]
end

#schema_ast(ast) ⇒ Object 



20
21
22
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 20

def schema_ast(ast)
  ast.map { |node| visit(node) }
end

#type(predicate, args) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 118

def type(predicate, args)
  default = self.class::PREDICATE_MAP[:default]

  type_value = if predicate == :type?
                 const = args[0]
                 self.class::CONST_MAP[const] || Types.identifier(const)
               else
                 self.class::PREDICATE_MAP[predicate] || default
               end
  Types[type_value].to_ast
end

#visit(node, *args) ⇒ Object 



24
25
26
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 24

def visit(node, *args)
  send(:"visit_#{node[0]}", node[1], *args)
end

#visit_and(node, first = true) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 55

def visit_and(node, first = true)
  if first
    name, type = node.map { |n| visit(n, false) }.uniq

    if name.is_a?(Array)
      type
    else
      [:member, [name, type]]
    end
  else
    result = node.map { |n| visit(n, first) }.uniq

    if result.size == 1
      result.first
    else
      result.select { |r| r != self.class::DEFAULT_TYPE_NODE }.last
    end
  end
end

#visit_each(node, *args) ⇒ Object 



104
105
106
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 104

def visit_each(node, *args)
  array_node(visit(node, *args))
end

#visit_implication(node, *args) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 75

def visit_implication(node, *args)
  left, right = node

  key = visit(left)

  if key.is_a?(Symbol)
    [:member, [key, visit(right, false)]]
  else
    [:sum, [key, visit(right, false), {}]]
  end
end

#visit_key(node, *args) ⇒ Object 



91
92
93
94
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 91

def visit_key(node, *args)
  _, other = node
  visit(other, *args)
end

#visit_not(node, *args) ⇒ Object 



87
88
89
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 87

def visit_not(node, *args)
  visit(node, *args)
end

#visit_or(node, *args) ⇒ Object 



50
51
52
53
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 50

def visit_or(node, *args)
  left, right = node
  [:sum, [visit(left, *args), visit(right, *args), {}]]
end

#visit_predicate(node) ⇒ Object 



108
109
110
111
112
113
114
115
116
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 108

def visit_predicate(node, *)
  id, args = node

  if id == :key?
    args[0][1]
  else
    type(id, args.map(&:last))
  end
end

#visit_rule(node, *args) ⇒ Object 



28
29
30
31
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 28

def visit_rule(node, *args)
  _, rule = node
  visit(rule, *args)
end

#visit_schema(schema, *args) ⇒ Object 



46
47
48
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 46

def visit_schema(schema, *args)
  hash_node(schema.input_processor_ast(identifier))
end

#visit_set(node) ⇒ Object 



100
101
102
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 100

def visit_set(node, *)
  hash_node(node.map { |n| visit(n) })
end

#visit_type(type, *args) ⇒ Object 



33
34
35
36
37
38
39
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 33

def visit_type(type, *args)
  if type.is_a?(Types::Constructor)
    constructor(type)
  elsif type.respond_to?(:rule)
    visit(type.rule.to_ast, *args)
  end
end

#visit_val(node, *args) ⇒ Object 



96
97
98
 
# File 'lib/dry/validation/input_processor_compiler.rb', line 96

def visit_val(node, *args)
  visit(node, *args)
end