ruby-hl7 1.0.3 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a1652685f5af3d1977d1d32eda59c87bad5523b
+  data.tar.gz: 6d995a2efccfb7fd8a0dad2d2c386b530f565824
+SHA512:
+  metadata.gz: fbaab918091adf2be1062b6343b9fea752d0210091765b0725b4d5d356fb643578a279e9bf21cb8525d7ba4e58b48073196c23f97138f1c3c2bb43c4d2afe7fe
+  data.tar.gz: fd5aaf2b829bc1cdbf3cce507312cba40d33c497915c94ba0accc09b96ca8bb60b2883188e5b7d88f6550f0b7612157811499d418424cfd73ce7242f215943f4

data/README.rdoc

@@ -1,5 +1,8 @@
 = Ruby HL7 Library README
 
+{<img src="https://travis-ci.org/ruby-hl7/ruby-hl7.png?branch=master" alt="Build Status" />}[https://travis-ci.org/ruby-hl7/ruby-hl7]
+{<img src="https://codeclimate.com/github/ruby-hl7/ruby-hl7.png" />}[https://codeclimate.com/github/ruby-hl7/ruby-hl7]
+
 A simple way to parse and create HL7 2.x messages with Ruby.
 
 Examples can be found in HL7::Message.
@@ -7,17 +10,14 @@ Examples can be found in HL7::Message.
 The version id can be found in the HL7::VERSION constant.
 
 * Git:          http://github.com/ruby-hl7/ruby-hl7.git
-* Docs:         http://ruby-hl7.rubyforge.org
+* Docs:         http://rubydoc.info/gems/ruby-hl7/1.0.3/frames
 * Rubygems:     https://rubygems.org/gems/ruby-hl7
-* Rubyforge:    http://rubyforge.org/projects/ruby-hl7
 
 Lists
 
-* Developers: mailto:ruby-hl7-devel@rubyforge.org
-* Users: mailto:ruby-hl7-users@rubyforge.org
 * Google group: http://groups.google.com/group/ruby-hl7
 
-Copyright (C) 2006-2010 Mark Guzman
+Copyright (C) 2006-2014 Mark Guzman
 
 Maintained by the Collaborative Software Initiative
 

data/lib/core_ext/date_time.rb

@@ -0,0 +1,65 @@
+module HL7Time
+  # Get a HL7 timestamp (type TS) for a Time instance.
+  #
+  # fraction_digits:: specifies a number of digits of fractional seconds.
+  #                   Its default value is 0.
+  #  Time.parse('01:23').to_hl7
+  #  => "20091202012300"
+  #  Time.now.to_hl7(3)
+  #  => "20091202153652.302"
+  def to_hl7( fraction_digits = 0)
+    strftime('%Y%m%d%H%M%S') + hl7_fractions(fraction_digits)
+  end
+
+private
+  def hl7_fractions(fraction_digits = 0)
+    return '' unless fraction_digits > 0
+    time_fraction =  hl7_time_fraction
+    answer = ".#{sprintf('%06d', time_fraction)}"
+    answer += '0' * ((fraction_digits - 6)).abs if fraction_digits > 6
+    answer[0, 1 + fraction_digits]
+  end
+
+  def hl7_time_fraction
+    if respond_to? :usec
+      usec
+    else
+      sec_fraction.to_f * 1000000
+    end
+  end
+end
+
+# Adding the to_hl7 method to the ruby Date class.
+class Date
+  # Get a HL7 timestamp (type TS) for a Date instance.
+  #
+  #  Date.parse('2009-12-02').to_hl7
+  #  => "20091202"
+  def to_hl7
+    strftime('%Y%m%d')
+  end
+end
+
+# Adding the to_hl7 method to the ruby Time class.
+class Time
+  include HL7Time
+end
+
+# Adding the to_hl7 method to the ruby DateTime class.
+class DateTime
+  include HL7Time
+end
+
+# TODO
+# parse an hl7 formatted date
+#def Date.from_hl7( hl7_date )
+#end
+
+#def Date.to_hl7_short( ruby_date )
+#end
+
+#def Date.to_hl7_med( ruby_date )
+#end
+
+#def Date.to_hl7_long( ruby_date )
+#end

data/lib/core_ext/string.rb

@@ -0,0 +1,6 @@
+# Adding a helper to the String class for the batch parse.
+class String
+  def hl7_batch?
+    !!match(/^FHS/)
+  end
+end

data/lib/message.rb

@@ -0,0 +1,272 @@
+# Ruby Object representation of an hl7 2.x message
+# the message object is actually a "smart" collection of hl7 segments
+# == Examples
+#
+# ==== Creating a new HL7 message
+#
+#  # create a message
+#  msg = HL7::Message.new
+#
+#  # create a MSH segment for our new message
+#  msh = HL7::Message::Segment::MSH.new
+#  msh.recv_app = "ruby hl7"
+#  msh.recv_facility = "my office"
+#  msh.processing_id = rand(10000).to_s
+#
+#  msg << msh # add the MSH segment to the message
+#
+#  puts msg.to_s # readable version of the message
+#
+#  puts msg.to_hl7 # hl7 version of the message (as a string)
+#
+#  puts msg.to_mllp # mllp version of the message (as a string)
+#
+# ==== Parse an existing HL7 message
+#
+#  raw_input = open( "my_hl7_msg.txt" ).readlines
+#  msg = HL7::Message.new( raw_input )
+#
+#  puts "message type: %s" % msg[:MSH].message_type
+#
+#
+class HL7::Message
+  include Enumerable # we treat an hl7 2.x message as a collection of segments
+  extend HL7::MessageBatchParser
+
+  attr_reader :message_parser
+  attr :element_delim
+  attr :item_delim
+  attr :segment_delim
+  attr :delimiter
+
+  # setup a new hl7 message
+  # raw_msg:: is an optional object containing an hl7 message
+  #           it can either be a string or an Enumerable object
+  def initialize( raw_msg=nil, &blk )
+    @segments = []
+    @segments_by_name = {}
+    @item_delim = "^"
+    @element_delim = '|'
+    @segment_delim = "\r"
+    @delimiter = HL7::Message::Delimiter.new( @element_delim,
+                                              @item_delim,
+                                              @segment_delim)
+
+    @message_parser = HL7::MessageParser.new(@delimiter)
+
+    parse( raw_msg ) if raw_msg
+
+    if block_given?
+      blk.call self
+    end
+  end
+
+  def parse( inobj )
+    if inobj.kind_of?(String)
+      generate_segments( message_parser.parse_string( inobj ))
+    elsif inobj.respond_to?(:each)
+      generate_segments_enumerable(inobj)
+    else
+      raise HL7::ParseError.new( "object to parse should be string or enumerable" )
+    end
+  end
+
+  def generate_segments_enumerable(enumerable)
+    enumerable.each do |segment|
+      generate_segments( message_parser.parse_string( segment.to_s ))
+    end
+  end
+
+  # access a segment of the message
+  # index:: can be a Range, Fixnum or anything that
+  #         responds to to_sym
+  def []( index )
+    ret = nil
+
+    if index.kind_of?(Range) || index.kind_of?(Fixnum)
+      ret = @segments[ index ]
+    elsif (index.respond_to? :to_sym)
+      ret = @segments_by_name[ index.to_sym ]
+      ret = ret.first if ret && ret.length == 1
+    end
+
+    ret
+  end
+
+  # modify a segment of the message
+  # index:: can be a Range, Fixnum or anything that
+  #         responds to to_sym
+  # value:: an HL7::Message::Segment object
+  def []=( index, value )
+    unless ( value && value.kind_of?(HL7::Message::Segment) )
+      raise HL7::Exception.new( "attempting to assign something other than an HL7 Segment" )
+    end
+
+    if index.kind_of?(Range) || index.kind_of?(Fixnum)
+      @segments[ index ] = value
+    elsif index.respond_to?(:to_sym)
+      (@segments_by_name[ index.to_sym ] ||= []) << value
+    else
+      raise HL7::Exception.new( "attempting to use an indice that is not a Range, Fixnum or to_sym providing object" )
+    end
+
+    value.segment_parent = self
+  end
+
+  # return the index of the value if it exists, nil otherwise
+  # value:: is expected to be a string
+  def index( value )
+    return nil unless (value && value.respond_to?(:to_sym))
+
+    segs = @segments_by_name[ value.to_sym ]
+    return nil unless segs
+
+    @segments.index( segs.to_a.first )
+  end
+
+  # add a segment or array of segments to the message
+  # * will force auto set_id sequencing for segments containing set_id's
+  def <<( value )
+    # do nothing if value is nil
+    return unless value
+
+    if value.kind_of? Array
+      value.map{|item| append(item)}
+    else
+      append(value)
+    end
+  end
+
+  def append( value )
+    unless ( value && value.kind_of?(HL7::Message::Segment) )
+      raise HL7::Exception.new( "attempting to append something other than an HL7 Segment" )
+    end
+
+    value.segment_parent = self unless value.segment_parent
+    (@segments ||= []) << value
+    name = value.class.to_s.gsub("HL7::Message::Segment::", "").to_sym
+    (@segments_by_name[ name ] ||= []) << value
+    sequence_segments unless @parsing # let's auto-set the set-id as we go
+  end
+
+  # yield each segment in the message
+  def each # :yields: segment
+    return unless @segments
+    @segments.each { |s| yield s }
+  end
+
+  # return the segment count
+  def length
+    0 unless @segments
+    @segments.length
+  end
+
+  # provide a screen-readable version of the message
+  def to_s
+    @segments.collect { |s| s if s.to_s.length > 0 }.join( "\n" )
+  end
+
+  # provide a HL7 spec version of the message
+  def to_hl7
+    @segments.collect { |s| s if s.to_s.length > 0 }.join( @delimiter.segment )
+  end
+
+  # provide the HL7 spec version of the message wrapped in MLLP
+  def to_mllp
+    pre_mllp = to_hl7
+    "\x0b" + pre_mllp + "\x1c\r"
+  end
+
+  # auto-set the set_id fields of any message segments that
+  # provide it and have more than one instance in the message
+  def sequence_segments(base=nil)
+    last = nil
+    segs = @segments
+    segs = base.children if base
+
+    segs.each do |s|
+      if s.kind_of?( last.class ) && s.respond_to?( :set_id )
+        last.set_id = 1 unless last.set_id && last.set_id.to_i > 0
+        s.set_id = last.set_id.to_i + 1
+      end
+
+      sequence_segments( s ) if s.has_children?
+
+      last = s
+    end
+  end
+
+  private
+  def generate_segments( ary )
+    raise HL7::ParseError.new( "no array to generate segments" ) unless ary.length > 0
+
+    @parsing = true
+    segment_stack = []
+    ary.each do |elm|
+      if elm.slice(0,3) == "MSH"
+        update_delimiters(elm)
+      end
+      last_seg = generate_segment( elm, segment_stack ) || last_seg
+    end
+    @parsing = nil
+  end
+
+  def update_delimiters(elm)
+    @item_delim = message_parser.parse_item_delim(elm)
+    @element_delim = message_parser.parse_element_delim(elm)
+    @delimiter.item = @item_delim
+    @delimiter.element = @element_delim
+  end
+
+  def generate_segment( elm, segment_stack )
+    segment_generator = HL7::Message::SegmentGenerator.new( elm,
+                                                            segment_stack,
+                                                            @delimiter )
+
+    return nil unless segment_generator.valid_segments_parts?
+    segment_generator.seg_name = segment_generator.seg_parts[0]
+
+    new_seg = segment_generator.build
+    new_seg.segment_parent = self
+
+    choose_segment_from(segment_stack, new_seg, segment_generator.seg_name)
+  end
+
+  def choose_segment_from(segment_stack, new_seg, seg_name)
+
+    # Segments have been previously seen
+    while(segment_stack.length > 0)
+      if segment_stack.last && segment_stack.last.has_children? && segment_stack.last.accepts?( seg_name )
+        # If a previous segment can accept the current segment as a child,
+        # add it to the previous segments children
+        segment_stack.last.children << new_seg
+        new_seg.is_child_segment = true
+        segment_stack << new_seg
+        break;
+      else
+        segment_stack.pop
+      end
+    end
+
+    # Root of segment 'tree'
+    if segment_stack.length == 0
+      @segments << new_seg
+      segment_stack << new_seg
+      setup_segment_lookup_by_name( seg_name, new_seg)
+    end
+  end
+
+  # Allow segment lookup by name
+  def setup_segment_lookup_by_name(seg_name, new_seg)
+    seg_sym = get_symbol_from_name(seg_name)
+    if seg_sym
+      @segments_by_name[ seg_sym ] ||= []
+      @segments_by_name[ seg_sym ] << new_seg
+    end
+  end
+
+   def get_symbol_from_name(seg_name)
+    seg_name.to_s.strip.length > 0 ? seg_name.to_sym : nil
+  end
+
+end

data/lib/message_parser.rb

@@ -0,0 +1,75 @@
+module HL7::MessageBatchParser
+  def parse_batch(batch) # :yields: message
+    raise HL7::ParseError, 'badly_formed_batch_message' unless
+      batch.hl7_batch?
+
+    batch = clean_batch_for_jruby batch
+
+    raise HL7::ParseError, 'empty_batch_message' unless
+      match = /\rMSH/.match(batch)
+
+    match.post_match.split(/\rMSH/).each do |_msg|
+      if md = /\rBTS/.match(_msg)
+        # TODO: Validate the message count in the BTS segment
+        # should == index + 1
+        _msg = md.pre_match
+      end
+
+      yield 'MSH' + _msg
+    end
+  end
+
+  # parse a String or Enumerable object into an HL7::Message if possible
+  # * returns a new HL7::Message if successful
+  def parse( inobj )
+    HL7::Message.new do |msg|
+      msg.parse( inobj )
+    end
+  end
+
+  # JRuby seems to change our literal \r characters in sample
+  # messages (from here documents) into newlines.  We make a copy
+  # here, reverting to carriage returns.  The input is unchanged.
+  #
+  # This does not occur when posts are received with CR
+  # characters, only in sample messages from here documents.  The
+  # expensive copy is only incurred when the batch message has a
+  # newline character in it.
+  private
+
+  def clean_batch_for_jruby(batch)
+    batch.gsub("\n", "\r") if batch.include?("\n")
+  end
+end
+
+# Provides basic methods to parse_string, element and item delimeter parser
+class HL7::MessageParser
+  attr_reader :delimiter
+
+  def self.split_by_delimiter(element, delimiter)
+    element.split( delimiter, -1 )
+  end
+
+  def initialize(delimiter)
+    @delimiter = delimiter
+  end
+
+  # parse the provided String or Enumerable object into this message
+  def parse_string( instr )
+    post_mllp = instr
+    if /\x0b((:?.|\r|\n)+)\x1c\r/.match( instr )
+      post_mllp = $1 #strip the mllp bytes
+    end
+    HL7::MessageParser.split_by_delimiter(post_mllp, @delimiter.segment)
+  end
+
+  # Get the element delimiter from an MSH segment
+  def parse_element_delim(str)
+    (str && str.kind_of?(String)) ? str.slice(3,1) : "|"
+  end
+
+  # Get the item delimiter from an MSH segment
+  def parse_item_delim(str)
+    (str && str.kind_of?(String)) ? str.slice(4,1) : "^"
+  end
+end