openehr 1.1.4 → 1.1.5

data/.gitignore

@@ -0,0 +1,32 @@
+*~
+*#
+
+\#*
+.\#*
+
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc/
+.yardoc
+
+# bundler
+.bundle
+*.lock
+
+# jeweler generated
+pkg
+
+# logger generated
+log
+
+# subversion ignore
+.svn
+
+tmp
+*.gem
+*.rbc

data/Gemfile

@@ -1,23 +1,3 @@
 source "http://rubygems.org"
 
-gem 'xml-simple'
-gem 'activesupport'
-gem 'locale'
-gem 'builder'
-gem 'jeweler'
-gem 'i18n'
-gem 'treetop'
-gem 'polyglot'
-gem 'rdoc'
-gem 'sqlite3'
-gem 'activerecord'
-
-group :development, :test do
-  gem 'rspec'
-  gem 'guard-rspec'
-  gem 'ruby-debug19'
-  gem 'spork',  '~> 1.0rc'
-  gem 'guard-spork'
-  gem 'simplecov'
-  gem 'libnotify'
-end
+gemspec

data/Guardfile

@@ -1,12 +1,20 @@
 guard 'spork' do
   watch('spec/spec_helper.rb')
+  watch('feature/support/env.rb')
 end
 
-guard 'rspec', :version => 2, :cli => '--drb' do
+guard 'rspec', :cli => '--drb --color' do
   watch(%r{^spec/.+_spec\.rb})
   watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb') { "spec" }
   watch(%r{^lib/open_ehr/parser/.+\.tt}) { "spec/lib/open_ehr/parser" }
 end
 
+guard 'cucumber', cli: '--drb --format progress' do
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})          { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end
+
 notification :libnotify, :timeout => 5, :transient => true, :append => false
+

data/README.rdoc

@@ -5,7 +5,7 @@ Ruby openEHR implementation project.
 
 = Version
 
-Release-1.1.4
+Release-1.1.5
 
 = Requirements
 
@@ -38,6 +38,8 @@ This package excludes:
 * ADL serializer(in progress)
 * ADL validator(in progress)
 * Data store/retrieve would be separate to the other project.
+* Terminology service(moved to open_terminology package)
+* Rails plugin(moved to openehr-rails package
 
 Almost all classes passed the test constructed by RSpec2. These spec
 files are under /spec.
@@ -59,7 +61,7 @@ reference implementation project of the openEHR.
 = Copyright
 The software, including all files in this directory and
 subdirectories is copyrighted to the original authors and
-contributors, 2011.
+contributors, 2011-2013.
 
 All Rights Reserved.
 
@@ -67,7 +69,7 @@ All Rights Reserved.
 
 This product is under Apache 2.0 license
 
-   Copyright [2012] Shinji Kobayashi, Akimichi Tatsukawa, openEHR.jp
+   Copyright [2012,2013] Shinji Kobayashi, Akimichi Tatsukawa, openEHR.jp
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,44 +1,14 @@
 require 'rubygems'
 require 'bundler'
-require './lib/openehr'
+require "bundler/gem_tasks"
+Bundler::GemHelper::install_tasks
 
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
 require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "openehr"
-  gem.homepage = "http://github.com/skoba/ruby-impl-openehr"
-  gem.license = "Apache 2.0 license"
-  gem.summary = %Q{Ruby implementation of the openEHR specification}
-  gem.description = %Q{This project is an implementation of the openEHR specification on Ruby.}
-  gem.email = "skoba@moss.gr.jp"
-  gem.authors = ["Shinji KOBAYASHI", "Akimichi Tatsukawa"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
-
 require 'rspec/core'
 require 'rspec/core/rake_task'
+
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
 task :default => :spec
-
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "gempack #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/features/rmfactory.feature

@@ -0,0 +1,9 @@
+Feature: RMFactory generates RM insntances
+  In order to generate RM instance by archetype definition
+  As RM factory
+  RM Type and attributes should be specified
+
+  Scenario: RMFactory generates DvText instance
+    Given "DV_TEXT" in archetype definition with attribute
+    When RM Factory generates instance
+    Then DvText instance should be available

data/features/step_definitions/rmfactory_steps.rb

@@ -0,0 +1,12 @@
+Given /^\"DV_TEXT\" in archetype definition with attribute$/ do
+  @type= "DV_TEXT"
+  @params = [value: 'text']
+end
+
+When /^RM Factory generates instance$/ do
+  @dv_text = OpenEHR::RM::Factory.create(@type, @params)
+end
+
+Then /^DvText instance should be available$/ do
+  @dv_text.should be_an_instance_of OpenEHR::RM::DataTypes::Text::DvText
+end

data/features/support/env.rb

@@ -0,0 +1,10 @@
+require 'spork'
+
+Spork.prefork do
+  $LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+  require 'openehr'
+end
+
+Spork.each_run do
+
+end

data/lib/openehr.rb

@@ -1,10 +1,11 @@
 $:.unshift(File.dirname(__FILE__))
+require 'openehr/version'
 
 module OpenEHR
   autoload :AssumedLibraryTypes, 'openehr/assumed_library_types'
   autoload :RM, 'openehr/rm'
   autoload :AM, 'openehr/am'
-  autoload :Terminology, 'openehr/terminology'
-  autoload :Serializer, 'openehr/serializer'
   autoload :Parser, 'openehr/parser'
+  autoload :Serializer, 'openehr/serializer'
+  autoload :Terminology, 'openehr/terminology'
 end

data/lib/openehr/rm.rb

@@ -11,5 +11,6 @@ module OpenEHR
     autoload :Integration, 'rm/integration'
     autoload :Security, 'rm/security'
     autoload :Support, 'rm/support'
+    autoload :Factory, 'rm/factory'
   end
 end

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

@@ -46,7 +46,7 @@ module OpenEHR
 
           def initialize(args)            
             super(args)
-            self.is_terminal = args[:is_terminal]
+            self.terminal = args[:is_terminal].nil? ? args[:terminal] : args[:is_terminal]
           end
 
           def value=(v)
@@ -58,10 +58,14 @@ module OpenEHR
             @is_terminal
           end
 
+          alias terminal? is_terminal?
+
           def is_terminal=(s)
             raise ArgumentError, "terminal should not be nil" if s.nil?
             @is_terminal = s
           end
+
+          alias terminal= is_terminal=
         end # end of DvState
 
         class DvIdentifier < DataValue

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

@@ -13,7 +13,7 @@ module OpenEHR
 
         class DvOrdered < OpenEHR::RM::DataTypes::Basic::DataValue
           include Comparable
-          attr_accessor :normal_range, :other_refference_ranges, :normal_status
+          attr_accessor :normal_range, :other_reference_ranges, :normal_status
 
           def initialize(args = {})
             super(args)

data/lib/openehr/rm/ehr.rb

@@ -93,7 +93,7 @@ module OpenEHR
         end
       end
 
-      class VersionedEHRAccesss < VersionedObject
+      class VersionedEHRAccess < VersionedObject
 
       end
 

data/lib/openehr/rm/factory.rb

@@ -0,0 +1,180 @@
+require 'active_support/inflector'
+
+module OpenEHR
+  module RM
+    class Factory
+      def self.create(type, *param)
+        type = type.downcase.camelize if type.include? '_'
+        class_eval("#{type}Factory").create(*param)
+      end
+    end
+
+    class DvBooleanFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Basic::DvBoolean.new(*param)
+      end
+    end
+
+    class DvStateFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Basic::DvState.new(*param)
+      end
+    end
+
+    class DvIdentifierFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Basic::DvIdentifier.new(*param)
+      end
+    end
+
+    class DvTextFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Text::DvText.new(*param)
+      end
+    end
+
+    class TermMappingFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Text::TermMapping.new(*param)
+      end
+    end
+
+    class CodePhraseFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Text::CodePhrase.new(*param)
+      end
+    end
+
+    class DvCodedTextFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Text::DvCodedText.new(*param)
+      end
+    end
+
+    class DvParagraphFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Text::DvParagraph.new(*param)
+      end
+    end
+
+    class DvOrderedFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DvOrdered.new(*param)
+      end
+    end
+
+    class DvIntervalFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DvInterval.new(*param)
+      end
+    end
+
+    class ReferenceRangeFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::ReferenceRange.new(*param)
+      end
+    end
+
+    class DvOrdinalFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(*param)
+      end
+    end
+
+    class DvQuantifiedFactory
+      def self.create(*param)
+        DataTypes::Quantity::DvQuantified.new(*param)
+      end
+    end
+
+    class DvAmountFactory
+      def self.create(*param)
+        DataTypes::Quantity::DvAmount.new(*param)
+      end
+    end
+
+    class DvQuantityFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DvQuantity.new(*param)
+      end
+    end
+
+    class DvCountFactory
+      def self.create(*param)
+        DataTypes::Quantity::DvCount.new(*param)
+      end
+    end
+
+    class DvProportionFactory
+      def self.create(*param)
+        DataTypes::Quantity::DvProportion.new(*param)
+      end
+    end
+
+    class DvAbsoluteQuantityFactory
+      def self.create(*param)
+        DataTypes::Quantity::DvAbsoluteQuantity.new(*param)
+      end
+    end
+
+    class DvTemporalFactory
+      def self.create(*param)
+        DataTypes::Quantity::DateTime::DvTemporal.new(*param)
+      end
+    end
+    
+    class DvDateFactory
+      def self.create(*param)
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDate.new(*param)
+      end
+    end
+
+    class DvTimeFactory
+      def self.create(*param)
+        DataTypes::Quantity::DateTime::DvTime.new(*param)
+      end
+    end
+
+    class DvDateTimeFactory
+      def self.create(*param)
+        DataTypes::Quantity::DateTime::DvDateTime.new(*param)
+      end
+    end
+
+    class DvDurationFactory
+      def self.create(*param)
+        DataTypes::Quantity::DateTime::DvDuration.new(*param)
+      end
+    end
+
+    class DvEncapsulatedFactory
+      def self.create(*param)
+        DataTypes::Encapsulated::DvEncapsulated.new(*param)
+      end
+    end
+
+    class DvMultimediaFactory
+      def self.create(*param)
+        DataTypes::Encapsulated::DvMultimedia.new(*param)
+      end
+    end
+
+    class DvParsableFactory
+      def self.create(*param)
+        DataTypes::Encapsulated::DvParsable.new(*param)
+      end
+    end
+
+    class DvUriFactory
+      def self.create(*param)
+        DataTypes::URI::DvUri.new(*param)
+      end
+    end
+
+    class DvEhrUriFactory
+      def self.create(*param)
+        DataTypes::URI::DvEhrUri.new(*param)
+      end
+    end
+  end
+end