open_ehr 0.9.3 → 0.9.4

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.9.4 2011-11-22
+Bug fix around ADL parser, ArchetypeOntology
+
+=== 0.9.3 2011-11-19
+Bug fix around ADL parser
+
 === 0.9.1 2011-10-04
 Archetype instance generated from ADL file.
 

data/README.rdoc

@@ -5,22 +5,20 @@ Ruby openEHR implementation project.
 
 = Version
 
-Release-0.9.3
+Release-0.9.4
 
 = Requirements
 
 * Ruby 1.9.2 reccomended
-* RubyGems
 * Tested with Ruby 1.9.2 on Linux and FreeBSD.
-* If you use early version of Ruby 1.8, you should
-  prepare racc runtime environment and some
-  adjustment. We do not support Ruby 1.6 anymore.
+* It would work with some adjustment on Ruby 1.8 or earlier,
+  but not confirmed.
 * It should work on other platforms with Ruby
   support as well.
 
 == DESCRIPTION:
 
-This is the beta version 0.9.3 release of Ruby openEHR implementation
+This is the beta version 0.9.4 release of Ruby openEHR implementation
 project. This release is still experimental preview of our work based
 on openEHR specification release 1.0.2. We implemented almost of the
 specifications of the openEHR.  The work is still in progress. The
@@ -31,7 +29,7 @@ Parser is nearly performing completely. We now consider to descrive
 archetype as another formalism such as YAML, instead of ADL.
 
 Almost all classes passed the test constructed by RSpec2 (formaly used
-test/unit). These test specifications are under /spec.
+test/unit). These spec files are under /spec.
 
 Some specifications are not well determined yet, such as rm/security
 and so on. We postponed to implement such classes.
@@ -41,7 +39,7 @@ project.
 
 = Authors
 * Main codes
-Akimichi Tatsukawa, Shinji Kobayashi
+Shinji Kobayashi, Akimichi Tatsukawa
 openEHR.jp, <http://openehr.jp>
 
 * ADL parser test cases are derived from Java and Eiffel

data/VERSION

@@ -1 +1 @@
-0.9.3
+0.9.4

data/lib/open_ehr/am/archetype/constraint_model/primitive.rb

@@ -39,7 +39,7 @@ module OpenEHR
 
             def default_value=(default_value)
               super
-              default_value_consistency(default_value)
+              default_value_consistency(default_value) unless default_value.nil?
             end
 
             def true_valid=(true_valid)
@@ -68,7 +68,7 @@ module OpenEHR
             end
 
             def default_value_consistency(default_value)
-              if (!@true_valid && default_value) || (!@false_valid && !default_value)
+              if (!@true_valid && default_value) || ((!@false_valid) && (!default_value))
                 raise ArgumentError, 'default value inconsistency'
               end
             end

data/lib/open_ehr/am/archetype/ontology.rb

@@ -5,86 +5,81 @@ module OpenEHR
         class ArchetypeOntology
           attr_accessor :specialisation_depth, :primary_language
           attr_accessor :term_attribute_names, :term_bindings
-          attr_accessor :languages_available
+          attr_accessor :languages_available, :terminologies_available
+          attr_accessor :constraint_bindings
           attr_reader :term_definitions, :constraint_definitions
 
           def initialize(args = { })
             self.primary_language = args[:primary_language]
             self.languages_available = args[:languages_available]
+            self.terminologies_available = args[:terminologies_available]
             self.specialisation_depth = args[:specialisation_depth]
             self.term_definitions = args[:term_definitions]
             if args[:constraint_definitions]
               self.constraint_definitions = args[:constraint_definitions]
             end
             self.term_bindings = args[:term_bindings]
+            self.constraint_bindings = args[:constraint_bindings]
           end
 
           def term_definitions=(term_definitions)
             if term_definitions.nil?
               raise ArgumentError, 'term_definitions is mandatory'
             end
-            @term_definition_map = definition_mapper(term_definitions)
             @term_definitions = term_definitions
           end
 
           def term_codes
-            return @term_definitions.values.collect {|value|
-              value.collect {|term| term.code}}.flatten.uniq
+            code_set @term_definitions
           end
 
           def constraint_codes
             if @constraint_definitions.nil?
               return nil
             else
-              return @constraint_definitions.values.collect {|value|
-                value.collect {|term| term.code}}.flatten.uniq
+              code_set @constraint_definitions
             end
           end
 
-          def terminologies_available
-            return @term_bindings.keys
-          end
-
-          def constraint_binding(a_terminology, a_code)
-            
+          def constraint_binding(args = {})
+            return @constraint_bindings[args[:terminology]][args[:code]]
           end
 
           def constraint_definitions=(constraint_definitions)
-            @constraint_definition_map = definition_mapper(constraint_definitions)
             @constraint_definitions = constraint_definitions
           end
 
           def constraint_definition(args = {})
-            return @constraint_definition_map[args[:lang]][args[:code]]
+            return @constraint_definitions[args[:lang]][args[:code]]
           end
 
           def has_language?(a_lang)
-            return @term_definition_map.has_key? a_lang
+            return @term_definitions.has_key? a_lang
           end
 
           def has_terminology?(a_terminology)
-            return @term_bindings.has_key? a_terminology
+            if !@terminologies_available.nil? &&
+                (@terminologies_available.include? a_terminology)
+              return true
+            else
+              return false
+            end
           end
 
           def term_binding(args = { })
-            
+            return @term_bindings[args[:terminology]][args[:code]]
           end
 
           def term_definition(args = { })
-            return @term_definition_map[args[:lang]][args[:code]]
+            return @term_definitions[args[:lang]][args[:code]]
           end
 
-          private
-          def definition_mapper(definitions)
-            map = { }
-            definitions.each do |lang, defs|
-              defs_map = { }
-              defs.each do |d|
-                defs_map[d.code] = d.items
-              end
-              map[lang] = defs_map
+          protected
+          def code_set(definitions)
+            codes = definitions.values.inject([]) do |codes, item|
+              item.keys
             end
-            return map
+            codes.uniq
           end
         end
 

data/lib/open_ehr/am/archetype.rb

@@ -68,7 +68,7 @@ module OpenEHR
         end
 
         def concept_name(a_lang)
-          return @ontology.term_definition(:lang => a_lang, :code => @concept)[:text]
+          return @ontology.term_definition(:lang => a_lang, :code => @concept).items[:text]
         end
 
         def constraint_references_valid?

data/lib/open_ehr/parser/adl.rb

@@ -1,3 +1,7 @@
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::DataTypes::Text
+
 module OpenEHR
   module Parser
     module ADLGrammar
@@ -6,12 +10,46 @@ module OpenEHR
       end
 
       class ArchLanguage < Base
-        def original_language
-          lang.value[:original_language]
+        def value
+          Language.new(lang.value)
         end
+      end
+
 
-        def translations
-          lang.value[:translations]
+      class Language
+        attr_reader :original_language, :translations
+        
+        def initialize(value)
+          self.original_language = value['original_language']
+          self.translations = value['translations']
+        end
+        
+        def original_language=(original_language)
+          @original_language = code2lang original_language
+        end
+        
+        def translations=(translations)
+          if translations.nil?
+            @translations = nil
+          else
+            tr = translations.inject({ }) do |trans, lang|
+              code, details  = lang
+              td = TranslationDetails.new(
+                     :language => code2lang(details['language']),
+                     :author => details['author'],
+                     :accreditation => details['accreditation'],
+                     :other_details => details['other_details'])
+              trans.update Hash[code, td]
+            end
+            @translations = tr
+          end
+        end
+        
+        protected
+        def code2lang(code)
+          ti, la = code.split '::'
+          ti = TerminologyID.new(:value => ti)
+          CodePhrase.new(:code_string => la, :terminology_id => ti)
         end
       end
     end

data/lib/open_ehr/parser/adl_grammar.tt

@@ -33,15 +33,11 @@ module OpenEHR
 	  end
 
 	  def original_language
-            tid, la = lang.original_language.split('::')
-            OpenEHR::RM::DataTypes::Text::CodePhrase.new(
-              :terminology_id => 
-                OpenEHR::RM::Support::Identification::TerminologyID.new(:value => tid),
-              :code_string => la)
+            lang.value.original_language
           end
 
           def translations
-            lang.translations
+            lang.value.translations
           end
 
           def description
@@ -147,40 +143,35 @@ module OpenEHR
           def value
             params = desc.value
             details = { }
-            params[:details].each do |lang, attrs|
-              term_id, la = attrs[:language].split('::')
+            params['details'].each do |lang, attrs|
+              term_id, la = attrs['language'].split('::')
               terminology_id = 
                 OpenEHR::RM::Support::Identification::TerminologyID.new(
                   :value => term_id)
-              misuse = attrs[:misuse].empty? ? nil : attrs[:misuse]
+              misuse = attrs['misuse']
+              misuse = nil if misuse.nil? or misuse.empty?
               item =
                 OpenEHR::RM::Common::Resource::ResourceDescriptionItem.new(
                   :language => OpenEHR::RM::DataTypes::Text::CodePhrase.new(
                                 :terminology_id => terminology_id,
                                 :code_string => la),
-                  :purpose => attrs[:purpose],
-                  :keywords => attrs[:keywords],
-                  :use => attrs[:use],
+                  :purpose => attrs["purpose"],
+                  :keywords => attrs["keywords"],
+                  :use => attrs["use"],
                   :misuse => misuse,
-                  :copyright => attrs[:copyright],
-                  :original_resource_uri => attrs[:original_resource_uri],
-                  :other_details => attrs[:other_details])
-              details[lang.to_s] = item
+                  :copyright => attrs['copyright'],
+                  :original_resource_uri => attrs['original_resource_uri'],
+                  :other_details => attrs['other_details'])
+              details[lang] = item
             end
-            oc = params[:other_contributors].nil? ? nil : params[:other_contributors].values
-            original_author = key_s params[:original_author]
-            other_details = key_s params[:other_details] if params[:other_details] 
+            oc = params['other_contributors'].nil? ? nil : params['other_contributors'].values
             OpenEHR::RM::Common::Resource::ResourceDescription.new(
-              :original_author => original_author,
+              :original_author => params['original_author'],
               :other_contributors => oc,
-              :lifecycle_state => params[:lifecycle_state],
+              :lifecycle_state => params['lifecycle_state'],
               :details => details,
-              :resource_package_uri => params[:archetype_package_uri],
-              :other_details => other_details)
-          end
-
-          def key_s(hash)
-            hash.inject({ }) {|h,i| h.update Hash[i[0].to_s,i[1]]}
+              :resource_package_uri => params['archetype_package_uri'],
+              :other_details => params['other_details'])
           end
         }
       end
@@ -200,21 +191,55 @@ module OpenEHR
       rule arch_ontology
         SYM_ONTOLOGY ontology:V_DADL_TEXT space {
           def value
-            ao = ontology.value[:term_definitions]
-            term_definitions = {}
-            ao.each do |lang, term_defs|
-              items = term_defs[:items]
-              terms = items.map do |code, item|
-                OpenEHR::AM::Archetype::Ontology::ArchetypeTerm.new(
-                  :code => code.to_s, :items => item)
-              end
-              term_definitions[lang.to_s] = terms
+            ao = ontology.value
+            arc_term = Proc.new do |code, item|
+              OpenEHR::AM::Archetype::Ontology::ArchetypeTerm.new(
+                       :code => code, :items => item)
+            end
+            td = itemizer(ao['term_definitions'], arc_term)
+            cd = ao['constraint_definitions']
+            if cd
+              cd = itemizer(cd , arc_term)
+            end
+            tb = ao['term_bindings']
+            term_bind = Proc.new do |code, item|
+              term_id, code_string = item.split '::'
+              term_id = OpenEHR::RM::Support::Identification::TerminologyID.new(:value => term_id)
+              OpenEHR::RM::DataTypes::Text::CodePhrase.new(:terminology_id => term_id, :code_string => code_string)
+            end
+            if tb
+              tb = itemizer(tb, term_bind)
+            end
+            cons_bind = Proc.new do |code, item|
+              item
+            end
+            cb = ao['constraint_bindings']
+            if cb
+              cb = itemizer(cb, cons_bind)
             end
             OpenEHR::AM::Archetype::Ontology::ArchetypeOntology.new(
-              :term_definitions => term_definitions)
-          end
+              :primary_language => ao['primary_language'],
+              :languages_available => ao['languages_available'],
+              :terminologies_available => ao['terminologies_available'],
+              :term_definitions => td,
+              :constraint_definitions => cd,
+              :term_bindings => tb,
+              :constraint_bindings => cb)
+          end
+
+           def itemizer(defs, itemize)
+             defs.inject({ }) do |term_defs, langs|
+               lang, items = langs
+               terms = items['items'].inject({ }) do |items, term|
+                 code, item = term
+                 item = itemize.call code, item
+                 items.update Hash[code => item]
+               end
+               term_defs.update Hash[lang => terms]
+             end
+           end
         }
-      end
-    end
-  end
-end
+      end # of arch_ontology
+    end # of ADLGrammar
+  end # of Parser
+end # of openEHR

data/lib/open_ehr/parser/adl_parser.rb

@@ -33,7 +33,7 @@ module OpenEHR
                                   :adl_version => @result.adl_version,
                                   :concept => @result.concept,
                                   :original_language => original_language,
-                                  :translation => @result.translations,
+                                  :translations => @result.translations,
                                   :description => @result.description,
                                   :definition => @result.definition,
                                   :ontology => @result.ontology)