openehr 1.2.999999 → 2.0.0

data/lib/openehr/assumed_library_types.rb

@@ -71,6 +71,35 @@ module OpenEHR
           (@lower_included == value.lower_included?) &&
             (@upper_included == value.upper_included?)
       end
+
+      # True if every value this interval has is also had by other (a
+      # standard subset test, e.g. for conformance checks: does a
+      # constraint's occurrences/existence/cardinality interval fit
+      # within its parent's).
+      def subset_of?(other)
+        return false if other.nil?
+
+        lower_ok = if lower_unbounded?
+                     other.lower_unbounded?
+                   elsif other.lower_unbounded? || lower > other.lower
+                     true
+                   elsif lower == other.lower
+                     !lower_included? || other.lower_included?
+                   else
+                     false
+                   end
+        upper_ok = if upper_unbounded?
+                     other.upper_unbounded?
+                   elsif other.upper_unbounded? || upper < other.upper
+                     true
+                   elsif upper == other.upper
+                     !upper_included? || other.upper_included?
+                   else
+                     false
+                   end
+        lower_ok && upper_ok
+      end
+
       private
 
       def check_lower_upper(lower, upper)
@@ -441,6 +470,8 @@ module OpenEHR
               return false
             end
           end
+          # A timezone is optional in ISO 8601; its absence does not make an
+          # otherwise-valid time invalid.
           unless tz.nil?
             timezone = Timezone.new(tz)
             if timezone.hour < 0 or timezone.hour >= HOURS_IN_DAY
@@ -449,10 +480,8 @@ module OpenEHR
             if timezone.minute < 0 or timezone.minute >= MINUTES_IN_HOUR
               return false
             end
-            return true
-          else
-            return false
           end
+          return true
         end
       end
     end # end of ISO8601_TIME
@@ -589,6 +618,19 @@ module OpenEHR
       include TimeDefinitions
       attr_reader :years, :months, :weeks, :days
       attr_reader :hours, :minutes, :seconds, :fractional_second
+      # RM 1.1.0 (SPECRM-96): a leading '-' before 'P' negates the whole
+      # duration (e.g. "-P10D", 10 days before an unstated origin point).
+      # Components stay non-negative magnitudes - the sign applies to
+      # the duration as a whole, not each field - so it's tracked here.
+      attr_reader :negative
+
+      def negative=(negative)
+        @negative = negative ? true : false
+      end
+
+      def negative?
+        @negative == true
+      end
 
       def years=(years)
         unless years.nil? || years >= 0
@@ -647,7 +689,7 @@ module OpenEHR
       end
 
       def as_string
-        str = 'P'
+        str = negative? ? '-P' : 'P'
         unless @years.nil?
           str += @years.to_s + 'Y'
         end
@@ -681,27 +723,36 @@ module OpenEHR
           nilthenzero(@months)*TimeDefinitions::DAYS_IN_MONTH +
           nilthenzero(@weeks)*TimeDefinitions::DAYS_IN_WEEK + 
           nilthenzero(@days)
-        seconds_with_fractional = (((days*TimeDefinitions::HOURS_IN_DAY + nilthenzero(@hours))*TimeDefinitions::MINUTES_IN_HOUR)+nilthenzero(@minutes))*TimeDefinitions::SECONDS_IN_MINUTE + 
+        seconds_with_fractional = (((days*TimeDefinitions::HOURS_IN_DAY + nilthenzero(@hours))*TimeDefinitions::MINUTES_IN_HOUR)+nilthenzero(@minutes))*TimeDefinitions::SECONDS_IN_MINUTE +
           nilthenzero(@seconds) +
           @fractional_second.to_f
-        return seconds_with_fractional
+        return negative? ? -seconds_with_fractional : seconds_with_fractional
       end
     end
 
     class ISO8601Duration
       include ISO8601DurationModule, Comparable
       def initialize(str)
-        /^P((\d+)[Yy])?((\d+)[Mm])?((\d+)[Ww])?((\d)[dD])?(T((\d+)[Hh])?((\d+)[Mm])?((\d+)(\.\d+)?[Ss])?)?$/ =~ str
-        self.years = $2.to_i
-        self.months = $4.to_i
-        self.weeks = $6.to_i
-        self.days = $8.to_i
-        self.hours = $11.to_i
-        self.minutes = $13.to_i
-        self.seconds = $15.to_i
-        unless $16.nil?
-          self.fractional_second = $16.to_f
-        end
+        # A leading '-' negates the whole duration (RM 1.1.0, SPECRM-96);
+        # stripped before the main match so the existing capture group
+        # numbering below doesn't need to shift.
+        self.negative = str.start_with?('-')
+        duration_str = negative? ? str[1..-1] : str
+        md = /^P((\d+)[Yy])?((\d+)[Mm])?((\d+)[Ww])?((\d+)[dD])?(T((\d+)[Hh])?((\d+)[Mm])?((\d+)(\.\d+)?[Ss])?)?$/.match(duration_str)
+        if md.nil?
+          raise ArgumentError, 'invalid ISO8601 duration format'
+        end
+        # Absent components stay nil rather than being coerced to 0, so
+        # as_string can round-trip a partially-specified duration and
+        # "unset" is distinguishable from "explicitly zero".
+        self.years = md[2] && md[2].to_i
+        self.months = md[4] && md[4].to_i
+        self.weeks = md[6] && md[6].to_i
+        self.days = md[8] && md[8].to_i
+        self.hours = md[11] && md[11].to_i
+        self.minutes = md[13] && md[13].to_i
+        self.seconds = md[15] && md[15].to_i
+        self.fractional_second = md[16] && md[16].to_f
       end
 
       def <=>(other)

data/lib/openehr/parser/adl_grammar.tt

@@ -15,7 +15,7 @@ module OpenEHR
         lang:(arch_language)?
         desc:(arch_description)?
         arch_definition
-        arch_invariant?
+        inv:(arch_invariant)?
         arch_ontology {
           def archetype_id
             arch_identification.archetype_id
@@ -52,6 +52,14 @@ module OpenEHR
           def ontology
             arch_ontology.value
           end
+
+          def parent_archetype_id
+            spec.archetype_id unless spec.empty?
+          end
+
+          def invariants
+            inv.value unless inv.empty?
+          end
         }
       end
 
@@ -116,9 +124,9 @@ module OpenEHR
             { :uid => uid.value }
           end
         }
-      / SYM_IS_CONTROLED space {
+      / SYM_IS_CONTROLLED space {
           def value
-	    { :is_controled? => true } # If elements[0]
+	    { :is_controlled? => true } # If elements[0]
           end
         }
       end
@@ -194,7 +202,11 @@ module OpenEHR
       end
 
       rule arch_invariant
-        SYM_INVARIANT V_ASSERTION_TEXT space
+        SYM_INVARIANT text:V_ASSERTION_TEXT space {
+          def value
+            text.value
+          end
+        }
       end
 
       rule arch_ontology
@@ -327,7 +339,7 @@ module OpenEHR
       rule c_complex_object_body
         c_any '' {
           def value(node)
-            Hash[:attributes => [c_any.value(node)]]
+            Hash[:attributes => nil]
           end
         }
       / c_attributes '' {
@@ -386,10 +398,10 @@ module OpenEHR
         }
       / V_C_DOMAIN_TYPE '' {
           def value(node = nil)
-            p elemetns
+            raise OpenEHR::Parser::ParseError,
+              "generic C_DOMAIN_TYPE constraints (e.g. C_DV_STATE) are not yet supported by the ADL parser: #{text_value}"
           end
         }
-#     / ERR_V_C_DOMAIN_TYPE
       end
 
       rule archetype_internal_ref
@@ -1460,7 +1472,7 @@ module OpenEHR
           def value
             if (id && !id.empty?)
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
-                :tag => id.value, :expression => boolean_expression.value,
+                :tag => id.elements[0].value, :expression => boolean_expression.value,
                 :string_expression => id.text_value + boolean_expression.text_value)
             else
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
@@ -1726,7 +1738,7 @@ module OpenEHR
         }
       / integer_value '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'Integer',
               :item => integer_value.value,
               :reference_type => 'CONSTANT')
@@ -1734,7 +1746,7 @@ module OpenEHR
         }
       / real_value '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'Real',
               :item => real_value.value,
               :reference_type => 'CONSTANT')
@@ -1742,7 +1754,7 @@ module OpenEHR
         }
       / absolute_path space {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'String',
               :item => absolute_path.value,
               :reference_type => 'CONSTANT')
@@ -2168,9 +2180,9 @@ module OpenEHR
             type_identifier.value
           end
         }
-      / V_ATTRIBUTE_IDENTIFIER '' {
+      / id:V_ATTRIBUTE_IDENTIFIER '' {
           def value
-            V_ATTRIBUTE_IDENTIFIER.value
+            id.value
           end
         }
       end
@@ -3004,6 +3016,10 @@ module OpenEHR
         '=' white_space
       end
 
+      rule SYM_NE
+        '!=' white_space
+      end
+
       rule SYM_GE
         ('=>' / '>=') white_space
       end

data/lib/openehr/parser/adl_parser.rb

@@ -13,8 +13,10 @@ module OpenEHR
         super
       end
       
-      def parse
-        archetype
+      def parse(validate: false)
+        archetype.tap do |a|
+          ArchetypeValidator.new(a).validate! if validate
+        end
       end
 
       private
@@ -67,6 +69,16 @@ module OpenEHR
         parsed_data.concept
       end
 
+      def parent_archetype_id
+        if parsed_data.parent_archetype_id
+          OpenEHR::RM::Support::Identification::ArchetypeID.new(:value => parsed_data.parent_archetype_id)
+        end
+      end
+
+      def invariants
+        parsed_data.invariants
+      end
+
       def description
         parsed_data.description
       end
@@ -82,13 +94,15 @@ module OpenEHR
       def archetype
         OpenEHR::AM::Archetype::Archetype.new(:archetype_id => archetype_id,
                                   :adl_version => adl_version,
-                                  :uid => uid,            
+                                  :uid => uid,
                                   :concept => concept,
                                   :original_language => original_language,
                                   :translations => translations,
                                   :description => description,
                                   :definition => definition,
-                                  :ontology => ontology)
+                                  :ontology => ontology,
+                                  :parent_archetype_id => parent_archetype_id,
+                                  :invariants => invariants)
       end
     end
   end # of Parser

data/lib/openehr/parser/archetype_validator.rb

@@ -0,0 +1,126 @@
+require_relative 'exception'
+
+module OpenEHR
+  module Parser
+    # Post-parse semantic validator, checking a parsed archetype
+    # against the VARID..VDFPT rules (Beale07, p.100). VARID/VARDF/
+    # VARON/VDFAI are already enforced structurally by the RM/AM
+    # object model itself (their setters raise on construction), so
+    # they can never actually fail here - they're still checked
+    # explicitly, both for rule-traceability and so a validator run
+    # against a duck-typed object (not necessarily a real
+    # OpenEHR::AM::Archetype::Archetype) stays honest.
+    class ArchetypeValidator
+      Validation = Exception::Validation
+
+      def initialize(archetype)
+        @archetype = archetype
+      end
+
+      def errors
+        RULES.filter_map { |rule| send(rule) }
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def validate!
+        error = errors.first
+        raise error if error
+      end
+
+      # Checks +rm_root+ against the archetype's definition, returning
+      # a path-annotated OpenEHR::Parser::Exception::Validation::
+      # InstanceNonConformant for the first violation found (path
+      # resolved via rm_root.path_of_item, the PATHABLE navigation
+      # method), or [] when rm_root fully conforms.
+      def validate_instance(rm_root)
+        return [] if @archetype.definition.valid_value?(rm_root)
+
+        _node, value = @archetype.definition.find_violation(rm_root)
+        message = "value does not conform to #{@archetype.archetype_id.value}"
+        [Validation::InstanceNonConformant.new(message, resolve_path(rm_root, value))]
+      end
+
+      private
+
+      def resolve_path(rm_root, value)
+        return nil unless rm_root.respond_to?(:path_of_item)
+
+        rm_root.path_of_item(value)
+      end
+
+      def varid
+        Validation::VARID.new(Validation::VARID::MESSAGE) if @archetype.archetype_id.nil?
+      end
+
+      def vardf
+        Validation::VARDF.new(Validation::VARDF::MESSAGE) if @archetype.definition.nil?
+      end
+
+      def varon
+        Validation::VARON.new(Validation::VARON::MESSAGE) if @archetype.ontology.nil?
+      end
+
+      def varcn
+        return if @archetype.concept.nil?
+        return if @archetype.ontology.term_codes.include?(@archetype.concept)
+
+        Validation::VARCN.new(Validation::VARCN::MESSAGE)
+      end
+
+      def vardt
+        definition_type = @archetype.definition.rm_type_name.to_s.upcase
+        id_type = @archetype.archetype_id.rm_entity.to_s.upcase
+        return if definition_type == id_type
+
+        Validation::VARDT.new(Validation::VARDT::MESSAGE)
+      end
+
+      def vatdf
+        Validation::VATDF.new(Validation::VATDF::MESSAGE) unless @archetype.node_ids_valid?
+      end
+
+      def vacdf
+        Validation::VACDF.new(Validation::VACDF::MESSAGE) unless @archetype.constraint_references_valid?
+      end
+
+      # In practice this can never actually fail through this gem's own
+      # object model: CArchetypeRoot#archetype_id= already rejects
+      # anything but a well-typed ArchetypeID at construction time.
+      # Still checked genuinely (rather than a hardcoded pass) in case
+      # +archetype+ is a duck-typed object built some other way.
+      def vdfai
+        return if archetype_roots(@archetype.definition).all? do |id|
+          id.is_a?(OpenEHR::RM::Support::Identification::ArchetypeID)
+        end
+
+        Validation::VDFAI.new(Validation::VDFAI::MESSAGE)
+      end
+
+      def archetype_roots(node, found = [])
+        return found if node.nil?
+
+        found << node.archetype_id if node.is_a?(OpenEHR::AM::Archetype::ConstraintModel::CArchetypeRoot)
+        if node.respond_to?(:attributes) && node.attributes
+          node.attributes.each { |attribute| archetype_roots(attribute, found) }
+        end
+        if node.respond_to?(:children) && node.children
+          node.children.each { |child| archetype_roots(child, found) }
+        end
+        found
+      end
+
+      def vdfpt
+        return if @archetype.internal_references_valid? &&
+                  @archetype.physical_paths.all? { |path| OpenEHR::Path.valid?(path) }
+
+        Validation::VDFPT.new(Validation::VDFPT::MESSAGE)
+      end
+
+      RULES = %i[varid vardf varon varcn vardt vatdf vacdf vdfai vdfpt].freeze
+      private_constant :RULES
+    end
+  end
+end

data/lib/openehr/parser/exception.rb

@@ -60,6 +60,19 @@ module OpenEHR
         class VDFPT < Base
           MESSAGE = "Any path mentioned in the definition section must be valid syntactically, and a valid path with respect to the hierarchical structure of the definition section."
         end
+
+        # Raised by ArchetypeValidator#validate_instance for an RM
+        # instance that does not conform to an archetype's definition;
+        # not one of the VARID..VDFPT archetype-structure rules, since
+        # this checks an RM instance against the archetype instead.
+        class InstanceNonConformant < Base
+          attr_reader :path
+
+          def initialize(message, path = nil)
+            super(message)
+            @path = path
+          end
+        end
       end
 
     end