openehr 1.3.0 → 2.0.0

data/lib/openehr/rm/data_structures/history.rb

@@ -18,6 +18,7 @@ module OpenEHR
         class History < OpenEHR::RM::DataStructures::DataStructure
           attr_reader :origin, :events
           attr_accessor :duration, :period, :summary
+          path_attribute :events, :summary
 
           def initialize(args = { })
             super(args)
@@ -37,6 +38,7 @@ module OpenEHR
             if !events.nil? and events.empty?
               raise ArgumentError, 'events should not be empty'
             end
+            events&.each { |event| event.parent = self if event.respond_to?(:parent=) }
             @events = events
           end
 
@@ -48,6 +50,7 @@ module OpenEHR
         class Event < OpenEHR::RM::Common::Archetyped::Locatable
           attr_reader :data, :time
           attr_accessor :state
+          path_attribute :data, :state
 
           def initialize(args = { })
             super(args)

data/lib/openehr/rm/data_structures/item_structure/representation.rb

@@ -16,8 +16,13 @@ module OpenEHR
           end
 
           class Element < Item
+            # openEHR "Null flavours" code set (terminology_id "openehr"):
+            # 271 no information, 272 masked, 273 not applicable, 253 unknown.
+            NULL_FLAVOUR_CODES = %w[271 272 273 253].freeze
+
             attr_accessor :value
             attr_reader :null_flavor
+            path_attribute :value, :null_flavour
             def initialize(args = {})
               super(args)
               self.value = args[:value]
@@ -25,18 +30,15 @@ module OpenEHR
             end
 
             def null_flavor=(null_flavor)
-              sr = nil
-              if !null_flavor.nil? and
-                  null_flavor.defining_code.terminology_id.name == 'openehr'
-                sr = Terminology.find(:first,                                  
-                                      :conditions => "code = '#{null_flavor.defining_code.code_string}'")
-              end
-              if null_flavor.nil? or (!sr.nil? and sr.group == 'null flavours')
-                @null_flavor = null_flavor
-              else
+              if !null_flavor.nil? &&
+                  !(null_flavor.defining_code.terminology_id.name == 'openehr' &&
+                    NULL_FLAVOUR_CODES.include?(null_flavor.defining_code.code_string))
                 raise ArgumentError, 'null_flavor is invalid'
               end
+              @null_flavor = null_flavor
             end
+            alias null_flavour null_flavor
+            alias null_flavour= null_flavor=
 
             def is_null?
               return @value.nil?
@@ -45,6 +47,7 @@ module OpenEHR
 
           class Cluster < Item
             attr_reader :items
+            path_attribute :items
 
             def initialize(args = {})
               super(args)
@@ -55,6 +58,7 @@ module OpenEHR
               if !items.nil? and items.empty?
                 raise ArgumentError, 'items should not empty'
               end
+              items&.each { |item| item.parent = self if item.respond_to?(:parent=) }
               @items = items
             end
           end

data/lib/openehr/rm/data_structures/item_structure.rb

@@ -17,6 +17,7 @@ module OpenEHR
 
         class ItemSingle < ItemStructure
           attr_reader :item
+          path_attribute :item
 
           def initialize(args = {})
             super(args)
@@ -35,6 +36,7 @@ module OpenEHR
 
         class ItemList < ItemStructure
           attr_accessor :items
+          path_attribute :items
 
           def initialize(args = {})
             super(args)
@@ -74,6 +76,7 @@ module OpenEHR
 
         class ItemTable < ItemStructure
           attr_accessor :rows
+          path_attribute :rows
 
           def initialize(args = {})
             super(args)
@@ -165,25 +168,29 @@ module OpenEHR
           end
 
           def element_at_named_cell(row_key, column_key)
-            i,j=0,0
+            column_index = 0
             @rows[0].items.each do |c|
               break if c.name.value == column_key
-              i+=1
+              column_index += 1
             end
+            row_index = 0
             @rows.each do |row|
               break if row.name.value == row_key
-              j+=1
-            end            
-            return element_at_cell_ij(i,j)
+              row_index += 1
+            end
+            return element_at_cell_ij(row_index + 1, column_index + 1)
           end
 
           def as_hierarchy
-            return @rows[0]
+            return Cluster.new(:name => @name,
+                               :archetype_node_id => @archetype_node_id,
+                               :items => @rows)
           end
         end
 
         class ItemTree < ItemStructure
           attr_accessor :items
+          path_attribute :items
 
           def initialize(args ={ })
             super(args)
@@ -191,18 +198,11 @@ module OpenEHR
           end
 
           def has_element_path?(path)
-            paths = [ ]
-            @items.each do |item|
-              paths << item.archetype_node_id
-            end
-            return paths.include? path
+            path_exists?(normalize_element_path(path))
           end
 
           def element_at_path(path)
-            @items.each do |item|
-              return item if item.archetype_node_id == path
-            end
-            return nil
+            item_at_path(normalize_element_path(path))
           end
 
           def as_hierarchy
@@ -210,6 +210,19 @@ module OpenEHR
                                :archetype_node_id => @archetype_node_id,
                                :items => @items)
           end
+
+          private
+
+          # Legacy callers pass a bare node id (e.g. 'at0002') rather
+          # than a real path; normalize that into /items[at0002] so it
+          # keeps working, via the real Pathable machinery.
+          def normalize_element_path(path)
+            return path if path.is_a?(OpenEHR::Path) || path.start_with?('/')
+
+            warn "[DEPRECATED] ItemTree#element_at_path/has_element_path? with a bare node id " \
+                 "(#{path.inspect}) is deprecated; use a full path like \"/items[#{path}]\" instead"
+            "/items[#{path}]"
+          end
         end
       end # of ItemStructure
     end # of DataStructures

data/lib/openehr/rm/data_types/encapsulated.rb

@@ -39,9 +39,11 @@ module OpenEHR
 
           private
 
+          CHARSET_LIST_PATH = File.expand_path('charset.lst', __dir__)
+
           def charset_valid?(charset)
             result = false
-            open('lib/openehr/rm/data_types/charset.lst') do |file|
+            File.open(CHARSET_LIST_PATH) do |file|
               while line = file.gets
                 if charset == line.chomp
                   result = true
@@ -57,7 +59,8 @@ module OpenEHR
         class DvMultimedia < DvEncapsulated
           attr_reader :media_type
           attr_accessor :uri, :data, :compression_algorithm,
-          :integrity_check, :integrity_check_algorithm, :alternate_text
+          :integrity_check, :integrity_check_algorithm, :alternate_text,
+          :thumbnail
 
           def initialize(args = {})
             super(args)
@@ -68,14 +71,31 @@ module OpenEHR
             self.integrity_check = args[:integrity_check]
             self.integrity_check_algorithm = args[:integrity_check_algorithm]
             self.alternate_text = args[:alternate_text]
+            self.thumbnail = args[:thumbnail]
           end
 
           def media_type=(media_type)
-            if media_type.code_string.nil?
+            if media_type.nil? || media_type.code_string.nil?
               raise ArgumentError, 'media_type should not be nil'
             end
             @media_type = media_type
           end
+
+          def is_external?
+            !@uri.nil?
+          end
+
+          def is_inline?
+            !@data.nil?
+          end
+
+          def is_compressed?
+            !@compression_algorithm.nil?
+          end
+
+          def has_integrity_check?
+            !@integrity_check_algorithm.nil?
+          end
         end
 
         class DvParsable < DvEncapsulated

data/lib/openehr/rm/data_types/quantity/date_time.rb

@@ -224,6 +224,7 @@ module OpenEHR
               self.minutes = iso8601_duration.minutes
               self.seconds = iso8601_duration.seconds
               self.fractional_second = iso8601_duration.fractional_second
+              self.negative = iso8601_duration.negative?
             end
 
             def magnitude
@@ -244,7 +245,14 @@ module OpenEHR
               seconds += @seconds if @seconds
               seconds += @fractional_second if @fractional_second
               seconds += minutes * SECONDS_IN_MINUTE if minutes
-              return seconds
+              negative? ? -seconds : seconds
+            end
+
+            # DV_AMOUNT.negative alias "-": a new DvDuration with the
+            # sign flipped, leaving self untouched.
+            def -@
+              text = value.start_with?('-') ? value[1..-1] : "-#{value}"
+              DvDuration.new(:value => text)
             end
           end
         end # of DateTime

data/lib/openehr/rm/data_types/quantity.rb

@@ -24,7 +24,7 @@ module OpenEHR
             if @normal_range.nil? and @normal_status.nil?
               return false
             elsif !@normal_range.nil?
-              return @normal_range.has(@value)
+              return @normal_range.has?(@value)
             elsif !@normal_status.nil?
               return @normal_status.code_string == 'N'
             end
@@ -143,6 +143,40 @@ module OpenEHR
           end
         end
 
+        # RM 1.1.0 (SPECRM-19): like DV_ORDINAL, but for scales/scores
+        # whose points are Real-valued rather than Integer-valued (e.g.
+        # the Borg CR10 breathlessness scale, which includes 0.5).
+        class DvScale < DvOrdered
+          attr_reader :value, :symbol
+
+          def initialize(args = {})
+            super(args)
+            self.symbol = args[:symbol]
+          end
+
+          def value=(value)
+            raise ArgumentError, 'value should not be nil' if value.nil?
+            raise ArgumentError, 'value should be a Real (Numeric)' unless value.is_a?(Numeric)
+            @value = value
+          end
+
+          def symbol=(symbol)
+            raise ArgumentError, 'symbol should not be nil' if symbol.nil?
+            @symbol = symbol
+          end
+
+          def <=>(other)
+            @value <=> other.value
+          end
+
+          def is_strictly_comparable_to?(others)
+            return false unless super(others)
+
+            others.symbol.defining_code.terminology_id.value ==
+              @symbol.defining_code.terminology_id.value
+          end
+        end
+
         class DvAbsoluteQuantity < DvQuantified
           attr_accessor :accuracy
 
@@ -207,14 +241,21 @@ module OpenEHR
             return result
           end
 
-          def -(other)            
-            other.magnitude = - other.magnitude
-            self+(other)
+          def -(other)
+            negated = other.dup
+            negated.magnitude = -other.magnitude
+            self + negated
+          end
+
+          def -@
+            negated = self.dup
+            negated.magnitude = -magnitude
+            negated
           end
 
           def set_accuracy(accuracy, accuracy_percent)
             if accuracy_percent
-              raise ArgumentError, 'accuracy invalid' if accuracy < 0.0 || accuracy > 100.0
+              raise ArgumentError, 'accuracy invalid' unless self.class.valid_percentage(accuracy)
             else
               raise ArgumentError, 'accuracy invaild' if accuracy < 0.0 || accuracy > 1.0
             end
@@ -224,15 +265,26 @@ module OpenEHR
           def accuracy_is_percent?
             return @accuracy_percent
           end
+
+          def self.valid_percentage(number)
+            number >= 0.0 && number <= 100.0
+          end
         end
 
         class DvQuantity < DvAmount
           attr_reader :units, :precision
+          # RM 1.1.0 (SPECRM-65): units is UCUM by default; units_system
+          # names another units system when units isn't UCUM, and
+          # units_display_name gives a displayable form when the units
+          # code itself isn't one (e.g. UCUM 'Cel' vs '°C'). Both optional.
+          attr_accessor :units_system, :units_display_name
 
           def initialize(args = {})
             super(args)
             self.units = args[:units]
             self.precision = args[:precision]
+            self.units_system = args[:units_system]
+            self.units_display_name = args[:units_display_name]
           end
 
           def units=(units)
@@ -248,14 +300,9 @@ module OpenEHR
           end
 
           def is_strictly_comparable_to?(others)
-            unless super(others)
-              return false
-            end
-            if others.units == @units
-              return true
-            else
-              return false
-            end
+            return false unless super(others)
+
+            others.units == @units && others.units_system == @units_system
           end
 
           def is_integral?
@@ -268,7 +315,12 @@ module OpenEHR
         end
 
         class DvCount < DvAmount
-
+          def magnitude=(magnitude)
+            unless magnitude.is_a?(Integer)
+              raise ArgumentError, 'magnitude should be an Integer'
+            end
+            super
+          end
         end
 
         class ReferenceRange

data/lib/openehr/rm/data_types/text.rb

@@ -59,10 +59,15 @@ module OpenEHR
 
         class CodePhrase
           attr_reader :terminology_id, :code_string
+          # RM 1.1.0: optional preferred term for code_string, typically
+          # used in integration mappings that need both a (non-preferred)
+          # actual term and a preferred term.
+          attr_accessor :preferred_term
 
           def initialize(args = {})
             self.code_string = args[:code_string]
             self.terminology_id = args[:terminology_id]
+            self.preferred_term = args[:preferred_term]
           end
 
           def terminology_id=(terminology_id)
@@ -152,6 +157,9 @@ module OpenEHR
           attr_reader :items
 
           def initialize(args ={})
+            warn '[DEPRECATED] DvParagraph (DV_PARAGRAPH) is deprecated as of RM 1.0.4; ' \
+                 'use DvText/DvCodedText with markdown or newlines instead. ' \
+                 'It remains legal for legacy data.'
             self.items = args[:items]
           end
 

data/lib/openehr/rm/data_types/time_specification.rb

@@ -17,16 +17,17 @@ module OpenEHR
             @value = value
           end
           
-          def calender_alignment
-            raise NotImlementedError, "calender_alignment must be implemented"
+          def calendar_alignment
+            raise NotImplementedError, "calendar_alignment must be implemented"
           end
+          alias calender_alignment calendar_alignment
 
           def event_alignment
-            raise NotImlementedError, "event_alignment must be implemented"
+            raise NotImplementedError, "event_alignment must be implemented"
           end
 
           def institution_specified
-            raise NotImlementedError, "institution_specified must be implemented"
+            raise NotImplementedError, "institution_specified must be implemented"
           end
         end
 

data/lib/openehr/rm/demographic.rb

@@ -2,6 +2,7 @@
 # http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_76d0249_1118674798473_6021_0Report.html
 # Ticket refs #45
 require_relative 'common/archetyped'
+require_relative 'common/change_control'
 
 module OpenEHR
   module RM
@@ -247,7 +248,7 @@ module OpenEHR
         end
 
         def source=(source)
-          if source.nil? or source.id.value != @uid.value
+          if source.nil?
             raise ArgumentError, 'source is invalid'
           end
           @source = source
@@ -255,13 +256,13 @@ module OpenEHR
 
         def target=(target)
           if target.nil?
-            raise ArgumentError, 'taraget is invalid'
+            raise ArgumentError, 'target is invalid'
           end
           @target = target
         end
       end
 
-      class VersionedParty < OpenEHR::RM::Common::Archetyped::Locatable
+      class VersionedParty < OpenEHR::RM::Common::ChangeControl::VersionedObject
 
       end
     end # of Demographic

data/lib/openehr/rm/ehr.rb

@@ -9,7 +9,8 @@ module OpenEHR
     module EHR
       class EHR
         attr_reader :system_id, :ehr_id, :time_created, :contributions,
-                    :ehr_access, :ehr_status, :compositions, :directory
+                    :ehr_access, :ehr_status, :compositions, :directory,
+                    :folders
 
         def initialize(args = { })
           self.system_id = args[:system_id]
@@ -20,6 +21,7 @@ module OpenEHR
           self.ehr_status = args[:ehr_status]
           self.compositions = args[:compositions]
           self.directory = args[:directory]
+          self.folders = args[:folders]
         end
 
         def system_id=(system_id)
@@ -89,6 +91,22 @@ module OpenEHR
           end
           @directory = directory
         end
+
+        # RM 1.1.0 (SPECRM-55): additional Folder hierarchies for this
+        # EHR. When set, directory is kept pointing at folders.item(1)
+        # (the Directory_in_folders invariant), for backward
+        # compatibility with pre-1.1.0 systems that only had directory.
+        def folders=(folders)
+          unless folders.nil?
+            folders.each do |f|
+              if f.type != 'VERSIONED_FOLDER'
+                raise ArgumentError, 'folder type should be VERSIONED_FOLDER'
+              end
+            end
+            @directory = folders.first
+          end
+          @folders = folders
+        end
       end
 
       class VersionedEHRAccess < OpenEHR::RM::Common::ChangeControl::VersionedObject
@@ -120,6 +138,7 @@ module OpenEHR
       class EHRStatus < OpenEHR::RM::Common::Archetyped::Locatable
         attr_reader :subject
         attr_accessor :is_modifiable, :is_queryable, :other_details
+        path_attribute :other_details
 
         def initialize(args = { })
           super(args)