openehr 1.2.999999 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b1262bf46aa8257e7bb3aded5078ca794a14febe4b60f258ad515f7b63fb372
-  data.tar.gz: 073635b1014bb231c543566532b6327b9e2c211a95eb0d8f85502e03530b5107
+  metadata.gz: a8b6b9646daa3a967d9addfb4effc70408a402ff746a52fc549bff5ed150593b
+  data.tar.gz: 9390b872a07e6b3e3291489cfd1dc2ef87cc8eb41f3d2906aab829cfeb317937
 SHA512:
-  metadata.gz: cd81e9d640e206637b9cc742294f079627699eb9d93abf243efc9e93141c16db987c5d5ebb7068a5f87cb56f378268ab5606f183646b98e6374f89f5f128e541
-  data.tar.gz: 3505875a5655d03b0657521dae3c657c33db22c0d61db91be7d559de6106d2f24429daa1b1ec9a54292e2d10922ec9d393052e5d5ff7bfcf8bf77d490ac99396
+  metadata.gz: a4d0d99c554e80da635c8d4d4bbbef09c5937dede153582e68793611e4708afac008eef063b2ca4a2b57cb7d25f6e18cf0db0914e9f74bf4463b200dd60a764a
+  data.tar.gz: 2b57b5b3556a2d431e7643936026067438d8d1405a9ad443cc7cd237cc7cd37f9b8dbf83085f3aa4d5407d3e3957a01945664b3e00fffa82299a23ab82387a60

data/README.rdoc

@@ -7,9 +7,9 @@ A Ruby implementation of the openEHR specifications
 
 = Requirements
 
-* Supports CRuby 2.3.6, 2.4.3, 2.5.0  or equivalents.
-* Developed with CRuby 2.5.0 on FreeBSD and Linux.
-* Ruby 2.2 or earlier are no longer supported.
+* Supports CRuby 2.5.0  or later.
+* Developed with CRuby 3.0.0 on FreeBSD and Linux.
+* Ruby 2.4 or earlier are no longer supported.
 
 =Description
 
@@ -34,7 +34,7 @@ This package excludes:
 * Terminology service(moved to openehr-terminology package)
 * Rails plugin(moved to openehr-rails package
 
-Almost all classes passed the test constructed by RSpec2. These spec
+Almost all classes passed the test constructed by RSpec23 These spec
 files are under /spec.
 
 Some specifications are not well determined yet, such as rm/security
@@ -66,7 +66,7 @@ All Rights Reserved.
 
 This product is released under Apache 2.0 license
 
-   Copyright [2012-2018] openEHR Ruby implementation project.
+   Copyright [2012-2020] openEHR Ruby implementation project.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/lib/openehr/am/template.rb

@@ -1,49 +1,80 @@
+require_relative 'archetype'
+
 module OpenEHR
   module AM
     module Template
-      class OperationalTemplate
-        attr_reader :uid, :concept, :language, :description, :template_id, :definition, :component_terminologies
+      # OPERATIONAL_TEMPLATE class represents a "compiled" template derived from 
+      # a source TEMPLATE by a "flattening" process, used for generating and 
+      # validating reference model instance data.
+      # According to openEHR AOM2 specification, it inherits from AUTHORED_ARCHETYPE.
+      class OperationalTemplate < OpenEHR::AM::Archetype::Archetype
+        attr_reader :component_terminologies, :terminology_extracts, :template_id
 
         def initialize(args = {})
-          self.uid = args[:uid]
-          self.concept = args[:concept]
+          # Initialize parent archetype with template-specific archetype_id
+          template_args = args.dup
+          template_args[:archetype_id] = args[:template_id] if args[:template_id] && !args[:archetype_id]
+          
+          super(template_args)
+          
           self.template_id = args[:template_id]
-          self.language = args[:language]
-          self.description = args[:description]
-          self.definition = args[:definition]
-          self.component_terminologies = args[:component_terminologies]
+          self.component_terminologies = args[:component_terminologies] || {}
+          self.terminology_extracts = args[:terminology_extracts] || {}
         end
 
-        def uid=(uid)
-          @uid = uid
+        def template_id=(template_id)
+          if template_id.nil?
+            raise ArgumentError, 'template_id is mandatory for operational template'
+          end
+          @template_id = template_id
+          # Update archetype_id to match template_id for consistency
+          @archetype_id = template_id if template_id
         end
 
-        def concept=(concept)
-          raise ArgumentError if concept.nil?
-          @concept = concept
+        def component_terminologies=(component_terminologies)
+          @component_terminologies = component_terminologies || {}
         end
 
-        def language=(language)
-          @language = language
+        def terminology_extracts=(terminology_extracts)
+          @terminology_extracts = terminology_extracts || {}
         end
 
-        def template_id=(template_id)
-          raise ArgumentError if template_id.nil?
-          @template_id = template_id
+        # Returns true if this is a valid operational template
+        def is_valid_operational_template?
+          return false if template_id.nil?
+          return false if definition.nil?
+          return false if component_terminologies.nil?
+          true
         end
 
-        def description=(description)
-          raise ArgumentError if description.nil?
-          @description=description 
+        # Returns whether the template is specialized (should be true for operational templates)
+        def is_specialized?
+          !parent_archetype_id.nil?
         end
 
-        def definition=(definition)
-          raise ArgumentError if definition.nil?
-          @definition = definition
+        # Get all archetype identifiers referenced in this operational template
+        def referenced_archetype_ids
+          component_terminologies.keys
         end
 
-        def component_terminologies=(component_terminologies)
-          @component_terminologies = component_terminologies
+        # Get terminology for a specific archetype
+        def terminology_for_archetype(archetype_id)
+          component_terminologies[archetype_id]
+        end
+
+        # Override concept to use template concept or fallback to archetype concept
+        def concept
+          @concept || (archetype_id ? archetype_id.concept_name : nil)
+        end
+
+        # Compatibility method for backward compatibility with existing tests
+        def language
+          original_language
+        end
+
+        # Compatibility setter for language (maps to original_language)
+        def language=(language)
+          self.original_language = language
         end
       end
     end

data/lib/openehr/parser/opt_parser.rb

@@ -39,9 +39,24 @@ 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))
         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: create_template_ontology,
+          component_terminologies: @component_terminologies || {},
+          terminology_extracts: @component_terminologies || {},
+          adl_version: "1.4"
+        )
       end
 
       private
@@ -92,6 +107,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 +213,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,20 +245,57 @@ 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
+        
+        # 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')
+        
+        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 constraint_ref(attr_xml, node)
@@ -278,18 +367,56 @@ module OpenEHR
       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_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 +436,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/rm/common/archetyped.rb

@@ -95,7 +95,7 @@ module OpenEHR
           attr_reader :archetype_id, :rm_version
           attr_accessor :template_id
 
-          def initialize(args = { })
+          def initialize(**args)
             self.archetype_id = args[:archetype_id]
             self.rm_version = args[:rm_version]
             self.template_id = args[:template_id]

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

@@ -24,7 +24,6 @@ module URI
       true
     end
   end
-  @@schemes['EHR'] = EHR
 end
 
 module OpenEHR

data/lib/openehr/rm/factory.rb

@@ -8,10 +8,26 @@ module OpenEHR
       end
 
       class << self
-        def create(type, *param)
-          type = type.downcase.camelize if type.include? '_'
-          class_eval("#{type}Factory").create(*param)
+        def create(type, **param)
+          if type.include? '_'
+            type = type.downcase.camelize
+          else
+            type = type.capitalize
+          end
+          class_eval("#{type}Factory").create(params(param))
         end
+
+        def params(param)
+          param.each_with_object({}) do |item, parameters|
+            key = item.shift
+            value = item.shift
+            if value.instance_of? Hash
+              parameters[key] = Factory.create(value[:_type], **value)
+            else
+              parameters[key] = value
+            end
+          end
+        end          
       end
 
       def build
@@ -155,75 +171,140 @@ module OpenEHR
     end
     
     class DvDateFactory
-      def self.create(*param)
-        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDate.new(*param)
+      def self.create(param)
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDate.new(param)
       end
     end
 
     class DvTimeFactory
-      def self.create(*param)
-        DataTypes::Quantity::DateTime::DvTime.new(*param)
+      def self.create(param)
+        DataTypes::Quantity::DateTime::DvTime.new(param)
       end
     end
 
     class DvDateTimeFactory
-      def self.create(*param)
-        DataTypes::Quantity::DateTime::DvDateTime.new(*param)
+      def self.create(param)
+        DataTypes::Quantity::DateTime::DvDateTime.new(param)
       end
     end
 
     class DvDurationFactory
-      def self.create(*param)
-        DataTypes::Quantity::DateTime::DvDuration.new(*param)
+      def self.create(param)
+        DataTypes::Quantity::DateTime::DvDuration.new(param)
       end
     end
 
     class DvEncapsulatedFactory
-      def self.create(*param)
-        DataTypes::Encapsulated::DvEncapsulated.new(*param)
+      def self.create(param)
+        DataTypes::Encapsulated::DvEncapsulated.new(param)
       end
     end
 
     class DvMultimediaFactory
-      def self.create(*param)
-        DataTypes::Encapsulated::DvMultimedia.new(*param)
+      def self.create(param)
+        DataTypes::Encapsulated::DvMultimedia.new(param)
       end
     end
 
     class DvParsableFactory
-      def self.create(*param)
-        DataTypes::Encapsulated::DvParsable.new(*param)
+      def self.create(param)
+        DataTypes::Encapsulated::DvParsable.new(param)
       end
     end
 
     class DvUriFactory
-      def self.create(*param)
-        DataTypes::URI::DvUri.new(*param)
+      def self.create(param)
+        DataTypes::URI::DvUri.new(param)
       end
     end
 
     class DvEhrUriFactory
-      def self.create(*param)
-        DataTypes::URI::DvEhrUri.new(*param)
+      def self.create(param)
+        DataTypes::URI::DvEhrUri.new(param)
       end
     end
 
-    class OBSERVATIONFactory
-      def self.create(*param)
-        Composition::Content::Entry::Observation.new(*param)
+    class ObservationFactory
+      def self.create(param)
+        Composition::Content::Entry::Observation.new(param)
       end
     end
 
-    class SECTIONFactory
-      def self.create(*param)
-        Composition::Content::Navigation::Section.new(*param)
+    class SectionFactory
+      def self.create(param)
+        Composition::Content::Navigation::Section.new(param)
       end
     end
 
-    class CLUSTERFactory
-      def self.create(*param)
-        DataStructures::ItemStructure::Representation::Cluster.new(*param)
+    class ClusterFactory
+      def self.create(param)
+        DataStructures::ItemStructure::Representation::Cluster.new(param)
+      end
+    end
+
+    class ArchetypedFactory
+      def self.create(param)
+        OpenEHR::RM::Common::Archetyped::Archetyped.new(**param)
+      end
+    end
+
+    class ArchetypeIdFactory
+      def self.create(param)
+        OpenEHR::RM::Support::Identification::ArchetypeID.new(param)
+      end
+    end
+
+    class TemplateIdFactory
+      def self.create(param)
+        OpenEHR::RM::Support::Identification::TemplateID.new(param)
+      end
+    end
+
+    class TerminologyIdFactory
+      def self.create(param)
+        OpenEHR::RM::Support::Identification::TerminologyID.new(param)
+      end
+    end
+
+    class GenericIdFactory
+      def self.create(param)
+        OpenEHR::RM::Support::Identification::GenericID.new(param)
+      end
+    end
+
+    class PartyRefFactory
+      def self.create(param)
+        OpenEHR::RM::Support::Identification::PartyRef.new(param)
+      end
+    end
+
+    class PartyIdentifiedFactory
+      def self.create(param)
+        OpenEHR::RM::Common::Generic::PartyIdentified.new(param)
+      end
+    end
+
+    class EventContextFactory
+      def self.create(param)
+        OpenEHR::RM::Composition::EventContext.new(param)
+      end
+    end
+
+    class TermMappingFactory
+      def self.create(param)
+        OpenEHR::RM::DataTypes::Text::TermMapping.new(param)
+      end
+    end
+
+    class CompositionFactory < Factory
+      class << self
+        def create_from_json(json)
+          hash = JSON.parse(json, max_nesting: false, symbolize_names: true)
+          OpenEHR::RM::Composition::Composition.new(params(hash))
+        end
       end
     end
   end
 end
+
+

data/lib/openehr/version.rb

@@ -1,3 +1,3 @@
 module OpenEHR
-  VERSION = "1.2.999999"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openehr
 version: !ruby/object:Gem::Version
-  version: 1.2.999999
+  version: 1.3.0
 platform: ruby
 authors:
 - Shinji KOBAYASHI
@@ -9,10 +9,9 @@ authors:
 - Michael Deryugin
 - Dmitry Lavrov
 - Evgeny Strokov
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -347,7 +346,6 @@ homepage: http://openehr.jp
 licenses:
 - Apache 2.0
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -362,8 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby implementation of the openEHR specification
 test_files: []