Module: Inferno::DSL::FHIRResourceNavigation

Included in:
Inferno::DSL::FHIREvaluation::Rules::AllMustSupportsPresent, MustSupportAssessment::InternalMustSupportLogic
Defined in:
lib/inferno/dsl/fhir_resource_navigation.rb

Overview

The FHIRResourceNavigation module is used to pick values from a FHIR resource, based on a profile. Originally intended for use for verifying the presence of Must Support elements on a resource and finding values to use for search parameters. The methods in this module related to slices expects pre-processed metadata defining the elements of the profile to be present in the attribute metadata in the including class.

See Also:

Constant Summary collapse

DAR_EXTENSION_URL = 
'http://hl7.org/fhir/StructureDefinition/data-absent-reason'.freeze
PRIMITIVE_DATA_TYPES = 
FHIR::PRIMITIVES.keys

Instance Method Summary collapse

Instance Method Details

#append_path_character(state, char, depth_change:) ⇒ Object 



195
196
197
198
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 195

def append_path_character(state, char, depth_change:)
  state[:current_segment] << char
  state[:parentheses_depth] += depth_change unless state[:in_quotes]
end

#choice_path?(property) ⇒ Boolean

Returns:

  • (Boolean) 


104
105
106
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 104

def choice_path?(property)
  property.end_with?('[x]')
end

#current_and_child_values_match?(el_found, value_definitions_for_path) ⇒ Boolean

Returns:

  • (Boolean) 


336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 336

def current_and_child_values_match?(el_found, value_definitions_for_path)
  child_element_value_definitions, current_element_value_definitions =
    value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }

  current_element_values_match =
    current_element_value_definitions
      .all? { |value_definition| value_definition[:value] == el_found }

  child_element_values_match =
    if child_element_value_definitions.present?
      verify_slice_by_values(el_found, child_element_value_definitions)
    else
      true
    end
  current_element_values_match && child_element_values_match
end

#extension_filter_value(element, extension_url) ⇒ Object 



94
95
96
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 94

def extension_filter_value(element, extension_url)
  element.url == extension_url ? element : nil
end

#field_value(element, field_name) ⇒ Object 



135
136
137
138
139
140
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 135

def field_value(element, field_name)
  local_name = local_field_name(field_name)
  value = element.send(local_name)
  primitive_value = get_primitive_type_value(element, field_name, value)
  primitive_value.present? ? primitive_value : value
end

#find_a_value_at(given_element, path, include_dar: false, &block) ⇒ Object

Get a value from the given FHIR element(s), by navigating through the resource to the given path. Fields with a DataAbsentReason extension present will be excluded unless include_dar is true. To filter the resulting elements, a block may be passed in.

Parameters:

Returns:

  • a single matching value (which can include false) or nil if not found



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 46

def find_a_value_at(given_element, path, include_dar: false, &block)
  return nil if given_element.nil?

  elements = Array.wrap(given_element)
  return find_in_elements(elements, include_dar:, &block) if path.empty?

  path_segments = path_segments(path)

  segment = path_segments.shift

  remaining_path = path_segments.join('.')
  elements.each do |element|
    child = get_next_value(element, segment)
    element_found = find_a_value_at(child, remaining_path, include_dar:, &block)
    return element_found if value_not_empty?(element_found)
  end

  nil
end

#find_in_elements(elements, include_dar: false) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 67

def find_in_elements(elements, include_dar: false, &)
  unless include_dar
    elements = elements.reject do |el|
      el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
    end
  end

  return elements.find(&) if block_given?

  elements.first
end

#find_slice_via_discriminator(element, property) ⇒ Object 



211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 211

def find_slice_via_discriminator(element, property)
  return unless metadata.present?

  element_name = local_field_name(property.to_s.split(':')[0])
  slice_name = local_field_name(property.to_s.split(':')[1])

  slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
  return nil if slice_by_name.blank?

  discriminator = slice_by_name[:discriminator]
  slices = Array.wrap(element.send(element_name))
  slices.find { |slice| matching_slice?(slice, discriminator) }
end

#flatten_bundles(resources) ⇒ Object 



365
366
367
368
369
370
371
372
373
374
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 365

def flatten_bundles(resources)
  resources.flat_map do |resource|
    if resource&.resourceType == 'Bundle'
      # Recursive to consider that Bundles may contain Bundles
      flatten_bundles(resource.entry.map(&:resource))
    else
      resource
    end
  end
end

#get_next_value(element, property) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 80

def get_next_value(element, property)
  property = property.to_s
  extension_url = property[/(?<=where\(url=').*(?='\))/]
  return extension_filter_value(element, extension_url) if extension_url.present?
  return sliced_choice_value(element, property) if sliced_choice_path?(property)
  return populated_choice_value(element, property) if choice_path?(property)
  return find_slice_via_discriminator(element, property) if slice_path?(property)

  field_value(element, property)
rescue NoMethodError
  nil
end

#get_primitive_type_value(element, property, value) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 143

def get_primitive_type_value(element, property, value)
  return nil unless element.respond_to?(:source_hash)

  source_hash = element.source_hash
  return nil unless source_hash.present?

  source_value = source_hash["_#{property}"]

  return nil unless source_value.present?

  primitive_value = PrimitiveType.new(source_value)
  primitive_value.value = value
  primitive_value
end

#local_field_name(field_name) ⇒ Object 



159
160
161
162
163
164
165
166
167
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 159

def local_field_name(field_name)
  # fhir_models prepends fields whose names are reserved in ruby with "local_"
  # This should be used before `x.send(field_name)`
  if ['method', 'class'].include?(field_name.to_s)
    "local_#{field_name}"
  else
    field_name
  end
end

#matching_pattern_codeable_concept_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


244
245
246
247
248
249
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 244

def matching_pattern_codeable_concept_slice?(slice, discriminator)
  slice_value = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s)&.coding : slice.coding
  slice_value&.any? do |coding|
    coding.code == discriminator[:code] && coding.system == discriminator[:system]
  end
end

#matching_pattern_coding_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


252
253
254
255
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 252

def matching_pattern_coding_slice?(slice, discriminator)
  slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
  slice_value&.code == discriminator[:code] && slice_value&.system == discriminator[:system]
end

#matching_pattern_identifier_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


258
259
260
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 258

def matching_pattern_identifier_slice?(slice, discriminator)
  slice.system == discriminator[:system]
end

#matching_required_binding_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


293
294
295
296
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 293

def matching_required_binding_slice?(slice, discriminator)
  slice_coding = required_binding_codings(slice, discriminator)
  slice_coding.any? { |coding| required_binding_value_match?(coding, discriminator[:values]) }
end

#matching_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 226

def matching_slice?(slice, discriminator)
  case discriminator[:type]
  when 'patternCodeableConcept'
    matching_pattern_codeable_concept_slice?(slice, discriminator)
  when 'patternCoding'
    matching_pattern_coding_slice?(slice, discriminator)
  when 'patternIdentifier'
    matching_pattern_identifier_slice?(slice, discriminator)
  when 'value'
    matching_value_slice?(slice, discriminator)
  when 'type'
    matching_type_slice?(slice, discriminator)
  when 'requiredBinding'
    matching_required_binding_slice?(slice, discriminator)
  end
end

#matching_type_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 269

def matching_type_slice?(slice, discriminator)
  slice_value = resolve_path(slice, discriminator[:path]).first

  case discriminator[:code]
  when 'Date'
    begin
      Date.parse(slice_value)
    rescue ArgumentError
      false
    end
  when 'DateTime'
    begin
      DateTime.parse(slice_value)
    rescue ArgumentError
      false
    end
  when 'String'
    slice_value.is_a? String
  else
    slice_value.is_a? FHIR.const_get(discriminator[:code])
  end
end

#matching_value_slice?(slice, discriminator) ⇒ Boolean

Returns:

  • (Boolean) 


263
264
265
266
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 263

def matching_value_slice?(slice, discriminator)
  values = discriminator[:values].map { |value| value.merge(path: path_segments(value[:path])) }
  verify_slice_by_values(slice, values)
end

#path_segments(path) ⇒ Object 



170
171
172
173
174
175
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 170

def path_segments(path)
  state = { current_segment: +'', segments: [], parentheses_depth: 0, in_quotes: false }
  path.each_char { |char| update_path_segment_state(state, char) }
  state[:segments] << state[:current_segment] unless state[:current_segment].empty?
  state[:segments]
end

#populated_choice_value(element, property) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 120

def populated_choice_value(element, property)
  choice_prefix = property.delete_suffix('[x]')
  populated_field =
    Array.wrap(element.to_hash&.keys)
      .map(&:to_s)
      .find do |field_name|
        field_name.start_with?(choice_prefix) && value_not_empty?(field_value(element, field_name))
      end

  return nil if populated_field.blank?

  field_value(element, populated_field)
end

#required_binding_codings(slice, discriminator) ⇒ Object 



299
300
301
302
303
304
305
306
307
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 299

def required_binding_codings(slice, discriminator)
  if discriminator[:path].present?
    Array.wrap(resolve_path(slice, discriminator[:path])).flat_map { |value| Array.wrap(value&.coding) }
  elsif slice.is_a?(FHIR::Coding)
    [slice]
  else
    Array.wrap(slice.coding)
  end
end

#required_binding_value_match?(coding, values) ⇒ Boolean

Returns:

  • (Boolean) 


310
311
312
313
314
315
316
317
318
319
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 310

def required_binding_value_match?(coding, values)
  values.any? do |value|
    case value
    when String
      value == coding.code
    when Hash
      value[:system] == coding.system && value[:code] == coding.code
    end
  end
end

#resolve_path(elements, path) ⇒ Array<FHIR::Model>

Get a value from the given FHIR element(s) by walking the given path through the element.

Parameters:

Returns:



23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 23

def resolve_path(elements, path)
  elements = Array.wrap(elements)
  return elements if path.blank?

  paths = path_segments(path)
  segment = paths.first
  remaining_path = paths.drop(1).join('.')

  elements.flat_map do |element|
    child = get_next_value(element, segment)
    resolve_path(child, remaining_path)
  end.compact
end

#slice_path?(property) ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 109

def slice_path?(property)
  property.include?(':') && !property.include?('url')
end

#sliced_choice_path?(property) ⇒ Boolean

Returns:

  • (Boolean) 


99
100
101
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 99

def sliced_choice_path?(property)
  property.include?('[x]:')
end

#sliced_choice_value(element, property) ⇒ Object 



114
115
116
117
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 114

def sliced_choice_value(element, property)
  _choice_path, sliced_field = property.split(':', 2)
  field_value(element, sliced_field)
end

#split_path_segment_or_append(state, char) ⇒ Object 



201
202
203
204
205
206
207
208
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 201

def split_path_segment_or_append(state, char)
  if state[:parentheses_depth].zero? && !state[:in_quotes]
    state[:segments] << state[:current_segment].dup
    state[:current_segment].clear
  else
    state[:current_segment] << char
  end
end

#update_path_segment_state(state, char) ⇒ Object 



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 178

def update_path_segment_state(state, char)
  case char
  when "'"
    state[:current_segment] << char
    state[:in_quotes] = !state[:in_quotes]
  when '('
    append_path_character(state, char, depth_change: 1)
  when ')'
    append_path_character(state, char, depth_change: -1)
  when '.'
    split_path_segment_or_append(state, char)
  else
    state[:current_segment] << char
  end
end

#value_at_path_matches?(element, path, include_dar: false) ⇒ Boolean

Returns:

  • (Boolean) 


354
355
356
357
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 354

def value_at_path_matches?(element, path, include_dar: false, &)
  value_found = find_a_value_at(element, path, include_dar:, &)
  value_not_empty?(value_found)
end

#value_not_empty?(value) ⇒ Boolean

Returns:

  • (Boolean) 


360
361
362
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 360

def value_not_empty?(value)
  value.present? || value == false
end

#verify_slice_by_values(element, value_definitions) ⇒ Object 



322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/inferno/dsl/fhir_resource_navigation.rb', line 322

def verify_slice_by_values(element, value_definitions)
  path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
  path_prefixes.all? do |path_prefix|
    value_definitions_for_path =
      value_definitions
        .select { |value_definition| value_definition[:path].first == path_prefix }
        .each { |value_definition| value_definition[:path].shift }
    value_at_path_matches?(element, path_prefix) do |el_found|
      current_and_child_values_match?(el_found, value_definitions_for_path)
    end
  end
end