simple_hl7 0.1.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in simple_hl7.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Rome Portlock
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# SimpleHl7
+
+SimpleHL7 is a library that manages HL7 v2.x documents for interfacing with
+health care systems.  The goal of SimpleHL7 is to make it easy to create basic
+HL7 messages while also having the power to create more complex ones. SimpleHL7
+is agnostic of message and segment types, it works only with the basic
+structure of HL7 documents.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simple_hl7'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_hl7
+
+## Usage
+
+SimpleHL7 can be used for either message creation or parsing.
+
+### Message Creation
+
+A simple example:
+
+```ruby
+msg = SimpleHL7::Message.new
+msg.msh[9][1] = "ADT"
+msg.msh[9][2] = "A04"
+msg.msh[10] = "12345678"
+msg.msh[11] = "D"
+msg.msh[12] = "2.5"
+
+msg.pid[3] = "454545"
+msg.pid[5][1] = "Doe"
+msg.pid[5][2] = "John"
+
+msg.pv1[2] = "O"
+
+msg.to_hl7
+```
+
+Would generate the following HL7 string.
+
+```
+MSH|^~\&|||||||ADT^A04|12345678|D|2.5
+PID|||454545||Doe^John
+PV1||O
+```
+
+This is the easiest way to use SimpleHL7, however most of the methods used
+above are syntactic sugar for underlying methods that are explained in detail
+later.
+
+### Adding a segment
+
+The easiest way to add a segment to a new message is by calling its three
+letter segment name as a method on the message. For example to create a PID
+segment, do the following:
+
+```ruby
+msg = SimpleHL7::Message.new
+msg.pid
+```
+
+Note that since the MSH segment is always required it is created automatically.
+So if to_hl7 was called on the message above, the result would be
+
+```
+MSH|^~\&|
+PID
+```
+
+### Repeating segments
+
+Using the segment name is the easiest way to create a new segment, but if you
+have more than one segment with the same name it won't work. The first name
+method call will create a segment, but subsequent calls will just reference
+that first created segment.
+
+To create multiple segments of the same type use the underlying `add_segment`
+method.
+
+```ruby
+obx1 = msg.add_segment('obx')
+obx2 = msg.add_segment('obx')
+```
+
+To later retreive a certain segment use the `segment` method.
+
+```
+obx2 = msg.segment('obx', 2)
+```
+
+### Adding components, subcomponents, fields etc.
+
+To add values to the message just specifiy the index in brackets
+
+```ruby
+msg = SimpleHL7::Message.new
+msg.msh[12] = '2.5'
+```
+
+To specifiy a certain component use more brackets.
+
+```ruby
+msg = SimpleHL7::Message.new
+msg.msh[9][1] = "ADT"
+msg.msh[9][2] = "A04"
+```
+
+It is important to note that under the hood the the bracket syntax actually
+adds the value to the first subcomponent of the first componenet of the first
+repition in the specified field.
+
+This means that:
+
+```ruby
+msg.msh[9] = "ADT"
+msg.msh[9][1] = "ADT"
+msg.msh[9][1][1] = "ADT"
+```
+
+are all equivalent.
+
+### Repeating fields
+
+Since repeating fields are less common in HL7 they require a little bit of
+extra work to create using SimpleHL7. Use the `r(index)` method to create
+repeats.
+
+```ruby
+msg.pid[13] = '123-4567'
+msg.pid[13].r(2)[1] = '876-5432'
+```
+
+Creates the following PID segment
+
+```
+PID|||||||||||||123-4567~876-5432
+```
+
+### HL7 Escaping
+
+HL7 special characters are automatically escaped properly when generating HL7,
+without doing any extra work.
+
+```ruby
+msg = SimpleHL7::Message.new
+msg.nte[3] = "Testing & escaping notes"
+msg.to_hl7
+```
+
+Outputs:
+
+```
+MSH|^~\&|
+NTE|||Testing \T\ escaping notes
+```
+
+### Parsing
+
+To parse HL7 string use the parse method
+
+```ruby
+hl7_str = "MSH|^~\\&|||||||ADT^A04|12345678|D|2.5\rPID|||454545||Doe^John"
+msg = SimpleHL7::Message.parse(hl7_str)
+```
+
+Once the message is parsed use to_s to pull out values
+
+```ruby
+msg.pid[5][1].to_s
+=> "Doe"
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/simple_hl7.rb

@@ -0,0 +1,15 @@
+require "simple_hl7/version"
+
+module SimpleHL7
+  # Your code goes here...
+end
+
+require "simple_hl7/separator_characters"
+require "simple_hl7/composite"
+require "simple_hl7/subcomponent"
+require "simple_hl7/component"
+require "simple_hl7/component_container"
+require "simple_hl7/field"
+require "simple_hl7/segment"
+require "simple_hl7/msh_segment"
+require "simple_hl7/message"

data/lib/simple_hl7/component.rb

@@ -0,0 +1,11 @@
+module SimpleHL7
+  class Component < Composite
+    def self.current_separator_char(separator_chars)
+      separator_chars.subcomponent
+    end
+
+    def self.subcomposite_class
+      Subcomponent
+    end
+  end
+end

data/lib/simple_hl7/component_container.rb

@@ -0,0 +1,11 @@
+module SimpleHL7
+  class ComponentContainer < Composite
+    def self.current_separator_char(separator_chars)
+      separator_chars.component
+    end
+
+    def self.subcomposite_class
+      Component
+    end
+  end
+end

data/lib/simple_hl7/composite.rb

@@ -0,0 +1,170 @@
+module SimpleHL7
+  # Generic building block of a HL7 message. The parts of the message
+  # subclass this, and this class does most of the work.
+  class Composite
+    # Constructor
+    #
+    # @param value [String] a value that is passed down to the subclass
+    #   constructor. This allows us to set values on top level components that
+    #   are passed down to the lowest component. Default nil.
+    def initialize(value = nil)
+      @subcomposites = {}
+      cls = self.class
+      unless value.nil?
+        @subcomposites[cls.start_index] = cls.subcomposite_class.new(value)
+      end
+    end
+
+    # Set the value of the specified subcomposite.
+    # The value is actually passed down to the first subcomposite of the
+    # specified subcomposite and so on until it reaches a Subcomponent
+    # composite.
+    #
+    # @param index [Integer] the subcomposite index.
+    # @param value [String] the value to set.
+    def []=(index, value)
+      set_subcomposite(index, self.class.subcomposite_class.new(value))
+    end
+
+    # Get a specific subcomposite.
+    #
+    # @param index [Integer] The index of the subcomposite.
+    # @return [Subcomposite] The subcomposite at index or a new subcomposite
+    #   if none exists. Note that this returns the Subcomposite object and not
+    #   the string value. This differs from how []= works, but it seems to make
+    #   the most sense when dealing with HL7 messages.
+    def [](index)
+      get_subcomposite(index)
+    end
+
+    # Alias for []
+    def get_subcomposite(index)
+      subcomposite = @subcomposites[index]
+      if subcomposite.nil?
+        subcomposite = self.class.subcomposite_class.new
+        set_subcomposite(index, subcomposite)
+      end
+      subcomposite
+    end
+
+    # Sets a specific subcomposite
+    #
+    # @param index [Integer] the indexs of the subcomposite, if there is an
+    #   existing compsite at the location it is replaced.
+    # @param value [Subcomposite] the new subcomposite object for the
+    #   specified location.
+    def set_subcomposite(index, value)
+      @subcomposites[index] = value
+    end
+
+    # Calls the specified block once for each index between the start index
+    # and the max specified subcomposite index.
+    #
+    # @yeild [subcomposite] Gives the subcomposite at the current index to the
+    #   block. If there isn't a subcomposite specified for the index then nil
+    #   is passed.
+    def each
+      start = self.class.start_index
+      (start..max_index).each { |i| yield @subcomposites[i] } if max_index
+    end
+
+    # Calls the specified block once for each index between the start index
+    # and the max specified subcomposite index and returns an array resulting
+    # from the return values of each block.
+    #
+    # @yeild [subcomposite] Gives the subcomposite at the current index to the
+    #   block. If there isn't a subcomposite specified for the index then nil
+    #   is passed.
+    def map
+      start = self.class.start_index
+      (start..max_index).map { |i| yield @subcomposites[i] } if max_index
+    end
+
+    # Get a HL7 string representation of this Composite.
+    #
+    # @separator_chars [SeparatorChars] The separator characters to be used
+    #   when converting this Composite to a string of HL7.
+    def to_hl7(separator_chars)
+      sep_char = self.class.current_separator_char(separator_chars)
+      map { |subc| subc.to_hl7(separator_chars) if subc }.join(sep_char)
+    end
+
+    # Get the value stored at the first Subcomponent below this Composite
+    def to_s
+      @subcomposites[self.class.start_index].to_s
+    end
+
+    # Get all the subcomposites as an array. Note that this array has the
+    # actual subcomposite object and not clones, so any changes will affect
+    # this class as well.
+    def to_a
+      a = []
+      each {|subc| a << subc}
+      a
+    end
+
+    # The index where the first subcomposite is located. This is usually either
+    # 1 or 0 depending on the specific Composite.
+    def self.start_index
+      1
+    end
+
+    # @abstract The character that is used to separate the subcomposites when
+    # generating a HL7 string.
+    #
+    # @param separator_chars [SeparatorChars] The separator characters in use
+    #   during the HL7 string conversion.
+    def self.current_separator_char(separator_chars)
+      raise Exception.new("Subclass Responsibility")
+    end
+
+    # @abstract The class that is used for subcomposites.
+    def self.subcomposite_class
+      raise Exception.new("Subclass Responsibility")
+    end
+
+    # Create a composite from a HL7 string.
+    #
+    # @param str [String] The string of HL7.
+    # @param separator_chars [SeparatorChars] The separator characters used
+    #   in the HL7 string.
+    # @return [Composite] The parsed composite.
+    def self.parse(str, separator_chars)
+      composite = new
+      parse_subcomposite_hash(str, separator_chars).each do |index, subc|
+        composite.set_subcomposite(start_index + index, subc)
+      end
+      composite
+    end
+
+    private
+
+    def max_index
+      @subcomposites.keys.max
+    end
+
+    class << self
+      private
+
+      # Parses the subcomposites of a HL7 string into a hash
+      #
+      # @param str [String] The HL7 string to parse.
+      # @param separator_chars [SeparatorChars] The separator characters used in
+      #   the HL7 string.
+      # @return A hash of composites, one for each subcomposite in the string
+      #   that actually had a value. Empty subcomposites are left out of the
+      #   hash.
+      def parse_subcomposite_hash(str, separator_chars)
+        subc_strs = str.split(current_separator_char(separator_chars))
+        subc_h = {}
+        subc_strs.each_with_index do |subc_str, index|
+          unless subc_str.empty?
+            subc_h[index] = subcomposite_class.parse(subc_str, separator_chars)
+          end
+        end
+        subc_h
+      end
+    end
+
+  end
+end

data/lib/simple_hl7/field.rb

@@ -0,0 +1,23 @@
+module SimpleHL7
+  class Field < Composite
+    def self.current_separator_char(separator_chars)
+      separator_chars.repetition
+    end
+
+    def self.subcomposite_class
+      ComponentContainer
+    end
+
+    def []=(index, value)
+      get_subcomposite(1)[index] = value
+    end
+
+    def [](index)
+      get_subcomposite(1)[index]
+    end
+
+    def r(index)
+      get_subcomposite(index)
+    end
+  end
+end

data/lib/simple_hl7/message.rb

@@ -0,0 +1,74 @@
+module SimpleHL7
+  class Message
+    def initialize(default_msh = true)
+      @segments = []
+      @segments << MSHSegment.new if default_msh
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^[a-zA-Z][a-zA-Z0-9]{2}$/
+        get_named_segment(meth)
+      elsif meth.to_s =~ /^[a-zA-Z][a-zA-Z0-9]{2}_all$/
+        seg_name = meth[0..3]
+        all_segments(seg_name)
+      else
+        super
+      end
+    end
+
+    def to_hl7
+      separator_chars = get_named_segment('MSH').separator_chars
+      @segments.map {|s| s.to_hl7(separator_chars)}.join("\r")
+    end
+
+    def to_a
+      @segments.reduce([]) {|a, s| a << s.to_a}
+    end
+
+    def segment(name, index=1)
+      all = all_segments(name)
+      seg = nil
+      seg = all[index - 1] if all.size >= index
+      seg
+    end
+
+    def add_segment(name)
+      segment = Segment.new(name)
+      @segments << segment
+      segment
+    end
+
+    def append_segment(segment)
+      @segments << segment
+      segment
+    end
+
+    private
+
+    def all_segments(name)
+      @segments.select {|seg| seg.name == name}
+    end
+
+
+    def get_named_segment(name)
+      name_str = name.to_s.upcase
+      segment = @segments.select {|seg| seg.name == name_str}.first
+      unless segment
+        segment = Segment.new(name_str)
+        @segments << segment
+      end
+      segment
+    end
+
+    def self.parse(str)
+      msg = new(false)
+      segment_strs = str.split("\r")
+      msh = MSHSegment.parse(segment_strs[0])
+      msg.append_segment(msh)
+      segment_strs[1, segment_strs.length].each do |seg_str|
+        msg.append_segment(Segment.parse(seg_str, msh.separator_chars))
+      end
+      msg
+    end
+  end
+end

data/lib/simple_hl7/msh_segment.rb

@@ -0,0 +1,38 @@
+module SimpleHL7
+  class MSHSegment < Segment
+    def initialize
+      super('MSH')
+      self[1] = '|'
+      self[2] = '^~\&'
+    end
+
+    def separator_chars
+      enc_chars = @subcomposites[2].to_s
+      SeparatorCharacters.new(@subcomposites[1].to_s,
+                              enc_chars[0],
+                              enc_chars[1],
+                              enc_chars[2],
+                              enc_chars[3])
+    end
+
+    def self.parse(str)
+      msh = new
+      msh[1] = str[3]
+      msh[2] = str[4..7]
+
+      fields = parse_subcomposite_hash(str[9, str.length], msh.separator_chars)
+      fields.each { |index, subc| msh.set_subcomposite(index + 3, subc) }
+      msh
+    end
+
+    def to_hl7(separator_chars)
+      sep_char = self.class.current_separator_char(separator_chars)
+      base_msh = "#{name}#{self[1]}#{self[2]}"
+      max_index = @subcomposites.keys.max
+      rest_msh = (3..max_index).map { |i|
+        @subcomposites[i].to_hl7(separator_chars) if @subcomposites[i]
+      }.join(sep_char)
+      [base_msh, rest_msh].join(sep_char)
+    end
+  end
+end

data/lib/simple_hl7/segment.rb

@@ -0,0 +1,23 @@
+module SimpleHL7
+  class Segment < Composite
+    def self.start_index
+      0
+    end
+
+    def self.subcomposite_class
+      Field
+    end
+
+    def self.current_separator_char(separator_chars)
+      separator_chars.field
+    end
+
+    def name
+      self[0].to_s
+    end
+
+    def to_a
+      super.insert(0, name)
+    end
+  end
+end

data/lib/simple_hl7/separator_characters.rb

@@ -0,0 +1,8 @@
+module SimpleHL7
+  class SeparatorCharacters < Struct.new(:field, :component, :repetition,
+                                         :escape, :subcomponent)
+    def self.defaults
+      SeparatorCharacters.new('|', '^', '~', '\\', '&')
+    end
+  end
+end

data/lib/simple_hl7/subcomponent.rb

@@ -0,0 +1,27 @@
+module SimpleHL7
+  class Subcomponent < Struct.new(:value)
+    def to_hl7(separator_chars)
+      hl7 = value
+      hl7.gsub!(separator_chars.escape, "\\E\\")
+      hl7.gsub!(separator_chars.field, "\\F\\")
+      hl7.gsub!(separator_chars.repetition, "\\R\\")
+      hl7.gsub!(separator_chars.component, "\\S\\")
+      hl7.gsub!(separator_chars.subcomponent, "\\T\\")
+      hl7
+    end
+
+    def to_s
+      value
+    end
+
+    def self.parse(str, separator_chars)
+      value = str
+      value.gsub!("\\E\\", separator_chars.escape)
+      value.gsub!("\\F\\", separator_chars.field)
+      value.gsub!("\\R\\", separator_chars.repetition)
+      value.gsub!("\\S\\", separator_chars.component)
+      value.gsub!("\\T\\", separator_chars.subcomponent)
+      Subcomponent.new(value)
+    end
+  end
+end

data/lib/simple_hl7/version.rb

@@ -0,0 +1,3 @@
+module SimpleHL7
+  VERSION = "0.1.2"
+end

data/simple_hl7.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/simple_hl7/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rome Portlock"]
+  gem.email         = ["rome@alivecor.com"]
+  gem.description   = %q{Parse and generate hl7 messages for interfacing with health care systems}
+  gem.summary       = %q{Parse and generate hl7 messages}
+  gem.homepage      = "https://github.com/alivecor/simple_hl7"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "simple_hl7"
+  gem.require_paths = ["lib"]
+  gem.version       = SimpleHL7::VERSION
+
+  gem.add_development_dependency "pry", "~> 0.9"
+  gem.add_development_dependency "rspec", "~> 2.14"
+end

data/spec/simple_hl7/component_container_spec.rb

@@ -0,0 +1,22 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe ComponentContainer do
+    describe "#to_hl7" do
+      it "generates proper hl7 for a field with subfields" do
+        container = ComponentContainer.new
+        container[1] = "foo"
+        container[2] = "bar"
+        container.to_hl7(SeparatorCharacters.defaults).should == "foo^bar"
+      end
+
+      it "generates proper hl7 for a field with components and subfields" do
+        container = ComponentContainer.new
+        container[1] = "foo"
+        container[1][2] = "bar"
+        container[2] = "baz"
+        container.to_hl7(SeparatorCharacters.defaults).should == "foo&bar^baz"
+      end
+    end
+  end
+end

data/spec/simple_hl7/component_spec.rb

@@ -0,0 +1,30 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe Component do
+    describe "#to_hl7" do
+      it "generates proper hl7 for a field with subfields" do
+        field = Component.new
+        field[1] = "foo"
+        field[2] = "bar"
+        field.to_hl7(SeparatorCharacters.defaults).should == "foo&bar"
+      end
+    end
+
+    describe "[]" do
+      it "gets the proper value" do
+        field = Component.new
+        field[1] = "foo"
+        field[1].to_s.should == "foo"
+      end
+    end
+
+    describe "#parse" do
+      it "parse hl7 correctly" do
+        component = Component.parse("foo&bar", SeparatorCharacters.defaults)
+        component[1].to_s.should == "foo"
+        component[2].to_s.should == "bar"
+      end
+    end
+  end
+end

data/spec/simple_hl7/field_spec.rb

@@ -0,0 +1,15 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe Field do
+    describe "#to_hl7" do
+      it "generates proper hl7 for a field with subfields" do
+        field = Field.new
+        field[1] = "foo"
+        field[2] = "baz"
+        field.r(2)[1] = "bar"
+        field.to_hl7(SeparatorCharacters.defaults).should == 'foo^baz~bar'
+      end
+    end
+  end
+end

data/spec/simple_hl7/message_spec.rb

@@ -0,0 +1,37 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe Message do
+    describe "#to_hl7" do
+      it "generates an hl7 message" do
+        msg = Message.new
+        msg.msh[6] = "accountid"
+        msg.pid[5] = "User"
+        msg.pid[5][2] = "Test"
+        msg.to_hl7.should == "MSH|^~\\&||||accountid\rPID|||||User^Test"
+      end
+    end
+
+    describe "#add_segment" do
+      it "adds segments properly" do
+        msg = Message.new
+        obx_1 = msg.add_segment('OBX')
+        obx_1[1] = "1"
+        obx_2 = msg.add_segment('OBX')
+        obx_2[1] = "2"
+        msg.segment('OBX', 1)[1].to_s.should == "1"
+        msg.segment('OBX', 2)[1].to_s.should == "2"
+      end
+    end
+
+    describe "#parse" do
+      it "properly parses a hl7 string" do
+        msg = Message.parse("MSH|^~\\&||||accountid\rPID|||||User^Test~Repeat")
+        msg.msh[6].to_s.should == "accountid"
+        msg.pid[5].to_s.should == "User"
+        msg.pid[5][2].to_s.should == "Test"
+        msg.pid[5].r(2)[1].to_s.should == "Repeat"
+      end
+    end
+  end
+end

data/spec/simple_hl7/msh_segment_spec.rb

@@ -0,0 +1,13 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe MSHSegment do
+    describe "#parse" do
+      it "parses a hl7 string correctly" do
+        msh = MSHSegment.parse('MSH|^~\\&|||test')
+        msh.separator_chars.field.should == '|'
+        msh[5].to_s.should == 'test'
+      end
+    end
+  end
+end

data/spec/simple_hl7/segment_spec.rb

@@ -0,0 +1,23 @@
+require "pry"
+require "simple_hl7"
+
+module SimpleHL7
+  describe Segment do
+    describe "#to_hl7" do
+      it "generates a message using the specified separator chars" do
+        sep_chars = SeparatorCharacters.defaults
+        seg = Segment.new('PID')
+        seg[5] = 'test'
+        seg.to_hl7(sep_chars).should == 'PID|||||test'
+      end
+    end
+
+    describe "#parse" do
+      it "parses a hl7 string correctly" do
+        sep_chars = SeparatorCharacters.defaults
+        seg = Segment.parse('PID|||||test', sep_chars)
+        seg[5].to_s.should == 'test'
+      end
+    end
+  end
+end

data/spec/simple_hl7/subcomponent_spec.rb

@@ -0,0 +1,32 @@
+require "simple_hl7"
+
+module SimpleHL7
+  describe Subcomponent do
+    describe "#to_hl7" do
+      it "returns the value" do
+        subf = Subcomponent.new('test')
+        subf.to_hl7(SeparatorCharacters.defaults).should == 'test'
+      end
+
+      it "escapes special characters in a string" do
+        subc = Subcomponent.new('peas&carrots')
+        subc.to_hl7(SeparatorCharacters.defaults).should == 'peas\T\carrots'
+      end
+
+      it "escapes all special characters" do
+        subc = Subcomponent.new('\\&^~|')
+        default_chars = SeparatorCharacters.defaults
+        subc.to_hl7(default_chars).should == "\\E\\\\T\\\\S\\\\R\\\\F\\"
+      end
+    end
+
+    describe "#parse" do
+      it "should unescape the special characters" do
+        str = "\\E\\\\T\\\\S\\\\R\\\\F\\"
+        default_chars = SeparatorCharacters.defaults
+        parsed = Subcomponent.parse(str, default_chars)
+        parsed.to_s.should == '\\&^~|'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: simple_hl7
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Rome Portlock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Parse and generate hl7 messages for interfacing with health care systems
+email:
+- rome@alivecor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/simple_hl7.rb
+- lib/simple_hl7/component.rb
+- lib/simple_hl7/component_container.rb
+- lib/simple_hl7/composite.rb
+- lib/simple_hl7/field.rb
+- lib/simple_hl7/message.rb
+- lib/simple_hl7/msh_segment.rb
+- lib/simple_hl7/segment.rb
+- lib/simple_hl7/separator_characters.rb
+- lib/simple_hl7/subcomponent.rb
+- lib/simple_hl7/version.rb
+- simple_hl7.gemspec
+- spec/simple_hl7/component_container_spec.rb
+- spec/simple_hl7/component_spec.rb
+- spec/simple_hl7/composite_spec.rb
+- spec/simple_hl7/field_spec.rb
+- spec/simple_hl7/message_spec.rb
+- spec/simple_hl7/msh_segment_spec.rb
+- spec/simple_hl7/segment_spec.rb
+- spec/simple_hl7/subcomponent_spec.rb
+homepage: https://github.com/alivecor/simple_hl7
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Parse and generate hl7 messages
+test_files:
+- spec/simple_hl7/component_container_spec.rb
+- spec/simple_hl7/component_spec.rb
+- spec/simple_hl7/composite_spec.rb
+- spec/simple_hl7/field_spec.rb
+- spec/simple_hl7/message_spec.rb
+- spec/simple_hl7/msh_segment_spec.rb
+- spec/simple_hl7/segment_spec.rb
+- spec/simple_hl7/subcomponent_spec.rb