openehr 2.1.0 → 2.3.1

data/lib/openehr/parser/xml_archetype_parser.rb

@@ -0,0 +1,255 @@
+require 'nokogiri'
+require_relative 'xml_constraint_parsing'
+require_relative 'xml_primitive_parsing'
+require_relative 'xml_domain_type_parsing'
+
+module OpenEHR
+  module Parser
+    # Reads the canonical openEHR ITS-XML archetype shape that
+    # XMLSerializer (lib/openehr/serializer/xml_serializer.rb) emits -
+    # see that file's header comment for how that shape was established
+    # as ground truth. Mirrors ADLParser#archetype's construction
+    # pattern (a small constructor-argument method per Archetype.new
+    # keyword) and shares the same <definition> constraint-tree readers
+    # as OPTParser via the 3 modules extracted in B3
+    # (xml_constraint_parsing/xml_primitive_parsing/xml_domain_type_parsing).
+    class XMLArchetypeParser < ::OpenEHR::Parser::Base
+      include XMLConstraintParsing
+      include XMLPrimitiveParsing
+      include XMLDomainTypeParsing
+
+      def parse
+        archetype
+      rescue OpenEHR::Parser::ParseError
+        raise
+      rescue StandardError => e
+        raise OpenEHR::Parser::ParseError, "invalid XML archetype (#{@filename}): #{e.class}: #{e.message}"
+      end
+
+      private
+
+      def doc
+        @doc ||= begin
+          parsed = Nokogiri::XML::Document.parse(File.open(@filename, 'rb:bom|utf-8'))
+          parsed.remove_namespaces!
+          parsed
+        end
+      end
+
+      def root
+        @root ||= doc.at('archetype')
+      end
+
+      def text_on_path(xml, path)
+        node = xml.at(path)
+        node.nil? ? nil : node.text
+      end
+
+      def code_phrase_from(node)
+        return nil if node.nil?
+
+        terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: text_on_path(node, 'terminology_id/value'))
+        OpenEHR::RM::DataTypes::Text::CodePhrase.new(terminology_id: terminology_id, code_string: text_on_path(node, 'code_string'))
+      end
+
+      # Nodes emitted with an 'id' attribute keying a plain text value
+      # (original_author/other_details/author/original_resource_uri) -
+      # the same shape everywhere it's used, so read generically.
+      def id_keyed_hash(nodes)
+        return nil if nodes.empty?
+
+        nodes.each_with_object({}) { |n, hash| hash[n['id']] = n.text }
+      end
+
+      def archetype_id
+        OpenEHR::RM::Support::Identification::ArchetypeID.new(value: text_on_path(root, 'archetype_id/value'))
+      end
+
+      def uid
+        value = text_on_path(root, 'uid/value')
+        value.nil? ? nil : OpenEHR::RM::Support::Identification::HierObjectID.new(value: value)
+      end
+
+      def adl_version
+        text_on_path(root, 'adl_version')
+      end
+
+      def parent_archetype_id
+        value = text_on_path(root, 'parent_archetype_id/value')
+        value.nil? ? nil : OpenEHR::RM::Support::Identification::ArchetypeID.new(value: value)
+      end
+
+      def concept
+        text_on_path(root, 'concept')
+      end
+
+      def original_language
+        code_phrase_from(root.at('original_language'))
+      end
+
+      def translations
+        translations_node = root.at('translations')
+        return nil if translations_node.nil?
+
+        translations_node.xpath('translation').each_with_object({}) do |node, hash|
+          hash[node['language']] = translation_details(node)
+        end
+      end
+
+      def translation_details(node)
+        OpenEHR::RM::Common::Resource::TranslationDetails.new(
+          language: code_phrase_from(node.at('language')),
+          author: id_keyed_hash(node.xpath('author')),
+          accreditation: text_on_path(node, 'accreditation'),
+          other_details: id_keyed_hash(node.xpath('other_details'))
+        )
+      end
+
+      def description
+        node = root.at('description')
+        return nil if node.nil?
+
+        OpenEHR::RM::Common::Resource::ResourceDescription.new(
+          original_author: id_keyed_hash(node.xpath('original_author')),
+          other_contributors: description_other_contributors(node),
+          lifecycle_state: text_on_path(node, 'lifecycle_state'),
+          details: description_details(node)
+        )
+      end
+
+      def description_other_contributors(node)
+        contributors = node.xpath('other_contributors').map(&:text)
+        contributors.empty? ? nil : contributors
+      end
+
+      def description_details(node)
+        node.xpath('details/detail').each_with_object({}) do |detail, hash|
+          hash[detail['language']] = description_detail_item(detail)
+        end
+      end
+
+      def description_detail_item(node)
+        keywords = node.xpath('keywords').map(&:text)
+        OpenEHR::RM::Common::Resource::ResourceDescriptionItem.new(
+          language: code_phrase_from(node.at('language')),
+          purpose: text_on_path(node, 'purpose'),
+          keywords: keywords.empty? ? nil : keywords,
+          use: text_on_path(node, 'use'),
+          misuse: text_on_path(node, 'misuse'),
+          copyright: text_on_path(node, 'copyright'),
+          original_resource_uri: id_keyed_hash(node.xpath('original_resource_uri')),
+          other_details: id_keyed_hash(node.xpath('other_details'))
+        )
+      end
+
+      # Unlike OPTParser (whose top-level definition is a
+      # CArchetypeRoot, read via c_archetype_root, which has its own
+      # root-path override), a standalone archetype's <definition> root
+      # is a plain CComplexObject. c_complex_object (shared with
+      # OPTParser) always appends [node_id] to the path it's handed,
+      # which is correct for every *nested* complex object it's called
+      # on via attributes()/children() but wrong for the root itself
+      # (whose path must stay "/") - so the root is built directly here
+      # instead, mirroring c_archetype_root's override.
+      def definition
+        xml = root.at('definition')
+        node = Node.new
+        rm_type_name = text_on_path(xml, './rm_type_name')
+        node_id = text_on_path(xml, './node_id')
+        node.id = node_id unless node_id.nil? || node_id.empty?
+        node.path = '/'
+        OpenEHR::AM::Archetype::ConstraintModel::CComplexObject.new(
+          rm_type_name: rm_type_name, node_id: node.id, path: node.path,
+          occurrences: occurrences(xml.xpath('./occurrences')), attributes: attributes(xml.xpath('./attributes'), node)
+        )
+      end
+
+      def invariants
+        node = root.at('invariants')
+        return nil if node.nil?
+
+        node.xpath('invariant').map { |invariant| invariant_assertion(invariant) }
+      end
+
+      def invariant_assertion(node)
+        assertions(node, Node.new).first
+      end
+
+      def ontology
+        node = root.at('ontology')
+        OpenEHR::AM::Archetype::Ontology::ArchetypeOntology.new(
+          primary_language: text_on_path(node, 'primary_language'),
+          specialisation_depth: ontology_specialisation_depth(node),
+          languages_available: ontology_string_list(node, 'languages_available'),
+          terminologies_available: ontology_string_list(node, 'terminologies_available'),
+          term_definitions: ontology_term_definitions(node, 'term_definitions'),
+          constraint_definitions: ontology_optional_term_definitions(node, 'constraint_definitions'),
+          term_bindings: ontology_bindings(node, 'term_bindings') { |value| [code_phrase_from_binding(value)] },
+          constraint_bindings: ontology_bindings(node, 'constraint_bindings') { |value| OpenEHR::RM::DataTypes::URI::DvUri.new(value: value) }
+        )
+      end
+
+      def ontology_specialisation_depth(node)
+        value = text_on_path(node, 'specialisation_depth')
+        value.nil? ? nil : value.to_i
+      end
+
+      def ontology_string_list(node, keyword)
+        values = node.xpath(keyword).map(&:text)
+        values.empty? ? nil : values
+      end
+
+      def ontology_term_definitions(node, keyword)
+        node.xpath(keyword).each_with_object({}) do |term_node, by_lang|
+          lang = term_node['language']
+          (by_lang[lang] ||= {})[term_node['code']] = archetype_term(term_node)
+        end
+      end
+
+      def ontology_optional_term_definitions(node, keyword)
+        result = ontology_term_definitions(node, keyword)
+        result.empty? ? nil : result
+      end
+
+      def archetype_term(term_node)
+        items = term_node.xpath('items').each_with_object({}) { |item, hash| hash[item['id']] = item.text }
+        OpenEHR::AM::Archetype::Ontology::ArchetypeTerm.new(code: term_node['code'], items: items)
+      end
+
+      def ontology_bindings(node, keyword)
+        result = node.xpath(keyword).each_with_object({}) do |binding_node, by_terminology|
+          terminology = binding_node['terminology']
+          (by_terminology[terminology] ||= {})[binding_node['code']] = yield(binding_node.text)
+        end
+        result.empty? ? nil : result
+      end
+
+      # term_bindings' value is a "terminology::code" qualified
+      # reference (matching ADLSerializer/XMLSerializer's own emission),
+      # not a bare code - split it back into a CodePhrase.
+      def code_phrase_from_binding(value)
+        terminology, code = value.split('::', 2)
+        OpenEHR::RM::DataTypes::Text::CodePhrase.new(
+          terminology_id: OpenEHR::RM::Support::Identification::TerminologyID.new(value: terminology),
+          code_string: code
+        )
+      end
+
+      def archetype
+        OpenEHR::AM::Archetype::Archetype.new(
+          archetype_id: archetype_id,
+          adl_version: adl_version,
+          uid: uid,
+          concept: concept,
+          original_language: original_language,
+          translations: translations,
+          description: description,
+          definition: definition,
+          ontology: ontology,
+          parent_archetype_id: parent_archetype_id,
+          invariants: invariants
+        )
+      end
+    end
+  end
+end

data/lib/openehr/parser/xml_constraint_parsing.rb

@@ -0,0 +1,275 @@
+module OpenEHR
+  module Parser
+    # Structural/constraint-tree node builders (C_COMPLEX_OBJECT,
+    # C_ATTRIBUTE, C_PRIMITIVE_OBJECT, ARCHETYPE_SLOT, ARCHETYPE_INTERNAL_REF,
+    # CONSTRAINT_REF, ASSERTION) shared between OPTParser and
+    # XMLArchetypeParser - both read the same canonical shape (see
+    # lib/openehr/serializer/xml_serializer.rb's header comment for how
+    # that shape was established as ground truth against real .opt
+    # fixtures). Extracted from opt_parser.rb without behavior changes,
+    # except: expr_unary_operator support and tag reading in assertions()
+    # were both added here since XMLSerializer already emits them, and
+    # occurrences()/numeric bounds are now real-aware where the caller
+    # asks for it (C_REAL ranges were silently truncated to Integer via
+    # String#to_i before this).
+    module XMLConstraintParsing
+      private
+
+      def c_archetype_root(xml, node = Node.new)
+        rm_type_name = text_on_path(xml, './rm_type_name')
+        id = text_on_path(xml, './node_id')
+        node.id = id unless id.nil? or id.empty?
+        occurrences = occurrences(xml.xpath('./occurrences'))
+        archetype_id = OpenEHR::RM::Support::Identification::ArchetypeID.new(value: text_on_path(xml, './archetype_id/value'))
+        if node.root? or node.id.nil?
+          node.path = "/"
+        end
+        component_terminologies(archetype_id, xml)
+        OpenEHR::AM::Archetype::ConstraintModel::CArchetypeRoot.new(rm_type_name: rm_type_name, node_id: node.id, path: node.path, occurrences: occurrences, archetype_id: archetype_id, attributes: attributes(xml.xpath('./attributes'), node))
+      end
+
+      def c_complex_object(xml, node)
+        rm_type_name = xml.xpath('./rm_type_name').text
+        node_id = xml.xpath('./node_id').text
+        unless node_id.nil? or node_id.empty?
+          node.id = node_id
+          node.path = "#{node.path}[#{node.id}]"
+        end
+        OpenEHR::AM::Archetype::ConstraintModel::CComplexObject.new(rm_type_name: rm_type_name, node_id: node.id, path: node.path, occurrences: occurrences(xml.xpath('./occurrences')), attributes: attributes(xml.xpath('./attributes'), node))
+      end
+
+      def attributes(attributes_xml, node)
+        attributes_xml.map do |attr|
+          rm_attribute_name = attr.at('rm_attribute_name').text
+          if node.root?
+            path = "/#{rm_attribute_name}"
+          else
+            path = "#{node.path}/#{rm_attribute_name}"
+          end
+          child_node = Node.new(node)
+          child_node.path = path
+          child_node.id = node.id
+          send attr.attributes['type'].text.downcase, attr, child_node
+        end
+      end
+
+      # Each sibling child gets its own Node, copied fresh from the
+      # attribute's node - c_complex_object mutates node.path/node.id
+      # in place when a node_id is present, so sharing one Node across
+      # a map() here would leak sibling A's path into sibling B (e.g. a
+      # C_MULTIPLE_ATTRIBUTE with 2+ C_COMPLEX_OBJECT children, each
+      # with its own node_id, would produce "/items[a][b]" instead of
+      # "/items[a]" and "/items[b]").
+      def children(children_xml, node)
+        children_xml.map do |child|
+          child_node = Node.new(node)
+          child_node.path = node.path
+          child_node.id = node.id
+          type_name = child.attributes['type'].text
+          handler = type_name.downcase
+          if respond_to?(handler, true)
+            send handler, child, child_node
+          else
+            # children is open to vendor/newer-model constraint extensions;
+            # the other xsi:type dispatch sites are schema-closed. Preserve
+            # the C_OBJECT core here, while warning that type-specific
+            # constraints are dropped and validation becomes more permissive.
+            warn "openehr parser: unknown constraint type \"#{type_name}\" at #{child_node.path}; treating as C_COMPLEX_OBJECT (type-specific constraints dropped)"
+            c_complex_object(child, child_node)
+          end
+        end
+      end
+
+      def c_single_attribute(attr_xml, node)
+        rm_attribute_name = attr_xml.at('rm_attribute_name').text
+        existence = occurrences(attr_xml.at('existence'))
+        OpenEHR::AM::Archetype::ConstraintModel::CSingleAttribute.new(rm_attribute_name: rm_attribute_name, existence: existence, path: node.path, children: children(attr_xml.xpath('./children'), node))
+      end
+
+      def c_multiple_attribute(attr_xml, node)
+        rm_attribute_name = attr_xml.at('rm_attribute_name').text
+        existence = occurrences(attr_xml.at('existence'))
+        OpenEHR::AM::Archetype::ConstraintModel::CMultipleAttribute.new(rm_attribute_name: rm_attribute_name, existence: existence, path: node.path, cardinality: cardinality(attr_xml), children: children(attr_xml.xpath('./children'), node))
+      end
+
+      def archetype_slot(attr_xml, node)
+        node_id = attr_xml.at('node_id').text
+        node.id = node_id
+        # Matches c_complex_object's path convention: a slot's own
+        # node_id belongs in its path (e.g. "/items[at0053]"), not just
+        # its parent attribute's path - without this, two slots under
+        # the same C_MULTIPLE_ATTRIBUTE would collapse to one path.
+        node.path = "#{node.path}[#{node.id}]" unless node_id.nil? || node_id.empty?
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        includes_leaf = attr_xml.at('includes')
+        includes = assertions(includes_leaf.children, node) if includes_leaf
+        excludes_leaf = attr_xml.at('excludes')
+        excludes = assertions(excludes_leaf.children, node) if excludes_leaf
+        OpenEHR::AM::Archetype::ConstraintModel::ArchetypeSlot.new(path: node.path, node_id: node.id, rm_type_name: rm_type_name, occurrences: occurrences, includes: includes, excludes: excludes)
+      end
+
+      def occurrences(occurrence_xml)
+        numeric_interval(occurrence_xml, real: false)
+      end
+
+      # Shared by occurrences()/existence/cardinality (always Integer
+      # bounds) and C_REAL's range (Real bounds, via numeric_interval's
+      # real: true - see xml_primitive_parsing.rb's c_real).
+      def numeric_interval(occurrence_xml, real:)
+        return nil if occurrence_xml.nil?
+
+        lower_node = occurrence_xml.at('lower')
+        upper_node = occurrence_xml.at('upper')
+        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 ? numeric_bound(lower_node.text, real) : nil
+        upper = upper_node ? numeric_bound(upper_node.text, real) : 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 numeric_bound(text, real)
+        real ? text.to_f : text.to_i
+      end
+
+      def cardinality(xml)
+        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
+
+      def constraint_ref(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        reference = attr_xml.at('reference').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        OpenEHR::AM::Archetype::ConstraintModel::ConstraintRef.new(rm_type_name: rm_type_name, occurrences: occurrences, reference: reference)
+      end
+
+      def assertions(attr_xml, node)
+        tag_node = attr_xml.at('tag')
+        tag = tag_node.nil? ? nil : tag_node.text
+        string_expression = attr_xml.at('string_expression')
+        string_expression = string_expression.nil? ? nil : string_expression.text
+        expression_leaf = attr_xml.at 'expression'
+        expression = send expression_leaf.attributes['type'].text.downcase, expression_leaf
+        [OpenEHR::AM::Archetype::Assertion::Assertion.new(tag: tag, expression: expression, string_expression: string_expression)]
+      end
+
+      def expr_binary_operator(attr_xml)
+        type = attr_xml.at('type').text
+        operator = OpenEHR::AM::Archetype::Assertion::OperatorKind.new(value: attr_xml.at('operator').text.to_i)
+
+        precedence_overridden = attr_xml.at('precedence_overridden').text == 'true' ? true : false
+        right_operand_leaf = attr_xml.at 'right_operand'
+        right_operand = send right_operand_leaf.attributes['type'].text.downcase, right_operand_leaf
+        left_operand_leaf = attr_xml.at 'left_operand'
+        left_operand = send left_operand_leaf.attributes['type'].text.downcase, left_operand_leaf
+        OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(type: type, operator: operator, precedence_overridden: precedence_overridden, right_operand: right_operand, left_operand: left_operand)
+      end
+
+      def expr_unary_operator(attr_xml)
+        type = attr_xml.at('type').text
+        operator = OpenEHR::AM::Archetype::Assertion::OperatorKind.new(value: attr_xml.at('operator').text.to_i)
+        precedence_overridden = attr_xml.at('precedence_overridden').text == 'true' ? true : false
+        operand_leaf = attr_xml.at 'operand'
+        operand = send operand_leaf.attributes['type'].text.downcase, operand_leaf
+        OpenEHR::AM::Archetype::Assertion::ExprUnaryOperator.new(type: type, operator: operator, precedence_overridden: precedence_overridden, operand: operand)
+      end
+
+      def expr_leaf(attr_xml)
+        type = attr_xml.at('type').text
+        item_leaf = attr_xml.at('item')
+        item = send type.downcase, item_leaf
+        reference_type = attr_xml.at('reference_type').text
+        OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(type: type, item: item, reference_type: reference_type)
+      end
+
+      def c_primitive_object(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        item = send attr_xml.at('item')['type'].downcase, attr_xml.at('item')
+        OpenEHR::AM::Archetype::ConstraintModel::CPrimitiveObject.new(rm_type_name: rm_type_name, occurrences: occurrences, node_id: node.id, item: item)
+      end
+
+      # Bare-literal ExprLeaf#item readers (type "String"/"Integer"/
+      # "Real"/"Boolean", reference_type "CONSTANT") - distinct from
+      # the C_STRING/C_INTEGER/... constraint-item readers in
+      # xml_primitive_parsing.rb, which are dispatched to for
+      # reference_type "constraint" leaves instead.
+      def string(attr_xml)
+        attr_xml.text
+      end
+
+      def integer(attr_xml)
+        attr_xml.text.to_i
+      end
+
+      def real(attr_xml)
+        attr_xml.text.to_f
+      end
+
+      def boolean(attr_xml)
+        to_bool(attr_xml.text)
+      end
+
+      def to_bool(str)
+        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
+end

data/lib/openehr/parser/xml_domain_type_parsing.rb

@@ -0,0 +1,142 @@
+module OpenEHR
+  module Parser
+    # openEHR Archetype Profile domain-type readers (C_CODE_PHRASE,
+    # C_DV_QUANTITY, C_DV_ORDINAL, C_DV_SCALE, C_DV_STATE), shared
+    # between OPTParser and XMLArchetypeParser. Extracted from
+    # opt_parser.rb without behavior changes, except: C_DV_QUANTITY now
+    # reads assumed_value (previously ignored) and its magnitude range
+    # reads Float bounds instead of Integer (precision stays Integer -
+    # see numeric_interval in xml_constraint_parsing.rb).
+    module XMLDomainTypeParsing
+      private
+
+      def c_code_phrase(attr_xml, node)
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(
+          code_phrase_constraint_args(attr_xml, node)
+        )
+      end
+
+      def c_code_reference(attr_xml, node)
+        args = code_phrase_constraint_args(attr_xml, node)
+        args[:code_list] = nil if args[:code_list] && args[:code_list].empty?
+        uri = attr_xml.at('referenceSetUri')&.text&.strip
+        args[:reference_set_uri] = uri unless uri.nil? || uri.empty?
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodeReference.new(args)
+      end
+
+      def code_phrase_constraint_args(attr_xml, node)
+        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
+
+        {
+          terminology_id: terminology_id,
+          code_list: code_list,
+          path: node.path,
+          occurrences: occurrences_obj,
+          rm_type_name: 'CODE_PHRASE'
+        }
+      end
+
+      # 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_quantity(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        property = property_code_phrase(attr_xml.at('property'))
+        list = attr_xml.xpath('.//list').map { |element| c_quantity_item(element) }
+        assumed_value = dv_quantity_assumed_value(attr_xml.at('assumed_value'))
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvQuantity.new(
+          rm_type_name: rm_type_name, occurrences: occurrences, list: list, property: property, assumed_value: assumed_value
+        )
+      end
+
+      def c_quantity_item(element)
+        units = element.at('units').text if element.at('units')
+        magnitude = numeric_interval(element.at('magnitude'), real: true) if element.at('magnitude')
+        precision = numeric_interval(element.at('precision'), real: false) if element.at('precision')
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CQuantityItem.new(magnitude: magnitude, precision: precision, units: units)
+      end
+
+      # assumed_value is a real DV_QUANTITY (plain magnitude/precision,
+      # not a range), matching XMLSerializer#emit_dv_quantity_assumed_value.
+      def dv_quantity_assumed_value(element)
+        return nil if element.nil?
+
+        units = element.at('units')&.text
+        magnitude_node = element.at('magnitude')
+        magnitude = magnitude_node ? magnitude_node.text.to_f : nil
+        precision_node = element.at('precision')
+        precision = precision_node ? precision_node.text.to_i : nil
+        OpenEHR::RM::DataTypes::Quantity::DvQuantity.new(units: units, magnitude: magnitude, precision: precision)
+      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
+
+      # No .opt fixture in this gem's corpus uses a C_DV_STATE (state
+      # machine) constraint, so its actual OPT XML shape is unverified,
+      # and XMLSerializer itself can't emit one to a standalone
+      # archetype either (ADL 1.4 has no grammar rule for it) - 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
+    end
+  end
+end