openehr 1.3.0 → 2.0.0

data/lib/openehr/rm/factory.rb

@@ -80,12 +80,6 @@ module OpenEHR
       end
     end
 
-    class TermMappingFactory
-      def self.create(*param)
-        OpenEHR::RM::DataTypes::Text::TermMapping.new(*param)
-      end
-    end
-
     class CodePhraseFactory
       def self.create(*param)
         OpenEHR::RM::DataTypes::Text::CodePhrase.new(*param)
@@ -128,6 +122,12 @@ module OpenEHR
       end
     end
 
+    class DvScaleFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DvScale.new(*param)
+      end
+    end
+
     class DvQuantifiedFactory
       def self.create(*param)
         DataTypes::Quantity::DvQuantified.new(*param)
@@ -296,6 +296,234 @@ module OpenEHR
       end
     end
 
+    class ElementFactory
+      def self.create(param)
+        DataStructures::ItemStructure::Representation::Element.new(param)
+      end
+    end
+
+    class ItemTreeFactory
+      def self.create(param)
+        DataStructures::ItemStructure::ItemTree.new(param)
+      end
+    end
+
+    class ItemListFactory
+      def self.create(param)
+        DataStructures::ItemStructure::ItemList.new(param)
+      end
+    end
+
+    class ItemSingleFactory
+      def self.create(param)
+        DataStructures::ItemStructure::ItemSingle.new(param)
+      end
+    end
+
+    class ItemTableFactory
+      def self.create(param)
+        DataStructures::ItemStructure::ItemTable.new(param)
+      end
+    end
+
+    class HistoryFactory
+      def self.create(param)
+        DataStructures::History::History.new(param)
+      end
+    end
+
+    class EventFactory
+      def self.create(param)
+        DataStructures::History::Event.new(param)
+      end
+    end
+
+    class PointEventFactory
+      def self.create(param)
+        DataStructures::History::PointEvent.new(param)
+      end
+    end
+
+    class IntervalEventFactory
+      def self.create(param)
+        DataStructures::History::IntervalEvent.new(param)
+      end
+    end
+
+    class EvaluationFactory
+      def self.create(param)
+        Composition::Content::Entry::Evaluation.new(param)
+      end
+    end
+
+    class InstructionFactory
+      def self.create(param)
+        Composition::Content::Entry::Instruction.new(param)
+      end
+    end
+
+    class ActionFactory
+      def self.create(param)
+        Composition::Content::Entry::Action.new(param)
+      end
+    end
+
+    class ActivityFactory
+      def self.create(param)
+        Composition::Content::Entry::Activity.new(param)
+      end
+    end
+
+    class AdminEntryFactory
+      def self.create(param)
+        Composition::Content::Entry::AdminEntry.new(param)
+      end
+    end
+
+    class InstructionDetailsFactory
+      def self.create(param)
+        Composition::Content::Entry::InstructionDetails.new(param)
+      end
+    end
+
+    class IsmTransitionFactory
+      def self.create(param)
+        Composition::Content::Entry::IsmTransition.new(param)
+      end
+    end
+
+    class GenericEntryFactory
+      def self.create(param)
+        Integration::GenericEntry.new(param)
+      end
+    end
+
+    class PartySelfFactory
+      def self.create(param)
+        Common::Generic::PartySelf.new(param)
+      end
+    end
+
+    class PartyRelatedFactory
+      def self.create(param)
+        Common::Generic::PartyRelated.new(param)
+      end
+    end
+
+    class ParticipationFactory
+      def self.create(param)
+        Common::Generic::Participation.new(param)
+      end
+    end
+
+    class LinkFactory
+      def self.create(param)
+        Common::Archetyped::Link.new(param)
+      end
+    end
+
+    class FeederAuditFactory
+      def self.create(param)
+        Common::Archetyped::FeederAudit.new(param)
+      end
+    end
+
+    class AuditDetailsFactory
+      def self.create(param)
+        Common::Generic::AuditDetails.new(param)
+      end
+    end
+
+    class AttestationFactory
+      def self.create(param)
+        Common::Generic::Attestation.new(param)
+      end
+    end
+
+    class ObjectRefFactory
+      def self.create(param)
+        Support::Identification::ObjectRef.new(param)
+      end
+    end
+
+    class LocatableRefFactory
+      def self.create(param)
+        Support::Identification::LocatableRef.new(param)
+      end
+    end
+
+    class ObjectVersionIdFactory
+      def self.create(param)
+        Support::Identification::ObjectVersionID.new(param)
+      end
+    end
+
+    class HierObjectIdFactory
+      def self.create(param)
+        Support::Identification::HierObjectID.new(param)
+      end
+    end
+
+    class UidBasedIdFactory
+      def self.create(param)
+        Support::Identification::UIDBasedID.new(param)
+      end
+    end
+
+    class AccessGroupRefFactory
+      def self.create(param)
+        Support::Identification::AccessGroupRef.new(param)
+      end
+    end
+
+    class PersonFactory
+      def self.create(param)
+        Demographic::Person.new(param)
+      end
+    end
+
+    class OrganisationFactory
+      def self.create(param)
+        Demographic::Organisation.new(param)
+      end
+    end
+
+    class RoleFactory
+      def self.create(param)
+        Demographic::Role.new(param)
+      end
+    end
+
+    class PartyIdentityFactory
+      def self.create(param)
+        Demographic::PartyIdentity.new(param)
+      end
+    end
+
+    class ContactFactory
+      def self.create(param)
+        Demographic::Contact.new(param)
+      end
+    end
+
+    class AddressFactory
+      def self.create(param)
+        Demographic::Address.new(param)
+      end
+    end
+
+    class CapabilityFactory
+      def self.create(param)
+        Demographic::Capability.new(param)
+      end
+    end
+
+    class PartyRelationshipFactory
+      def self.create(param)
+        Demographic::PartyRelationship.new(param)
+      end
+    end
+
     class CompositionFactory < Factory
       class << self
         def create_from_json(json)

data/lib/openehr/rm/integration.rb

@@ -9,6 +9,7 @@ module OpenEHR
     module Integration
       class GenericEntry < OpenEHR::RM::Composition::Content::ContentItem
         attr_reader :data
+        path_attribute :data
 
         def initialize(args = { })
           super(args)

data/lib/openehr/rm/support/identification.rb

@@ -68,7 +68,7 @@ module OpenEHR
           end
 
           def value=(value)
-            if /([a-zA-Z]\w+)-([a-zA-Z]\w+)-([a-zA-Z]\w+)\.([a-zA-Z]\w+)(-([a-zA-Z]\w+))?\.(v[1-9]\d*)/ =~ value
+            if /\A([a-zA-Z]\w+)-([a-zA-Z]\w+)-([a-zA-Z]\w+)\.([a-zA-Z]\w+)(-([a-zA-Z]\w+))?\.(v\d+)\z/ =~ value
               self.rm_originator = $1
               self.rm_name = $2
               self.rm_entity = $3
@@ -108,7 +108,7 @@ module OpenEHR
             if domain_concept.nil? or domain_concept.empty?
               raise ArgumentError, "domain concept not valid"
             end
-            if /([a-zA-Z]\w+)(-([a-zA-Z]\w))?/ =~ domain_concept
+            if /\A([a-zA-Z]\w+)(-([a-zA-Z]\w+))?\z/ =~ domain_concept
               self.concept_name = $1
               self.specialisation = $3
             else
@@ -249,6 +249,8 @@ module OpenEHR
               self.objectid = UID.new(:value => $1)
               self.creating_system_id = UID.new(:value => $2)
               self.version_tree_id = VersionTreeID.new(:value => $3)
+              @root = @oid
+              @extension = @creating_system_id.value + '::' + @version_tree_id.value
             else
               raise ArgumentError, 'invalid format'
             end
@@ -297,12 +299,14 @@ module OpenEHR
           end
 
           def path=(path)
-            raise ArgumentError if path.nil? or path.empty?
+            raise ArgumentError if !path.nil? and path.empty?
             @path = path
           end
 
           def as_uri
-            'ehr://' + @id.value + '/' + @path
+            uri = 'ehr://' + @id.value
+            uri += '/' + @path unless @path.nil?
+            uri
           end
         end
 
@@ -395,16 +399,41 @@ module OpenEHR
         end
 
         class UUID < UID
+          FORMAT = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
 
+          def value=(value)
+            unless value.is_a?(String) && value =~ FORMAT
+              raise ArgumentError, 'invalid UUID form'
+            end
+            super
+          end
         end
 
-        class InternetID <UID
-          
+        class InternetID < UID
+          # RFC 1034 domain-name form: dot-separated labels, each
+          # alphanumeric (with internal hyphens allowed).
+          FORMAT = /\A[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+\z/
+
+          def value=(value)
+            unless value.is_a?(String) && value =~ FORMAT
+              raise ArgumentError, 'invalid internet id form'
+            end
+            super
+          end
         end
 
-        class IsoOID <UID
+        class IsoOID < UID
+          # ISO/IEC 8824 OID form: a dot-separated sequence of
+          # non-negative integers, e.g. "1.2.840.113619.2.1".
+          FORMAT = /\A\d+(\.\d+)+\z/
 
-        end        
+          def value=(value)
+            unless value.is_a?(String) && value =~ FORMAT
+              raise ArgumentError, 'invalid ISO OID form'
+            end
+            super
+          end
+        end
       end # of Identification
     end # of Support
   end # of RM

data/lib/openehr/rm/support/measurement.rb

@@ -2,7 +2,39 @@ module OpenEHR
   module RM
     module Support
       module Measurement
+        # A minimal UCUM-lite syntactic checker, not a full UCUM
+        # parser/conversion table: it validates that a units string is
+        # *shaped* like a UCUM unit (allowed characters, balanced
+        # brackets) and treats "equivalent" as exact string equality of
+        # two syntactically-valid units strings. It does not perform
+        # unit conversion (e.g. "kg" and "1000g" are not recognized as
+        # equivalent).
         class MeasurementService
+          UCUM_LITE_PATTERN = /\A[A-Za-z0-9%\/.*\[\]{}'_-]+\z/
+
+          def self.is_valid_units_string?(units)
+            return false unless units.is_a?(String) && !units.empty?
+            return false unless units =~ UCUM_LITE_PATTERN
+
+            balanced_brackets?(units, '[', ']') && balanced_brackets?(units, '{', '}')
+          end
+
+          def self.units_equivalent?(units1, units2)
+            return false unless is_valid_units_string?(units1) && is_valid_units_string?(units2)
+
+            units1 == units2
+          end
+
+          def self.balanced_brackets?(str, open, close)
+            depth = 0
+            str.each_char do |c|
+              depth += 1 if c == open
+              depth -= 1 if c == close
+              return false if depth.negative?
+            end
+            depth.zero?
+          end
+          private_class_method :balanced_brackets?
         end
         module ExternalEnvironmentAccess
           def eea_terminology_svc

data/lib/openehr/rm/type_name.rb

@@ -0,0 +1,90 @@
+require 'set'
+require 'active_support/core_ext/string/inflections'
+
+module OpenEHR
+  module RM
+    module TypeName
+      module_function
+
+      def type_name_of(class_or_instance)
+        class_of(class_or_instance).name.split('::').last.underscore.upcase
+      end
+
+      def class_for(type_name)
+        registry[normalize(type_name)]
+      end
+
+      def subtype_of?(class_or_instance, type_name)
+        expected = normalize(type_name)
+        ancestor = class_of(class_or_instance)
+        while ancestor
+          return true if ancestor.name && type_name_of(ancestor) == expected
+
+          ancestor = ancestor.superclass
+        end
+        false
+      end
+
+      # Accepts a spec type name in any of its forms seen across this
+      # codebase - UPPER_SNAKE ('DV_QUANTITY', from the ADL/OPT
+      # parsers), CamelCase ('DvQuantity', hardcoded by some
+      # CDomainType constructors) or lower_snake - and normalises to
+      # the UPPER_SNAKE form used as the registry key.
+      def normalize(type_name)
+        type_name.to_s.underscore.upcase
+      end
+      private_class_method :normalize
+
+      def class_of(class_or_instance)
+        class_or_instance.is_a?(Module) ? class_or_instance : class_or_instance.class
+      end
+      private_class_method :class_of
+
+      def registry
+        @registry ||= build_registry
+      end
+      private_class_method :registry
+
+      # Skips Factory (OpenEHR::RM::Factory and the *Factory helper
+      # classes in factory.rb) - those are builders, not RM types, and
+      # would otherwise shadow nothing but add registry noise.
+      def build_registry
+        classes = {}
+        visit(OpenEHR::RM, Set.new.compare_by_identity) do |klass|
+          next if klass.name.end_with?('Factory')
+
+          classes[type_name_of(klass)] ||= klass
+        end
+        classes
+      end
+      private_class_method :build_registry
+
+      def visit(mod, seen, &block)
+        mod.constants(false).each do |const_name|
+          const = mod.const_get(const_name)
+          next unless const.is_a?(Module)
+          next if seen.include?(const)
+
+          seen << const
+          yield const if const.is_a?(Class)
+          visit(const, seen, &block)
+        end
+      end
+      private_class_method :visit
+    end
+
+    class << self
+      def type_name_of(class_or_instance)
+        TypeName.type_name_of(class_or_instance)
+      end
+
+      def class_for(type_name)
+        TypeName.class_for(type_name)
+      end
+
+      def subtype_of?(class_or_instance, type_name)
+        TypeName.subtype_of?(class_or_instance, type_name)
+      end
+    end
+  end
+end

data/lib/openehr/rm.rb

@@ -44,3 +44,6 @@ require_relative 'rm/integration'
 
 #factory and builder
 require_relative 'rm/factory'
+
+#RM type name <-> class lookup
+require_relative 'rm/type_name'