Module: Kumi::Core::Export::NodeSerializers

Included in:
Serializer
Defined in:
lib/kumi/core/export/node_serializers.rb

Instance Method Summary collapse

Instance Method Details

#serialize_attribute_declaration(node) ⇒ Object

Attribute Declaration: preserves name and expression tree



28
29
30
31
32
33
34
 
# File 'lib/kumi/core/export/node_serializers.rb', line 28

def serialize_attribute_declaration(node)
  {
    name: node.name.to_s,
    name_type: node.name.class.name,
    expression: serialize_node(node.expression)
  }
end

#serialize_binding_reference(node) ⇒ Object

DeclarationReference Reference: critical for dependency resolution



71
72
73
74
75
76
 
# File 'lib/kumi/core/export/node_serializers.rb', line 71

def serialize_binding_reference(node)
  {
    binding_name: node.name.to_s,
    name_type: node.name.class.name
  }
end

#serialize_call_expression(node) ⇒ Object

Call Expression: critical for dependency analysis



46
47
48
49
50
51
52
 
# File 'lib/kumi/core/export/node_serializers.rb', line 46

def serialize_call_expression(node)
  {
    function_name: node.fn_name.to_s,
    function_name_type: node.fn_name.class.name,
    arguments: node.args.map { |arg| serialize_node(arg) }
  }
end

#serialize_cascade_expression(node) ⇒ Object

Cascade Expression: preserve condition/result pairs



86
87
88
89
90
 
# File 'lib/kumi/core/export/node_serializers.rb', line 86

def serialize_cascade_expression(node)
  {
    cases: node.cases.map { |case_node| serialize_node(case_node) }
  }
end

#serialize_field_declaration(node) ⇒ Object

Field Declaration: preserves type info for analyzer



18
19
20
21
22
23
24
25
 
# File 'lib/kumi/core/export/node_serializers.rb', line 18

def serialize_field_declaration(node)
  {
    name: node.name.to_s,
    name_type: node.name.class.name,
    field_type: serialize_type(node.type),
    domain: serialize_domain(node.domain)
  }
end

#serialize_field_reference(node) ⇒ Object

Field Reference: critical for dependency resolution



63
64
65
66
67
68
 
# File 'lib/kumi/core/export/node_serializers.rb', line 63

def serialize_field_reference(node)
  {
    field_name: node.name.to_s,
    name_type: node.name.class.name
  }
end

#serialize_list_expression(node) ⇒ Object

List Expression: preserve order and elements



79
80
81
82
83
 
# File 'lib/kumi/core/export/node_serializers.rb', line 79

def serialize_list_expression(node)
  {
    elements: node.elements.map { |element| serialize_node(element) }
  }
end

#serialize_literal(node) ⇒ Object

Literal: preserve exact value and Ruby type



55
56
57
58
59
60
 
# File 'lib/kumi/core/export/node_serializers.rb', line 55

def serialize_literal(node)
  {
    value: node.value,
    ruby_type: node.value.class.name
  }
end

#serialize_root(node) ⇒ Object

Root node: top-level container



8
9
10
11
12
13
14
15
 
# File 'lib/kumi/core/export/node_serializers.rb', line 8

def serialize_root(node)
  {
    type: "root",
    inputs: node.inputs.map { |input| serialize_node(input) },
    values: node.values.map { |attr| serialize_node(attr) },
    traits: node.traits.map { |trait| serialize_node(trait) }
  }
end

#serialize_trait_declaration(node) ⇒ Object

Trait Declaration: preserves name and expression tree



37
38
39
40
41
42
43
 
# File 'lib/kumi/core/export/node_serializers.rb', line 37

def serialize_trait_declaration(node)
  {
    name: node.name.to_s,
    name_type: node.name.class.name,
    expression: serialize_node(node.expression)
  }
end

#serialize_when_case_expression(node) ⇒ Object

When Case Expression: individual case in cascade



93
94
95
96
97
98
 
# File 'lib/kumi/core/export/node_serializers.rb', line 93

def serialize_when_case_expression(node)
  {
    condition: serialize_node(node.condition),
    result: serialize_node(node.result)
  }
end