hippo_eyeDoc 0.0.1

data/lib/hippo_eyeDoc/exceptions.rb

@@ -0,0 +1,10 @@
+module Hippo_eyeDoc
+  module Exceptions
+    class Exception < StandardError; end
+
+    class InvalidValue    < Exception; end
+    class InvalidField    < Exception; end
+    class InvalidSegment  < Exception; end
+    class ParseError      < Exception; end
+  end
+end

data/lib/hippo_eyeDoc/field.rb

@@ -0,0 +1,149 @@
+require 'date'
+require 'time'
+require 'bigdecimal'
+
+module Hippo_eyeDoc
+  class Field
+    attr_accessor :name, :sequence, :datatype, :options,
+                  :restrictions, :minimum, :maximum, :required,
+                  :separator, :composite, :composite_sequence
+
+    def minimum
+      @minimum ||= 0
+    end
+
+    def formatted_value(value)
+      return nil if value.nil?
+
+      case datatype
+      when :binary  then value
+      when :integer then value.to_i
+      when :decimal then parse_decimal(value)
+      when :date    then parse_date(value)
+      when :time    then parse_time(value)
+      else parse_string(value)
+      end
+    end
+
+    def string_value(value)
+      return '' if value.nil? && !required
+
+      case datatype
+      when :binary  then value
+      when :integer then value.to_s.rjust(minimum, '0')
+      when :decimal then generate_decimal(value)
+      when :date    then generate_date(value)
+      when :time    then generate_time(value)
+      else generate_string(value)
+      end
+    end
+
+    def generate_string(value)
+      if required
+        value.to_s.ljust(minimum)
+      else
+        value.to_s
+      end
+    end
+
+    def parse_string(value)
+      if value.to_s.empty? && !required
+        nil
+      else
+        value.to_s.strip
+      end
+    end
+
+    def generate_decimal(value)
+      value ||= BigDecimal('0')
+
+      value.to_s('F').sub(/\.0\z/,'').rjust(minimum, '0')
+    end
+
+    def parse_decimal(value)
+      if value == ''
+        invalid! if required
+        return nil
+      end
+
+      BigDecimal(value.to_s)
+    end
+
+    def generate_time(value)
+      value ||= Time.now
+
+      if maximum == 4 || value.sec == 0
+        value.strftime('%H%M')
+      else
+        value.strftime('%H%M%S')
+      end
+    end
+
+    def parse_time(value)
+      if value == ''
+        invalid! if required
+        return nil
+      end
+
+      case value.class.to_s
+      when 'Time' then value
+      when 'String'
+        format =  case value
+                  when /\A\d{4}\z/ then '%H%M'
+                  when /\A\d{6}\z/ then '%H%M%S'
+                  when /\A\d{7,8}\z/ then '%H%M%S%N'
+                  else invalid!
+                  end
+
+        Time.strptime(value, format)
+      else invalid!
+      end
+    rescue
+      invalid!
+    end
+
+    def generate_date(value)
+      value ||= Date.today
+
+      if value.class.to_s == 'Range'
+        "#{value.first.strftime('%Y%m%d')}-#{value.last.strftime('%Y%m%d')}"
+      elsif maximum == 6
+        value.strftime('%y%m%d')
+      else
+        value.strftime('%Y%m%d')
+      end
+    end
+
+    def parse_date(value)
+      if value == ''
+        invalid! if required
+        return nil
+      end
+
+      case value.class.to_s
+      when "Range"  then value
+      when "Date"   then value
+      when "Time"   then value.to_date
+      when "String"
+        format =  case value
+                  when /\A\d{6}\z/ then '%y%m%d'
+                  when /\A\d{8}\z/ then '%Y%m%d'
+                  when /\A(\d{8})-(\d{8})\z/ then
+                    return Date.parse($1, '%Y%m%d')..Date.parse($2, '%Y%m%d')
+                  else
+                    invalid!
+                  end
+
+        Date.parse(value, format)
+      else
+        invalid! "Invalid datatype(#{value.class}) for date field."
+      end
+    rescue
+      invalid!
+    end
+
+    def invalid!(message = "Invalid value specified for #{self.datatype} field.")
+      raise Hippo_eyeDoc::Exceptions::InvalidValue.new message
+    end
+  end
+end

data/lib/hippo_eyeDoc/outputters.rb

@@ -0,0 +1,4 @@
+require_relative 'outputters/html'
+require_relative 'outputters/pdf'
+require_relative 'outputters/paper_claim'
+require_relative 'outputters/pretty_string'

data/lib/hippo_eyeDoc/outputters/html.rb

@@ -0,0 +1,39 @@
+ module Hippo_eyeDoc::Outputters
+  module HTML
+    module TransactionSet
+      def to_html
+        output = ''
+        initial_call = caller.select{|m| m =~ /#{__FILE__}/}.length == 0
+
+        if initial_call
+          output = %{<fieldset class="hippo-transaction-set"><legend>#{self.class.to_s.sub('Hippo_eyeDoc::TransactionSets::','')}</legend>}
+        end
+
+        values.sort.each do |sequence, component|
+          component_definition = self.class.components[sequence]
+          if component_definition.klass.ancestors.include?(Hippo_eyeDoc::TransactionSets::Base)
+            output += %Q{<fieldset class="hippo-component"><legend>#{component_definition.klass.to_s.sub('Hippo_eyeDoc::TransactionSets::','')} - #{component_definition.options[:name]}</legend>}
+            output += component.to_html
+            output += '</fieldset>'
+          else
+            output += %Q{<span class="hippo-segment-name">#{component_definition.options[:name]}</span><span class="hippo-segment-data">#{component.to_s}</span><br/>}
+          end
+        end
+
+        output + (initial_call ? '</fieldset>' : '')
+      end
+    end
+
+    module RepeatingComponent
+      def to_html
+       map{|component| component.to_html}.join
+      end
+    end
+
+    module Segment
+      def to_html
+        to_s
+      end
+    end
+  end
+end

data/lib/hippo_eyeDoc/outputters/paper_claim.rb

@@ -0,0 +1,7 @@
+module Hippo_eyeDoc::Outputters
+  module PaperClaim
+    def to_claim
+
+    end
+  end
+end

data/lib/hippo_eyeDoc/outputters/pdf.rb

@@ -0,0 +1,18 @@
+module Hippo_eyeDoc::Outputters
+  module PDF
+    module TransactionSet
+      def to_pdf
+      end
+    end
+
+    module RepeatingComponent
+      def to_pdf
+      end
+    end
+
+    module Segment
+      def to_pdf
+      end
+    end
+  end
+end

data/lib/hippo_eyeDoc/outputters/pretty_string.rb

@@ -0,0 +1,45 @@
+module Hippo_eyeDoc::Outputters
+  module PrettyString
+    module TransactionSet
+      def pretty_print(pp)
+        pp.text to_pretty_string
+      end
+
+      def to_pretty_string(indent_level = 0)
+        output = ''
+
+        values.sort.each do |sequence, component|
+          component_definition = self.class.components[sequence]
+
+          extra_indent = if component_definition.klass.ancestors.include?(Hippo::TransactionSets::Base)
+                           2
+                         elsif sequence == 0
+                           0
+                         else
+                           2
+                         end
+
+          output += component.to_pretty_string(indent_level + extra_indent)
+        end
+
+        output
+      end
+    end
+
+    module RepeatingComponent
+      def pretty_print(pp)
+        pp.text to_pretty_string
+      end
+
+      def to_pretty_string(indent_level = 0)
+        map{|component| component.to_pretty_string(indent_level)}.join
+      end
+    end
+
+    module Segment
+      def to_pretty_string(indent_level = 0)
+        ' ' * indent_level + to_s + "\n"
+      end
+    end
+  end
+end

data/lib/hippo_eyeDoc/parser.rb

@@ -0,0 +1,70 @@
+require_relative 'parser/segment'
+require_relative 'parser/transaction_set'
+
+module Hippo_eyeDoc
+  class Parser
+    include Hippo_eyeDoc::Separator
+    include TransactionSet
+
+    def self.parse_file(input)
+      parser = new
+      parser.parse_string(input)
+    end
+
+    def self.parse_string(input)
+      parser = new
+      parser.parse_string(input)
+    end
+
+    def initialize
+      super
+    end
+
+    def initialize_transaction_set(index)
+      {
+        :segments  => [],
+        :ISA       => find_first_segment(parsed_segments[0,index + 1], 'ISA', true),
+        :GS        => find_first_segment(parsed_segments[0,index + 1], 'GS', true),
+        :GE        => find_first_segment(parsed_segments[index + 1, parsed_segments.length - index + 1], 'GE'),
+        :IEA       => find_first_segment(parsed_segments[index + 1, parsed_segments.length - index + 1], 'IEA')
+      }
+    end
+
+    def parse_transaction_sets
+      raw_transaction_sets  = []
+      inside_transaction    = false
+
+      parsed_segments.each_with_index do |segment, index|
+        if segment.identifier == 'ST'
+          raw_transaction_sets << initialize_transaction_set(index)
+
+          inside_transaction = true
+        end
+
+        raw_transaction_sets.last[:segments] << segment if inside_transaction
+
+        inside_transaction = false if segment.identifier == 'SE'
+      end
+
+      raw_transaction_sets
+    end
+
+    def populate_transaction_sets
+      parse_transaction_sets.collect do |transaction|
+        transaction_set_id = transaction[:segments].first.ST01
+        transaction_set = Hippo_eyeDoc::TransactionSets.constants.select{|c| c.to_s.end_with?(transaction_set_id) }.first
+
+        Hippo_eyeDoc::TransactionSets.const_get(transaction_set)::Base.new(separators.merge(transaction))
+      end
+    end
+
+    def parse_file(filename)
+      parse_string(File.read(filename))
+    end
+
+    def parse_string(input)
+      read(input)
+      populate_transaction_sets
+    end
+  end
+end

data/lib/hippo_eyeDoc/parser/segment.rb

@@ -0,0 +1,35 @@
+module Hippo_eyeDoc
+  class Parser
+    module Segment
+      def parse(input)
+        input.gsub!(/[\a\e\f\n\r\t\v]/,'')
+        fields = input.split(@field_separator)
+
+        segment_identifier = fields.shift
+
+        fields.each_with_index do |value, index|
+          field = self.class.fields[index]
+
+          # if the field is an array that means it is a
+          # composite field
+          if field.class == Array
+            composite_fields    = value.split(@composite_separator)
+            composite_sequence  = field.first.composite_sequence
+
+            self.values[composite_sequence] = {}
+
+            composite_fields.each_with_index do |comp_value, comp_index|
+              composite_field = field[comp_index]
+
+              self.values[composite_sequence][composite_field.sequence] = composite_field.formatted_value(comp_value)
+            end
+          else
+            self.values[field.sequence] = field.formatted_value(value)
+          end
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/hippo_eyeDoc/parser/transaction_set.rb

@@ -0,0 +1,45 @@
+module Hippo_eyeDoc
+  class Parser
+    module TransactionSet
+      attr_accessor :unparsed_data
+
+      def initialize(options={})
+        super
+      end
+
+      def find_first_segment(segments, identifier, reverse = false)
+        segments.reverse! if reverse
+
+        if index = segments.index{|o| o.identifier == identifier}
+          segments[index]
+        else
+          nil
+        end
+      end
+
+      def parsed_segments
+        @segments ||= @unparsed_data.split(@segment_separator).collect do |segment_string|
+          segment_identifier = segment_string.split(@field_separator).first
+          segment = Hippo_eyeDoc::Segments.const_get(segment_identifier.lstrip).new(:parent => self)
+
+          segment.parse(segment_string)
+
+          segment.to_s == '' ? nil : segment
+        end.compact
+      end
+
+      def read(input = nil)
+        input ||= ''
+
+        @unparsed_data = input.gsub(/[\a\e\f\n\r\t\v]/,'')
+        parse_separators(@unparsed_data)
+      end
+
+      def parse(input)
+        read(input)
+        populate(parsed_segments)
+        self
+      end
+    end
+  end
+end

data/lib/hippo_eyeDoc/segments.rb

@@ -0,0 +1,111 @@
+require_relative 'segments/base'
+
+module Hippo_eyeDoc
+  module Segments
+    autoload_relative :AAA,   'segments/AAA'
+    autoload_relative :AK1,   'segments/AK1'
+    autoload_relative :AK2,   'segments/AK2'
+    autoload_relative :AK3,   'segments/AK3'
+    autoload_relative :AK4,   'segments/AK4'
+    autoload_relative :AK5,   'segments/AK5'
+    autoload_relative :AK9,   'segments/AK9'
+    autoload_relative :AMT,   'segments/AMT'
+    autoload_relative :BHT,   'segments/BHT'
+    autoload_relative :BPR,   'segments/BPR'
+    autoload_relative :CAS,   'segments/CAS'
+    autoload_relative :CL1,   'segments/CL1'
+    autoload_relative :CLM,   'segments/CLM'
+    autoload_relative :CLP,   'segments/CLP'
+    autoload_relative :CN1,   'segments/CN1'
+    autoload_relative :CR1,   'segments/CR1'
+    autoload_relative :CR2,   'segments/CR2'
+    autoload_relative :CR3,   'segments/CR3'
+    autoload_relative :CR4,   'segments/CR4'
+    autoload_relative :CR5,   'segments/CR5'
+    autoload_relative :CR6,   'segments/CR6'
+    autoload_relative :CR7,   'segments/CR7'
+    autoload_relative :CR8,   'segments/CR8'
+    autoload_relative :CRC,   'segments/CRC'
+    autoload_relative :CTP,   'segments/CTP'
+    autoload_relative :CTX,   'segments/CTX'
+    autoload_relative :CUR,   'segments/CUR'
+    autoload_relative :DMG,   'segments/DMG'
+    autoload_relative :DN1,   'segments/DN1'
+    autoload_relative :DN2,   'segments/DN2'
+    autoload_relative :DSB,   'segments/DSB'
+    autoload_relative :DTM,   'segments/DTM'
+    autoload_relative :DTP,   'segments/DTP'
+    autoload_relative :EB,    'segments/EB'
+    autoload_relative :EM,    'segments/EM'
+    autoload_relative :EQ,    'segments/EQ'
+    autoload_relative :FRM,   'segments/FRM'
+    autoload_relative :HCP,   'segments/HCP'
+    autoload_relative :HI,    'segments/HI'
+    autoload_relative :HL,    'segments/HL'
+    autoload_relative :HSD,   'segments/HSD'
+    autoload_relative :III,   'segments/III'
+    autoload_relative :IK3,   'segments/IK3'
+    autoload_relative :IK4,   'segments/IK4'
+    autoload_relative :IK5,   'segments/IK5'
+    autoload_relative :IMM,   'segments/IMM'
+    autoload_relative :INS,   'segments/INS'
+    autoload_relative :K3,    'segments/K3'
+    autoload_relative :LE,    'segments/LE'
+    autoload_relative :LIN,   'segments/LIN'
+    autoload_relative :LQ,    'segments/LQ'
+    autoload_relative :LS,    'segments/LS'
+    autoload_relative :LX,    'segments/LX'
+    autoload_relative :MEA,   'segments/MEA'
+    autoload_relative :MIA,   'segments/MIA'
+    autoload_relative :MOA,   'segments/MOA'
+    autoload_relative :MPI,   'segments/MPI'
+    autoload_relative :MSG,   'segments/MSG'
+    autoload_relative :N1,    'segments/N1'
+    autoload_relative :N2,    'segments/N2'
+    autoload_relative :N3,    'segments/N3'
+    autoload_relative :N4,    'segments/N4'
+    autoload_relative :NM1,   'segments/NM1'
+    autoload_relative :NTE,   'segments/NTE'
+    autoload_relative :OI,    'segments/OI'
+    autoload_relative :PAT,   'segments/PAT'
+    autoload_relative :PCT,   'segments/PCT'
+    autoload_relative :PDP,   'segments/PDP'
+    autoload_relative :PDR,   'segments/PDR'
+    autoload_relative :PER,   'segments/PER'
+    autoload_relative :PID,   'segments/PID'
+    autoload_relative :PKD,   'segments/PKD'
+    autoload_relative :PLB,   'segments/PLB'
+    autoload_relative :PRV,   'segments/PRV'
+    autoload_relative :PS1,   'segments/PS1'
+    autoload_relative :PWK,   'segments/PWK'
+    autoload_relative :QTY,   'segments/QTY'
+    autoload_relative :RDM,   'segments/RDM'
+    autoload_relative :REF,   'segments/REF'
+    autoload_relative :SBR,   'segments/SBR'
+    autoload_relative :SD1,   'segments/SD1'
+    autoload_relative :SE,    'segments/SE'
+    autoload_relative :ST,    'segments/ST'
+    autoload_relative :STC,   'segments/STC'
+    autoload_relative :SV1,   'segments/SV1'
+    autoload_relative :SV2,   'segments/SV2'
+    autoload_relative :SV3,   'segments/SV3'
+    autoload_relative :SV4,   'segments/SV4'
+    autoload_relative :SV5,   'segments/SV5'
+    autoload_relative :SV6,   'segments/SV6'
+    autoload_relative :SV7,   'segments/SV7'
+    autoload_relative :SVC,   'segments/SVC'
+    autoload_relative :SVD,   'segments/SVD'
+    autoload_relative :TOO,   'segments/TOO'
+    autoload_relative :TRN,   'segments/TRN'
+    autoload_relative :TS2,   'segments/TS2'
+    autoload_relative :TS3,   'segments/TS3'
+    autoload_relative :UR,    'segments/UR'
+    autoload_relative :VEH,   'segments/VEH'
+
+    autoload_relative :ISA,   'segments/ISA'
+    autoload_relative :GS,    'segments/GS'
+    autoload_relative :GE,    'segments/GE'
+    autoload_relative :IEA,   'segments/IEA'
+    autoload_relative :TA1,   'segments/TA1'
+  end
+end