Class: Lutaml::Model::MappingRule

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/model/mapping/mapping_rule.rb

Direct Known Subclasses

KeyValueMappingRule, Xml::MappingRule

Constant Summary collapse

ALLOWED_OPTIONS = 
{
  render_nil: i[
    omit
    as_nil
    as_blank
    as_empty
  ],
  render_empty: i[
    omit
    as_empty
    as_blank
    as_nil
  ],
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, to:, render_nil: false, render_default: false, render_empty: false, treat_nil: :nil, treat_empty: :empty, treat_omitted: :nil, with: {}, attribute: false, delegate: nil, root_mappings: nil, polymorphic: {}, polymorphic_map: {}, transform: {}, value_map: {}) ⇒ MappingRule

Returns a new instance of MappingRule.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 44

def initialize(
  name,
  to:,
  render_nil: false,
  render_default: false,
  render_empty: false,
  treat_nil: :nil,
  treat_empty: :empty,
  treat_omitted: :nil,
  with: {},
  attribute: false,
  delegate: nil,
  root_mappings: nil,
  polymorphic: {},
  polymorphic_map: {},
  transform: {},
  value_map: {}
)
  @name = name
  @to = to
  @render_nil = render_nil
  @render_default = render_default
  @render_empty = render_empty
  @treat_nil = treat_nil
  @treat_empty = treat_empty
  @treat_omitted = treat_omitted
  @custom_methods = with
  @attribute = attribute
  @delegate = delegate
  @root_mappings = root_mappings
  @polymorphic = polymorphic
  @polymorphic_map = polymorphic_map
  @transform = transform

  @value_map = default_value_map
  @value_map[:from].merge!(value_map[:from] || {})
  @value_map[:to].merge!(value_map[:to] || {})
end

Instance Attribute Details

#attribute ⇒ Object (readonly) Also known as: attribute?

Returns the value of attribute attribute.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def attribute
  @attribute
end

#custom_methods ⇒ Object (readonly)

Returns the value of attribute custom_methods.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def custom_methods
  @custom_methods
end

#delegate ⇒ Object (readonly)

Returns the value of attribute delegate.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def delegate
  @delegate
end

#format ⇒ Object (readonly)

Returns the value of attribute format.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def format
  @format
end

#name ⇒ Object (readonly) Also known as: from

Returns the value of attribute name.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def name
  @name
end

#polymorphic ⇒ Object (readonly)

Returns the value of attribute polymorphic.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def polymorphic
  @polymorphic
end

#polymorphic_map ⇒ Object (readonly)

Returns the value of attribute polymorphic_map.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def polymorphic_map
  @polymorphic_map
end

#render_default ⇒ Object (readonly) Also known as: render_default?

Returns the value of attribute render_default.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def render_default
  @render_default
end

#render_empty ⇒ Object (readonly)

Returns the value of attribute render_empty.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def render_empty
  @render_empty
end

#render_nil ⇒ Object (readonly)

Returns the value of attribute render_nil.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def render_nil
  @render_nil
end

#to ⇒ Object (readonly)

Returns the value of attribute to.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def to
  @to
end

#transform ⇒ Object (readonly)

Returns the value of attribute transform.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def transform
  @transform
end

#treat_empty ⇒ Object (readonly)

Returns the value of attribute treat_empty.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def treat_empty
  @treat_empty
end

#treat_nil ⇒ Object (readonly)

Returns the value of attribute treat_nil.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def treat_nil
  @treat_nil
end

#treat_omitted ⇒ Object (readonly)

Returns the value of attribute treat_omitted.



4
5
6
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 4

def treat_omitted
  @treat_omitted
end

Instance Method Details

#deep_dup ⇒ Object

Raises:

  • (NotImplementedError) 


243
244
245
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 243

def deep_dup
  raise NotImplementedError, "Subclasses must implement `deep_dup`."
end

#default_value_map(options = {}) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 83

def default_value_map(options = {})
  render_nil_as = render_as(:render_nil, :omitted, options)
  render_empty_as = render_as(:render_empty, :empty, options)

  treat_nil_as = treat_as(:treat_nil, :nil, options)
  treat_empty_as = treat_as(:treat_empty, :empty, options)
  treat_omitted_as = treat_as(:treat_omitted, :nil, options)

  {
    from: { omitted: treat_omitted_as, nil: treat_nil_as, empty: treat_empty_as },
    to: { omitted: :omitted, nil: render_nil_as, empty: render_empty_as },
  }
end

#deserialize(model, value, attributes, mapper_class = nil) ⇒ Object 



212
213
214
215
216
217
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 212

def deserialize(model, value, attributes, mapper_class = nil)
  handle_custom_method(model, value, mapper_class) ||
    handle_delegate(model, value, attributes) ||
    handle_transform_method(model, value, attributes) ||
    assign_value(model, value)
end

#eql?(other) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 


235
236
237
238
239
240
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 235

def eql?(other)
  other.class == self.class &&
    instance_variables.all? do |var|
      instance_variable_get(var) == other.instance_variable_get(var)
    end
end

#has_custom_method_for_deserialization? ⇒ Boolean

Returns:

  • (Boolean) 


223
224
225
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 223

def has_custom_method_for_deserialization?
  !custom_methods.empty? && custom_methods[:from]
end

#has_custom_method_for_serialization? ⇒ Boolean

Returns:

  • (Boolean) 


219
220
221
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 219

def has_custom_method_for_serialization?
  !custom_methods.empty? && custom_methods[:to]
end

#multiple_mappings? ⇒ Boolean

Returns:

  • (Boolean) 


227
228
229
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 227

def multiple_mappings?
  name.is_a?(Array)
end

#polymorphic_mapping? ⇒ Boolean

Returns:

  • (Boolean) 


184
185
186
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 184

def polymorphic_mapping?
  polymorphic_map && !polymorphic_map.empty?
end

#raw_mapping? ⇒ Boolean

Returns:

  • (Boolean) 


231
232
233
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 231

def raw_mapping?
  name == Constants::RAW_MAPPING_KEY
end

#render?(value, instance = nil, options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


125
126
127
128
129
130
131
132
133
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 125

def render?(value, instance = nil, options = {})
  if invalid_value?(value, options)
    false
  elsif instance.respond_to?(:using_default?) && instance.using_default?(to)
    render_default?
  else
    true
  end
end

#render_as(key, default_value, options = {}) ⇒ Object 



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 97

def render_as(key, default_value, options = {})
  value = public_send(key)
  value = options[key] if value.nil?

  if value == true
    key.to_s.split("_").last.to_sym
  elsif value == false
    :omitted
  elsif value
    {
      as_empty: :empty,
      as_blank: :empty,
      as_nil: :nil,
      omit: :omitted,
    }[value]
  else
    default_value
  end
end

#render_empty?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


164
165
166
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 164

def render_empty?(options = {})
  value_map(:to, options)[:empty] != :omitted
end

#render_nil?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


160
161
162
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 160

def render_nil?(options = {})
  value_map(:to, options)[:nil] != :omitted
end

#render_omitted?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


168
169
170
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 168

def render_omitted?(options = {})
  value_map(:to, options)[:omitted] != :omitted
end

#render_value_for(value) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 141

def render_value_for(value)
  if value.nil?
    value_for_option(value_map(:to)[:nil])
  elsif Utils.empty?(value)
    value_for_option(value_map(:to)[:empty], value)
  elsif Utils.uninitialized?(value)
    value_for_option(value_map(:to)[:omitted])
  else
    value
  end
end

#serialize(model, parent = nil, doc = nil) ⇒ Object 



204
205
206
207
208
209
210
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 204

def serialize(model, parent = nil, doc = nil)
  if custom_methods[:to]
    model.send(custom_methods[:to], model, parent, doc)
  else
    to_value_for(model)
  end
end

#serialize_attribute(model, element, doc) ⇒ Object 



188
189
190
191
192
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 188

def serialize_attribute(model, element, doc)
  if custom_methods[:to]
    model.send(custom_methods[:to], model, element, doc)
  end
end

#to_value_for(model) ⇒ Object 



194
195
196
197
198
199
200
201
202
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 194

def to_value_for(model)
  if delegate
    model.public_send(delegate).public_send(to)
  else
    return if to.nil?

    model.public_send(to)
  end
end

#treat?(value) ⇒ Boolean

Returns:

  • (Boolean) 


135
136
137
138
139
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 135

def treat?(value)
  (treat_nil? || !value.nil?) &&
    (treat_empty? || !Utils.empty?(value)) &&
    (treat_omitted? || Utils.initialized?(value))
end

#treat_as(key, default_value, options = {}) ⇒ Object 



117
118
119
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 117

def treat_as(key, default_value, options = {})
  public_send(key) || options[key] || default_value
end

#treat_empty?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


176
177
178
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 176

def treat_empty?(options = {})
  value_map(:from, options)[:empty] != :omitted
end

#treat_nil?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


172
173
174
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 172

def treat_nil?(options = {})
  value_map(:from, options)[:nil] != :omitted
end

#treat_omitted?(options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


180
181
182
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 180

def treat_omitted?(options = {})
  value_map(:from, options)[:omitted] != :omitted
end

#value_for_option(option, empty_value = nil) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 153

def value_for_option(option, empty_value = nil)
  return nil if option == :nil
  return empty_value || "" if option == :empty

  Lutaml::Model::UninitializedClass.instance
end

#value_map(key, options = {}) ⇒ Object 



247
248
249
250
251
252
253
254
255
 
# File 'lib/lutaml/model/mapping/mapping_rule.rb', line 247

def value_map(key, options = {})
  options = {
    nil: options[:nil],
    empty: options[:empty],
    omitted: options[:omitted],
  }.compact

  @value_map[key].merge(options)
end