open_ehr 0.6.1

data/lib/open_ehr/serializer.rb

@@ -0,0 +1,272 @@
+$:.unshift(File.dirname(__FILE__))
+require 'rexml/document'
+require 'builder'
+
+module OpenEHR
+  module Serializer
+    NL = "\r\n"
+    INDENT = '    '
+
+    class BaseSerializer
+      def initialize(archetype)
+        @archetype = archetype
+      end
+
+      def serialize
+        return self.merge
+      end
+    end
+
+    class ADLSerializer < BaseSerializer
+      def header
+        hd = 'archetype'
+        unless @archetype.adl_version.nil?
+          hd << " (adl_version = #{@archetype.adl_version})"
+        end
+        hd << NL+INDENT + "#{@archetype.archetype_id.value}"+NL*2
+        hd << 'concept'+NL+ INDENT+"[#{@archetype.concept}]"+NL
+        hd << NL+'language'+NL+INDENT+'original_language = <['+
+          @archetype.original_language.terminology_id.value+'::'+
+          @archetype.original_language.code_string+']>'+NL
+        return hd
+      end
+
+      def description
+        desc = ''
+        if @archetype.description
+          ad = @archetype.description
+          desc << 'description' + NL
+          desc << INDENT + 'original_author = <' + NL
+          ad.original_author.each do |k,v|
+            desc << INDENT+INDENT+'["'+k+'"] = <"'+v+'">'+NL
+          end
+          desc << INDENT+'>'+NL
+          desc << INDENT+'lifecycle_state = <"'+ad.lifecycle_state+'">'+NL
+          desc << INDENT+'details = <'+NL
+          ad.details.each do |lang,item|
+            desc << INDENT*2+'["'+lang+'"] = <'+NL
+            desc << INDENT*3+'language = <['+
+              item.language.terminology_id.value+'::'+
+              item.language.code_string+']>'+NL
+            desc << INDENT*3+'purpose = <"'+item.purpose+'">'+NL
+            if item.keywords then
+              desc << INDENT*3+'keywords = <'
+              item.keywords.each do |word|
+                desc << '"'+word+'",'
+              end
+              desc.chop! << '>'+NL
+            end
+            desc << INDENT*3+'use = <"'+item.use+'">'+NL if item.use
+            desc << INDENT*3+'misuse = <"'+item.misuse+'">'+NL if item.misuse
+            desc << INDENT*3+'copyright = <"'+item.copyright+'">'+NL if item.copyright
+            if item.original_resource_uri
+              desc << INDENT*3 + 'original_resource_uri = <'
+              item.original_resource_uri.each do |k,v|
+                desc << INDENT*4+'["'+k+'"] = <"'+v+'">'+NL
+              end
+              desc << INDENT*3+'>'+NL
+            end
+            if item.other_details
+              desc << INDENT*3 + 'other_details = <'
+              item.original_resource_uri.each do |k,v|
+                desc << INDENT*4+'["'+k+'"] = <"'+v+'">'+NL
+              end
+              desc << INDENT*3+'>'+NL
+            end
+            desc << INDENT*2+'>'+NL
+          end
+          desc << INDENT+'>'+NL
+        end
+        return desc
+      end
+
+      def definition
+        ad = @archetype.definition
+        definition = 'definition'+NL
+        definition << INDENT+ad.rm_type_name+"[#{ad.node_id}] matches {"
+        if ad.any_allowed?
+          definition << '*}'+NL
+        else
+          definition << NL
+          if ad.attributes
+            attributes = ad.attributes
+            indents = 2
+            while attributes
+              definition << INDENT*indents+attributes.rm_type_name
+              definition << "[#{attributes.node_id}] "
+              definition << existence(attributes.existence)
+              definition << " matches {"
+            end
+          end
+        end
+      end
+
+      def ontology
+        ao = @archetype.ontology
+        ontology = 'ontology'+NL
+        ontology << INDENT + 'term_definitions = <' + NL
+        ao.term_definitions.each do |lang, items|
+          ontology << INDENT*2 + "[\"#{lang}\"] = <" + NL
+          ontology << INDENT*3 + 'items = <'  + NL
+          items.each do |item|
+            ontology << INDENT*4 + "[\"#{item.code}\"] = <" + NL            
+            item.items.each do |name, desc|
+              ontology << INDENT*5 + "#{name} = <\"#{desc}\">" +NL
+            end
+            ontology << INDENT*4 + '>'+NL
+          end
+          ontology << INDENT*3 + '>' + NL
+          ontology << INDENT*2 + '>' + NL
+        end
+        ontology << INDENT + '>' + NL
+      end
+
+      def merge
+        return header + NL + description + NL + definition + NL + ontology
+      end
+
+      private
+      def c_object
+      end
+
+      def existence(existence)
+        "existence matches {#{existence.lower}..#{existence.upper}}"
+      end
+    end
+
+    class XMLSerializer < BaseSerializer
+      def header
+        header = ''
+        xml = Builder::XmlMarkup.new(:indent => 2, :target => header)
+        xml.archetype_id do 
+          xml.value @archetype.archetype_id.value
+        end
+        xml.concept @archetype.concept
+        xml.original_language do
+          xml.terminology_id do
+            xml.value @archetype.original_language.terminology_id.value
+          end
+          xml.code_string @archetype.original_language.code_string
+        end
+        return header
+      end
+
+      def description
+        desc = ''
+        xml = Builder::XmlMarkup.new(:indent => 2, :target => desc)
+        ad = @archetype.description
+        if ad
+          xml.description do
+            ad.original_author.each do |key,value|
+              xml.original_author(value,"id"=>key)
+            end
+            if ad.other_contributors
+              ad.other_contributors.each do |co|
+                xml.other_contributors co
+              end
+            end
+            xml.lifecycle_state ad.lifecycle_state
+            xml.details do
+              ad.details.each do |lang, item|
+                xml.language do
+                  xml.terminology_id do
+                    xml.value item.language.terminology_id.value
+                  end
+                  xml.code_string lang
+                end
+                xml.purpose item.purpose
+                if item.keywords then
+                  item.keywords.each do |word|
+                    xml.keywords word
+                  end
+                end
+                xml.use item.use if item.use
+                xml.misuse item.misuse if item.misuse
+                xml.copyright item.copyright if item.copyright
+                if ad.other_details
+                  ad.other_details.each do |key,value|
+                    xml.other_details(value, "id"=>key)
+                  end
+                end
+              end
+            end
+          end
+        end
+        return desc
+      end
+
+      def definition
+        definition = ''
+        ad = @archetype.definition
+        xml = Builder::XmlMarkup.new(:indent => 2, :target => definition)
+        xml.definition do
+          xml.rm_type_name ad.rm_type_name
+          xml.occurrence do
+            oc = ad.occurrences
+            xml.lower_included oc.lower_included? unless oc.lower_included?.nil?
+            xml.upper_included oc.upper_included? unless oc.upper_included?.nil?
+            xml.lower_unbounded oc.lower_unbounded?
+            xml.upper_unbounded oc.upper_unbounded?
+            xml.lower oc.lower
+            xml.upper oc.lower
+          end
+          xml.node_id ad.node_id
+        end
+        return definition
+      end
+
+      def ontology
+        ontology = ''
+        ao = @archetype.ontology
+        xml = Builder::XmlMarkup.new(:indent => 2, :target => ontology)
+        xml.ontology do
+          xml.specialisation_depth ao.specialisation_depth
+          xml.term_definitions do
+            ao.term_definitions.each do |lang, terms|
+              xml.language lang
+              xml.terms do
+                terms.each do |term|
+                  xml.code term.code
+                  xml.items do
+                    term.items.each do |key, value|
+                      xml.item do
+                        xml.key key
+                        xml.value value
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def merge
+        archetype = "<?xml version='1.0' encoding='UTF-8'?>" + NL +
+          "<archetype xmlns=\"http://schemas.openehr.org/v1\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + NL +
+          header + description + definition +
+          ontology + '</archetype>'
+        return archetype
+      end
+    end
+  end
+end
+
+class Publisher
+  def initialize(serializer)
+    @serializer = serializer
+  end
+
+  def publish(writer)
+    writer.out(@serializer.serialize)
+  end
+end
+
+class Writer
+  def initialize(target)
+    @target = target
+  end
+  def out
+  end
+end

data/lib/open_ehr/terminology/open_ehr_terminology.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'xmlsimple'
+#require 'ActiveSupport'
+
+module OpenEHR
+  module Terminology
+    class OpenEHRTerminology
+      def initialize
+        @terms = XmlSimple.xml_in(File.open('doc/openehr_terminology.xml'))
+      end
+
+      def languages
+        @terms['Language']
+      end
+
+      def primary_rubrics
+        @terms['PrimaryRubric']
+      end
+
+      def concepts
+        @terms['Concept']
+      end
+
+      def groupers
+        @terms['Grouper']
+      end
+
+      def grouped_concepts
+        @terms['GroupedConcept']
+      end
+
+      def terminology_identifiers
+        @terms['TerminologyIdentifiers']
+      end
+
+      def territories
+        @terms['Territory']
+      end
+    end 
+  end
+end

data/lib/open_ehr/terminology.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+module OpenEHR
+  module Terminology
+    autoload :OpenEHRTerminology, 'terminology/open_ehr_terminology'
+  end
+end

data/lib/open_ehr/writer.rb

@@ -0,0 +1,12 @@
+module OpenEHR
+  module Writer
+    class BaseWriter
+      def initiailze(source, target)
+      end
+
+      def out
+      end
+    end
+  end
+end
+

data/lib/open_ehr.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module OpenEHR
+  VERSION = '0.6.0'
+  autoload :AssumedLibraryTypes, 'open_ehr/assumed_library_types'
+  autoload :RM, 'open_ehr/rm'
+  autoload :AM, 'open_ehr/am'
+  autoload :Terminology, 'open_ehr/terminology'
+  autoload :Serializer, 'open_ehr/serializer'
+end

data/spec/lib/open_ehr/am/archetype/archetype_spec.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AM::Archetype::Ontology
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::Support::Identification
+
+describe Archetype do
+  before(:each) do
+    original_language = stub(CodePhrase, :code_string => 'ja')
+    archetype_id = ArchetypeID.new(:value => 'openEHR-EHR-SECTION.physical_examination-prenatal.v2')
+    definition = stub(CComplexObject, :rm_type_name => 'SECTION')
+    ontology = stub(ArchetypeOntology, :specialisation_depth => 1)
+    uid = HierObjectID.new(:value => 'ABCD::1')
+    parent_archetype_id = ArchetypeID.new(:value => 'openEHR-EHR-SECTION.physical_examination.v1')
+    invariants = stub(Set, :size => 2)
+    @archetype = Archetype.new(:original_language => original_language,
+                               :adl_version => '1.4',
+                               :archetype_id => archetype_id,
+                               :concept => 'at0000',
+                               :definition => definition,
+                               :ontology => ontology,
+                               :uid => uid,
+                               :parent_archetype_id => parent_archetype_id,
+                               :invariants => invariants)
+  end
+
+  it 'should be an instance of Archetype' do
+    @archetype.should be_an_instance_of Archetype
+  end
+
+  it 'adl_version should be assigned properly' do
+    @archetype.adl_version.should == '1.4'
+  end
+  
+  it 'archetype_id should be assigned prorperly' do
+    @archetype.archetype_id.value.should == 'openEHR-EHR-SECTION.physical_examination-prenatal.v2'
+  end
+
+  it 'should raise ArgumentError when archetype_id is nil' do
+    lambda {
+      @archetype.archetype_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'uid should be assigned properly' do
+    @archetype.uid.value.should == 'ABCD::1'
+  end
+
+  it 'concept should be assigned properly' do
+    @archetype.concept.should == 'at0000'
+  end
+
+  it 'should raise ArgumentError when concept is nil' do
+    lambda {
+      @archetype.concept = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'parent_archetype_id should be assigned properly' do
+    @archetype.parent_archetype_id.value.should == 'openEHR-EHR-SECTION.physical_examination.v1'
+  end
+
+  it 'definition should be assigned properly' do
+    @archetype.definition.rm_type_name.should == 'SECTION'
+  end
+
+  it 'should raise ArgumentError when definition is nil' do
+    lambda {
+      @archetype.definition = nil
+    }.should raise_error ArgumentError
+  end
+  
+  it 'ontology should be assigned properly' do
+    @archetype.ontology.specialisation_depth.should be_equal 1
+  end
+
+  it 'should raise ArgumentError when ontology is nil' do
+    lambda {
+      @archetype.ontology = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'invariants should be assigned properly' do
+    @archetype.invariants.size.should be_equal 2
+  end
+
+  it 'version should be extracted form id' do
+    @archetype.version.should == 'v2'
+  end
+
+  it 'short concept name should be extracted from archetype id' do
+    @archetype.short_concept_name.should == 'physical_examination'
+  end
+
+  it 'concept name should be extracted from ontology'
+end

data/spec/lib/open_ehr/am/archetype/assertion/assertion_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe Assertion do
+  before(:each) do
+    expression = stub(ExprItem, :type => 'Boolean')
+    $string_expression = "/[at0001]/speed[at0002]/kilometres/magnitude = " +
+      "/[at0003]/speed[at0004]/miles/magnitude * 1.6"
+    variables = stub(Array, :size => 2)
+    @assertion = OpenEHR::AM::Archetype::Assertion::Assertion.new(:tag => 'validity',
+                               :expression => expression,
+                               :string_expression => $string_expression,
+                               :variables => variables)
+  end
+
+  it 'should be an instance of Assertion' do
+    @assertion.should be_an_instance_of OpenEHR::AM::Archetype::Assertion::Assertion
+  end
+
+  it 'expression should be assigned properly' do
+    @assertion.expression.type.should == 'Boolean'
+  end
+
+  it 'should raise ArgumentError when expression is nil' do
+    lambda {
+      @assertion.expression = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when expression type is not Boolean' do
+    invalid_expression = stub(ExprItem, :type => 'Real')
+    lambda {
+      @assertion.expression = invalid_expression
+    }.should raise_error ArgumentError
+  end
+
+  it 'tag should be assigned properly' do
+    @assertion.tag.should == 'validity'
+  end
+
+  it 'tag should not be empty' do
+    lambda {
+      @assertion.tag = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError when tag = nil' do
+    lambda {
+      @assertion.tag = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'string_expression should be assigned properly' do
+    @assertion.string_expression.should == $string_expression
+  end
+
+  it 'variables should be assigned properly' do
+    @assertion.variables.size.should be_equal 2
+  end
+end

data/spec/lib/open_ehr/am/archetype/assertion/assertion_variable_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe AssertionVariable do
+  before(:each) do
+    @assertion_variable =
+      AssertionVariable.new(:name => 'test',
+                            :definition => 'examine spec')
+  end
+
+  it 'name should be assigned properly' do
+    @assertion_variable.name.should == 'test'
+  end
+
+  it 'should raise ArgumentError when name is nil' do
+    lambda {
+      @assertion_variable.name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'definition should be assigned properly' do
+    @assertion_variable.definition.should == 'examine spec'
+  end
+
+  it 'should raise ArgumentError if definiton is nil' do
+    lambda {
+      @assertion_variable.definition = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/assertion/expr_binary_operator.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprBinaryOperator do
+  before(:each) do
+    operator = OperatorKind.new(:value => 2001)
+    right_operand = ExprItem.new(:type => 'Real')
+    left_operand = stub(ExprItem, :item => 'ANY')
+    @expr_binary_operator =
+      ExprBinaryOperator.new(:type => 'Integer',
+                             :item => 'ANY',
+                             :reference_type => 'operator',
+                             :operator => operator,
+                             :precedence_overridden => true,
+                             :right_operand => right_operand,
+                             :left_operand => left_operand)
+  end
+
+
+  it 'right_operand should be assigned properly' do
+    @expr_binary_operator.right_operand.type.should == 'Real'
+  end
+
+  it 'should raise ArgumentError when right_operand is nil' do
+    lambda {
+      @expr_binary_operator.right_operand = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'left_operand should be assigned properly' do
+    @expr_binary_operator.left_operand.item.should == 'ANY'
+  end
+
+  it 'should raise ArgumentError when left_oprand is nil' do
+    lambda {
+      @expr_binary_operator.left_operand = nil
+    }.should raise_error ArgumentError
+  end
+end
+

data/spec/lib/open_ehr/am/archetype/assertion/expr_item_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprItem do
+  before(:each) do
+    @expr_item = ExprItem.new(:type => 'Real')
+  end
+
+  it 'should be an instance of ExprItem' do
+    @expr_item.should be_an_instance_of ExprItem
+  end
+
+  it 'type should be assigned properly' do
+    @expr_item.type.should == 'Real'
+  end
+
+  it 'should raise ArgumentError when type is nil' do
+    lambda {
+      @expr_item.type = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when type is empty' do
+    lambda {
+      @expr_item.type = ''
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/assertion/expr_leaf_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprLeaf do
+  before(:each) do
+    @expr_leaf = ExprLeaf.new(:type => 'Boolean',
+                              :item => 'ANY',
+                              :reference_type => 'DV_TEXT')
+  end
+
+  it 'should be an instance of ExprLeaf' do
+    @expr_leaf.should be_an_instance_of ExprLeaf
+  end
+
+  it 'item should be assigned properly' do
+    @expr_leaf.item.should == 'ANY'
+  end
+
+  it 'should raise ArgumentError when item is nil' do
+    lambda {
+      @expr_leaf.item = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'reference_type should be assigned properly' do
+    @expr_leaf.reference_type.should == 'DV_TEXT'
+  end
+
+  it 'should raise ArgumentError when reference_type is nil' do
+    lambda {
+      @expr_leaf.reference_type = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/assertion/expr_operator_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprOperator do
+  before(:each) do
+    operator = OperatorKind.new(:value => 2001)
+    @expr_operator = ExprOperator.new(:type => 'Integer',
+                                      :item => 'ANY',
+                                      :reference_type => 'operator',
+                                      :operator => operator,
+                                      :precedence_overridden => true)
+  end
+
+  it 'should be an instance of ExprOperator' do
+    @expr_operator.should be_an_instance_of ExprOperator
+  end
+
+  it 'operator should be assigned properly' do
+    @expr_operator.operator.value.should be_equal 2001
+  end
+
+  it 'precedence_overridden should be assigned properly' do
+    @expr_operator.precedence_overridden.should be_true
+  end
+end