openehr 2.0.2 → 2.3.0

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

@@ -11,7 +11,8 @@ module OpenEHR
 
         class DvOrdered < OpenEHR::RM::DataTypes::Basic::DataValue
           include Comparable
-          attr_accessor :normal_range, :other_reference_ranges, :normal_status
+          attr_accessor :normal_range, :normal_status
+          attr_reader :other_reference_ranges
 
           def initialize(args = {})
             super(args)
@@ -236,23 +237,27 @@ module OpenEHR
             unless self.is_strictly_comparable_to? other
               raise ArgumentError, 'type mismatch'
             end
-            result = self.dup
-            result.magnitude = @magnitude + other.magnitude
-            return result
+            build_arithmetic_result(magnitude + other.magnitude)
           end
 
           def -(other)
-            negated = other.dup
-            negated.magnitude = -other.magnitude
-            self + negated
+            unless self.is_strictly_comparable_to? other
+              raise ArgumentError, 'type mismatch'
+            end
+            build_arithmetic_result(magnitude - other.magnitude)
           end
 
           def -@
-            negated = self.dup
-            negated.magnitude = -magnitude
-            negated
+            build_arithmetic_result(-magnitude)
           end
 
+          def multiply(factor)
+            raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+            build_arithmetic_result(magnitude * factor)
+          end
+          alias * multiply
+
           def set_accuracy(accuracy, accuracy_percent)
             if accuracy_percent
               raise ArgumentError, 'accuracy invalid' unless self.class.valid_percentage(accuracy)
@@ -269,6 +274,20 @@ module OpenEHR
           def self.valid_percentage(number)
             number >= 0.0 && number <= 100.0
           end
+
+          private
+
+          # Overridable hook used by +/-/-@/multiply: reconstructs the
+          # result from a new magnitude via dup + magnitude=. Works for
+          # any subclass whose magnitude is ivar-backed (DvQuantity,
+          # DvCount). DvProportion's magnitude is derived from
+          # numerator/denominator instead, so it overrides +/-@/multiply
+          # directly rather than relying on this hook.
+          def build_arithmetic_result(new_magnitude)
+            result = dup
+            result.magnitude = new_magnitude
+            result
+          end
         end
 
         class DvQuantity < DvAmount
@@ -445,6 +464,43 @@ module OpenEHR
               return false
             end
           end
+
+          # DvProportion's magnitude is derived from numerator/denominator
+          # rather than ivar-backed, so it cannot use DvAmount's default
+          # build_arithmetic_result (magnitude=-based reconstruction) -
+          # +/-@/multiply are overridden here at the numerator/denominator
+          # level instead. Only same-denominator addition/subtraction is
+          # well-defined without inventing a fraction-normalization
+          # policy beyond what the RM specifies.
+          def +(other)
+            unless is_strictly_comparable_to?(other) && denominator == other.denominator
+              raise ArgumentError, 'type mismatch: proportions must share type and denominator'
+            end
+            build_arithmetic_result(numerator + other.numerator)
+          end
+
+          def -(other)
+            self + (-other)
+          end
+
+          def -@
+            build_arithmetic_result(-numerator)
+          end
+
+          def multiply(factor)
+            raise ArgumentError, 'factor must be Numeric' unless factor.is_a?(Numeric)
+
+            build_arithmetic_result(numerator * factor)
+          end
+          alias * multiply
+
+          private
+
+          def build_arithmetic_result(new_numerator)
+            result = dup
+            result.numerator = new_numerator
+            result
+          end
         end # end of DvProportion
       end # of Quantity
     end # of Data_Types

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

@@ -1,5 +1,6 @@
 # This module is related to the ticket #47
 require_relative 'basic'
+require_relative 'quantity/date_time'
 
 module OpenEHR
   module RM
@@ -8,19 +9,24 @@ module OpenEHR
         class DvTimeSpecification < OpenEHR::RM::DataTypes::Basic::DataValue
           attr_reader :value
 
-          def initialize(value)
-            self.value=(value)
-          end
-
           def value=(value)
             raise ArgumentError, 'value must be not nil' if value.nil?
+            unless value.respond_to?(:formalism) && value.respond_to?(:value)
+              raise ArgumentError, 'value must be a DV_PARSABLE'
+            end
             @value = value
           end
-          
+
           def calendar_alignment
             raise NotImplementedError, "calendar_alignment must be implemented"
           end
-          alias calender_alignment calendar_alignment
+
+          # Legacy misspelling, deliberately kept (pinned by spec). Defined
+          # as a delegating method rather than `alias` so a subclass
+          # override of calendar_alignment is still reached through it.
+          def calender_alignment
+            calendar_alignment
+          end
 
           def event_alignment
             raise NotImplementedError, "event_alignment must be implemented"
@@ -35,39 +41,107 @@ module OpenEHR
 # because I could not obtain HL7 specification related them.
 
         class DvGeneralTimeSpecification < DvTimeSpecification
-          attr_reader :value
-          def initialize(value)
-            super(value)
-          end
+          FORMALISM = 'HL7:GTS'
+
           def value=(value)
-            raise ArgumentError, "value is not valied" unless value.formalism.is_equal?('HL7:GTS')
-            @value = value
-          end
-          private
-          def value_valid(value)
+            unless value.respond_to?(:formalism) && value.formalism == FORMALISM
+              raise ArgumentError, "formalism must be #{FORMALISM}"
+            end
+            super
           end
+          # calendar_alignment / event_alignment / institution_specified
+          # remain NotImplementedError (inherited from DvTimeSpecification):
+          # deriving them requires parsing the full HL7 GTS set-algebra
+          # (union/intersection/exclusion of interval sets), which is
+          # explicitly out of scope here.
         end
 
         class DvPeriodicTimeSpecification < DvTimeSpecification
-          attr_reader :value, :calender_alignment, :event_alingment, :period
-          def initialize(value)
-            value_valid(value)
-            super(value)
-          end
+          PIVL_FORMALISM = 'HL7:PIVL'
+          EIVL_FORMALISM = 'HL7:EIVL'
+
+          # Single-literal PIVL: [phase_low(;phase_high)?]/(period)@ALIGN? IST?
+          # e.g. "[200004181100;200004181110]/(7d)@DW IST"
+          PIVL_PATTERN = %r{\A\[(?<phase_low>\d+)(?:;(?<phase_high>\d+))?\]/
+                            \((?<period>\d+(?:\.\d+)?)(?<unit>[a-z]+)\)
+                            (?:@(?<alignment>[A-Z]{2}))?(?<ist>\ ?IST)?\z}x
+
+          # Single-literal EIVL: EVENT([+-]offset)? e.g. "ACM+10min"
+          EIVL_PATTERN = /\A(?<event>[A-Z]+)(?:(?<sign>[+-])(?<offset>\d+(?:\.\d+)?)(?<unit>[a-z]+))?\z/
+
+          # HL7 CalendarCycle codes (DW=day of week, HD=hour of day, ...)
+          CALENDAR_CYCLE_CODES = %w[CY MY CM CW WY DM CD DY DW HD CH NH CN SN CS].freeze
+          # HL7 TimingEvent codes (HS=bedtime, ACM=before breakfast, ...)
+          TIMING_EVENT_CODES = %w[HS WAKE C CM CD CV AC ACM ACD ACV PC PCM PCD PCV].freeze
+          # HL7 physical-quantity time units -> ISO8601 duration templates
+          PERIOD_UNIT_TO_ISO8601 = { 's' => 'PT%sS', 'min' => 'PT%sM', 'h' => 'PT%sH',
+                                     'd' => 'P%sD', 'wk' => 'P%sW', 'mo' => 'P%sM',
+                                     'a' => 'P%sY' }.freeze
+
+          attr_reader :period, :calendar_alignment, :event_alignment
+
           def value=(value)
-            unless value.formalism.is_equal('HL7:PIVL') or value.formalism.is_equal('HL7:EIVL')
-              raise ArgumentError, "value is not valid"
+            unless value.respond_to?(:formalism) &&
+                   [PIVL_FORMALISM, EIVL_FORMALISM].include?(value.formalism)
+              raise ArgumentError, "formalism must be #{PIVL_FORMALISM} or #{EIVL_FORMALISM}"
+            end
+            if value.formalism == PIVL_FORMALISM
+              parse_pivl(value.value)
+            else
+              parse_eivl(value.value)
             end
-            if value.formalism('HL7:PIVL')
-              /^\[(\d+)\;?(\d+)?\]\/\((\d+\w+)\)(@(\w+?))?(IST)?$/ =~ value
-              interval1, interval2, difference, allignment = $1, $2, $3, $5
+            super
+          end
+
+          def institution_specified
+            @institution_specified
+          end
+          alias institution_specified? institution_specified
+
+          private
+
+          def parse_pivl(raw)
+            match = PIVL_PATTERN.match(raw)
+            raise ArgumentError, 'value does not match HL7:PIVL syntax' unless match
+
+            unit = match[:unit]
+            unless PERIOD_UNIT_TO_ISO8601.key?(unit)
+              raise ArgumentError, "unknown HL7 PIVL period unit #{unit.inspect}"
             end
-            if value
+
+            alignment = match[:alignment]
+            if alignment && !CALENDAR_CYCLE_CODES.include?(alignment)
+              raise ArgumentError, "unknown HL7 CalendarCycle code #{alignment.inspect}"
             end
+
+            @period = DataTypes::Quantity::DateTime::DvDuration.new(:value => period_from(match[:period], unit))
+            @calendar_alignment = alignment
+            @event_alignment = nil
+            @institution_specified = !match[:ist].nil?
           end
 
-          def institution_specified?
+          def parse_eivl(raw)
+            match = EIVL_PATTERN.match(raw)
+            raise ArgumentError, 'value does not match HL7:EIVL syntax' unless match
+
+            event = match[:event]
+            unless TIMING_EVENT_CODES.include?(event)
+              raise ArgumentError, "unknown HL7 TimingEvent code #{event.inspect}"
+            end
+
+            unit = match[:unit]
+            if unit && !PERIOD_UNIT_TO_ISO8601.key?(unit)
+              raise ArgumentError, "unknown HL7 EIVL offset unit #{unit.inspect}"
+            end
+
+            @event_alignment = event
+            @calendar_alignment = nil
+            @period = nil
+            @institution_specified = false
+          end
 
+          def period_from(quantity, unit)
+            format(PERIOD_UNIT_TO_ISO8601[unit], quantity)
           end
         end
       end

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

@@ -31,10 +31,6 @@ module OpenEHR
     module DataTypes
       module URI
         class DvUri < OpenEHR::RM::DataTypes::Basic::DataValue
-          def initialize(args = {})
-            self.value = args[:value]
-          end
-
           def value
             @value
           end
@@ -69,10 +65,6 @@ module OpenEHR
         end
 
         class DvEhrUri < DvUri
-          def initialize(value)
-            super
-          end
-
           def value=(value)
             raise ArgumentError, "scheme must be ehr" if !(value =~ /^ehr/i)
             parse(value)

data/lib/openehr/rm/ehr.rb

@@ -45,6 +45,8 @@ module OpenEHR
           @time_created = time_created
         end
 
+        # contributions is optional (0..1) since RM 1.1.0 (was mandatory
+        # pre-1.1.0).
         def contributions=(contributions)
           unless contributions.nil?
             contributions.each do |contrib|
@@ -52,10 +54,8 @@ module OpenEHR
                 raise ArgumentError, 'contribution type should be CONTRIBUTION'
               end
             end
-            @contributions = contributions
-          else
-            raise ArgumentError, 'contributions are mandatory'
           end
+          @contributions = contributions
         end
 
         def ehr_access=(ehr_access)
@@ -72,6 +72,8 @@ module OpenEHR
           @ehr_status = ehr_status
         end
 
+        # compositions is optional (0..1) since RM 1.1.0 (was mandatory
+        # pre-1.1.0).
         def compositions=(compositions)
           unless compositions.nil?
             compositions.each do |compo|
@@ -79,10 +81,8 @@ module OpenEHR
                 raise ArgumentError, 'composition type should be VERSIONED_COMPOSITION'
               end
             end
-            @compositions = compositions
-          else
-            raise ArgumentError, 'compositions are mandatory'
           end
+          @compositions = compositions
         end
 
         def directory=(directory)

data/lib/openehr/rm/factory.rb

@@ -277,6 +277,24 @@ module OpenEHR
       end
     end
 
+    class DvTimeSpecificationFactory
+      def self.create(param)
+        DataTypes::TimeSpecification::DvTimeSpecification.new(param)
+      end
+    end
+
+    class DvGeneralTimeSpecificationFactory
+      def self.create(param)
+        DataTypes::TimeSpecification::DvGeneralTimeSpecification.new(param)
+      end
+    end
+
+    class DvPeriodicTimeSpecificationFactory
+      def self.create(param)
+        DataTypes::TimeSpecification::DvPeriodicTimeSpecification.new(param)
+      end
+    end
+
     class ObservationFactory
       def self.create(param)
         Composition::Content::Entry::Observation.new(param)
@@ -579,6 +597,10 @@ module OpenEHR
 
     class CompositionFactory < Factory
       class << self
+        def create(param)
+          OpenEHR::RM::Composition::Composition.new(param)
+        end
+
         def create_from_json(json)
           hash = JSON.parse(json, max_nesting: false, symbolize_names: true)
           OpenEHR::RM::Composition::Composition.new(params(hash))

data/lib/openehr/rm/security.rb

@@ -5,7 +5,9 @@ module OpenEHR
   module RM
     module Security
       class AccessControlSettings
-        
+        # Deliberate stub: openEHR RM 1.0.1 Security package class (see
+        # UML reference above); no behavior is specified for it beyond
+        # existence.
       end
     end
   end

data/lib/openehr/rm/type_name.rb

@@ -1,4 +1,3 @@
-require 'set'
 require 'active_support/core_ext/string/inflections'
 
 module OpenEHR