ruby-hl7 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e12909d9bf4258faa015ede7da03afce19e915640b8aa240c99c993bf938acd3
-  data.tar.gz: 54bea819722c67aab4342ad667dc54b141ea6ac0bbb180070f467c12fb45f893
+  metadata.gz: 035f9636e28515eae6fbc2a678ce86b39263c48cd1568b8b97c7ce4152bef4a7
+  data.tar.gz: d8773a865c2ec350577dcafb478a077de96ad591b35dfc3660feca586d037631
 SHA512:
-  metadata.gz: 119f5c5c4bb3063d3a6e6abcc50309590e677be55f2f75fd91c69a7907a9adbac247462573fe9e5973fc37cf8416c8ba0aabcc87ca81709cf56a557773d27429
-  data.tar.gz: 427934f749b5dde398e4e6c236472ad8e2cb514380945ed6f35bf99dd9b41448a9572ef438ddc247e229d7df82055f289c8a2966a06ee9087d82d0f2c20d0fee
+  metadata.gz: 4bc0af59178fe08d1dd5eec8a1452e94a30d0fefc499f5ccba3571fb20e3c55131904bf7ee3692f586c9f8a5cc4665d45352e87f335d403b25966c2480de06c6
+  data.tar.gz: 6af3309af2c11db2a8d51541e709dcd70f941e03b16323492443c58a83aca3908df1eab3083b255bb765d7192010bfc9aafd6031d91110fe1dc51991749f73be

data/lib/configuration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module HL7
+  # This class enables detailed configuration of the HL7 parser services.
+  #
+  # By calling
+  #
+  #   HL7.configuration # => instance of HL7::Configuration
+  #
+  # or
+  #   HL7.configure do |config|
+  #     config # => instance of HL7::Configuration
+  #   end
+  #
+  # you are able to perform configuration updates.
+  #
+  # Setting the keys with this Configuration
+  #
+  #   HL7.configure do |config|
+  #     config.empty_segment_is_error  = false
+  #   end
+  #
+  class Configuration
+    attr_accessor :empty_segment_is_error
+
+    def initialize # :nodoc:
+      @empty_segment_is_error = true
+    end
+  end
+end

data/lib/core_ext/date_time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HL7Time
   # Get a HL7 timestamp (type TS) for a Time instance.
   #
@@ -7,16 +9,18 @@ module HL7Time
   #  => "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)
+  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
+    return "" unless fraction_digits.positive?
+
     time_fraction =  hl7_time_fraction
-    answer = ".#{sprintf('%06d', time_fraction)}"
-    answer += '0' * ((fraction_digits - 6)).abs if fraction_digits > 6
+    answer = ".#{format("%06d", time_fraction)}"
+    answer += "0" * ((fraction_digits - 6)).abs if fraction_digits > 6
     answer[0, 1 + fraction_digits]
   end
 
@@ -24,7 +28,7 @@ private
     if respond_to? :usec
       usec
     else
-      sec_fraction.to_f * 1000000
+      sec_fraction.to_f * 1_000_000
     end
   end
 end
@@ -36,7 +40,7 @@ class Date
   #  Date.parse('2009-12-02').to_hl7
   #  => "20091202"
   def to_hl7
-    strftime('%Y%m%d')
+    strftime("%Y%m%d")
   end
 end
 
@@ -52,14 +56,14 @@ end
 
 # TODO
 # parse an hl7 formatted date
-#def Date.from_hl7( hl7_date )
-#end
+# def Date.from_hl7( hl7_date )
+# end
 
-#def Date.to_hl7_short( ruby_date )
-#end
+# def Date.to_hl7_short( ruby_date )
+# end
 
-#def Date.to_hl7_med( ruby_date )
-#end
+# def Date.to_hl7_med( ruby_date )
+# end
 
-#def Date.to_hl7_long( ruby_date )
-#end
+# def Date.to_hl7_long( ruby_date )
+# end

data/lib/core_ext/string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Adding a helper to the String class for the batch parse.
 class String
   def hl7_batch?

data/lib/helpers/time_formatter_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TimeFormatterHelper
+  class ValueTypeNotSupportedError < StandardError; end
+
+  # Get an HL7 timestamp (type TS) for a Time or DateTime instance.
+  #
+  # fraction_digits:: specifies a number of digits of fractional seconds.
+  #                   Its default value is 0.
+  #  hl7_formatted_timestamp(Time.parse('01:23'))
+  #  => "20091202012300"
+  #  hl7_formatted_timestamp(Time.now, 3)
+  #  => "20091202153652.302"
+  def hl7_formatted_timestamp(value, fraction_digits = 0)
+    raise ValueTypeNotSupportedError, "Value must be an instance of Time or DateTime" unless value.is_a?(Time) || value.is_a?(DateTime)
+
+    value.strftime("%Y%m%d%H%M%S") + hl7_formatted_fractions(value, fraction_digits)
+  end
+
+  # Get an HL7 timestamp (type TS) for a Date instance.
+  def hl7_formatted_date(value)
+    raise ValueTypeNotSupportedError, "Value must be an instance of Date" unless value.is_a?(Date)
+
+    value.strftime("%Y%m%d")
+  end
+
+private
+
+  def hl7_formatted_fractions(value, fraction_digits = 0)
+    return "" unless fraction_digits.positive?
+
+    time_fraction =  if value.respond_to?(:usec)
+      value.usec
+    else
+      value.sec_fraction.to_f * 1_000_000
+    end
+
+    answer = ".#{format("%06d", time_fraction)}"
+    answer += "0" * ((fraction_digits - 6)).abs if fraction_digits > 6
+    answer[0, 1 + fraction_digits]
+  end
+end

data/lib/message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Ruby Object representation of an hl7 2.x message
 # the message object is actually a "smart" collection of hl7 segments
 # == Examples
@@ -33,60 +35,56 @@ 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_reader :element_delim
-  attr_reader :item_delim
-  attr_reader :segment_delim
-  attr_reader :delimiter
+  attr_reader :message_parser, :element_delim, :item_delim, :segment_delim, :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 )
+  def initialize(raw_msg = nil, &blk)
     @segments = []
     @segments_by_name = {}
     @item_delim = "^"
-    @element_delim = '|'
+    @element_delim = "|"
     @segment_delim = "\r"
-    @delimiter = HL7::Message::Delimiter.new( @element_delim,
-                                              @item_delim,
-                                              @segment_delim)
+    @delimiter = HL7::Message::Delimiter.new(@element_delim,
+      @item_delim,
+      @segment_delim)
 
     @message_parser = HL7::MessageParser.new(@delimiter)
 
-    parse( raw_msg ) if raw_msg
+    parse(raw_msg) if raw_msg
 
-    if block_given?
-      blk.call self
-    end
+    return unless block_given?
+
+    yield self
   end
 
-  def parse( inobj )
-    if inobj.kind_of?(String)
-      generate_segments( message_parser.parse_string( inobj ))
+  def parse(inobj)
+    if inobj.is_a?(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" )
+      raise HL7::ParseError, "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 ))
+      generate_segments(message_parser.parse_string(segment.to_s))
     end
   end
 
   # access a segment of the message
   # index:: can be a Range, Integer or anything that
   #         responds to to_sym
-  def []( index )
+  def [](index)
     ret = nil
 
-    if index.kind_of?(Range) || index.kind_of?(Integer)
-      ret = @segments[ index ]
-    elsif (index.respond_to? :to_sym)
-      ret = @segments_by_name[ index.to_sym ]
+    if index.is_a?(Range) || index.is_a?(Integer)
+      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
 
@@ -97,17 +95,17 @@ class HL7::Message
   # index:: can be a Range, Integer 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" )
+  def []=(index, value)
+    unless value.is_a?(HL7::Message::Segment)
+      raise HL7::Exception, "attempting to assign something other than an HL7 Segment"
     end
 
-    if index.kind_of?(Range) || index.kind_of?(Integer)
-      @segments[ index ] = value
+    if index.is_a?(Range) || index.is_a?(Integer)
+      @segments[index] = value
     elsif index.respond_to?(:to_sym)
-      (@segments_by_name[ index.to_sym ] ||= []) << value
+      (@segments_by_name[index.to_sym] ||= []) << value
     else
-      raise HL7::Exception.new( "attempting to use an indice that is not a Range, Integer or to_sym providing object" )
+      raise HL7::Exception, "attempting to use an indice that is not a Range, Integer or to_sym providing object"
     end
 
     value.segment_parent = self
@@ -115,43 +113,44 @@ class HL7::Message
 
   # 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))
+  def index(value)
+    return nil unless value.respond_to?(:to_sym)
 
-    segs = @segments_by_name[ value.to_sym ]
+    segs = @segments_by_name[value.to_sym]
     return nil unless segs
 
-    @segments.index( segs.to_a.first )
+    @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 )
+  def <<(value)
     # do nothing if value is nil
     return unless value
 
-    if value.kind_of? Array
-      value.map{|item| append(item)}
+    if value.is_a? 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" )
+  def append(value)
+    unless value.is_a?(HL7::Message::Segment)
+      raise HL7::Exception, "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
+    (@segments_by_name[name] ||= []) << value
     sequence_segments unless defined?(@parsing) && @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
 
@@ -163,34 +162,34 @@ class HL7::Message
 
   # provide a screen-readable version of the message
   def to_s
-    @segments.collect { |s| s if s.to_s.length > 0 }.join( "\n" )
+    @segments.collect {|s| s if s.to_s.length.positive? }.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 )
+    @segments.collect {|s| s if s.to_s.length.positive? }.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"
+    "\v#{pre_mllp}\u001C\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)
+  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
+      if s.is_a?(last.class) && s.respond_to?(:set_id)
+        last.set_id = 1 unless last.set_id&.to_i&.positive?
         s.set_id = last.set_id.to_i + 1
       end
 
-      sequence_segments( s ) if s.has_children?
+      sequence_segments(s) if s.has_children?
 
       last = s
     end
@@ -201,17 +200,16 @@ class HL7::Message
     Array(self[:OBX]).any?(&:correction?)
   end
 
-  private
-  def generate_segments( ary )
-    raise HL7::ParseError.new( "no array to generate segments" ) unless ary.length > 0
+private
+
+  def generate_segments(ary)
+    raise HL7::ParseError, "no array to generate segments" unless ary.length.positive?
 
     @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
+      update_delimiters(elm) if elm.slice(0, 3) == "MSH"
+      generate_segment(elm, segment_stack)
     end
     @parsing = nil
   end
@@ -223,12 +221,13 @@ class HL7::Message
     @delimiter.element = @element_delim
   end
 
-  def generate_segment( elm, segment_stack )
-    segment_generator = HL7::Message::SegmentGenerator.new( elm,
-                                                            segment_stack,
-                                                            @delimiter )
+  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
@@ -238,40 +237,38 @@ class HL7::Message
   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 )
+    while segment_stack.length.positive?
+      if 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;
+        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
+    return unless segment_stack.empty?
+
+    @segments << new_seg
+    segment_stack << new_seg
+    setup_segment_lookup_by_name(seg_name, new_seg)
   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
+    return unless seg_sym
+
+    @segments_by_name[seg_sym] ||= []
+    @segments_by_name[seg_sym] << new_seg
   end
 
   def get_symbol_from_name(seg_name)
-    seg_name.to_s.strip.length > 0 ? seg_name.to_sym : nil
+    seg_name.to_s.strip.length.positive? ? seg_name.to_sym : nil
   end
-
 end

data/lib/message_parser.rb

@@ -1,29 +1,31 @@
+# frozen_string_literal: true
+
 module HL7::MessageBatchParser
   def parse_batch(batch) # :yields: message
-    raise HL7::ParseError, 'badly_formed_batch_message' unless
+    raise HL7::ParseError, "badly_formed_batch_message" unless
       batch.hl7_batch?
 
     batch = clean_batch_for_jruby batch
 
-    raise HL7::ParseError, 'empty_batch_message' unless
+    raise HL7::ParseError, "empty_batch_message" unless
       match = /\rMSH/.match(batch)
 
-    match.post_match.split(/\rMSH/).each do |_msg|
+    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
+      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 )
+  def parse(inobj)
     HL7::Message.new do |msg|
-      msg.parse( inobj )
+      msg.parse(inobj)
     end
   end
 
@@ -35,10 +37,10 @@ module HL7::MessageBatchParser
   # 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
+private
 
   def clean_batch_for_jruby(batch)
-    batch.gsub("\n", "\r") if batch.include?("\n")
+    batch.tr("\n", "\r") if batch.include?("\n")
   end
 end
 
@@ -47,7 +49,7 @@ class HL7::MessageParser
   attr_reader :delimiter
 
   def self.split_by_delimiter(element, delimiter)
-    element.split( delimiter, -1 )
+    element.split(delimiter, -1)
   end
 
   def initialize(delimiter)
@@ -55,21 +57,21 @@ class HL7::MessageParser
   end
 
   # parse the provided String or Enumerable object into this message
-  def parse_string( instr )
+  def parse_string(instr)
     post_mllp = instr
-    if /\x0b((:?.|\r|\n)+)\x1c\r/.match( instr )
-      post_mllp = $1 #strip the mllp bytes
+    if /\x0b((:?.|\r|\n)+)\x1c\r/ =~ 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) : "|"
+    str.is_a?(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) : "^"
+    str.is_a?(String) ? str.slice(4, 1) : "^"
   end
-end
+end

data/lib/ruby-hl7.rb

@@ -1,4 +1,5 @@
-# encoding: UTF-8
+# frozen_string_literal: true
+
 #= ruby-hl7.rb
 # Ruby HL7 is designed to provide a simple, easy to use library for
 # parsing and generating HL7 (2.x) messages.
@@ -16,14 +17,23 @@
 # see the LICENSE file
 #
 
-require 'rubygems'
-require 'stringio'
-require 'date'
+require "rubygems"
+require "stringio"
+require "date"
+require "configuration"
+require "helpers/time_formatter_helper"
 
 module HL7 # :nodoc:
-  VERSION = '1.3.3'
-  def self.ParserConfig
-    @parser_cfg ||= { :empty_segment_is_error => true }
+  # Gives access to the current Configuration.
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Allows easy setting of multiple configuration options. See Configuration
+  # for all available options.
+  def self.configure
+    config = configuration
+    yield(config)
   end
 end
 
@@ -48,13 +58,13 @@ end
 class HL7::EmptySegmentNotAllowed < HL7::ParseError
 end
 
-require 'message_parser'
-require 'message'
-require 'segment_list_storage'
-require 'segment_generator'
-require 'segment_fields'
-require 'segment'
-require 'segment_default'
+require "message_parser"
+require "message"
+require "segment_list_storage"
+require "segment_generator"
+require "segment_fields"
+require "segment"
+require "segment_default"
 
-require 'core_ext/date_time'
-require 'core_ext/string'
+require "core_ext/date_time"
+require "core_ext/string"