open_ehr 0.6.1

data/lib/open_ehr/rm/composition.rb

@@ -0,0 +1,103 @@
+# rm::composition
+# composition module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109005072243_448526_217Report.html
+# refs #79
+include OpenEHR::RM::Common::Archetyped
+module OpenEHR
+  module RM
+    module Composition
+      class Composition < Locatable
+        attr_reader :language, :category, :territory, :composer
+        attr_accessor :content, :context
+
+        def initialize(args = { })
+          super(args)
+          self.language = args[:language]
+          self.category = args[:category]
+          self.territory = args[:territory]
+          self.composer = args[:composer]
+          self.content = args[:content]
+          self.context = args[:context]
+        end
+
+        def language=(language)
+          if language.nil?
+            raise ArgumentError, 'language is mandatory'
+          end
+          @language = language
+        end
+
+        def category=(category)
+          if category.nil?
+            raise ArgumentError, 'category is mandatory'
+          end
+          @category = category
+        end
+
+        def territory=(territory)
+          if territory.nil?
+            raise ArgumentError, 'territory is mandatory'
+          end
+          @territory = territory
+        end
+
+        def composer=(composer)
+          if composer.nil?
+            raise ArgumentError, 'composer is mandatory'
+          end
+          @composer = composer
+        end
+
+        def is_persistent?
+          return category.value == 'persistent'
+        end
+      end
+
+      class EventContext < Pathable
+        attr_reader :start_time, :setting, :participations, :location
+        attr_accessor :end_time, :other_context
+
+        def initialize(args = { })
+          super(args)
+          self.start_time = args[:start_time]
+          self.setting = args[:setting]
+          self.end_time = args[:end_time]
+          self.participations = args[:participations]
+          self.location = args[:location]
+          self.other_context = args[:other_context]
+        end
+
+        def start_time=(start_time)
+          if start_time.nil?
+            raise ArgumentError, 'start_time is mandatory'
+          end
+          @start_time = start_time
+        end
+
+        def setting=(setting)
+          if setting.nil?
+            raise ArgumentError, 'setting is mandatory'
+          end
+          @setting = setting
+        end
+
+        def participations=(participations)
+          if !participations.nil? and participations.empty?
+            raise ArgumentError, 'participations should not be empty'
+          end
+          @participations = participations
+        end
+
+        def location=(location)
+          if !location.nil? and location.empty?
+            raise ArgumentError, 'location should not be empty'
+          end
+          @location = location
+        end
+      end
+
+      autoload :Content, 'composition/content'
+
+    end # end of Composition
+  end # end of RM
+end # end of OpenEHR

data/lib/open_ehr/rm/data_structures/history.rb

@@ -0,0 +1,117 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# rm::data_structures::history
+# history module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109157527311_729550_7234Report.html
+# refs #55
+require 'time'
+require 'active_support/core_ext'
+include OpenEHR::RM::DataStructures
+include OpenEHR::RM::Common::Archetyped
+
+module OpenEHR
+  module RM
+    module DataStructures
+      module History
+        class History < DataStructure
+          attr_reader :origin, :events
+          attr_accessor :duration, :period, :summary
+
+          def initialize(args = { })
+            super(args)
+            self.origin = args[:origin]
+            self.duration = args[:duration]
+            self.period = args[:period]
+            self.events = args[:events]
+            self.summary = args[:summary]
+          end
+
+          def origin=(origin)
+            raise ArgumentError, 'origin is mandatory' if origin.nil?
+            @origin = origin
+          end
+
+          def events=(events)
+            if !events.nil? and events.empty?
+              raise ArgumentError, 'events should not be empty'
+            end
+            @events = events
+          end
+
+          def is_periodic?
+            return !@period.nil?
+          end
+        end
+
+        class Event < Locatable
+          attr_reader :data, :time
+          attr_accessor :state
+
+          def initialize(args = { })
+            super(args)
+            self.data = args[:data]
+            self.time = args[:time]
+            self.state = args[:state]
+          end
+
+          def data=(data)
+            raise ArgumentError, 'data is mandatory' if data.nil?
+            @data = data
+          end
+
+          def time=(time)
+            raise ArgumentError, 'time is mandatory' if time.nil?
+            @time = time
+          end
+
+          def offset
+            return @time.diff(@parent.origin)
+          end
+        end
+
+        class PointEvent < Event
+
+        end
+
+        class IntervalEvent < Event
+          attr_reader :width, :math_function
+          attr_accessor :sample_count
+
+          def initialize(args = { })
+            super(args)
+            self.width = args[:width]
+            self.math_function = args[:math_function]
+            self.sample_count = args[:sample_count]
+          end
+
+          def width=(width)
+            raise ArgumentError, 'width is mandatory' if width.nil?
+            @width = width
+          end
+
+          def math_function=(math_function)
+            if math_function.nil?
+              raise ArgumentError, 'math_function is mandatory'
+            end
+            @math_function = math_function
+          end
+
+          def interval_start_time
+            date_time = ::Time.iso8601(time.as_string)
+            start_time = (@width.years).years.ago date_time
+            start_time = (@width.months).months.ago start_time
+            start_time = (@width.days).days.ago start_time
+            start_time = (@width.hours).hours.ago start_time
+            start_time = (@width.minutes).minutes.ago start_time
+            seconds = @width.seconds
+            unless @width.fractional_second.nil?
+              seconds += @width.fractional_second
+            end
+            start_time = seconds.ago start_time
+            return DvDateTime.new(:value => start_time.iso8601)
+          end
+        end
+      end # end of History
+    end # end of DataStructure
+  end # end of RM
+end # end of OpenEHR

data/lib/open_ehr/rm/data_structures/item_structure/representation.rb

@@ -0,0 +1,63 @@
+# rm::data_structures::item_structure::representation
+# representation module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109066789167_738055_2581Report.html
+# refs #53
+module OpenEHR
+  module RM
+    module DataStructures
+      module ItemStructure
+        module Representation
+          class Item < OpenEHR::RM::Common::Archetyped::Locatable
+            def initialize(args = {})
+              super(args)
+            end
+          end
+
+          class Element < Item
+            attr_accessor :value
+            attr_reader :null_flavor
+            def initialize(args = {})
+              super(args)
+              self.value = args[:value]
+              self.null_flavor= args[:null_flavor]
+            end
+
+            def null_flavor=(null_flavor)
+              sr = nil
+              if !null_flavor.nil? and
+                  null_flavor.defining_code.terminology_id.name == 'openehr'
+                sr = Terminology.find(:first,                                  
+                                      :conditions => "code = '#{null_flavor.defining_code.code_string}'")
+              end
+              if null_flavor.nil? or (!sr.nil? and sr.group == 'null flavours')
+                @null_flavor = null_flavor
+              else
+                raise ArgumentError, 'null_flavor is invalid'
+              end
+            end
+
+            def is_null?
+              return @value.nil?
+            end
+          end
+
+          class Cluster < Item
+            attr_reader :items
+
+            def initialize(args = {})
+              super(args)
+              self.items = args[:items]
+            end
+
+            def items=(items)
+              if !items.nil? and items.empty?
+                raise ArgumentError, 'items should not empty'
+              end
+              @items = items
+            end
+          end
+        end # of Representation
+      end # of ItemStructure
+    end # of DataStructures
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/data_structures/item_structure.rb

@@ -0,0 +1,216 @@
+# rm::data_structures::item_structure
+# ItemStructure module
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109346709572_859750_3810Report.html
+# refs #54
+require 'set'
+include OpenEHR::RM::DataStructures
+module OpenEHR
+  module RM
+    module DataStructures
+      module ItemStructure
+
+        autoload :Representation, 'item_structure/representation'
+
+        class ItemStructure < DataStructure
+        end
+
+        class ItemSingle < ItemStructure
+          attr_reader :item
+
+          def initialize(args = {})
+            super(args)
+            self.item = args[:item]
+          end
+
+          def as_hierarchy
+            return @item
+          end
+
+          def item=(item)
+            raise ArgumentError, 'item is mandatory' if item.nil?
+            @item = item
+          end
+        end
+
+        class ItemList < ItemStructure
+          attr_accessor :items
+
+          def initialize(args = {})
+            super(args)
+            self.items = args[:items]
+          end
+
+          def item_count
+            unless @items.nil?
+              return @items.size
+            else
+              return 0
+            end
+          end
+
+          def names
+            return @items.collect{|item| item.name}
+          end
+
+          def named_item(a_name)
+            @items.each do |item|
+              return item if item.name.value == a_name
+            end
+            return nil
+          end
+
+          def ith_item(i)
+            raise ArgumentError, 'index invalid' if i <= 0
+            return @items[i - 1]
+          end
+
+          def as_hierarchy
+            return Cluster.new(:name => @name,
+                               :archetype_node_id => @archetype_node_id,
+                               :items => @items)
+          end
+        end
+
+        class ItemTable < ItemStructure
+          attr_accessor :rows
+
+          def initialize(args = {})
+            super(args)
+            self.rows = args[:rows]
+          end
+
+          def row_count
+            if @rows.nil?
+              return 0
+            else
+              return @rows.size
+            end
+          end
+
+          def column_count
+            if @rows.nil?
+              return 0
+            else
+              return @rows[0].items.count
+            end
+          end
+
+          def row_names
+            if @rows.nil?
+              return []
+            else
+              return @rows.collect{|r| r.name}
+            end
+          end
+
+          def column_names
+            if @rows.nil?
+              return []
+            else
+              return @rows[0].items.collect{|i| i.name}
+            end
+          end
+
+          def ith_row(i)
+            raise ArgumentError, 'invalid index' if i<=0 or i>@rows.size
+            return @rows[i - 1]
+          end
+
+          def has_row_with_name?(key)
+            raise ArgumentError, 'invalid argument' if key.nil? or key.empty?
+            @rows.each do |row|
+              return true if row.items[0].name.value == key
+            end
+            return false
+          end
+
+          def has_column_with_name?(key)
+            raise ArgumentError, 'invalid argument' if key.nil? or key.empty?
+            self.column_names.each do |name|
+              return true if name.value == key
+            end
+            return false
+          end
+
+          def named_row(key)
+            raise ArgumentError, 'invalid argument' unless has_row_with_name?(key)
+            @rows.each do |row|
+              return row if row.items[0].name.value == key
+            end
+          end
+
+          def has_row_with_key?(keys)
+            keys.each do |key|
+              @rows.each do |row|
+                return true if row.items[0].name.value == key
+              end
+            end
+            return false
+          end
+
+          def row_with_key(keys)
+            unless has_row_with_key?(keys)
+              raise ArgumentError, 'no row for key'
+            end
+            keys.each do |key|
+              @rows.each do |row|
+                return row if row.items[0].name.value == key
+              end
+            end
+          end
+
+          def element_at_cell_ij(i,j)
+            return @rows[i-1].items[j-1]
+          end
+
+          def element_at_named_cell(row_key, column_key)
+            i,j=0,0
+            @rows[0].items.each do |c|
+              break if c.name.value == column_key
+              i+=1
+            end
+            @rows.each do |row|
+              break if row.name.value == row_key
+              j+=1
+            end            
+            return element_at_cell_ij(i,j)
+          end
+
+          def as_hierarchy
+            return @rows[0]
+          end
+        end
+
+        class ItemTree < ItemStructure
+          attr_accessor :items
+
+          def initialize(args ={ })
+            super(args)
+            self.items = args[:items]
+          end
+
+          def has_element_path?(path)
+            paths = [ ]
+            @items.each do |item|
+              paths << item.archetype_node_id
+            end
+            return paths.include? path
+          end
+
+          def element_at_path(path)
+            @items.each do |item|
+              return item if item.archetype_node_id == path
+            end
+            return nil
+          end
+
+          def as_hierarchy
+            return Cluster.new(:name => @name,
+                               :archetype_node_id => @archetype_node_id,
+                               :items => @items)
+          end
+        end
+      end # of ItemStructure
+    end # of DataStructures
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/data_structures.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# rm::data_structures
+# class DATA_STRUCTURE
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1140447518205_872539_864Report.html
+# refs #59
+
+module OpenEHR
+  module RM
+    module DataStructures
+      autoload :ItemStructure, 'data_structures/item_structure'
+      autoload :History, 'data_structures/history'
+
+      class DataStructure < OpenEHR::RM::Common::Archetyped::Locatable
+        def initialize(args = { })
+          super(args)
+        end
+
+        def as_hierarchy
+          raise NotImplementedError, "as_hirarchy must be implemented"
+        end
+      end
+    end # of Data_Structures
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/data_types/basic.rb

@@ -0,0 +1,108 @@
+# This module is implemented from this UML:
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067591791_562382_3151Report.html
+# Ticket refs #52
+module OpenEHR
+  module RM
+    module DataTypes
+      module Basic
+        module CanonicalFragment
+        end
+
+        class DataValue
+          include OpenEHR::RM::Support::Definition::BasicDefinition
+          attr_accessor :value
+          alias :v :value
+
+          def initialize(args = {})
+            self.value = args[:value]
+          end
+
+          def ==(other)
+            return self.value == other.value
+          end
+        end
+
+        class DvBoolean < DataValue
+          def initialize(args)
+            super(args)
+          end
+
+          def value=(value)
+            raise ArgumentError, "value must not be nil" if value.nil?
+            if value == true or value =~ /TRUE/i
+              @value = true
+            else
+              @value = false
+            end
+          end
+
+          def value?
+            @value == true
+          end
+        end  # end of DvBoolean
+
+        class DvState < DataValue
+          attr_reader :is_terminal
+
+          def initialize(args)            
+            super(args)
+            self.is_terminal = args[:is_terminal]
+          end
+
+          def value=(v)
+            raise ArgumentError, "value should not be nil" if v.nil?
+            @value = v
+          end
+
+          def is_terminal?
+            @is_terminal
+          end
+
+          def is_terminal=(s)
+            raise ArgumentError, "terminal should not be nil" if s.nil?
+            @is_terminal = s
+          end
+        end # end of DvState
+
+        class DvIdentifier < DataValue
+          attr_reader :issuer, :assigner, :id, :type
+
+          def initialize(args = {})
+            self.issuer = args[:issuer]
+            self.assigner = args[:assigner]
+            self.id = args[:id]
+            self.type = args[:type]
+          end
+
+          def issuer=(issuer)
+            if issuer.nil? or issuer.empty?
+              raise ArgumentError, 'issuer is mandatory'
+            end
+            @issuer = issuer
+          end
+
+          def assigner=(assigner)
+            if assigner.nil? or assigner.empty?
+              raise ArgumentError, 'assigner is mandatory'
+            end
+            @assigner = assigner
+          end
+
+          def id=(id)
+            if id.nil? or id.empty?
+              raise ArgumentError, 'id is manadtory'
+            end
+            @id = id
+          end
+
+          def type=(type)
+            if type.nil? or type.empty?
+              raise ArgumentError, 'type is mandatory'
+            end
+            @type = type
+          end
+        end #end of DvIdentifier
+      end # end of Basic
+    end # end of DataTypes
+  end # end of RM
+end # end of OpenEHR