pipehat 0.1.0

data/lib/pipehat/field/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pipehat
+  module Field
+    class Base < Pipehat::Node
+      def initialize(segment, fnum)
+        @segment = segment
+        @fnum = fnum
+      end
+
+      attr_reader :segment, :fnum
+
+      def repeat(rnum)
+        repeat_class.new(segment, fnum, rnum)
+      end
+
+      def [](rnum)
+        repeat(rnum)
+      end
+
+      def []=(rnum, value)
+        repeat(rnum).set(value)
+      end
+
+      def first
+        repeat(1)
+      end
+
+      # Set on a field should replace the entire tree at this field
+      # This should discard anything under repeats etc
+      def set(value)
+        segment.set_field(fnum, value)
+      end
+
+      # calling component(n) on a field assumes you mean the first repeat
+      def component(cnum, type = Pipehat::Component::Base)
+        first.component(cnum, type)
+      end
+
+      def to_hl7
+        (segment.tree(fnum) || []).map do |repeat|
+          (repeat || []).map do |component|
+            (component || []).join(parser.subcomponent_sep)
+          end.join(parser.component_sep)
+        end.join(parser.repetition_sep)
+      end
+
+      def inspect
+        inspect_node(fnum)
+      end
+
+      private
+
+      def repeat_class
+        Object.const_get(self.class.name.sub(/Field/, "Repeat"))
+      end
+    end
+  end
+end

data/lib/pipehat/message.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pipehat
+  class Message
+    def initialize(hl7 = "", parser: Pipehat::DEFAULT_PARSER)
+      @parser = parser
+      @segments = parser.parse(hl7)
+    end
+
+    attr_reader :parser
+
+    def to_hl7
+      segments.map(&:to_hl7).join(parser.segment_sep)
+    end
+
+    def <<(segment)
+      @segments << segment
+    end
+
+    # Returns an enumerator over the message's segments
+    # The optional parameter limits it to the given type
+    def segments(type = nil)
+      return to_enum(:segments, type) unless block_given?
+
+      @segments.each do |segment|
+        next if type && segment.segment_name != type.to_s
+
+        yield segment
+      end
+    end
+  end
+end

data/lib/pipehat/node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pipehat
+  # Parent class of all accessor types (Field, Repeat, (Sub)Component
+  # providing common methods
+  class Node
+    def fnum
+      1
+    end
+
+    def rnum
+      1
+    end
+
+    def cnum
+      1
+    end
+
+    def snum
+      1
+    end
+
+    def to_s
+      segment.parser.unescape(unescaped)
+    end
+
+    def unescaped
+      segment.get(fnum, rnum, cnum, snum)
+    end
+
+    def component_names
+      self.class.component_names
+    end
+
+    def self.component_names
+      @component_names ||= []
+    end
+
+    def parser
+      segment.parser
+    end
+
+    private
+
+    def inspect_node(*nums)
+      s = "#<#{self.class} #{segment.segment_name}(#{nums.join(",")}) "
+      maxlen = 76 - s.length
+      fragment = to_hl7
+      fragment = fragment[0, maxlen - 3] + "..." if fragment.length > maxlen
+      "#{s}#{fragment}>"
+    end
+  end
+end

data/lib/pipehat/parser.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Pipehat
+  class Parser
+    def segment_sep
+      "\r"
+    end
+
+    def field_sep
+      "|"
+    end
+
+    def repetition_sep
+      "~"
+    end
+
+    def component_sep
+      "^"
+    end
+
+    def subcomponent_sep
+      "&"
+    end
+
+    def escape_char
+      "\\"
+    end
+
+    def escaped_field_sep
+      "#{escape_char}F#{escape_char}"
+    end
+
+    def escaped_repetition_sep
+      "#{escape_char}R#{escape_char}"
+    end
+
+    def escaped_component_sep
+      "#{escape_char}S#{escape_char}"
+    end
+
+    def escaped_subcomponent_sep
+      "#{escape_char}T#{escape_char}"
+    end
+
+    def escaped_escape_char
+      "#{escape_char}E#{escape_char}"
+    end
+
+    def escaped_field_sep_regex
+      @escaped_field_sep_regex ||= Regexp.new Regexp.quote escaped_field_sep
+    end
+
+    def escaped_repetition_sep_regex
+      @escaped_repetition_sep_regex ||= Regexp.new Regexp.quote escaped_repetition_sep
+    end
+
+    def escaped_component_sep_regex
+      @escaped_component_sep_regex ||= Regexp.new Regexp.quote escaped_component_sep
+    end
+
+    def escaped_subcomponent_sep_regex
+      @escaped_subcomponent_sep_regex ||= Regexp.new Regexp.quote escaped_subcomponent_sep
+    end
+
+    def escaped_escape_char_regex
+      @escaped_escape_char_regex ||= Regexp.new Regexp.quote escaped_escape_char
+    end
+
+    def escaped_hex_regex
+      @escaped_hex_regex ||= Regexp.new "#{Regexp.quote escape_char}X\\h+#{Regexp.quote escape_char}"
+    end
+
+    def msh2
+      @msh2 ||= [
+        component_sep,
+        repetition_sep,
+        escape_char,
+        subcomponent_sep
+      ].join
+    end
+
+    def escape(string)
+      return "" if string.nil?
+
+      string.each_char.map do |chr|
+        case chr
+        when field_sep then escaped_field_sep
+        when repetition_sep then escaped_repetition_sep
+        when component_sep then escaped_component_sep
+        when subcomponent_sep then escaped_subcomponent_sep
+        when escape_char then escaped_escape_char
+        else
+          if (32.chr..127.chr).cover?(chr)
+            chr
+          else
+            format("\\X%02X\\", chr.ord)
+          end
+        end
+      end.join
+    end
+
+    def unescape(string)
+      return "" if string.nil?
+      return string unless string.include?(escape_char)
+
+      s = StringScanner.new(string)
+      out = String.new
+      until s.eos?
+        if s.scan(escaped_field_sep_regex)
+          out << field_sep
+        elsif s.scan(escaped_repetition_sep_regex)
+          out << repetition_sep
+        elsif s.scan(escaped_component_sep_regex)
+          out << component_sep
+        elsif s.scan(escaped_subcomponent_sep_regex)
+          out << subcomponent_sep
+        elsif s.scan(escaped_escape_char_regex)
+          out << escape_char
+        elsif s.scan(escaped_hex_regex)
+          s.matched[2..-2].scan(/../).each { |hex| out << hex.to_i(16).chr }
+        else
+          out << s.getch
+        end
+      end
+      out
+    end
+
+    # Returns an array of Pipehat::Segments of the right class
+    def parse(hl7)
+      hl7.split(segment_sep).map do |seg|
+        name = seg[0, seg.index("|")]
+        klass = if Pipehat::Segment.const_defined?(name)
+                  Pipehat::Segment.const_get(name)
+                else
+                  Pipehat::Segment::Base
+                end
+        klass.new(seg, parser: self)
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{field_sep}#{msh2}>"
+    end
+  end
+
+  DEFAULT_PARSER = Parser.new
+end

data/lib/pipehat/repeat/base.rb

@@ -0,0 +1,31 @@
+module Pipehat
+  module Repeat
+    class Base < Pipehat::Node
+      def initialize(segment, fnum, rnum)
+        @segment = segment
+        @fnum = fnum
+        @rnum = rnum
+      end
+
+      attr_reader :segment, :fnum, :rnum
+
+      def component(cnum, type = Pipehat::Component::Base)
+        type.new(segment, fnum, rnum, cnum)
+      end
+
+      def set(value)
+        segment.set_repeat(fnum, rnum, value)
+      end
+
+      def to_hl7
+        (segment.tree(fnum, rnum) || []).map do |component|
+          (component || []).join(parser.subcomponent_sep)
+        end.join(parser.component_sep)
+      end
+
+      def inspect
+        inspect_node(fnum, rnum)
+      end
+    end
+  end
+end

data/lib/pipehat/segment/aip.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pipehat
+  module Segment
+    # Appointment Information - Personnel Resource
+    class AIP < Base
+      add_field :set_id,                        :SI
+      add_field :segment_action_code,           :ID
+      add_field :personnel_resource_id,         :XCN
+      add_field :resource_type,                 :CWE
+      add_field :resource_group,                :CWE
+      add_field :start_date_time,               :DTM
+      add_field :start_date_time_offset,        :NM
+      add_field :start_date_time_offset_units,  :CNE
+      add_field :duration,                      :NM
+      add_field :duration_units,                :CNE
+      add_field :allow_substitution_code,       :CWE
+      add_field :filler_status_code,            :CWE
+    end
+  end
+end

data/lib/pipehat/segment/ais.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pipehat
+  module Segment
+    # Appointment Information
+    class AIS < Base
+      add_field :set_id,                                  :SI
+      add_field :segment_action_code,                     :ID
+      add_field :universal_service_identifier,            :CWE
+      add_field :start_date_time,                         :DTM
+      add_field :start_date_time_offset,                  :NM
+      add_field :start_date_time_offset_units,            :CNE
+      add_field :duration,                                :NM
+      add_field :duration_units,                          :CNE
+      add_field :allow_substitution_code,                 :CWE
+      add_field :filler_status_code,                      :CWE
+      add_field :placer_supplemental_service_information, :CWE
+      add_field :filler_supplemental_service_information, :CWE
+    end
+  end
+end

data/lib/pipehat/segment/al1.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pipehat
+  module Segment
+    # Patient Allergy Information
+    class AL1 < Base
+      add_field :set_id,                :SI
+      add_field :allergen_type_code,    :CE
+      add_field :allergen_code,         :CE
+      add_field :allergy_severity_code, :CE
+      add_field :allergy_reaction_code, :ST
+      add_field :identification_date,   :DT
+    end
+  end
+end

data/lib/pipehat/segment/base.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Pipehat
+  module Segment
+    class Base
+      def initialize(string = nil, parser: Pipehat::DEFAULT_PARSER)
+        string ||= self.class.name.split("::").last
+        # storage is nested array (to depth of subcomponents).  The unescaped
+        # strings is stored (escape/unescape occurs in accessors).
+        @data = string.split(parser.field_sep).map do |field|
+          field.split(parser.repetition_sep).map do |repeat|
+            repeat.split(parser.component_sep).map do |component|
+              component.split(parser.subcomponent_sep)
+            end
+          end
+        end
+        @parser = parser
+      end
+
+      # Returns a reference to a field by number
+      def field(fnum, type = Pipehat::Field::Base)
+        type.new(self, fnum)
+      end
+
+      # Return the raw (unescaped) string at the specified position.
+      # If the position doesn't exist, returns nil.
+      #
+      # Note this works by assuming @data always has arrays nesting to
+      # the subcomponent position
+      def get(fnum, rnum, cnum, snum)
+        tree(fnum, rnum, cnum, snum)
+      end
+
+      def tree(fnum, rnum = nil, cnum = nil, snum = nil)
+        tmp = @data.dig(fnum)
+        tmp = tmp&.dig(rnum - 1) if rnum
+        tmp = tmp&.dig(cnum - 1) if cnum
+        tmp = tmp&.dig(snum - 1) if snum
+        tmp
+      end
+
+      # TODO: set_* currently assume a string only.  Would be good to accept
+      # and insert arrays (for nodes higher than subcomponents)
+      # There should also be a way to avoid the escaping (eg, FT values use
+      # escape sequences that shouldn't be escaped again).
+
+      def set_field(fnum, value)
+        @data[fnum] = [[[parser.escape(value)]]]
+      end
+
+      def set_repeat(fnum, rnum, value)
+        @data[fnum] ||= [[[]]]
+        @data[fnum][rnum - 1] = [[parser.escape(value)]]
+      end
+
+      def set_component(fnum, rnum, cnum, value)
+        @data[fnum] ||= [[[]]]
+        @data[fnum][rnum - 1] ||= [[]]
+        @data[fnum][rnum - 1][cnum - 1] = [parser.escape(value)]
+      end
+
+      def set_subcomponent(fnum, rnum, cnum, snum, value)
+        @data[fnum] ||= [[[]]]
+        @data[fnum][rnum - 1] ||= [[]]
+        @data[fnum][rnum - 1][cnum - 1] ||= []
+        @data[fnum][rnum - 1][cnum - 1][snum - 1] = parser.escape(value)
+      end
+
+      def field_names
+        self.class.field_names
+      end
+
+      def segment_name
+        field(0).to_s
+      end
+
+      attr_accessor :parser
+
+      def to_hl7
+        @data.map do |field|
+          (field || []).map do |repeat|
+            (repeat || []).map do |component|
+              (component || []).join(parser.subcomponent_sep)
+            end.join(parser.component_sep)
+          end.join(parser.repetition_sep)
+        end.join(parser.field_sep)
+      end
+
+      class << self
+        # returns a list of the fields define on this segment as symbols
+        def field_names
+          @field_names ||= []
+        end
+
+        def add_field(name, type, options = {})
+          field_names << name
+          count = field_names.size
+          klass = Object.const_get("Pipehat::Field::#{type}")
+
+          invalid_options = options.keys - %i[setter]
+          raise "Invalid options: #{invalid_options.join(", ")}" if invalid_options.any?
+
+          define_method name do
+            field(count, klass)
+          end
+
+          return unless options.fetch(:setter, true)
+
+          define_method "#{name}=" do |value|
+            send(name).set(value)
+          end
+        end
+      end
+
+      def inspect
+        s = "#<#{self.class} "
+        maxlen = 76 - s.length
+        fragment = to_hl7
+        fragment = fragment[0, maxlen - 3] + "..." if fragment.length > maxlen
+        "#{s}#{fragment}>"
+      end
+    end
+  end
+end