openehr 1.3.0 → 2.0.0

data/lib/openehr/parser.rb

@@ -16,7 +16,9 @@ module OpenEHR
 
     end
 
+    require_relative 'parser/exception'
     require_relative 'parser/adl_parser'
     require_relative 'parser/opt_parser'
+    require_relative 'parser/archetype_validator'
   end
 end

data/lib/openehr/path.rb

@@ -0,0 +1,195 @@
+# OpenEHR::Path parses the openEHR archetype path syntax used to
+# navigate LOCATABLE/PATHABLE trees, e.g.
+#   /content[at0001]/data[at0002]/events[at0006]/data[at0003]/items[at0004, 'Systolic']/value
+#
+# Grammar subset supported (see the plan for the full rationale):
+#   path      := '/' | ('/' segment)+
+#   segment   := attribute predicate?
+#   attribute := [a-z][a-zA-Z0-9_]*
+#   predicate := '[' node_id (',' ws* name)? ']'
+#   node_id   := at-code (at\d+(\.\d+)*, incl. specialised at0001.1 and
+#                the short at0.2 form ADL 1.4 uses for nodes newly
+#                introduced by a specialisation)
+#              | archetype-id
+#   name      := "'" ... "'" (a Locatable#name.value literal)
+#
+# Deliberately unsupported (raises InvalidPathError): relative paths,
+# '//' wildcards, numeric index predicates, and general expression
+# predicates. Those are layered on top by consumers (e.g. AQL); this
+# class only parses the path shape used by RM path navigation.
+#
+# This file has no dependency on any RM class, so it can be required
+# standalone.
+module OpenEHR
+  class Path
+    class InvalidPathError < ArgumentError; end
+
+    AT_CODE = /\Aat\d+(\.\d+)*\z/
+    ARCHETYPE_ID = /\A[a-zA-Z]\w+-[a-zA-Z]\w+-[a-zA-Z]\w+\.[a-zA-Z]\w+(-[a-zA-Z]\w+)?\.v\d+\z/
+    ATTRIBUTE = /\A[a-z][a-zA-Z0-9_]*\z/
+
+    class Segment
+      attr_reader :attribute, :archetype_node_id, :name
+
+      def initialize(attribute, archetype_node_id: nil, name: nil)
+        unless attribute.is_a?(String) && attribute =~ ATTRIBUTE
+          raise InvalidPathError, "invalid path attribute: #{attribute.inspect}"
+        end
+        if archetype_node_id && !(archetype_node_id =~ AT_CODE || archetype_node_id =~ ARCHETYPE_ID)
+          raise InvalidPathError, "invalid node id: #{archetype_node_id.inspect}"
+        end
+        raise InvalidPathError, 'name predicate requires a node_id predicate' if name && archetype_node_id.nil?
+
+        @attribute = attribute
+        @archetype_node_id = archetype_node_id
+        @name = name
+        freeze
+      end
+
+      def predicate?
+        !@archetype_node_id.nil?
+      end
+
+      def to_s
+        return @attribute unless predicate?
+
+        s = "#{@attribute}[#{@archetype_node_id}"
+        s += ", '#{@name}'" if @name
+        s + ']'
+      end
+
+      def ==(other)
+        other.is_a?(Segment) &&
+          attribute == other.attribute &&
+          archetype_node_id == other.archetype_node_id &&
+          name == other.name
+      end
+      alias eql? ==
+
+      def hash
+        [attribute, archetype_node_id, name].hash
+      end
+    end
+
+    def self.parse(str)
+      raise InvalidPathError, 'path must be a String' unless str.is_a?(String)
+      raise InvalidPathError, "path must start with '/': #{str.inspect}" unless str.start_with?('/')
+      return new([]) if str == '/'
+
+      body = str[1..-1]
+      raise InvalidPathError, "path must not end with '/': #{str.inspect}" if body.end_with?('/')
+
+      new(split_segments(body).map { |token| parse_segment(token) })
+    end
+
+    def self.valid?(str)
+      parse(str)
+      true
+    rescue InvalidPathError
+      false
+    end
+
+    # Splits on top-level '/' only (not '/' occurring inside a '[...]'
+    # predicate), and rejects empty segments (i.e. a '//' wildcard).
+    def self.split_segments(body)
+      tokens = []
+      depth = 0
+      current = +''
+      body.each_char do |c|
+        case c
+        when '['
+          depth += 1
+          current << c
+        when ']'
+          depth -= 1
+          current << c
+        when '/'
+          if depth.zero?
+            raise InvalidPathError, "empty path segment ('//' is not supported): #{body.inspect}" if current.empty?
+
+            tokens << current
+            current = +''
+          else
+            current << c
+          end
+        else
+          current << c
+        end
+      end
+      raise InvalidPathError, "unbalanced '[' in path: #{body.inspect}" unless depth.zero?
+      raise InvalidPathError, "empty path segment ('//' is not supported): #{body.inspect}" if current.empty?
+
+      tokens << current
+      tokens
+    end
+    private_class_method :split_segments
+
+    def self.parse_segment(token)
+      if token =~ /\A([^\[\]]+)\[(.*)\]\z/
+        attribute = Regexp.last_match(1)
+        predicate = Regexp.last_match(2)
+        if predicate =~ /\A([^,]+),\s*'([^']*)'\z/
+          Segment.new(attribute, archetype_node_id: Regexp.last_match(1).strip, name: Regexp.last_match(2))
+        else
+          Segment.new(attribute, archetype_node_id: predicate.strip)
+        end
+      elsif token =~ /\A[^\[\]]+\z/
+        Segment.new(token)
+      else
+        raise InvalidPathError, "malformed path segment: #{token.inspect}"
+      end
+    end
+    private_class_method :parse_segment
+
+    attr_reader :segments
+
+    def initialize(segments)
+      @segments = segments.freeze
+      freeze
+    end
+
+    def root?
+      @segments.empty?
+    end
+
+    def to_s
+      return '/' if root?
+
+      '/' + @segments.map(&:to_s).join('/')
+    end
+
+    def ==(other)
+      other.is_a?(Path) && segments == other.segments
+    end
+    alias eql? ==
+
+    def hash
+      segments.hash
+    end
+
+    def parent
+      return self if root?
+
+      self.class.new(segments[0..-2])
+    end
+
+    def +(other)
+      case other
+      when Segment
+        self.class.new(segments + [other])
+      when Path
+        self.class.new(segments + other.segments)
+      when String
+        self.class.new(segments + [Segment.new(other)])
+      else
+        raise ArgumentError, "cannot append #{other.class} to a Path"
+      end
+    end
+
+    def descend
+      return [nil, self] if root?
+
+      [segments.first, self.class.new(segments[1..-1])]
+    end
+  end
+end

data/lib/openehr/rm/common/archetyped.rb

@@ -13,31 +13,138 @@ module OpenEHR
           MULTIPART_ID_DELIMITER = "::"
         end
 
+        # Raised by Pathable#item_at_path when a path predicate matches
+        # more than one child (e.g. a node_id shared by siblings with
+        # different names).
+        class PathNotUniqueError < StandardError; end
+
         class Pathable
           attr_accessor :parent
 
+          # Declares which of this class's attributes are exposed to
+          # path navigation, e.g. `path_attribute :data, :state`.
+          # Declarations accumulate down the inheritance chain.
+          def self.path_attribute(*attr_names)
+            @path_attributes ||= []
+            @path_attributes.concat(attr_names.map(&:to_sym))
+          end
+
+          def self.path_attributes
+            own = @path_attributes || []
+            self == Pathable ? own : superclass.path_attributes + own
+          end
+
           def initialize(args = { })
             self.parent = args[:parent]
           end
 
+          # The one-level-deep path-navigable children of this node, as
+          # {attribute_name_string => value}. Attributes whose value is
+          # nil are omitted; a value may itself be an Array (e.g. a
+          # CLUSTER's items).
+          def path_children
+            self.class.path_attributes.each_with_object({}) do |attr, hash|
+              value = send(attr)
+              hash[attr.to_s] = value unless value.nil?
+            end
+          end
+
           def item_at_path(path)
-            raise NotImplementedError, "item_at_path must be implemented"
+            matches = items_at_path(path)
+            case matches.size
+            when 0 then nil
+            when 1 then matches.first
+            else raise PathNotUniqueError, "path #{path} matches #{matches.size} items"
+            end
           end
 
           def items_at_path(path)
-            raise NotImplementedError, "items_at_path must be implemented"
+            path = self.class.normalize_path(path)
+            return [self] if path.root?
+
+            segment, rest = path.descend
+            children = path_children[segment.attribute]
+            return [] if children.nil?
+
+            matched = self.class.select_by_predicate(Array(children), segment)
+            return matched if rest.root?
+
+            matched.flat_map do |child|
+              child.is_a?(Pathable) ? child.items_at_path(rest) : []
+            end
           end
 
           def path_exists?(path)
-            raise NotImplementedError, "path_exists? must be implemented"
+            !items_at_path(path).empty?
           end
 
           def path_of_item(item)
-            raise NotImplementedError, "path_of_item must be implemented"
+            find_path_to(item, OpenEHR::Path.new([]))
           end
 
           def path_unique?(path)
-            raise NotImplementedError, "path_unique? must be implemented"
+            items_at_path(path).size == 1
+          end
+
+          def self.normalize_path(path)
+            path.is_a?(OpenEHR::Path) ? path : OpenEHR::Path.parse(path)
+          end
+
+          # Filters children matched by a path segment's predicate: a
+          # node_id predicate keeps only children whose
+          # archetype_node_id matches (non-Locatable children never
+          # match a node_id predicate); a name predicate further
+          # narrows to the child whose name.value matches.
+          def self.select_by_predicate(children, segment)
+            return children unless segment.predicate?
+
+            matched = children.select do |child|
+              child.respond_to?(:archetype_node_id) &&
+                child.archetype_node_id == segment.archetype_node_id
+            end
+            return matched if segment.name.nil?
+
+            matched.select do |child|
+              child.respond_to?(:name) && child.name.respond_to?(:value) &&
+                child.name.value == segment.name
+            end
+          end
+
+          private
+
+          def find_path_to(target, prefix)
+            return prefix.to_s if equal?(target)
+
+            self.class.path_attributes.each do |attr|
+              value = send(attr)
+              next if value.nil?
+
+              siblings = Array(value)
+              siblings.each do |child|
+                child_prefix = prefix + segment_for(attr, child, siblings)
+                if child.equal?(target)
+                  return child_prefix.to_s
+                elsif child.is_a?(Pathable)
+                  found = child.send(:find_path_to, target, child_prefix)
+                  return found if found
+                end
+              end
+            end
+            nil
+          end
+
+          def segment_for(attribute, child, siblings)
+            node_id = child.respond_to?(:archetype_node_id) ? child.archetype_node_id : nil
+            return OpenEHR::Path::Segment.new(attribute.to_s) if node_id.nil?
+
+            sharing_node_id = siblings.count do |sibling|
+              sibling.respond_to?(:archetype_node_id) && sibling.archetype_node_id == node_id
+            end
+            if sharing_node_id > 1 && child.respond_to?(:name) && child.name.respond_to?(:value)
+              OpenEHR::Path::Segment.new(attribute.to_s, archetype_node_id: node_id, name: child.name.value)
+            else
+              OpenEHR::Path::Segment.new(attribute.to_s, archetype_node_id: node_id)
+            end
           end
         end
 
@@ -79,7 +186,7 @@ module OpenEHR
 
           def concept
             if self.is_archetype_root?
-              return DvText.new(:value => 
+              return OpenEHR::RM::DataTypes::Text::DvText.new(:value =>
                                 @archetype_details.archetype_id.concept_name)
             else
               raise ArgumentError, 'this is not root'
@@ -159,6 +266,8 @@ module OpenEHR
         class FeederAuditDetails
           attr_reader :system_id
           attr_accessor :provider, :location, :time, :subject, :version_id
+          # RM 1.1.0 (SPECRM-74): optional custom meta-data, ITEM_STRUCTURE.
+          attr_accessor :other_details
 
           def initialize(args = { })
             self.system_id = args[:system_id]
@@ -167,6 +276,7 @@ module OpenEHR
             self.time = args[:time]
             self.subject = args[:subject]
             self.version_id = args[:version_id]
+            self.other_details = args[:other_details]
           end
 
           def system_id=(system_id)

data/lib/openehr/rm/common/change_control.rb

@@ -99,7 +99,7 @@ module OpenEHR
           end
 
           def owner_id
-            return HierObjectID.new(:value => @uid.value)
+            return OpenEHR::RM::Support::Identification::HierObjectID.new(:value => @uid.value)
           end
 
           def is_branch?
@@ -187,7 +187,7 @@ module OpenEHR
           end
 
           def all_versions=(all_versions)
-            if all_versions.nil? || all_versions.size < 0
+            if all_versions.nil? || all_versions.empty?
               raise ArgumentError, 'version count invalid'
             end
             @all_versions = all_versions
@@ -251,12 +251,7 @@ module OpenEHR
           end
 
           def latest_trunk_version
-            trunk_versions = [ ]
-            @all_versions.each do |ver|
-              if ver.uid.version_tree_id.trunk_version == '1'
-                trunk_versions << ver
-              end
-            end
+            trunk_versions = @all_versions.reject { |ver| ver.uid.is_branch? }
             sorted_trunk_version = trunk_versions.sort do |a,b|
               a.commit_audit.time_committed <=> b.commit_audit.time_committed
             end

data/lib/openehr/rm/common/directory.rb

@@ -11,11 +11,15 @@ module OpenEHR
         class Folder < OpenEHR::RM::Common::Archetyped::Locatable
           attr_accessor :items
           attr_reader :folders
+          # details: ITEM_STRUCTURE [0..1], "Archetypable meta-data for FOLDER".
+          attr_accessor :details
+          path_attribute :folders, :items, :details
 
           def initialize(args = { })
             super(args)
             self.folders = args[:folders]
             self.items = args[:items]
+            self.details = args[:details]
           end
 
           def folders=(folders)

data/lib/openehr/rm/common/generic.rb

@@ -99,38 +99,52 @@ module OpenEHR
         end
 
         class PartyIdentified < PartyProxy
-          attr_reader :name, :identifier
+          attr_reader :name, :identifiers
 
           def initialize(args = { })
-            if args[:external_ref].nil? && args[:name].nil? &&
-                args[:identifier].nil?
+            identifiers = args[:identifiers] || args[:identifier]
+            if args[:external_ref].nil? && args[:name].nil? && identifiers.nil?
               raise ArgumentError, 'cannot identified'
             end
             self.name = args[:name]
-            self.identifier = args[:identifier]
+            self.identifiers = identifiers
             super(args)
           end
 
           def name=(name)
-            if name.nil? && @external_ref.nil? && @identifier.nil?
+            if name.nil? && @external_ref.nil? && @identifiers.nil?
               raise ArgumentError, 'cannot identified'
             end
             raise ArgumentError, 'invaild name' unless name.nil? || !name.empty?
             @name = name
           end
 
-          def identifier=(identifier)
-            if @name.nil? && @external_ref.nil? && identifier.nil?
+          def identifiers=(identifiers)
+            if @name.nil? && @external_ref.nil? && identifiers.nil?
               raise ArgumentError, 'cannot identified'
             end
-            if !identifier.nil? && identifier.empty?
+            if !identifiers.nil? && identifiers.empty?
               raise ArgumentError, 'invaild identifier'
             end
-            @identifier = identifier
+            @identifiers = identifiers
+          end
+
+          # Deprecated: PartyIdentified's identifiers attribute is a
+          # List<DV_IDENTIFIER> per spec, so the plural #identifiers is
+          # the correct name; these singular aliases exist only for
+          # backward compatibility with earlier releases.
+          def identifier
+            warn '[DEPRECATED] PartyIdentified#identifier is deprecated; use #identifiers instead'
+            @identifiers
+          end
+
+          def identifier=(identifier)
+            warn '[DEPRECATED] PartyIdentified#identifier= is deprecated; use #identifiers= instead'
+            self.identifiers = identifier
           end
 
           def external_ref=(external_ref)
-            if @name.nil? && @identifier.nil? && external_ref.nil?
+            if @name.nil? && @identifiers.nil? && external_ref.nil?
               raise ArgumentError, 'invalid external_ref'
             end
             @external_ref = external_ref

data/lib/openehr/rm/composition/content/entry.rb

@@ -48,12 +48,13 @@ module OpenEHR
             end
 
             def subject_is_self?
-              return @subject.instance_of? PartySelf
+              return @subject.instance_of? OpenEHR::RM::Common::Generic::PartySelf
             end
           end
 
           class AdminEntry < Entry
             attr_reader :data
+            path_attribute :data
 
             def initialize(args = { })
               super(args)
@@ -67,6 +68,7 @@ module OpenEHR
           end
           class CareEntry < Entry
             attr_accessor :protocol, :guideline_id
+            path_attribute :protocol
 
             def initialize(args = { })
               super(args)
@@ -78,6 +80,7 @@ module OpenEHR
           class Observation < CareEntry
             attr_reader :data
             attr_accessor :state
+            path_attribute :data, :state
 
             def initialize(args = { })
               super(args)
@@ -93,6 +96,7 @@ module OpenEHR
 
           class Evaluation < CareEntry
             attr_reader :data
+            path_attribute :data
 
             def initialize(args = { })
               super(args)
@@ -108,6 +112,7 @@ module OpenEHR
           class Instruction < CareEntry
             attr_reader :narrative, :activities
             attr_accessor :expiry_time, :wf_definition
+            path_attribute :activities
 
             def initialize(args = { })
               super(args)
@@ -134,6 +139,7 @@ module OpenEHR
 
           class Activity < OpenEHR::RM::Common::Archetyped::Locatable
             attr_reader :description, :timing, :action_archetype_id
+            path_attribute :description
 
             def initialize(args = { })
               super(args)
@@ -149,10 +155,10 @@ module OpenEHR
               @description = description
             end
 
+            # RM 1.1.0: optional - may be omitted when timing is instead
+            # represented structurally in description, or is unavailable
+            # (e.g. imported legacy data).
             def timing=(timing)
-              if timing.nil?
-                raise ArgumentError, 'timing is mandatory'
-              end
               @timing = timing
             end
 
@@ -167,7 +173,8 @@ module OpenEHR
           class Action < CareEntry
             attr_reader :time, :description, :ism_transition
             attr_accessor :instruction_details
-            
+            path_attribute :description, :ism_transition, :instruction_details
+
             def initialize(args = { })
               super(args)
               self.description = args[:description]
@@ -201,6 +208,7 @@ module OpenEHR
           class InstructionDetails < OpenEHR::RM::Common::Archetyped::Pathable
             attr_reader :instruction_id, :activity_id
             attr_accessor :wf_details
+            path_attribute :wf_details
 
             def initialize(args = { })
               super(args)
@@ -227,18 +235,26 @@ module OpenEHR
           class IsmTransition < OpenEHR::RM::Common::Archetyped::Pathable
             attr_reader :current_state, :transition
             attr_accessor :careflow_step
+            # RM 1.1.0: optional list of one or more reasons for this
+            # careflow step having been taken (e.g. useful in medication
+            # management, where several reasons may apply).
+            attr_accessor :reason
 
             def initialize(args = { })
               super(args)
               self.current_state = args[:current_state]
               self.transition = args[:transition]
               self.careflow_step = args[:careflow_step]
+              self.reason = args[:reason]
             end
 
             def current_state=(current_state)
               if current_state.nil?
                 raise ArgumentError, 'current_state is mandatory'
               end
+              unless OpenEHR::TerminologyService.has_code_for_group?('ism transition current state', current_state.defining_code.code_string)
+                raise ArgumentError, 'current_state code is invalid'
+              end
               @current_state = current_state
             end
 
@@ -246,6 +262,9 @@ module OpenEHR
               if transition.nil?
                 raise ArgumentError, 'transition is mandatory'
               end
+              unless OpenEHR::TerminologyService.has_code_for_group?('ism transition careflow transition', transition.defining_code.code_string)
+                raise ArgumentError, 'transition code is invalid'
+              end
               @transition = transition
             end
           end

data/lib/openehr/rm/composition/content/navigation.rb

@@ -10,7 +10,8 @@ module OpenEHR
       module Content
         module Navigation
           class Section < ::OpenEHR::RM::Composition::Content::ContentItem
-            attr_reader :items 
+            attr_reader :items
+            path_attribute :items
 
             def initialize(args = { })
               super(args)

data/lib/openehr/rm/composition.rb

@@ -9,7 +9,9 @@ module OpenEHR
     module Composition
       class Composition < OpenEHR::RM::Common::Archetyped::Locatable
         attr_reader :language, :category, :territory, :composer
-        attr_accessor :content, :context
+        attr_accessor :context
+        attr_reader :content
+        path_attribute :content, :context
 
         def initialize(args = { })
           super(args)
@@ -25,6 +27,9 @@ module OpenEHR
           if language.nil?
             raise ArgumentError, 'language is mandatory'
           end
+          unless OpenEHR::TerminologyService.valid_code?('ISO_639-1', language.code_string)
+            raise ArgumentError, 'language code is invalid'
+          end
           @language = language
         end
 
@@ -32,6 +37,9 @@ module OpenEHR
           if category.nil?
             raise ArgumentError, 'category is mandatory'
           end
+          unless OpenEHR::TerminologyService.has_code_for_group?('composition category', category.defining_code.code_string)
+            raise ArgumentError, 'category code is invalid'
+          end
           @category = category
         end
 
@@ -49,6 +57,11 @@ module OpenEHR
           @composer = composer
         end
 
+        def content=(content)
+          content.each { |item| item.parent = self if item.respond_to?(:parent=) } if content.respond_to?(:each)
+          @content = content
+        end
+
         def is_persistent?
           return category.value == 'persistent'
         end
@@ -56,7 +69,7 @@ module OpenEHR
 
       class EventContext < OpenEHR::RM::Common::Archetyped::Pathable
         attr_reader :start_time, :setting, :participations, :location
-        attr_accessor :end_time, :other_context
+        attr_accessor :end_time, :other_context, :health_care_facility
 
         def initialize(args = { })
           super(args)
@@ -66,6 +79,7 @@ module OpenEHR
           self.participations = args[:participations]
           self.location = args[:location]
           self.other_context = args[:other_context]
+          self.health_care_facility = args[:health_care_facility]
         end
 
         def start_time=(start_time)
@@ -79,6 +93,9 @@ module OpenEHR
           if setting.nil?
             raise ArgumentError, 'setting is mandatory'
           end
+          unless OpenEHR::TerminologyService.has_code_for_group?('event context setting', setting.defining_code.code_string)
+            raise ArgumentError, 'setting code is invalid'
+          end
           @setting = setting
         end