Class: FHIR::Model

Inherits:

Object

Object
FHIR::Model

Extended by:: Deprecate

Defined in:: lib/fhir_models/bootstrap/model.rb

Direct Known Subclasses

Instance Method Summary collapse

#==(other) ⇒ Object (also: #eql?)

allow two FHIR models to be compared for equality.
#attribute_mismatch(left, right, exclude = []) ⇒ Object
#compare_attribute(left, right, exclude = []) ⇒ Object
#equals?(other, exclude = []) ⇒ Boolean
#hash ⇒ Object

This is necessary for uniq to properly identify two FHIR models as being identical.
#initialize(hash = {}) ⇒ Model constructor

A new instance of Model.
#method_missing(method, *_args, &_block) ⇒ Object
#mismatch(other, exclude = []) ⇒ Object
#primitive?(datatype, value) ⇒ Boolean
#to_reference ⇒ Object
#valid? ⇒ Boolean
#validate(contained = nil) ⇒ Object
#validate_profile(metadata, contained = nil) ⇒ Object

Methods included from Deprecate

deprecate

Constructor Details

#initialize(hash = {}) ⇒ `Model`

Returns a new instance of Model.

# File 'lib/fhir_models/bootstrap/model.rb', line 9

def initialize(hash = {})
  from_hash(hash)
  self.class::METADATA.each do |key, value|
    local_name = key
    local_name = value['local_name'] if value['local_name']
    if value['max'] > 1 && instance_variable_get("@#{local_name}").nil?
      instance_variable_set("@#{local_name}".to_sym, [])
    end
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *_args, &_block) ⇒ `Object`

Raises:

(NoMethodError)

# File 'lib/fhir_models/bootstrap/model.rb', line 31

def method_missing(method, *_args, &_block)
  if defined?(self.class::MULTIPLE_TYPES) && self.class::MULTIPLE_TYPES[method.to_s]
    self.class::MULTIPLE_TYPES[method.to_s].each do |type|
      type[0] = type[0].upcase
      value = send("#{method}#{type}".to_sym)
      return value unless value.nil?
    end
    return nil
  elsif !@extension.nil? && !@extension.empty?
    ext = @extension.select do |x|
      name = x.url.tr('-', '_').split('/').last
      anchor = name.split('#').last
      (method.to_s == name || method.to_s == anchor)
    end
    unless ext.first.nil?
      return ext.first.value.nil? ? ext.first : ext.first.value
    end
  elsif !@modifierExtension.nil? && !@modifierExtension.empty?
    ext = @modifierExtension.select do |x|
      name = x.url.tr('-', '_').split('/').last
      anchor = name.split('#').last
      (method.to_s == name || method.to_s == anchor)
    end
    unless ext.first.nil?
      return ext.first.value.nil? ? ext.first : ext.first.value
    end
  end
  raise NoMethodError.new("undefined method `#{method}' for #{inspect}", method)
end

Instance Method Details

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

allow two FHIR models to be compared for equality



26
27
28

# File 'lib/fhir_models/bootstrap/model.rb', line 26

def ==(other)
  self.class == other.class && to_hash == other.to_hash
end

#attribute_mismatch(left, right, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 84

def attribute_mismatch(left, right, exclude = [])
  if left.respond_to?(:mismatch) && right.respond_to?(:mismatch)
    left.mismatch right, exclude
  else
    compare_attribute(left, right, exclude)
  end
end

#compare_attribute(left, right, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 92

def compare_attribute(left, right, exclude = [])
  if left.respond_to?(:equals?) && right.respond_to?(:equals?)
    left.equals? right, exclude
  elsif left.is_a?(Array) && right.is_a?(Array) && (left.length == right.length)
    result = true
    (0...(left.length)).each { |i| result &&= compare_attribute(left[i], right[i], exclude) }
    result
  else
    left == right
  end
end

#equals?(other, exclude = []) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/fhir_models/bootstrap/model.rb', line 65

def equals?(other, exclude = [])
  (self.class::METADATA.keys - exclude).each do |attribute|
    return false unless compare_attribute(instance_variable_get("@#{attribute}".to_sym), other.instance_variable_get("@#{attribute}".to_sym), exclude)
  end
  true
end

#hash ⇒ `Object`

This is necessary for uniq to properly identify two FHIR models as being identical



21
22
23

# File 'lib/fhir_models/bootstrap/model.rb', line 21

def hash
  to_hash.hash
end

#mismatch(other, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 72

def mismatch(other, exclude = [])
  misses = []
  (self.class::METADATA.keys - exclude).each do |key|
    these = attribute_mismatch(instance_variable_get("@#{key}".to_sym), other.instance_variable_get("@#{key}".to_sym), exclude)
    if !these || (these.is_a?(Array) && !these.empty?)
      misses << "#{self.class}::#{key}"
      misses.concat these if these.is_a?(Array)
    end
  end
  misses
end

#primitive?(datatype, value) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/fhir_models/bootstrap/model.rb', line 274

def primitive?(datatype, value)
  FHIR.logger.warn("prefer using FHIR.primitive? Called from #{caller.first}")
  FHIR.primitive?(datatype: datatype, value: value)
end

#to_reference ⇒ `Object`



61
62
63

# File 'lib/fhir_models/bootstrap/model.rb', line 61

def to_reference
  FHIR::Reference.new(reference: "#{self.class.name.split('::').last}/#{id}")
end

#valid? ⇒ `Boolean`

Returns:

(Boolean)



104
105
106

# File 'lib/fhir_models/bootstrap/model.rb', line 104

def valid?
  validate.empty?
end

#validate(contained = nil) ⇒ `Object`



109
110
111

# File 'lib/fhir_models/bootstrap/model.rb', line 109

def validate(contained = nil)
  validate_profile(self.class::METADATA, contained)
end

#validate_profile(metadata, contained = nil) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 113

def validate_profile(metadata, contained = nil)
  contained_here = [instance_variable_get('@contained'.to_sym)].flatten
  contained_here << contained
  contained_here = contained_here.flatten.compact
  errors = {}
  metadata.each do |field, meta|
    if meta.is_a?(Array)
      # this field has been 'sliced'
      meta.each do |slice|
        local_name = slice['local_name'] || field
        value = [instance_variable_get("@#{local_name}".to_sym)].flatten.compact
        subset = [] # subset is the values associated with just this slice
        if slice['type'] == 'Extension'
          subset = if slice['type_profiles']
                     value.select { |x| slice['type_profiles'].include?(x.url) }
                   else
                     value
                   end
        else
          FHIR.logger.warn 'Validation not supported on slices (except for Extensions)'
        end
        validate_field(field, subset, contained_here, slice, errors)
      end
    else
      local_name = meta['local_name'] || field
      value = [instance_variable_get("@#{local_name}".to_sym)].flatten.compact
      validate_field(field, value, contained_here, meta, errors)
    end
  end # metadata.each
  # check multiple types
  multiple_types = begin
                     self.class::MULTIPLE_TYPES
                   rescue
                     {}
                   end
  multiple_types.each do |prefix, suffixes|
    present = []
    suffixes.each do |suffix|
      typename = "#{prefix}#{suffix[0].upcase}#{suffix[1..-1]}"
      # check which multiple data types are actually present, not just errors
      # actually, this might be allowed depending on cardinality
      value = instance_variable_get("@#{typename}")
      present << typename if !value.nil? || (value.is_a?(Array) && !value.empty?)
    end
    errors[prefix] = ["#{prefix}[x]: more than one type present."] if present.length > 1
    # remove errors for suffixes that are not present
    next unless present.length == 1
    suffixes.each do |suffix|
      typename = "#{prefix}#{suffix[0].upcase}#{suffix[1..-1]}"
      errors.delete(typename) unless present.include?(typename)
    end
  end
  errors.keep_if { |_k, v| (v && !v.empty?) }
end

Class: FHIR::Model

Direct Known Subclasses

Instance Method Summary collapse

Methods included from Deprecate

Constructor Details

#initialize(hash = {}) ⇒ Model

Dynamic Method Handling

#method_missing(method, *_args, &_block) ⇒ Object

Instance Method Details

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

#attribute_mismatch(left, right, exclude = []) ⇒ Object

#compare_attribute(left, right, exclude = []) ⇒ Object

#equals?(other, exclude = []) ⇒ Boolean

#hash ⇒ Object

#mismatch(other, exclude = []) ⇒ Object

#primitive?(datatype, value) ⇒ Boolean

#to_reference ⇒ Object

#valid? ⇒ Boolean

#validate(contained = nil) ⇒ Object

#validate_profile(metadata, contained = nil) ⇒ Object

#initialize(hash = {}) ⇒ `Model`

#method_missing(method, *_args, &_block) ⇒ `Object`

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

#attribute_mismatch(left, right, exclude = []) ⇒ `Object`

#compare_attribute(left, right, exclude = []) ⇒ `Object`

#equals?(other, exclude = []) ⇒ `Boolean`

#hash ⇒ `Object`

#mismatch(other, exclude = []) ⇒ `Object`

#primitive?(datatype, value) ⇒ `Boolean`

#to_reference ⇒ `Object`

#valid? ⇒ `Boolean`

#validate(contained = nil) ⇒ `Object`

#validate_profile(metadata, contained = nil) ⇒ `Object`