openehr 1.2.99999 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9cb803ae534a0b21a6f32f49a6ab67f23e9a2310
-  data.tar.gz: 83f4c97ef8df85d96c2e9a21a19ec75e11e45f78
+SHA256:
+  metadata.gz: a8b6b9646daa3a967d9addfb4effc70408a402ff746a52fc549bff5ed150593b
+  data.tar.gz: 9390b872a07e6b3e3291489cfd1dc2ef87cc8eb41f3d2906aab829cfeb317937
 SHA512:
-  metadata.gz: 2c4ec78adc29711593e9bec0adebffca790c18f5b3dcd9b80dc878347ae5466a841aa0b24df3b6c4f34f9f58ff410477a8df9cfdd1311ca25cbb027d2572054f
-  data.tar.gz: 143ca8d16048c7865ece5de9c8a9d75bebbce386619ac0e3e324ad84b39a2608d6f7726f1e6985ca78a1dcabceb208167aadb47e87afe6ed6a6a90e0821584a7
+  metadata.gz: a4d0d99c554e80da635c8d4d4bbbef09c5937dede153582e68793611e4708afac008eef063b2ca4a2b57cb7d25f6e18cf0db0914e9f74bf4463b200dd60a764a
+  data.tar.gz: 2b57b5b3556a2d431e7643936026067438d8d1405a9ad443cc7cd237cc7cd37f9b8dbf83085f3aa4d5407d3e3957a01945664b3e00fffa82299a23ab82387a60

data/README.rdoc

@@ -7,9 +7,9 @@ A Ruby implementation of the openEHR specifications
 
 = Requirements
 
-* Supports Ruby 1.9.3, 2.0.0, 2.1.0, 2.2.3 or equivalents.
-* Developed with CRuby 2.2.3, 2.0.0, 1.9.3 on FreeBSD and Linux.
-* Ruby 1.8 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-2014] 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/archetype.rb

@@ -100,6 +100,12 @@ module OpenEHR
           return archetype
         end
 
+        def to_rm
+          ::OpenEHR::RM::Factory.create(definition.rm_type_name,
+                                        archetype_node_id: definition.archetype_node_id,
+                                        name: definition
+                                        )
+        end
       end # end of Archetype
       # original file:
       # ref_imple_eiffel/components/adl_parser/src/interface/adl_definition.e

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/adl_grammar.tt

@@ -25,6 +25,10 @@ module OpenEHR
             arch_identification.adl_version
           end
 
+          def uid
+            arch_identification.uid
+          end
+
 	  def concept
 	    arch_concept.value
 	  end
@@ -61,6 +65,10 @@ module OpenEHR
 	    head.value[:adl_version]
 	  end
 
+          def uid
+            head.value[:uid]
+          end
+
           def is_controlled?
             head.value[:is_controlled?]
           end
@@ -89,11 +97,10 @@ module OpenEHR
       end
 
       rule arch_meta_data_items
-        item:arch_meta_data_item other_item:(';' arch_meta_data_item)* {
+        item:arch_meta_data_item other_items:(';' white_space arch_meta_data_item)* {
           def value
 	    v = item.value
-            other_item.elements.map {|i| i.arch_meta_data_item.value}
-            v
+            other_items.elements.map {|m| m.arch_meta_data_item.value }.inject(v, :update)
 	  end
         }
       end
@@ -104,9 +111,14 @@ module OpenEHR
             {:adl_version => ver.value}
           end
         }
+      / SYM_UID SYM_EQ uid:V_HIER_OBJECT space {
+          def value
+            { :uid => uid.value }
+          end
+        }
       / SYM_IS_CONTROLED space {
           def value
-	    {:is_controled? => true} # if elements[0]
+	    { :is_controled? => true } # If elements[0]
           end
         }
       end
@@ -562,7 +574,7 @@ module OpenEHR
               path = node.path + id.value
             elsif node.id
               path = node.path + "[#{node.id}]/" + id.value
-            elsif
+            else
               path = node.path + '/' + id.value
             end
             OpenEHR::AM::Archetype::ConstraintModel::CMultipleAttribute.new(
@@ -578,7 +590,7 @@ module OpenEHR
               path = node.path + id.value
             elsif node.id
               path = node.path + "[#{node.id}]/" + id.value
-            elsif
+            else
               path = node.path + '/' + id.value
             end
             OpenEHR::AM::Archetype::ConstraintModel::CSingleAttribute.new(
@@ -2880,6 +2892,10 @@ module OpenEHR
         [a-zA-Z0-9]
       end
 
+      rule HEXADECIMAL
+        [a-fA-F0-9]
+      end
+
       rule IDCHAR
         [a-zA-Z0-9_]
       end
@@ -3144,6 +3160,10 @@ module OpenEHR
         [Aa] [Dd] [Ll] '_' [Vv] [Ee] [Rr] [Ss] [Ii] [Oo] [Nn] space
       end
 
+      rule SYM_UID
+        [Uu] [Ii] [Dd] space
+      end
+
       rule SYM_IS_CONTROLLED
         [Cc] [Oo] [Nn] [Tt] [Rr] [Oo] [Ll] [Ll] [Ee] [Dd] space
       end
@@ -3208,6 +3228,14 @@ module OpenEHR
         }
       end
 
+      rule V_HIER_OBJECT
+        HEXADECIMAL 8..8 '-' (HEXADECIMAL 4..4 '-') 3..3 HEXADECIMAL 12..12 {
+          def value
+            text_value
+          end
+        }
+      end   
+
       rule V_URI
         [a-z]+ '://' [^<>|\\{}^~"\[\] ]* { 
           def value
@@ -3353,7 +3381,7 @@ module OpenEHR
           end
         }
       end
-
+                                                             
       rule V_CHAR
         [^\\\n\"] {
           def value

data/lib/openehr/parser/adl_parser.rb

@@ -25,7 +25,7 @@ module OpenEHR
 
       def parsed_data
         filestream = File.open(@filename, 'rb:bom|utf-8')
-        @parsed_data ||= adl_grammar_parser.parse(filestream.read)
+        @parsed_data ||= adl_grammar_parser.parse(filestream.read.scrub)
         filestream.close
         unless @parsed_data
           puts adl_grammar_parser.failure_reason
@@ -59,6 +59,10 @@ module OpenEHR
         parsed_data.adl_version
       end
 
+      def uid
+        OpenEHR::RM::Support::Identification::HierObjectID.new(value: parsed_data.uid) if parsed_data.uid
+      end
+
       def concept
         parsed_data.concept
       end
@@ -78,6 +82,7 @@ module OpenEHR
       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,

data/lib/openehr/parser/opt_parser.rb

@@ -27,6 +27,8 @@ module OpenEHR
         '/template/description/details/misuse'
       DESC_DETAILS_COPYRIGHT_PATH =
         '/template/description/details/copyright'
+      DESC_OTHER_DETAILS_PATH =
+        '/template/description/other_details'
       DEFINITION_PATH = '/template/definition'
       OCCURRENCE_PATH = '/occurrences'
       
@@ -37,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
@@ -59,7 +76,7 @@ module OpenEHR
       def description
         original_author = text_on_path(@opt, DESC_ORIGINAL_AUTHOR_PATH)
         lifecycle_state = text_on_path(@opt, DESC_LIFECYCLE_STATE_PATH)
-        OpenEHR::RM::Common::Resource::ResourceDescription.new(original_author: original_author, lifecycle_state: lifecycle_state, details: [description_details])
+        OpenEHR::RM::Common::Resource::ResourceDescription.new(original_author: original_author, lifecycle_state: lifecycle_state, details: [description_details], other_details: description_other_details)
       end
 
       def description_details
@@ -73,15 +90,15 @@ module OpenEHR
         OpenEHR::RM::Common::Resource::ResourceDescriptionItem.new(language: language, purpose: purpose, keywords: keywords, use: use, misuse: misuse, copyright: copyright)
       end
 
+      def description_other_details
+        @opt.xpath(DESC_OTHER_DETAILS_PATH).inject({}) do |hash, detail|
+          hash[detail.attributes['id'].value] = detail.text
+          hash
+        end
+      end
+
       def definition
-        root_rm_type = text_on_path(@opt, DEFINITION_PATH + '/rm_type_name')
-        root_node = Node.new
-        root_node.id = text_on_path(@opt, DEFINITION_PATH + '/node_id')
-        root_occurrences = occurrences(@opt.xpath(DEFINITION_PATH + OCCURRENCE_PATH))
-        root_archetype_id = OpenEHR::RM::Support::Identification::ArchetypeID.new(value: text_on_path(@opt, DEFINITION_PATH+'/archetype_id/value'))
-        root_node.path = "/[#{root_archetype_id.value}]"
-        component_terminologies(root_archetype_id, @opt.xpath(DEFINITION_PATH))
-        OpenEHR::AM::Archetype::ConstraintModel::CArchetypeRoot.new(rm_type_name: root_rm_type, node_id: root_node.id, path: root_node.path, occurrences: root_occurrences, archetype_id: root_archetype_id, attributes: attributes(@opt.xpath(DEFINITION_PATH+'/attributes'), root_node))
+        c_archetype_root @opt.xpath(DEFINITION_PATH)
       end
 
       def component_terminologies(archetype_id, nodes)
@@ -90,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]
@@ -111,12 +152,6 @@ module OpenEHR
         { language.code_string => term_items }
       end
 
-      def children(children_xml, node)
-        children_xml.map do |child|
-          send child.attributes['type'].text.downcase, child, node
-        end
-      end
-
       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')
@@ -124,9 +159,9 @@ module OpenEHR
         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 = "/[#{archetype_id.value}]"
-        else
-          node.path += "/[#{archetype_id.value}]"
+          node.path = "/"
+        # else
+        #   node.path += "/"  #"/[#{archetype_id.value}]"
         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))
@@ -137,55 +172,64 @@ module OpenEHR
         node_id = xml.xpath('./node_id').text
         unless node_id.nil? or node_id.empty?
           node.id = node_id
-          node.path += "[#{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|
-          send attr.attributes['type'].text.downcase, attr, node
+          rm_attribute_name = attr.at('rm_attribute_name').text
+          if node.root?
+            path = "/#{rm_attribute_name}"
+          # elsif node.id
+          #   path = "#{node.path}[#{node.id}]/#{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
+
+      def children(children_xml, node)
+        children_xml.map do |child|
+          send child.attributes['type'].text.downcase, child, node
         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'))
-        if node.root?
-          path = "/#{rm_attribute_name}"
-        elsif node.id
-          path = "#{node.path}[#{node.id}]/#{rm_attribute_name}"
-        else
-          path = "#{node.path}/#{rm_attribute_name}"
-        end
-        child_node = Node.new(node)
-        child_node.path = node.path
-        child_node.id = node.id
-        OpenEHR::AM::Archetype::ConstraintModel::CSingleAttribute.new(rm_attribute_name: rm_attribute_name, existence: existence, path: path, children: children(attr_xml.xpath('./children'), child_node))
+        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'))
-        if node.root?
-          path = "/#{rm_attribute_name}"
-        elsif node.id
-          path = "#{node.path}[#{node.id}]/#{rm_attribute_name}"
-        else
-          path = "#{node.path}/#{rm_attribute_name}"
-        end
-        child_node = Node.new(node)
-        child_node.path = node.path
-        child_node.id = node.id
-        OpenEHR::AM::Archetype::ConstraintModel::CMultipleAttribute.new(rm_attribute_name: rm_attribute_name, existence: existence, path: path, children: children(attr_xml.xpath('./children'), child_node))
+        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 c_code_phrase(attr_xml, node)
-        terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: attr_xml.at('terminology_id/value').text.strip)
-        path = node.path
-        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: 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)
@@ -201,15 +245,59 @@ 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)
+        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)
         rm_type_name = attr_xml.at('rm_type_name').text
         reference = attr_xml.at('reference').text
@@ -248,12 +336,19 @@ module OpenEHR
       def c_primitive_object(attr_xml, node)
         rm_type_name = attr_xml.at('rm_type_name').text
         occurrences = occurrences(attr_xml.at('occurrences'))
-        OpenEHR::AM::Archetype::ConstraintModel::CPrimitiveObject.new(rm_type_name: rm_type_name, occurrences: occurrences, node_id: node.id)
+        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
-      
+
       def c_string(attr_xml)
-        pattern = attr_xml.at('pattern').text
-        OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(pattern: pattern)
+        if attr_xml.at('pattern')
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(pattern: attr_xml.at('pattern').text)
+        else
+          list = attr_xml.xpath('.//list').map do |str|
+            str.text
+          end
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(list: list)
+        end
       end
 
       def c_dv_quantity(attr_xml, node)
@@ -271,6 +366,59 @@ 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)
+        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)
         attr_xml.text
       end
@@ -288,12 +436,11 @@ module OpenEHR
       end
 
       def to_bool(str)
-        if str =~ /true/i
-          return true
-        elsif str =~ /false/i
-          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/basic.rb

@@ -31,9 +31,13 @@ module OpenEHR
 
           def value=(value)
             raise ArgumentError, "value must not be nil" if value.nil?
-            if value == true or value =~ /TRUE/i
+            if value == true
               @value = true
-            else
+            elsif  value == false
+              @value = false
+            elsif /TRUE/i =~ value
+              @value = true
+            elsif /FALSE/i =~ value
               @value = false
             end
           end

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

@@ -3,9 +3,56 @@ require 'active_support/inflector'
 module OpenEHR
   module RM
     class Factory
-      def self.create(type, *param)
-        type = type.downcase.camelize if type.include? '_'
-        class_eval("#{type}Factory").create(*param)
+      def initialize(cobject)
+        @cobject = cobject
+      end
+
+      class << self
+        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
+        Factory.create(type, params)
+      end
+
+      private
+      def type
+        @cobject.rm_type_name
+      end
+
+      def name
+        OpenEHR::RM::DataTypes::Text::DvText.new(value: ' ')
+      end
+
+      def params
+        @cobject.attributes.inject({}) do |hash, attribute|
+          if attribute.children
+            hash[attribute.rm_attribute_name.to_sym] =
+              attribute.children.map { |child| Factory.new(child).build }
+          end
+          hash
+        end.merge(
+        { archetype_node_id: @cobject.node_id,
+          occurrences: @cobject.occurrences })
       end
     end
 
@@ -124,63 +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)
+      end
+    end
+
+    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/rm.rb

@@ -42,6 +42,5 @@ require_relative 'rm/demographic'
 #Integration Information Model
 require_relative 'rm/integration'
 
-
+#factory and builder
 require_relative 'rm/factory'
-

data/lib/openehr/serializer.rb

@@ -14,6 +14,10 @@ module OpenEHR
       def serialize
         return self.merge
       end
+
+      private
+      def merge
+      end
     end
 
     class ADLSerializer < BaseSerializer
@@ -249,6 +253,22 @@ module OpenEHR
         return archetype
       end
     end
+
+    class OPTSerializer < BaseSerializer
+      def initialize(opt, format:)
+        @opt = OpenEHR::Parser::OPTParser.new(opt).parse
+      end
+
+      def name
+        @opt.definition.archetype_id.concept_name
+      end
+
+      def header
+
+      end
+
+
+    end
   end
 end
 

data/lib/openehr/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openehr
 version: !ruby/object:Gem::Version
-  version: 1.2.99999
+  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: 2015-10-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -211,7 +210,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard-spork
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -225,7 +224,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: libnotify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -239,7 +238,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: libnotify
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: meowcop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: better_errors
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -319,7 +346,6 @@ homepage: http://openehr.jp
 licenses:
 - Apache 2.0
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -334,9 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby implementation of the openEHR specification
 test_files: []