Changeset 297


Ignore:
Timestamp:
Sep 25, 2009, 12:15:59 PM (15 years ago)
Author:
KOBAYASHI, Shinji
Message:

hand merge

Location:
ruby/trunk
Files:
13 edited
4 copied

Legend:

Unmodified
Added
Removed

  • ruby/trunk/config/environment.rb

    r164 r297  
    66
    77# Specifies gem version of Rails to use when vendor/rails is not present
    8 RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION
     8#RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION
    99
    1010# Bootstrap the Rails environment, frameworks, and default configuration

  • ruby/trunk/lib/open_ehr/assumed_library_types.rb

    r167 r297  
    33require 'time'
    44
    5 module OpenEhr
     5module OpenEHR
    66  module AssumedLibraryTypes
    77    class Any < Object
    … …  
    1212      attr_reader :lower, :upper
    1313     
    14       def initialize(lower, upper,
    15                      lower_included = nil, upper_included = nil)
    16         check_lower_upper(lower, upper)
    17         self.lower_included = lower_included
    18         self.upper_included = upper_included
     14      def initialize(args = {})
     15        check_lower_upper(args[:lower], args[:upper])
     16        self.lower_included = args[:lower_included]
     17        self.upper_included = args[:upper_included]
    1918      end
    2019
    … …  
    4746
    4847      def upper_included=(upper_included)
    49         if (upper == nil) && (upper_included != nil)
     48        if (@upper.nil?) && (upper_included != nil)
    5049          raise ArgumentError, "upper is not set"
    5150        end
    … …  
    5857
    5958      def has?(value)
    60         if ((@lower < value) && (value < @upper) ||
    61             (@lower_included == true) && (@lower == value) ||
    62             (@upper_included == true) && (@upper == value))
     59        if ((@lower.nil?||@lower < value||((@lower_included == true) && (@lower == value)))&&
     60            (@upper.nil?||value < @upper||((@upper_included == true) && (@upper == value))))
    6361          true
    6462        else
    … …  
    7068
    7169      def check_lower_upper(lower, upper)
    72         if (lower == nil) && (upper == nil)
     70        if lower.nil? && upper.nil?
    7371          raise ArgumentError, "Either lower or upper must be assigned"
    7472        end
    … …  
    8381    end # end of Interval
    8482 
    85     class TIME_DEFINITIONS < Any
     83    class TimeDefinitions < Any
    8684      DAYS_IN_LEAP_YEAR = 366
    8785      DAYS_IN_WEEK = 7
    … …  
    9795
    9896      def self.valid_year?(year)
    99         year >= 0
     97        return !year.nil? && year >= 0
    10098      end
    10199
    102100      def self.valid_day?(y, m, d)
    103         Date.valid_date?(y,m,d) and valid_year? y
     101        unless y.nil? || m.nil? || d.nil?
     102          return Date.valid_date?(y,m,d)
     103        end
     104        if (y.nil?) || (m.nil? && !d.nil?)
     105          return false
     106        end
     107        return self.valid_year?(y) && self.valid_month?(m)
    104108      end
    105109
    106110      def self.valid_hour?(h,m = nil, s = nil)
     111        if h.nil?
     112          return false
     113        end
    107114        if !m.nil? and !valid_minute?(m)
    108115          return false
    … …  
    113120        (h >= 0 and h < HOURS_IN_DAY) or (h == HOURS_IN_DAY and m == 0 and s == 0)
    114121      end
     122
    115123      def self.valid_minute?(mi)
    116124        mi >= 0 and mi < MINUTES_IN_HOUR
    117125      end
     126
    118127      def self.valid_second?(s)
    119128        s >= 0 and s < SECONDS_IN_MINUTE
    120129      end
     130
    121131      def self.valid_month?(mo)
    122132        mo >= 1 and mo <= MONTH_IN_YEAR
    123133      end
    124     end # end of TIME_DEFINITIONS
    125 
    126     module ISO8601_DATE_MODULE
     134    end # end of TimeDefinitions
     135
     136    module ISO8601DateModule
    127137      attr_reader :year, :month, :day
     138
    128139      def year=(year)
    129         raise ArgumentError, "Year is not valid" unless ISO8601_DATE.valid_year?(year)
     140        unless ISO8601Date.valid_year?(year)
     141          raise ArgumentError, "Year is not valid"
     142        end
    130143        @year = year
    131144      end
     145
    132146      def month=(month)
    133         raise ArgumentError, "Month is not valid" unless month.nil? or ISO8601_DATE.valid_month?(month)
     147        raise ArgumentError, "Month is not valid" unless month.nil? or ISO8601Date.valid_month?(month)
    134148        @month = month
    135149      end
    136150
    137151      def day=(day)
    138         raise ArgumentError, "Day is not valid" unless day.nil? or ISO8601_DATE.valid_day?(@year, @month, day)
     152       
     153        raise ArgumentError, "Day is not valid" unless day.nil? or ISO8601Date.valid_day?(@year, @month, day)
    139154        @day = day
    140155      end
    … …  
    176191    end
    177192
    178     class ISO8601_DATE < TIME_DEFINITIONS
    179       include ISO8601_DATE_MODULE
     193    class ISO8601Date < TimeDefinitions
     194      include ISO8601DateModule
    180195      def initialize(string)
    181196        /(\d{4})(?:-(\d{2})(?:-(\d{2})?)?)?/ =~ string
    … …  
    207222    end # end of ISO8601_DATE
    208223
    209     module ISO8601_TIME_MODULE
     224    module ISO8601TimeModule
    210225      attr_reader :hour, :minute, :second, :fractional_second, :timezone
    211226
    212227      def hour=(hour)
    213         raise ArgumentError, "hour is not valid" if !ISO8601_TIME.valid_hour?(hour, @minute, @second)
     228        unless ISO8601Time.valid_hour?(hour, @minute, @second)
     229          raise ArgumentError, "hour is not valid"
     230        end
    214231        @hour = hour
    215232      end
    … …  
    220237
    221238      def minute=(minute)
    222         raise ArgumentError, "minute is not valid" if !minute.nil? and !ISO8601_TIME.valid_minute?(minute)
     239        raise ArgumentError, "minute is not valid" if !minute.nil? and !ISO8601Time.valid_minute?(minute)
    223240        @minute = minute
    224241      end
    … …  
    230247      def second=(second)
    231248        raise ArgumentError, "minute not defined" if @minute.nil? and !second.nil?
    232         raise ArgumentError, "second is not valid" if !second.nil? and !ISO8601_TIME.valid_second?(second)
     249        raise ArgumentError, "second is not valid" if !second.nil? and !ISO8601Time.valid_second?(second)
    233250        @second = second
    234251      end
    … …  
    237254        raise ArgumentError, "minute not defined" if minute_unknown? and !fractional_second.nil?
    238255        raise ArgumentError, "second not defined" if second_unknown? and !fractional_second.nil?
    239         raise ArgumentError, "fractional second should be lower than 1.0" if !fractional_second.nil? and fractional_second >= 1.0
     256        if !fractional_second.nil? &&
     257            (fractional_second < 0.0 || fractional_second >= 1.0)
     258          raise ArgumentError, 'fractional second should be between 0.0 - 1.0'
     259        end
    240260        @fractional_second = fractional_second
    241261      end
    242262
    243263      def has_fractional_second?
    244         if @fractional_second.nil?
    245           return false
    246         else
    247           return true
    248         end
     264        return !@fractional_second.nil?
    249265      end
    250266
    … …  
    291307    end
    292308
    293     class ISO8601_TIME < TIME_DEFINITIONS
    294       include ISO8601_TIME_MODULE
     309    class ISO8601Time < TimeDefinitions
     310      include ISO8601TimeModule
    295311      def initialize(string)
    296312        /(\d{2}):?(\d{2})?(:?)(\d{2})?((\.|,)(\d+))?(Z|([+-](\d{2}):?(\d{2})))?/ =~ string
    … …  
    321337        end
    322338      end
     339
    323340      def self.valid_iso8601_time?(s)
    324         if /(\d{2}):?(\d{2})?(:?)(\d{2})?((\.|,)(\d+))?(Z|([+-](\d{2}):?(\d{2})))?/ =~ s
     341        if /^(\d{2}):?(\d{2})?(:?)(\d{2})?((\.|,)(\d+))?(Z|([+-](\d{2}):?(\d{2})))?$/ =~ s
    325342# ISO 8601 regular expression by H. Yuki
    326343#  http://digit.que.ne.jp/work/wiki.cgi?Perl%E3%83%A1%E3%83%A2%2FW3C%E5%BD%A2%E5%BC%8F%E3%81%AE%E6%97%A5%E6%99%82%E3%81%AE%E8%A7%A3%E6%9E%90
    … …  
    352369                return false
    353370              end
    354             else
    355               return false
    356371            end
    357372          end
    … …  
    363378    end # end of ISO8601_TIME
    364379
    365     module ISO8601_DATE_TIME_MODULE
    366       include ISO8601_DATE_MODULE, ISO8601_TIME_MODULE
     380    module ISO8601DateTimeModule
     381      include ISO8601DateModule, ISO8601TimeModule
    367382      def as_string
    368383        if (!@year.nil? and !@month.nil? and !@day.nil?)
    … …  
    392407    end
    393408
    394     class ISO8601_DATE_TIME < ISO8601_DATE
    395       include ISO8601_DATE_TIME_MODULE
     409    class ISO8601DateTime < ISO8601Date
     410      include ISO8601DateTimeModule
    396411      def initialize(string)
    397         /(\d{4})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|([+-]\d{2}):?(\d{2}))?)?)?)?/ =~ string
    398         if $1.empty?
     412        unless /(\d{4})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|([+-]\d{2}):?(\d{2}))?)?)?)?/ =~ string
    399413          raise ArgumentError, 'format invalid'
    400414        else
    … …  
    439453    end
    440454 
    441     class ISO8601_TIMEZONE
     455    class ISO8601Timezone
    442456      attr_accessor :sign, :hour, :minute
    443457
     458      def initialize(string)
     459        unless /(Z|(([+-])(\d{2}):?(\d{2})))/ =~ string
     460          raise ArgumentError, 'invaild format'
     461        end
     462        if $1 == 'Z'
     463          @sign, @hour, @minute = +1, 0, 0
     464        else
     465          @sign, @hour, @minute = ($3+'1').to_i, $4.to_i , $5.to_i
     466        end
     467      end
     468
    444469      def is_gmt?
    445         @sign == "+1" and @hour == 0 and @minute == 0
     470        @sign == +1 and @hour == 0 and @minute == 0
    446471      end
    447472
    448473      def as_string
    449         if @sign == "+1"
     474        if @sign == +1
    450475          s = "+"
    451         elsif @sign == "-1"
     476        elsif @sign == -1
    452477          s = "-"
    453478        end
    454         sprintf("Z%s%02d%02d", s, @hour, @minute)
    455       end
    456     end # end of ISO8601_TIMEZONE
    457 
    458     module ISO8601_DURATION_MODULE
     479        sprintf("%s%02d%02d", s, @hour, @minute)
     480      end
     481    end # end of ISO8601Timezone
     482
     483    module ISO8601DurationModule
    459484      attr_reader :years, :months, :weeks, :days
    460485      attr_reader :hours, :minutes, :seconds, :fractional_second
    … …  
    546571      end
    547572    end
    548     class ISO8601_DURATION < TIME_DEFINITIONS
    549       include ISO8601_DURATION_MODULE
     573
     574    class ISO8601Duration < TimeDefinitions
     575      include ISO8601DurationModule
    550576      def initialize(str)
    551577        /^P((\d+)Y)?((\d+)M)?((\d+)W)?((\d)D)?(T((\d+)H)?((\d+)M)?((\d+)(\.\d+)?S)?)?$/ =~ str
    … …  
    559585        self.fractional_second = $16.to_f
    560586      end
    561     end # end of ISO8601_DURATION
     587    end # end of ISO8601Duration
    562588  end # end of Assumed_Types
    563589end # end of OpenEHR

  • ruby/trunk/lib/open_ehr/rm.rb

    r167 r297  
    99
    1010# OpenEHR::RM
    11 module OpenEhr
     11module OpenEHR
    1212
    1313  autoload :Assumed_Library_Types, "assumed_library_types.rb"

  • ruby/trunk/lib/open_ehr/rm/common/archetyped.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109318114715_211173_0Report.html
    33# Ticket refs #65
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module Common
    … …  
    1717          attr_accessor :parent
    1818
    19           def initialize(parent = nil)
    20             @parent = parent
     19          def initialize(args = { })
     20            self.parent = args[:parent]
    2121          end
    2222
    2323          def item_at_path(path)
    24             raise NotImplementError, "item_at_path must be implemented"
     24            raise NotImplementedError, "item_at_path must be implemented"
    2525          end
    2626
    2727          def items_at_path(path)
    28             raise NotImplementError, "items_at_path must be implemented"
     28            raise NotImplementedError, "items_at_path must be implemented"
    2929          end
    3030
    3131          def path_exists?(path)
    32             raise NotImplementError, "path_exists? must be implemented"
     32            raise NotImplementedError, "path_exists? must be implemented"
    3333          end
    3434
    3535          def path_of_item(item)
    36             raise NotImplementError, "path_of_item must be implemented"
     36            raise NotImplementedError, "path_of_item must be implemented"
    3737          end
    3838
    39           def path_unique(path)
    40             raise NotImplementError, "path_unique must be implemented"
     39          def path_unique?(path)
     40            raise NotImplementedError, "path_unique? must be implemented"
    4141          end
    4242        end
    … …  
    4848
    4949          def initialize(args = { })
    50             super(args[:parent])
     50            super(args)
    5151            self.archetype_node_id = args[:archetype_node_id]
    5252            self.name = args[:name]
    … …  
    5858         
    5959          def archetype_node_id=(archetype_node_id)
    60             raise ArgumentError, 'archetype_node_id should not be nil' if archetype_node_id.nil?
     60            if archetype_node_id.nil? or archetype_node_id.empty?
     61              raise ArgumentError, 'archetype_node_id should not be nil'
     62            end
    6163            @archetype_node_id = archetype_node_id
    6264          end

  • ruby/trunk/lib/open_ehr/rm/data_types/basic.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067591791_562382_3151Report.html
    33# Ticket refs #52
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module DataTypes
    … …  
    1010
    1111        class DataValue
    12           include OpenEhr::RM::Support::Definition::BasicDefinition
     12          include OpenEHR::RM::Support::Definition::BasicDefinition
     13          attr_accessor :value
     14          alias :v :value
     15
     16          def initialize(args = {})
     17            self.value = args[:value]
     18          end
     19
     20          def ==(other)
     21            return self.value == other.value
     22          end
    1323        end
    1424
    1525        class DvBoolean < DataValue
    16           def initialize(value)
    17             self.value = value
     26          def initialize(args)
     27            super(args)
    1828          end
     29
    1930          def value=(value)
    2031            raise ArgumentError, "value must not be nil" if value.nil?
    … …  
    2536            end
    2637          end
     38
    2739          def value?
    2840            @value == true
    … …  
    3143
    3244        class DvState < DataValue
    33           attr_reader :value
     45          attr_reader :is_terminal
    3446
    35           def initialize(value, is_terminal)
    36             self.value=value
    37             self.is_terminal=is_terminal
     47          def initialize(args)           
     48            super(args)
     49            self.is_terminal = args[:is_terminal]
    3850          end
     51
    3952          def value=(v)
    4053            raise ArgumentError, "value should not be nil" if v.nil?
    4154            @value = v
    4255          end
     56
    4357          def is_terminal?
    4458            @is_terminal
    4559          end
     60
    4661          def is_terminal=(s)
    4762            raise ArgumentError, "terminal should not be nil" if s.nil?
    … …  
    5065        end # end of DvState
    5166
    52         class DvIdentifier
    53           attr_accessor :issuer, :assigner, :id, :type
    54           def initialize(assigner, id, issuer, type)
    55             if assigner.nil? or assigner.empty?\
    56               or id.nil? or id.empty? or issuer.nil? or issuer.empty?\
    57               or type.nil? or type.empty?
    58               raise ArgumentError, "invalid argument"
     67        class DvIdentifier < DataValue
     68          attr_reader :issuer, :assigner, :id, :type
     69
     70          def initialize(args = {})
     71            self.issuer = args[:issuer]
     72            self.assigner = args[:assigner]
     73            self.id = args[:id]
     74            self.type = args[:type]
     75          end
     76
     77          def issuer=(issuer)
     78            if issuer.nil? or issuer.empty?
     79              raise ArgumentError, 'issuer is mandatory'
    5980            end
    6081            @issuer = issuer
     82          end
     83
     84          def assigner=(assigner)
     85            if assigner.nil? or assigner.empty?
     86              raise ArgumentError, 'assigner is mandatory'
     87            end
    6188            @assigner = assigner
     89          end
     90
     91          def id=(id)
     92            if id.nil? or id.empty?
     93              raise ArgumentError, 'id is manadtory'
     94            end
    6295            @id = id
     96          end
     97
     98          def type=(type)
     99            if type.nil? or type.empty?
     100              raise ArgumentError, 'type is mandatory'
     101            end
    63102            @type = type
    64103          end

  • ruby/trunk/lib/open_ehr/rm/data_types/encapsulated.rb

    r167 r297  
    55require 'locale/info'
    66
    7 module OpenEhr
     7module OpenEHR
    88  module RM
    99    module DataTypes
    1010      module Encapsulated
    11         class DvEncapsulated  < OpenEhr::RM::DataTypes::Basic::DataValue
    12           attr_reader :language, :charset, :size
    13           def initialize(charset, language, size)
    14             self.charset = charset
    15             self.language = language
    16             self.size = size
     11        class DvEncapsulated  < OpenEHR::RM::DataTypes::Basic::DataValue
     12          attr_reader :language, :charset
     13
     14          def initialize(args = {})
     15            super(args)
     16            self.charset = args[:charset]
     17            self.language = args[:language]
    1718          end
    1819
    19           def size=(size)
    20             if size < 0
    21               raise ArgumentError, "negative size"
    22             end
    23             @size = size
     20          def size
     21            @value.size
    2422          end
    2523
    2624          def language=(language)
    27             if language.nil? ||
     25            if !language.nil? &&
    2826                !Locale::Info.language_code?(language.code_string)
    2927              raise ArgumentError, 'invalid language code'
    … …  
    3331
    3432          def charset=(charset)
    35             if charset.nil? || !charset_valid?(charset.code_string)
     33            if !charset.nil? && !charset_valid?(charset.code_string)
    3634              raise ArgumentError, 'invalid charset'
    3735            end
    … …  
    4038
    4139          private
    42           def size_positive
    43             raise ArgumentError, "size must be positive" if size < 0
    44           end
    4540
    4641          def charset_valid?(charset)
    4742            result = false
    48             open('rm/data_types/charset.lst') do |file|
     43            open('lib/open_ehr/rm/data_types/charset.lst') do |file|
    4944              while line = file.gets
    5045                if charset == line.chomp
    … …  
    6358          attr_accessor :uri, :data, :compression_algorithm,
    6459          :integrity_check, :integrity_check_algorithm, :alternate_text
    65           def initialize(charset, language, size, media_type, uri=nil,
    66                          data=nil, compression_algorithm=nil,
    67                          integrity_check=nil, integrity_check_algorithm=nil,
    68                          alternate_text=nil)
    69             super(charset, language, size)
    70             self.media_type = media_type
    71             @uri = uri
    72             @data = data
    73             @compression_algorithm = compression_algorithm
    74             @integrity_check = integrity_check
    75             @integrity_check_algorithm = integrity_check_algorithm
    76             @alternate_text = alternate_text
     60
     61          def initialize(args = {})
     62            super(args)
     63            self.media_type = args[:media_type]
     64            self.uri = args[:uri]
     65            self.data = args[:data]
     66            self.compression_algorithm = args[:compression_algorithm]
     67            self.integrity_check = args[:integrity_check]
     68            self.integrity_check_algorithm = args[:integrity_check_algorithm]
     69            self.alternate_text = args[:alternate_text]
    7770          end
     71
    7872          def media_type=(media_type)
    7973            if media_type.code_string.nil?
    … …  
    8579
    8680        class DvParsable < DvEncapsulated
    87           attr_reader :value, :formalism
    88           def initialize(charset, language, size, formalism, value)
    89             super(charset, language, size)
    90             self.formalism = formalism
    91             self.value = value
    92           end
     81          attr_reader :formalism
    9382
    94           def value=(value)
    95             raise ArgumentError, 'value must not be nil' if value.nil?
    96             @value = value
     83          def initialize(args = {})
     84            super(args)
     85            self.formalism = args[:formalism]
    9786          end
    9887
    9988          def formalism=(formalism)
    100             if formalism.nil?
    101               raise ArgumentError, "formalism must not be nil"
    102             elsif formalism.empty?
    103               raise ArgumentError, "formalism must nto be empty"
     89            if formalism.nil? || formalism.empty?
     90              raise ArgumentError, 'formalism is mandatory'
    10491            end
    10592            @formalism = formalism

  • ruby/trunk/lib/open_ehr/rm/data_types/quantity.rb

    r167 r297  
    33# Ticket refs #50
    44require 'assumed_library_types'
    5 module OpenEhr
     5module OpenEHR
    66  module RM
    77    module DataTypes
    … …  
    1010        autoload :Date_Time, "rm/data_types/quantity/date_time.rb"
    1111
    12         class DvOrdered < OpenEhr::RM::DataTypes::Basic::DataValue
     12        class DvOrdered < OpenEHR::RM::DataTypes::Basic::DataValue
    1313          include Comparable
    1414          attr_accessor :normal_range, :other_refference_ranges, :normal_status
    … …  
    5151        end
    5252
    53         class DvInterval < OpenEhr::AssumedLibraryTypes::Interval
     53        class DvInterval < OpenEHR::AssumedLibraryTypes::Interval
    5454
    5555        end

  • ruby/trunk/lib/open_ehr/rm/data_types/text.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067605961_209522_3179Report.html
    33# Ticket refs #48
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module DataTypes
    … …  
    6262        end # of CodePhrase
    6363
    64         class DvText < OpenEhr::RM::DataTypes::Basic::DataValue
     64        class DvText < OpenEHR::RM::DataTypes::Basic::DataValue
    6565          attr_reader :value, :formatting, :hyperlink, :mappings
    6666          attr_reader :language, :encoding
    … …  
    146146        end
    147147
    148         class DvParagraph < OpenEhr::RM::DataTypes::Basic::DataValue
     148        class DvParagraph < OpenEHR::RM::DataTypes::Basic::DataValue
    149149          attr_reader :items
    150150          def initialize(items)

  • ruby/trunk/lib/open_ehr/rm/data_types/uri.rb

    r167 r297  
    44
    55require 'uri'
    6 #require 'uri/generic'
    7 module Uri
    8   class Ehr < ::URI::Generic
     6
     7module URI
     8  class EHR < ::URI::Generic
    99    COMPONENT = [
    1010      :scheme, :path, :fragment, :query
    1111    ].freeze
     12
    1213    def self.build(args)
    1314      tmp = Util::make_components_hash(self, args)
    1415      super(tmp)
    1516    end
     17
    1618    def initialize(*arg)
    1719      super(*arg)
    1820    end
     21
    1922    def self.use_registry
    2023      true
    2124    end
    2225  end
    23   @@schemes['EHR'] = Ehr
     26  @@schemes['EHR'] = EHR
    2427end
    2528
    26 module OpenEhr
     29module OpenEHR
    2730  module RM
    2831    module DataTypes
    2932      module Uri
    30         class DvUri < OpenEhr::RM::DataTypes::Basic::DataValue
    31           def initialize(value)
    32             self.value = value
     33        class DvUri < OpenEHR::RM::DataTypes::Basic::DataValue
     34          def initialize(args = {})
     35            self.value = args[:value]
    3336          end
     37
     38          def value
     39            @value.to_s
     40          end
     41
    3442          def fragment_id
    3543            @value.fragment
    3644          end
     45
    3746          def path
    3847            @value.path
    3948          end
     49
    4050          def query
    4151            @value.query
    4252          end
     53
    4354          def scheme
    4455            @value.scheme
    4556          end
     57
    4658          def value=(value)
    4759            raise ArgumentError, "value is empty" if value.nil?
    4860            parse(value)
    4961          end
    50           def value
    51             @value.to_s
    52           end
     62
    5363          private
     64
    5465          def parse(value)
    5566            @value = ::URI.parse(value)
    … …  
    6172            super(value)
    6273          end
     74
    6375          def value=(value)
    6476            raise ArgumentError, "scheme must be ehr" if !(value =~ /^ehr/i)
    65             parse(value)
     77            @value = parse(value)
    6678          end
    6779        end # of DV_EHR_URI

  • ruby/trunk/lib/open_ehr/rm/security.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_5_1_76d0249_1155650882301_836618_5314Report.html
    33# Ticket refs #41
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module Security

  • ruby/trunk/lib/open_ehr/rm/support/definition.rb

    r167 r297  
    1 module OpenEhr
     1module OpenEHR
    22  module RM
    33    module Support

  • ruby/trunk/lib/open_ehr/rm/support/identification.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109331021343_528780_2066Report.html
    33# Ticket refs #39
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module Support
    77      module Identification
    8         class ObjectId
     8        class ObjectID
    99          attr_reader :value
    1010
    11           def initialize(value)
    12             self.value=value
     11          def initialize(args = {})
     12            self.value=args[:value]
    1313          end
    1414
    … …  
    1717            @value = value           
    1818          end
     19
    1920          def ==(object_id)
    20             @value == object_id.value
     21            self.value == object_id.value
    2122          end
    2223        end # of ObjectID
    … …  
    2526          attr_reader :namespace, :type, :id
    2627
    27           def initialize(namespace, type, id)
    28             self.namespace = namespace
    29             self.type = type
    30             self.id = id
     28          def initialize(args = {})
     29            self.namespace = args[:namespace]
     30            self.type = args[:type]
     31            self.id = args[:id]
    3132          end
    3233
    3334          def namespace=(namespace)
    34             raise ArgumentError if namespace.nil? or namespace.empty? or !(/([a-z]|[A-Z]).*/ =~ namespace) # error original is =~ #([a-z][A-Z])([a-z]|[A-Z]|\s|[0-9]|[_-\:\/\&\+\?])*/
     35            if namespace.nil? or namespace.empty? or
     36                !(/^[a-zA-Z][a-zA-Z0-9_\-\:\/\&\+\?]*$/ =~ namespace)
     37              raise ArgumentError
     38            end
    3539            @namespace = namespace
    3640          end
    … …  
    4751        end
    4852
    49         class ArchetypeId < ObjectId
    50           attr_reader :domain_concept, :rm_name, :rm_entity, :rm_originator, :specialisation, :version_id
    51 
    52           def initialize(value, domain_concept, rm_name, rm_entity, rm_originator, specialisation, version_id)
    53             super(value)
    54             self.domain_concept = domain_concept
    55             self.rm_name = rm_name
    56             self.rm_entity = rm_entity
    57             self.rm_originator = rm_originator
    58             self.specialisation = specialisation
    59             self.version_id = version_id
     53        class ArchetypeID < ObjectID
     54          attr_reader :rm_originator, :rm_name, :rm_entity,
     55                      :concept_name, :specialisation, :version_id
     56         
     57          def initialize(args = {})
     58            if args[:value].nil?
     59              self.rm_originator = args[:rm_originator]
     60              self.rm_name = args[:rm_name]
     61              self.rm_entity = args[:rm_entity]
     62              self.concept_name = args[:concept_name]
     63              self.version_id = args[:version_id]
     64              self.specialisation = args[:specialisation]
     65            else
     66              super(args)
     67            end
     68          end
     69
     70          def value=(value)
     71            if /([a-zA-Z]\w+)-([a-zA-Z]\w+)-([a-zA-Z]\w+)\.([a-zA-Z]\w+)(-([a-zA-Z]\w+))?\.(v[1-9]\d*)/ =~ value
     72              self.rm_originator = $1
     73              self.rm_name = $2
     74              self.rm_entity = $3
     75              self.concept_name = $4
     76              self.specialisation = $6
     77              self.version_id = $7
     78            else
     79              raise ArgumentError, 'invalid archetype id form'
     80            end
     81          end
     82
     83          def qualified_rm_entity
     84            return @rm_originator + '-' + @rm_name + '-' + @rm_entity
     85          end
     86
     87          def domain_concept
     88            if @specialisation.nil?
     89              return @concept_name
     90            else
     91              return @concept_name + '-' + @specialisation
     92            end
     93          end
     94
     95          def value
     96            return self.qualified_rm_entity + '.' +
     97              self.domain_concept + '.' + @version_id
     98          end
     99
     100          def concept_name=(concept_name)
     101            if concept_name.nil? or concept_name.empty?
     102              raise ArgumentError, 'concept_name is mandatory'
     103            end
     104            @concept_name = concept_name
    60105          end
    61106
    62107          def domain_concept=(domain_concept)
    63             raise ArgumentError, "domain concept not valid" if domain_concept.nil? or domain_concept.empty?
    64             @domain_concept = domain_concept
     108            if domain_concept.nil? or domain_concept.empty?
     109              raise ArgumentError, "domain concept not valid"
     110            end
     111            if /([a-zA-Z]\w+)(-([a-zA-Z]\w))?/ =~ domain_concept
     112              self.concept_name = $1
     113              self.specialisation = $3
     114            else
     115              raise ArgumentError, 'invalid domain concept form'
     116            end
    65117          end
    66118
    … …  
    71123
    72124          def rm_entity=(rm_entity)
    73             raise ArgumentError, "rm_entity not valid" if rm_entity.nil? or rm_entity.empty?
     125            if rm_entity.nil? or rm_entity.empty?
     126              raise ArgumentError, "rm_entity is mandatory"
     127            end
    74128            @rm_entity = rm_entity
    75129          end
    76130
    77131          def rm_originator=(rm_originator)
    78             raise ArgumentError, "rm_originator not valid" if rm_originator.nil? or rm_originator.empty?
     132            if rm_originator.nil? or rm_originator.empty?
     133              raise ArgumentError, "rm_originator not valid"
     134            end
    79135            @rm_originator = rm_originator
    80136          end
    81137
    82138          def specialisation=(specialisation)
    83             raise ArgumentError, "rm_specialisation not valid" if specialisation.nil? or specialisation.empty?
     139            if !specialisation.nil? and specialisation.empty?
     140              raise ArgumentError, "rm_specialisation not valid"
     141            end
    84142            @specialisation = specialisation
    85143          end
     144
    86145          def version_id=(version_id)
    87146            raise ArgumentError, "version_id not valid" if version_id.nil? or version_id.empty?
    … …  
    90149        end
    91150
    92         class TerminologyId < ObjectId
     151        class TerminologyID < ObjectID
    93152          attr_reader :name, :version_id
    94153
    95           def initialize(value)
    96             super(value)
     154          def initialize(args = {})
     155            if args[:value].nil?
     156              self.name = args[:name]
     157              self.version_id = args[:version_id]
     158            else
     159              super(args)
     160            end
    97161          end
    98162
    … …  
    108172          def value=(value)
    109173            raise ArgumentError, "value not valid" if value.nil? or value.empty?
    110             if /(.*)\((.*)\)$/ =~ value
    111               @name = $1
    112               @version_id = $2
    113             else
    114               @name = value
    115               @version_id = ''
    116             end
    117             @value = value
     174            if /(.*)\((.*)\)/ =~ value
     175              self.name = $1
     176              self.version_id = $2
     177            else
     178              self.name = value
     179              self.version_id = ''
     180            end
    118181          end
    119182
    … …  
    124187
    125188          def version_id=(version_id)
    126             raise ArgumentError, "version_id not valid" if version_id.nil?
    127             @version_id = version_id
     189            if version_id.nil?
     190              @version_id = ''
     191            else
     192              @version_id = version_id
     193            end
    128194          end
    129195        end # of Terminology_ID
    130196
    131         class GenericId < ObjectId
     197        class GenericID < ObjectID
    132198          attr_reader :scheme
    133199
    134           def initialize(value, scheme)
     200          def initialize(args)
     201            super(args)
     202            self.scheme = args[:scheme]
     203          end
     204
     205          def scheme=(scheme)
     206            if scheme.nil? or scheme.empty?
     207              raise ArgumentError, "scheme not valid"
     208            end
     209            @scheme = scheme
     210          end
     211        end # of Generic_ID
     212
     213        class TemplateID < ObjectID
     214
     215        end
     216
     217        class UIDBasedID < ObjectID
     218          attr_reader :root, :extension
     219
     220          def initialize(args = {})
     221            super(args)
     222          end
     223
     224          def value=(value)
    135225            super(value)
    136             self.scheme = scheme
    137           end
    138 
    139           def scheme=(scheme)
    140             raise ArgumentError, "scheme not valid" if scheme.nil? or scheme.empty?
    141             @scheme = scheme
    142           end
    143         end # of Generic_ID
    144 
    145         class TemplateId < ObjectId
    146 
    147         end
    148 
    149         class UidBasedId < ObjectId
    150           def initialize(value)
    151             super(value)
    152           end
    153 
    154           def extension
    155             if self.has_extension?
    156               @value[/::.*/][2..-1]
    157             else
    158               ''
     226            if /(\S+)::(\S+)/ =~ value
     227              @root = UID.new(:value => $1)
     228              @extension = $2
     229            else
     230              @root = UID.new(:value => value)
     231              @extension = ''
    159232            end
    160233          end
    161234
    162235          def has_extension?
    163             @value.include? '::'
    164           end
    165 
    166           def root
    167             if self.has_extension?
    168               @value[/.*::/][0..-3]
    169             else
    170               @value
    171             end
    172           end
    173         end
    174 
    175         class ObjectVersionId < UidBasedId
     236            return !@extension.empty?
     237          end
     238        end
     239
     240        class ObjectVersionID < UIDBasedID
    176241          attr_reader :object_id, :creating_system_id, :version_tree_id
    177242
    178           def initialize(value)
    179             super(value)
    180           end
    181 
    182           def value=(value)
    183             super(value)
    184             if /^(\w+)::(\w+)::((\d|\.)+)$/ =~ value
    185               self.object_id = Uid.new($1)
    186               self.creating_system_id = Uid.new($2)
    187               self.version_tree_id = VersionTreeId.new($3)
     243          def initialize(args= {})
     244            super(args)
     245          end
     246
     247          def value=(value)
     248            if /^(\S+)::(\S+)::((\d|\.)+)$/ =~ value
     249              self.object_id = UID.new(:value => $1)
     250              self.creating_system_id = UID.new(:value => $2)
     251              self.version_tree_id = VersionTreeID.new(:value => $3)
    188252            else
    189253              raise ArgumentError, 'invalid format'
    190254            end
     255          end
     256
     257          def value
     258            return @object_id.value + '::' +
     259              @creating_system_id.value + '::' +
     260              @version_tree_id.value
    191261          end
    192262
    … …  
    216286
    217287        class LocatableRef < ObjectRef
    218           attr_reader :namespace, :type, :id, :path
    219 
    220           def initialize(namespace, type, id, path)
    221             super(namespace, type, id)
    222             self.path = path
     288          attr_reader :path
     289
     290          def initialize(args = {})
     291            super(args)
     292            self.path = args[:path]
    223293          end
    224294
    … …  
    234304
    235305        class PartyRef < ObjectRef
    236 
    237306          def type=(type)
    238             parties = ['PERSON', 'ORGANISATION', 'GROUP', 'AGENT', 'ROLE','PARTY', 'ACTOR']
     307            parties = %w[PERSON ORGANISATION GROUP AGENT ROLE PARTY ACTOR]
    239308            raise ArgumentError, 'type invalid' unless parties.include? type
    240309            @type = type
    … …  
    243312
    244313        class AccessGroupRef < ObjectRef
     314          def initialize(args = {})
     315            super(args)
     316            @type = 'ACCESS_GROUP'
     317          end
     318
    245319          def type=(type)
    246             raise ArgumentError, 'type invalid' unless type == 'ACCESS_GROUP'
    247             @type = type
    248           end
    249         end
    250 
    251         class HierObjectId < UidBasedId
    252 
    253         end
    254 
    255         class VersionTreeId
    256           attr_reader :value, :trunk_version, :branch_number, :branch_version
    257 
    258           def initialize(value)
    259             self.value = value
     320          end
     321        end
     322
     323        class HierObjectID < UIDBasedID
     324
     325        end
     326
     327        class VersionTreeID
     328          attr_reader :trunk_version, :branch_number, :branch_version
     329
     330          def initialize(args = {})
     331            self.value = args[:value]
    260332          end
    261333
    262334          def value=(value)
    263335            raise ArgumentError, 'value invalid' if value.nil? or value.empty?
    264             @trunk_version = @branch_number = @branch_version = nil
    265336            (trunk_version, branch_number, branch_version) = value.split '.'
    266337            self.trunk_version = trunk_version
    … …  
    269340          end
    270341
    271           def trunk_version=(trunk_version)
    272             raise ArgumentError, 'trunk_version invalid' if trunk_version.nil? and !trunk_version.to_i >= 1
    273             @trunk_version = trunk_version
    274             set_value
    275           end
    276 
    277           def branch_number=(branch_number)
    278             raise ArgumentError, 'branch number invalid' unless branch_number.nil? or branch_number.to_i >= 1
    279             @branch_number = branch_number
    280             set_value
    281           end
    282 
    283           def branch_version=(branch_version)
    284             raise ArgumentError, 'branch version invalid' if (!branch_version.nil? and !( branch_version.to_i >= 1)) or (!branch_version.nil? and @branch_number.nil?)
    285             @branch_version = branch_version
    286             set_value
    287           end
    288           def is_branch?
    289             !@branch_version.nil? and !@branch_number.nil?
    290           end
    291 
    292           def is_first?
    293             trunk_version == '1'
    294           end
    295 
    296           private
    297           def set_value
     342          def value
    298343            @value = trunk_version
    299344            @value = @value + '.' + @branch_number unless @branch_number.nil?
    300345            @value = @value + '.' + @branch_version unless @branch_version.nil?
    301           end
    302         end
    303 
    304         class Uid
     346            return @value
     347          end
     348
     349          def trunk_version=(trunk_version)
     350            if trunk_version.nil? || (trunk_version.to_i < 1)
     351              raise ArgumentError, 'trunk_version invalid'
     352            end
     353            @trunk_version = trunk_version
     354          end
     355
     356          def branch_number=(branch_number)
     357            unless branch_number.nil? or branch_number.to_i >= 1
     358              raise ArgumentError, 'branch number invalid'
     359            end
     360            @branch_number = branch_number
     361          end
     362
     363          def branch_version=(branch_version)
     364            if (!branch_version.nil? and !(branch_version.to_i >= 1)) or
     365                (!branch_version.nil? and @branch_number.nil?)
     366              raise ArgumentError, 'branch version invalid'
     367            end
     368            @branch_version = branch_version
     369          end
     370
     371          def is_branch?
     372            !@branch_version.nil? and !@branch_number.nil?
     373          end
     374
     375          def is_first?
     376            trunk_version == '1'
     377          end
     378        end
     379
     380        class UID
    305381          attr_reader :value
    306382
    307           def initialize(value)
    308             self.value = value
     383          def initialize(args = {})
     384            self.value = args[:value]
    309385          end
    310386
    … …  
    315391        end
    316392
    317         class Uuid < Uid
    318 
    319         end
    320 
    321         class InternetId <Uid
     393        class UUID < UID
     394
     395        end
     396
     397        class InternetID <UID
    322398         
    323399        end
    324400
    325         class IsoOid <Uid
     401        class IsoOID <UID
    326402
    327403        end       

  • ruby/trunk/log/development.log

    r164 r297  
    16401640  [4;36;1mTerminology Load (0.001251)[0m   [0;1mSELECT * FROM "terminologies" WHERE ("terminologies"."lang" = 'ja' AND "terminologies"."code" = '3' AND "terminologies"."name" = 'openehr') LIMIT 1[0m
    16411641Completed in 0.01486 (67 reqs/sec) | Rendering: 0.00061 (4%) | DB: 0.00125 (8%) | 404 Not Found [http://localhost/terminology/openehr/ja/3]
     1642  [4;36;1mSQL (0.8ms)[0m   [0;1m SELECT name
     1643 FROM sqlite_master
     1644 WHERE type = 'table' AND NOT name = 'sqlite_sequence'
     1645[0m
     1646  [4;35;1mSQL (0.4ms)[0m   [0mSELECT version FROM schema_migrations[0m
     1647  [4;36;1mSQL (0.3ms)[0m   [0;1mselect sqlite_version(*)[0m
     1648  [4;35;1mSQL (0.6ms)[0m   [0m SELECT name
     1649 FROM sqlite_master
     1650 WHERE type = 'table' AND NOT name = 'sqlite_sequence'
     1651[0m
     1652  [4;36;1mSQL (37.7ms)[0m   [0;1mCREATE TABLE "terminologies" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "code" varchar(255), "name" varchar(255), "lang" varchar(255), "group" text, "rubric" varchar(255), "description" text, "mappings" varchar(255)) [0m
     1653  [4;35;1mSQL (0.2ms)[0m   [0m SELECT name
     1654 FROM sqlite_master
     1655 WHERE type = 'table' AND NOT name = 'sqlite_sequence'
     1656[0m
     1657  [4;36;1mSQL (2.2ms)[0m   [0;1mCREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) [0m
     1658  [4;35;1mSQL (2.9ms)[0m   [0mCREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")[0m
     1659  [4;36;1mSQL (0.2ms)[0m   [0;1m SELECT name
     1660 FROM sqlite_master
     1661 WHERE type = 'table' AND NOT name = 'sqlite_sequence'
     1662[0m
     1663  [4;35;1mSQL (0.1ms)[0m   [0mSELECT version FROM "schema_migrations"[0m
     1664  [4;36;1mSQL (2.3ms)[0m   [0;1mINSERT INTO "schema_migrations" (version) VALUES ('20090725052538')[0m
Note: See TracChangeset for help on using the changeset viewer.