openehr 1.2.999999 → 2.0.0

data/lib/openehr/parser/opt_parser.rb

@@ -39,15 +39,42 @@ module OpenEHR
       def parse
         @opt = Nokogiri::XML::Document.parse(File.open(@filename))
         @opt.remove_namespaces!
-        uid = OpenEHR::RM::Support::Identification::UIDBasedID.new(value: text_on_path(@opt, UID_PATH))
+        
+        uid = build_uid
         defs = definition
-        OpenEHR::AM::Template::OperationalTemplate.new(uid: uid, concept: concept, language: language, description: description, template_id: template_id, definition: defs, component_terminologies: @component_terminologies)
+        
+        # Create operational template with archetype-compatible parameters
+        OpenEHR::AM::Template::OperationalTemplate.new(
+          uid: uid,
+          concept: concept,
+          original_language: language,
+          description: description,
+          template_id: template_id,
+          archetype_id: template_id,  # Use template_id as archetype_id for compatibility
+          definition: defs,
+          ontology: (@component_terminologies || {})[defs.archetype_id.value] || create_template_ontology,
+          component_terminologies: @component_terminologies || {},
+          terminology_extracts: @component_terminologies || {},
+          adl_version: "1.4"
+        )
       end
 
       private
 
+      # template_id is mandatory for an operational template (enforced by
+      # OperationalTemplate itself); a missing/blank <template_id> element
+      # must therefore resolve to nil rather than an invalid TemplateID.
       def template_id
-        @template_id ||= OpenEHR::RM::Support::Identification::TemplateID.new(value: text_on_path(@opt, TEMPLATE_ID_PATH))
+        return @template_id if @template_id
+        value = text_on_path(@opt, TEMPLATE_ID_PATH)
+        @template_id = value.nil? || value.empty? ? nil : OpenEHR::RM::Support::Identification::TemplateID.new(value: value)
+      end
+
+      # uid is optional on an operational template; a missing/blank <uid>
+      # element must resolve to nil rather than an invalid UIDBasedID.
+      def build_uid
+        value = text_on_path(@opt, UID_PATH)
+        value.nil? || value.empty? ? nil : OpenEHR::RM::Support::Identification::UIDBasedID.new(value: value)
       end
 
       def concept
@@ -92,6 +119,30 @@ module OpenEHR
           archetype_terminology(nodes)
       end
 
+      def create_template_ontology
+        # Create a basic ontology for the template using the main concept
+        concept_code = 'at0000'
+        original_lang = language
+        
+        term_definitions = {
+          original_lang.code_string => [
+            OpenEHR::AM::Archetype::Terminology::ArchetypeTerm.new(
+              code: concept_code,
+              items: {
+                'text' => concept || 'Template',
+                'description' => 'Operational template'
+              }
+            )
+          ]
+        }
+        
+        OpenEHR::AM::Archetype::Terminology::ArchetypeTerminology.new(
+          concept_code: concept_code,
+          original_language: original_lang,
+          term_definitions: term_definitions
+        )
+      end
+
       def archetype_terminology(nodes)
         td = term_definitions(nodes)
         concept_code = td[language.code_string][0]
@@ -174,10 +225,23 @@ module OpenEHR
       end
 
       def c_code_phrase(attr_xml, node)
-        terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: attr_xml.at('terminology_id/value').text.strip)
-        code_list = attr_xml.xpath('code_list').text.strip
-        occurrences = occurrences(attr_xml.at('occurrences'))
-        OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(terminology_id: terminology_id, code_list: [code_list], path: node.path, occurrences: occurrences, rm_type_name: 'CodePhrase')
+        terminology_id_node = attr_xml.at('terminology_id/value')
+        terminology_id = terminology_id_node ? OpenEHR::RM::Support::Identification::TerminologyID.new(value: terminology_id_node.text.strip) : nil
+        
+        code_list_nodes = attr_xml.xpath('code_list')
+        code_list = code_list_nodes.map { |code_node| code_node.text.strip }
+        code_list = [code_list.first] if code_list.size == 1 && code_list.first.empty?
+        
+        occurrences_node = attr_xml.at('occurrences')
+        occurrences_obj = occurrences_node ? occurrences(occurrences_node) : nil
+        
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(
+          terminology_id: terminology_id, 
+          code_list: code_list, 
+          path: node.path, 
+          occurrences: occurrences_obj, 
+          rm_type_name: 'CODE_PHRASE'
+        )
       end
 
       def archetype_slot(attr_xml,node)
@@ -193,22 +257,82 @@ module OpenEHR
       end
 
       def occurrences(occurrence_xml)
+        return nil if occurrence_xml.nil?
+        
         lower_node = occurrence_xml.at('lower')
         upper_node = occurrence_xml.at('upper')
-        lower = lower_node.text.to_i if lower_node
-        upper = upper_node.text.to_i if upper_node
-        lower_included = to_bool(occurrence_xml.at('lower_included'))
-        upper_included = to_bool(occurrence_xml.at('upper_included'))
-        OpenEHR::AssumedLibraryTypes::Interval.new(lower: lower, upper: upper, lower_included: lower_included, upper_included: upper_included)
+        lower_included_node = occurrence_xml.at('lower_included')
+        upper_included_node = occurrence_xml.at('upper_included')
+        lower_unbounded_node = occurrence_xml.at('lower_unbounded')
+        upper_unbounded_node = occurrence_xml.at('upper_unbounded')
+        
+        lower = lower_node ? lower_node.text.to_i : nil
+        upper = upper_node ? upper_node.text.to_i : nil
+        lower_included = lower_included_node ? to_bool(lower_included_node.text) : (lower.nil? ? nil : true)
+        upper_included = upper_included_node ? to_bool(upper_included_node.text) : (upper.nil? ? nil : true)
+        lower_unbounded = lower_unbounded_node ? to_bool(lower_unbounded_node.text) : false
+        upper_unbounded = upper_unbounded_node ? to_bool(upper_unbounded_node.text) : false
+
+        # An occurrences element with none of its children present carries no
+        # constraint at all; Interval requires at least one bound, so treat
+        # this as "no occurrences data" rather than raising.
+        return nil if lower.nil? && upper.nil? && !lower_unbounded && !upper_unbounded
+
+        # Handle unbounded intervals properly
+        if upper_unbounded || upper.nil?
+          upper = nil
+          upper_included = nil
+        end
+        
+        if lower_unbounded || lower.nil?
+          lower = nil
+          lower_included = nil
+        end
+        
+        OpenEHR::AssumedLibraryTypes::Interval.new(
+          lower: lower, 
+          upper: upper, 
+          lower_included: lower_included, 
+          upper_included: upper_included
+        )
       end
 
       def cardinality(xml)
-        order = to_bool(xml.at('is_ordered').text)
-        unique = to_bool(xml.at('is_unique').text)
-        interval = occurrences(xml)
-        OpenEHR::AM::Archetype::ConstraintModel::Cardinality.new(is_ordered: order, is_unique: unique, interval: interval)
+        return nil if xml.nil?
+
+        order_node = xml.at('is_ordered')
+        unique_node = xml.at('is_unique')
+        interval_node = xml.at('interval')
+
+        # No cardinality sub-elements at all means no cardinality data.
+        return nil if order_node.nil? && unique_node.nil? && interval_node.nil?
+
+        order = order_node ? to_bool(order_node.text) : false
+        unique = unique_node ? to_bool(unique_node.text) : false
+        interval = interval_node ? occurrences(interval_node) : nil
+        
+        OpenEHR::AM::Archetype::ConstraintModel::Cardinality.new(
+          is_ordered: order, 
+          is_unique: unique, 
+          interval: interval
+        )
       end        
 
+      def archetype_internal_ref(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        target_path = attr_xml.at('target_path').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        OpenEHR::AM::Archetype::ConstraintModel::ArchetypeInternalRef.new(rm_type_name: rm_type_name, occurrences: occurrences, target_path: target_path)
+      end
+
+      # No .opt fixture in this gem's corpus uses a C_DV_STATE (state
+      # machine) constraint, so its actual OPT XML shape is unverified;
+      # raising a clear, documented error here is safer than guessing
+      # at element names and risking a silently wrong StateMachine.
+      def c_dv_state(_attr_xml, _node)
+        raise NotImplementedError, 'OPTParser does not yet support C_DV_STATE (state machine) constraints'
+      end
+
       def constraint_ref(attr_xml, node)
         rm_type_name = attr_xml.at('rm_type_name').text
         reference = attr_xml.at('reference').text
@@ -265,9 +389,7 @@ module OpenEHR
       def c_dv_quantity(attr_xml, node)
         rm_type_name = attr_xml.at('rm_type_name').text
         occurrences = occurrences(attr_xml.at('occurrences'))
-        property_terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: attr_xml.at('property/terminology_id/value').text)
-        property_code_string = attr_xml.at('property/code_string').text
-        property = OpenEHR::RM::DataTypes::Text::CodePhrase.new(terminology_id: property_terminology_id, code_string: property_code_string)
+        property = property_code_phrase(attr_xml.at('property'))
         list = attr_xml.xpath('.//list').map do |element|
           units = element.at('units').text if element.at('units')
           magnitude = occurrences(element.at('magnitude')) if element.at('magnitude')
@@ -277,19 +399,177 @@ module OpenEHR
         OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvQuantity.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list, property: property)
       end
 
-      def c_date(xml)
+      # The <property> element is optional in real templates; return nil rather
+      # than dereferencing missing terminology/code nodes.
+      def property_code_phrase(property_xml)
+        return nil if property_xml.nil?
+        terminology_node = property_xml.at('terminology_id/value')
+        code_node = property_xml.at('code_string')
+        return nil if terminology_node.nil? || code_node.nil?
+        terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: terminology_node.text)
+        OpenEHR::RM::DataTypes::Text::CodePhrase.new(terminology_id: terminology_id, code_string: code_node.text)
+      end
+
+      def c_dv_ordinal(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        list = attr_xml.xpath('list').map { |element| dv_ordinal_item(element) }.compact
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvOrdinal.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list)
+      end
+
+      # DV_ORDINAL.symbol is spec'd as DV_CODED_TEXT; the OPT XML only
+      # carries a defining_code (terminology_id + code_string), so the
+      # DvCodedText's own value is set to that same code_string (there
+      # is no separate display text in this element).
+      def dv_ordinal_item(element)
+        value_node = element.at('value')
+        return nil unless value_node && !value_node.text.empty?
+
+        code_phrase = property_code_phrase(element.at('symbol/defining_code'))
+        return nil if code_phrase.nil?
+
+        symbol = OpenEHR::RM::DataTypes::Text::DvCodedText.new(value: code_phrase.code_string, defining_code: code_phrase)
+        OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(value: value_node.text.to_i, symbol: symbol)
+      end
 
+      def c_dv_scale(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        list = attr_xml.xpath('list').map { |element| dv_scale_item(element) }.compact
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvScale.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list)
+      end
+
+      # Same XML shape as C_DV_ORDINAL's list items, but DV_SCALE.value
+      # is Real rather than Integer.
+      def dv_scale_item(element)
+        value_node = element.at('value')
+        return nil unless value_node && !value_node.text.empty?
+
+        code_phrase = property_code_phrase(element.at('symbol/defining_code'))
+        return nil if code_phrase.nil?
+
+        symbol = OpenEHR::RM::DataTypes::Text::DvCodedText.new(value: code_phrase.code_string, defining_code: code_phrase)
+        OpenEHR::RM::DataTypes::Quantity::DvScale.new(value: value_node.text.to_f, symbol: symbol)
+      end
+
+      def c_date(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new
+        end
       end
 
       def c_date_time(xml)
-        
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new
+        end
       end
 
       def c_integer(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(range: occurrences(range))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_i }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new
+        end
+      end
+
+      def c_real(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(range: occurrences(range))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_f }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new
+        end
+      end
+
+      def c_duration(xml)
+        pattern = xml.at('pattern')
+        range_xml = xml.at('range')
+        list = xml.xpath('list')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(pattern: pattern.text)
+        elsif range_xml
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(range: duration_range(range_xml))
+        elsif !list.empty?
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(list: list.map(&:text))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new
+        end
+      end
+
+      # A C_DURATION range's bounds are ISO8601 duration strings (e.g.
+      # PT24H), not plain numbers, so occurrences() (built for numeric
+      # Interval bounds) doesn't apply here; wrap each bound as a
+      # DV_DURATION instead, matching what CDuration#valid_value?
+      # already expects its range bounds to be.
+      def duration_range(range_xml)
+        lower = duration_bound(range_xml.at('lower'), range_xml.at('lower_unbounded'))
+        upper = duration_bound(range_xml.at('upper'), range_xml.at('upper_unbounded'))
+        return nil if lower.nil? && upper.nil?
+
+        OpenEHR::AssumedLibraryTypes::Interval.new(
+          lower: lower, upper: upper,
+          lower_included: lower.nil? ? nil : bool_node(range_xml.at('lower_included'), true),
+          upper_included: upper.nil? ? nil : bool_node(range_xml.at('upper_included'), true))
+      end
+
+      def duration_bound(value_node, unbounded_node)
+        return nil if bool_node(unbounded_node, false)
+        return nil if value_node.nil? || value_node.text.empty?
 
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDuration.new(value: value_node.text)
+      end
+
+      def bool_node(node, default)
+        node ? to_bool(node.text) : default
+      end
+
+      def c_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new
+        end
       end
 
       def c_boolean(xml)
+        true_valid = xml.at('true_valid')
+        false_valid = xml.at('false_valid')
+        assumed_value = xml.at('assumed_value')
+        
+        true_valid_value = true_valid ? to_bool(true_valid.text) : nil
+        false_valid_value = false_valid ? to_bool(false_valid.text) : nil
+        assumed_value_value = assumed_value ? to_bool(assumed_value.text) : nil
+        
+        OpenEHR::AM::Archetype::ConstraintModel::Primitive::CBoolean.new(
+          true_valid: true_valid_value, 
+          false_valid: false_valid_value, 
+          assumed_value: assumed_value_value
+        )
       end
 
       def string(attr_xml)
@@ -309,12 +589,11 @@ module OpenEHR
       end
 
       def to_bool(str)
-        if /true/i =~ str
-          return true
-        elsif /false/i =~ str
-          return false
-        end
-        return nil
+        return nil if str.nil?
+        str = str.text if str.respond_to?(:text)
+        return true if /true/i =~ str.to_s
+        return false if /false/i =~ str.to_s
+        nil
       end
     end
   end

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