Class: FHIR::Model

Inherits:

Object

Object
FHIR::Model

Defined in:: lib/bootstrap/model.rb

Direct Known Subclasses

Instance Method Summary collapse

Constructor Details

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

Returns a new instance of Model.

# File 'lib/bootstrap/model.rb', line 4

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ `Object`

# File 'lib/bootstrap/model.rb', line 13

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 = self.method("#{method}#{type}").call()
      return value if !value.nil?
    end
    return nil
  elsif (!@extension.nil? && !@extension.empty?)
    ext = @extension.select do |x|
      name = x.url.gsub('-','_').split('/').last
      anchor = name.split('#').last
      (method.to_s==name || method.to_s==anchor)
    end
    if !ext.first.nil?
      if !ext.first.value.nil?
        return ext.first.value 
      else
        return ext.first
      end
    end
  elsif (!@modifierExtension.nil? && !@modifierExtension.empty?)
    ext = @modifierExtension.select do |x|
      name = x.url.gsub('-','_').split('/').last
      anchor = name.split('#').last
      (method.to_s==name || method.to_s==anchor)
    end
    if !ext.first.nil?
      if !ext.first.value.nil?
        return ext.first.value 
      else
        return ext.first
      end
    end
  end
  super(method, *args, &block)
end

Instance Method Details

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

# File 'lib/bootstrap/model.rb', line 74

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/bootstrap/model.rb', line 82

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/bootstrap/model.rb', line 55

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

#is_valid? ⇒ `Boolean`

Returns:

(Boolean)



94
95
96

# File 'lib/bootstrap/model.rb', line 94

def is_valid?
  validate.empty?
end

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

# File 'lib/bootstrap/model.rb', line 62

def mismatch(other, exclude=[])
  misses = []
  (self.class::METADATA.keys - exclude).each do |key|
    these = attribute_mismatch(self.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

#to_reference ⇒ `Object`



51
52
53

# File 'lib/bootstrap/model.rb', line 51

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

#validate(contained = nil) ⇒ `Object`



98
99
100

# File 'lib/bootstrap/model.rb', line 98

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

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

# File 'lib/bootstrap/model.rb', line 102

def validate_profile(metadata,contained=nil)
  contained_here = [ self.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 = [ self.instance_variable_get("@#{local_name}".to_sym) ].flatten.compact
        subset = [] # subset is the values associated with just this slice
        if slice['type']=='Extension'
          if slice['type_profiles']
            subset = value.select{|x|slice['type_profiles'].include?(x.url)}
          else
            subset = 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 = [ self.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 = self.class::MULTIPLE_TYPES rescue {}
  multiple_types.each do |prefix,suffixes|
    count = 0
    suffixes.each do |suffix|
      count += 1 if errors["#{prefix}#{suffix}"]
      # TODO check if multiple data types are actually present, not just errors
      # actually, this might be allowed depending on cardinality
    end
    errors[prefix] = ["#{prefix}[x]: more than one type present."] if(count > 1)
  end
  errors.keep_if{|k,v|(v && !v.empty?)}
end

Class: FHIR::Model

Direct Known Subclasses

Instance Method Summary collapse

Constructor Details

#initialize(hash = {}) ⇒ Model

Dynamic Method Handling

#method_missing(method, *args, &block) ⇒ Object

Instance Method Details

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

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

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

#is_valid? ⇒ Boolean

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

#to_reference ⇒ Object

#validate(contained = nil) ⇒ Object

#validate_profile(metadata, contained = nil) ⇒ Object

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

#method_missing(method, *args, &block) ⇒ `Object`

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

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

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

#is_valid? ⇒ `Boolean`

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

#to_reference ⇒ `Object`

#validate(contained = nil) ⇒ `Object`

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