nacha 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ab30c59682e44d667d8341db3d7caa948d310231f18e7bd95ca4326294a64c5
-  data.tar.gz: 2b8302f2ef6dc7aaad982c1519be8e22d08dcecd559588968789745e9af0a706
+  metadata.gz: 0f9c3cffdb4484e108a60fb3f34a59ddff273b1d519fc7e5da6dabbe3a56c49a
+  data.tar.gz: 8e2ec6f4a3a18b795e4cd9906942262766439bab0b6f309a95f57f7fe7931676
 SHA512:
-  metadata.gz: 114c117d5945dc843efe761f5b665caaed444e452f45c1a248449c250cf56c8975b990199d29d546a2a83a9ed270330e4bba619de37ec51a691a31faadd98769
-  data.tar.gz: 717e8720c587b4860f6e9003c448632e77b32a35a98d9016c16232af26252ef70cf431f216aa465d746b39405063fb278f4daedc575bdecabb8453d7fb2bbd69
+  metadata.gz: ac4490619d1bf8be9ea04b8ee4544e0498a2c59921a4a6c374dfa3d659ea17f4b03d03947f84ad630859511358da9e1f3a4e5992d53106a9285f903b8b5ea791
+  data.tar.gz: ef3dc1c6be90957f1fc056fc532235e3b8841ab10a259e507b1aebacd784997db57f65630a703bbbd06d57b067a670697045eca088e0c268775ad43953a4f8cb

data/.gitignore

@@ -7,7 +7,9 @@
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/bundle/
 
 # rspec failure tracking
 .rspec_status
-.byebug_history
+.byebug_history
+.aider*

data/Guardfile

@@ -12,7 +12,9 @@ guard :rspec, cmd: 'bundle exec rspec' do
   watch(rspec.spec_support) { rspec.spec_dir }
   watch(rspec.spec_files)
   watch(%r{^lib/nacha/base_record\.rb}) { Dir.glob('spec/nacha/record_types/*_spec.rb') }
-  watch(%r{^lib/config/definitions/(.+)\.yml}) { |m| "spec/nacha/record_types/#{m[1]}_spec.rb" }
+  watch(%r{^lib/config/definitions/(.+)\.yml}) do |m|
+    "spec/nacha/record_types/#{m[1]}_spec.rb"
+  end
 
   # Ruby files
   ruby = dsl.ruby

data/README.md

@@ -56,6 +56,28 @@ API may change at any time.   Pull requests welcomed
 }
 ```
 
+## Parse an ach file into an HTML file
+
+```
+nacha parse ach_file.ach > ach_file.html`
+
+
+## Discussion
+
+* Nacha::Record::Base defines a class method `nacha_field`
+* Each ACH record class defines its fields using `nacha_field`
+* Based on the information provided by `nacha_field` a regex matcher
+  for different record types can be built out of the constant parts
+  of the ACH record.
+* Each ACH record has a "RecordType" mixin that specifies the record
+  types that can follow this record.
+
+Parsing starts by looking for a default record type 'Nacha::Record::FileHeader'
+When that is found, the valid child record types for 'Nacha::Record::FileHeader'
+are gathered and the subsequent lines are parsed using only those types
+
+When a record is created, the fields for the instance are created from
+the field definitions.
 
 ## Development
 

data/exe/nacha

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+require 'nacha' # Assuming this loads the Nacha gem
+
+module Nacha
+  class CLI < Thor
+    TEMPLATES_DIR = File.join(Gem::Specification.find_by_name("nacha").gem_dir,
+                              "templates").freeze
+
+    HTML_PREAMBLE_FILE = File.join(TEMPLATES_DIR, "html_preamble.html")
+    HTML_POSTAMBLE_FILE = File.join(TEMPLATES_DIR, "html_postamble.html")
+
+    desc "parse FILE", "Parse an ACH file"
+    def parse(file_path)
+      unless File.exist?(file_path)
+        puts "Error: File not found at #{file_path}"
+        exit 1
+      end
+
+      ach_file = [Nacha.parse(File.open(file_path)).first] # Use Nacha.parse
+
+      # TODO: Determine a user-friendly way to output the parsed data.
+      # For now, let's print the records.
+      if ach_file && ach_file.is_a?(Array) && !ach_file.empty?
+        output_html(file_path, ach_file)
+      else
+        puts "Could not parse the file or the file was empty."
+      end
+    rescue StandardError => e
+      puts "An error occurred during parsing: #{e.message}"
+      puts e.backtrace.join("\n")
+      exit 1
+    end
+
+    private
+
+    def output_html(file_path, ach_file)
+      puts html_preamble
+      puts "<h1>Successfully parsed #{file_path}</h1>\n"
+      display_child(0, ach_file.first) # Display the first record
+      puts html_postamble
+    end
+
+    def html_preamble
+      @html_preamble ||= File.read(HTML_PREAMBLE_FILE)
+    end
+
+    def html_postamble
+      @html_postamble ||= File.read(HTML_POSTAMBLE_FILE)
+    end
+
+    def display_child(level, record)
+      # Attempt to call a summary or to_s method if it exists,
+      # otherwise inspect the record.
+      return unless record
+      level_indent = '  ' * level.to_i
+      puts "<html>"
+      puts record.to_html
+      if record.respond_to?(:children) && record.children.any?
+        if record.children.any?
+          record.children.each_with_index do |child_record, child_index|
+            display_child(level + 1, child_record)
+          end
+        end
+      end
+      puts "</html>"
+    end
+  end
+end
+
+Nacha::CLI.start(ARGV)

data/lib/nacha/aba_number.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require "nacha/has_errors"
+
 class Nacha::AbaNumber
   attr_reader :routing_number
   attr_reader :aba_number
 
+  include HasErrors
+
   def initialize(routing_number)
     self.routing_number = routing_number
   end
@@ -31,7 +35,25 @@ class Nacha::AbaNumber
   end
 
   def valid?
-    @valid ||= (@routing_number.length == 9 && compute_check_digit == @routing_number.chars[8])
+    @valid ||= valid_routing_number_length? && valid_check_digit?
+  end
+
+  def valid_routing_number_length?
+    if @routing_number.length != 9
+      add_error("Routing number must be 9 digits long, but was #{@routing_number.length} digits long.")
+      false
+    else
+      true
+    end
+  end
+
+  def valid_check_digit?
+    if compute_check_digit != @routing_number.chars[8]
+      add_error("Incorrect Check Digit \"#{@routing_number.chars[8]}\" should be \"#{ compute_check_digit }\" ")
+      false
+    else
+      true
+    end
   end
 
   def to_s(with_checkdigit = true)

data/lib/nacha/field.rb

@@ -40,6 +40,13 @@ class Nacha::Field
     case @contents
     when /\AC(.*)\z/ # Constant
       @data = Regexp.last_match(1)
+    when /\$.*¢*/
+      @data_type = Nacha::Numeric
+      @justification = :rjust
+      cents = 10 ** (@contents.count('¢'))
+      @json_output = [[:to_i], [:/, cents]]
+      @output_conversion = [:to_i]
+      @fill_character = '0'
     when /Numeric/
       @data_type = Nacha::Numeric
       @justification = :rjust
@@ -64,18 +71,17 @@ class Nacha::Field
       @justification = :ljust
       @output_conversion = [:to_s]
       @fill_character = ' '
-    when /\$+\u00a2\u00a2/
-      @data_type = Nacha::Numeric
-      @justification = :rjust
-      @json_output = [[:to_i], [:/, 100.0]]
-      @output_conversion = [:to_i]
-      @fill_character = '0'
     end
   end
 
   def data=(val)
     @data = @data_type.new(val)
     @input_data = val
+  rescue StandardError => e
+    add_error("Invalid data for #{@name}: \"#{val.inspect}\"")
+    add_error("Error: #{e.message}")
+    @data = String.new(val.to_s)
+    @input_data = val
   end
 
   def mandatory?
@@ -126,6 +132,25 @@ class Nacha::Field
     end
   end
 
+  def human_name
+    # @human_name ||= @name.to_s.gsub('_', ' ').capitalize
+    @human_name ||= @name.to_s.split('_').map(&:capitalize).join(' ')
+  end
+
+  def to_html
+    tooltip_text = "<span class=\"tooltiptext\" >#{human_name}</span>"
+    field_classes = ["nacha-field tooltip"]
+    field_classes += ['mandatory'] if mandatory?
+    field_classes += ['required'] if required?
+    field_classes += ['optional'] if optional?
+    field_classes += ['error'] if errors.any?
+
+    ach_string = to_ach.gsub(' ', '&nbsp;')
+    "<span data-field-name=\"#{@name}\" class=\"#{field_classes.join(' ')}\" data-name=\"#{@name}\">#{ach_string}" +
+      tooltip_text.to_s +
+      "</span>"
+  end
+
   def to_s
     @data.send(*output_conversion).to_s
   end

data/lib/nacha/has_errors.rb

@@ -0,0 +1,12 @@
+module HasErrors
+  attr_reader :errors
+
+  def add_error(message)
+    @errors ||= []
+    @errors << message
+  end
+
+  def has_errors?
+    !@errors.nil? && !@errors.empty?
+  end
+end

data/lib/nacha/numeric.rb

@@ -6,8 +6,8 @@ class Nacha::Numeric
 
   def to_i
     if @value
-      if @value.is_a?(String) && @value.match(/ */)
-        self
+      if @value.is_a?(String) && @value.match(/\A *\z/)
+        @value # blank strings should return as blank
       else
         @value.to_i
       end
@@ -20,11 +20,14 @@ class Nacha::Numeric
     if val.is_a?(String)
       @value = val.dup
       if(val.strip.length > 0)
-        @value = BigDecimal(val.strip)
-        @op_value = @value
+        @op_value = BigDecimal(val.strip)
+        @value = val.dup
       else
         @op_value = BigDecimal(0)
       end
+    elsif val.nil?
+      @value = BigDecimal(0)
+      @op_value = @value
     else
       @value = BigDecimal(val)
       @op_value = @value
@@ -32,7 +35,7 @@ class Nacha::Numeric
   end
 
   def to_s
-    @value ? @value.to_s : nil
+    @value ? @value.to_i.to_s : nil
   end
 
   def respond_to_missing?(method_name, include_private = false)

data/lib/nacha/parser.rb

@@ -1,35 +1,42 @@
 # frozen_string_literal: true
 
 require 'nacha'
+require 'nacha/parser_context'
 
 class Nacha::Parser
   DEFAULT_RECORD_TYPES = ['Nacha::Record::FileHeader'].freeze
+
+  attr_reader :context
+
   def initialize
+    @context = Nacha::ParserContext.new
     reset!
   end
 
   def reset!; end
 
   def parse_file(file)
-    parent = nil
-    records = []
-    File.foreach(file).with_index do |line, line_num|
-      records << process(line, line_num, records.last)
-      parent = records.last if records.lasts.class.child_record_types.any?
-    end
+    @context.parser_started_at = Time.now
+    @context.file_name = file
+    parse_string(file.read)
   end
 
   def parse_string(str)
     line_num = -1
     records = []
-    str.scan(/.{94}/).each do |line|
+    @context.parser_started_at ||= Time.now
+    str.scan(/(.{94}|(\A[^\n]+))/).each do |line|
+      line = line.first.strip
       line_num += 1
+      @context.line_number = line_num
+      @context.line_length = line.length
       records << process(line, line_num, records.last)
     end.compact
     records
   end
 
   def process(line, line_num, previous = nil)
+    @context.line_errors = []
     parent = previous
     record = nil
 
@@ -37,10 +44,11 @@ class Nacha::Parser
     while record_types
       record = parse_by_types(line, record_types)
       break if record || !parent
-
+      record.validate if record
       parent = parent.parent
       record_types = valid_record_types(parent)
     end
+    record.line_number = line_num if record
     add_child(parent, record)
     record
   end
@@ -61,7 +69,8 @@ class Nacha::Parser
   def parse_by_types(line, record_types)
     record_types.detect do |rt|
       record_type = Object.const_get(rt)
-      return record_type.parse(line) if record_type.matcher =~ line
+      record = record_type.parse(line) if record_type.matcher =~ line
+      return record if record
     end
   end
 end

data/lib/nacha/parser_context.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class Nacha::ParserContext
+  attr_accessor :file_name
+  attr_accessor :line_number
+  attr_accessor :line_length
+  attr_accessor :line_errors
+  attr_accessor :parser_started_at
+  attr_accessor :parser_ended_at # nil 'till the end of parsing
+  attr_accessor :previous_record
+  attr_reader :validated
+
+  def initialize (opts = {})
+    @file_name = opts[:file_name] || ''
+    @line_number = opts[:line_number] || 0
+    @line_length = opts[:line_length] || 0
+    @current_line_errors = []
+    @parser_started_at = Time.now
+    @parser_ended_at = nil
+    @previous_record = nil
+    @validated = false
+  end
+
+  def validated?
+    @validated ||= false
+  end
+
+  def valid?
+    @valid ||= errors.empty?
+  end
+
+end

data/lib/nacha/record/base.rb

@@ -10,10 +10,12 @@ module Nacha
       include Validations::FieldValidations
 
       attr_accessor :children, :parent, :fields
-      attr_reader :name, :validations
+      attr_reader :name, :validations, :errors
+      attr_accessor :line_number
 
       def initialize(opts = {})
         @children = []
+        @errors = []
         create_fields_from_definition
         opts.each do |k, v|
           setter = "#{k}="
@@ -25,6 +27,96 @@ module Nacha
         end
       end
 
+      class << self
+        attr_reader :nacha_record_name
+
+        def nacha_field(name, inclusion:, contents:, position:)
+          definition[name] = { inclusion: inclusion,
+                               contents: contents,
+                               position: position,
+                               name: name}
+          validation_method = "valid_#{name}".to_sym
+          return unless respond_to?(validation_method)
+
+          validations[name] ||= []
+          validations[name] << validation_method
+        end
+        def definition
+          @definition ||= {}
+        end
+
+        def validations
+          @validations ||= {}
+        end
+
+        def unpack_str
+          @unpack_str ||= definition.values.collect do |d|
+            Nacha::Field.unpack_str(d)
+          end.join.freeze
+        end
+
+        def old_matcher
+          @matcher ||=
+            Regexp.new('\A' + definition.values.collect do |d|
+                         if d[:contents] =~ /\AC(.+)\z/ || d['contents'] =~ /\AC(.+)\z/
+                           Regexp.last_match(1)
+                         else
+                           '.' * (d[:position] || d['position']).size
+                         end
+                       end.join + '\z')
+        end
+
+        # A more strict matcher that accounts for numeric and date fields
+        # and allows for spaces in those fields, but not alphabetic characters
+        # Also matches strings that might not be long enough.
+        #
+        # Processes the definition in reverse order to allow later fields to be
+        # skipped if they are not present in the input string.
+        def matcher
+          return @matcher if @matcher
+
+          output_started = false
+          skipped_output = false
+          @matcher ||=
+            Regexp.new('\A' + definition.values.reverse.collect do |d|
+                         if d[:contents] =~ /\AC(.+)\z/
+                           output_started = true
+                           Regexp.last_match(1)
+                         elsif d[:contents] =~ /\ANumeric\z/
+                           if output_started
+                             '[0-9 ]' + "{#{(d[:position] || d['position']).size}}"
+                           else
+                             skipped_output = true
+                             ''
+                           end
+                         elsif d[:contents] =~ /\AYYMMDD\z/
+                           if output_started
+                             '[0-9 ]' + "{#{(d[:position] || d['position']).size}}"
+                           else
+                             skipped_output = true
+                             ''
+                           end
+                         else
+                           if output_started
+                             '.' + "{#{(d[:position] || d['position']).size}}"
+                           else
+                             skipped_output = true
+                             ''
+                           end
+                         end
+                       end.reverse.join + (skipped_output ? '.*' : '') + '\z')
+        end
+
+
+        def parse(ach_str)
+          rec = new
+          ach_str.unpack(unpack_str).zip(rec.fields.values) do |input_data, field|
+            field.data = input_data
+          end
+          rec
+        end
+      end
+
       def create_fields_from_definition
         @fields ||= {}
         definition.each_pair do |field_name, field_def|
@@ -36,6 +128,10 @@ module Nacha
         Nacha.record_name(self.class)
       end
 
+      def human_name
+        @human_name ||= record_type.to_s.split('_').map(&:capitalize).join(' ')
+      end
+
       def to_h
         { nacha_record_type: record_type }.merge(
           @fields.keys.map do |key|
@@ -53,32 +149,22 @@ module Nacha
         end.join
       end
 
-      def inspect
-        "#<#{self.class.name}> #{to_h}"
-      end
-
-      def self.nacha_field(name, inclusion:, contents:, position:)
-        definition[name] = { inclusion: inclusion,
-                             contents: contents,
-                             position: position,
-                             name: name}
-        validation_method = "valid_#{name}".to_sym
-        return unless respond_to?(validation_method)
+      def to_html(opts = {})
+        record_error_class = nil
 
-        validations[name] ||= []
-        validations[name] << validation_method
-      end
-
-      def self.definition
-        @definition ||= {}
-      end
-
-      def self.validations
-        @validations ||= {}
+        field_html = @fields.keys.collect do |key|
+          record_error_class ||= 'error' if @fields[key].errors.any?
+          @fields[key].to_html
+        end.join
+        "<div class=\"nacha-record tooltip #{record_type} #{record_error_class}\">" +
+          "<span class=\"nacha-field\" data-name=\"record-number\">#{"%05d" % [line_number]}&nbsp;|&nbsp</span>" +
+          field_html +
+          "<span class=\"record-type\" data-name=\"record-type\">#{human_name}</span>" +
+          "</div>"
       end
 
-      class << self
-        attr_reader :nacha_record_name
+      def inspect
+        "#<#{self.class.name}> #{to_h}"
       end
 
       def definition
@@ -86,64 +172,119 @@ module Nacha
       end
 
       def validate
-        self.class.definition.keys.map do |field|
-          next unless self.class.validations[field]
+        failing_checks = self.class.definition.keys.map do |field|
+          next true unless self.class.validations[field]
 
           # rubocop:disable GitlabSecurity/PublicSend
           field_data = send(field)
-          send(self.class.validations[:field], field_data)
+
+          self.class.validations[field].map do |validation_method|
+            self.class.send(validation_method, field_data)
+          end
           # rubocop:enable GitlabSecurity/PublicSend
-        end
+        end.flatten
       end
 
       # look for invalid fields, if none, then return true
       def valid?
-        statuses = self.class.definition.keys.map do |field_sym|
-          # rubocop:disable GitlabSecurity/PublicSend
-          field = send(field_sym)
-          # rubocop:enable GitlabSecurity/PublicSend
-          next true unless field.mandatory?
+        # statuses = self.class.definition.keys.map do |field_sym|
+        #   # rubocop:disable GitlabSecurity/PublicSend
+        #   field = send(field_sym)
+        #   # rubocop:enable GitlabSecurity/PublicSend
+        #   next true unless field.mandatory?
 
-          ## TODO: levels of validity with 'R' and 'O' fields
-          field.valid?
-        end
-        !statuses.detect { |valid| valid == false }
+        #   ## TODO: levels of validity with 'R' and 'O' fields
+        #   field.valid?
+        # end
+        statuses = validate
+        (statuses.detect { |valid| valid == false } != false)
       end
 
+      # Checks if the current transaction code represents a debit transaction.
+      #
+      # This method evaluates the `transaction_code` (which is expected to be
+      # an attribute or method available in the current context) against a
+      # predefined set of debit transaction codes.
+      #
+      # @return [Boolean] `true` if `transaction_code` is present and its
+      #   string representation is included in `DEBIT_TRANSACTION_CODES`,
+      #   `false` otherwise.
+      #
+      # @example
+      #   # Assuming transaction_code is "201" and DEBIT_TRANSACTION_CODES includes "201"
+      #   debit? #=> true
+      #
+      #   # Assuming transaction_code is "100" and DEBIT_TRANSACTION_CODES does not include "100"
+      #   debit? #=> false
+      #
+      #   # Assuming transaction_code is nil
+      #   debit? #=> false
+      #
+      # @note
+      #   This method includes robust error handling. If a `NoMethodError`
+      #   occurs (e.g., if `transaction_code` is undefinable or does not respond
+      #   to `to_s` in an unexpected way) or a `NameError` occurs (e.g., if
+      #   `transaction_code` or `DEBIT_TRANSACTION_CODES` is not defined
+      #   in the current scope), the method gracefully rescues these exceptions
+      #   and returns `false`. This default behavior ensures that an inability
+      #   to determine the transaction type results in it being considered
+      #   "not a debit".
+      #
+      # @see #transaction_code (if `transaction_code` is an instance method or attribute)
+      # @see DEBIT_TRANSACTION_CODES (the constant defining debit codes)
       def debit?
         transaction_code &&
           DEBIT_TRANSACTION_CODES.include?(transaction_code.to_s)
+      rescue NoMethodError, NameError
+        false
       end
 
+      # Checks if the current transaction code represents a credit transaction.
+      #
+      # This method evaluates the `transaction_code` (which is expected to be
+      # an attribute or method available in the current context) against a
+      # predefined set of credit transaction codes.
+      #
+      # @return [Boolean] `true` if `transaction_code` is present and its
+      #   string representation is included in `CREDIT_TRANSACTION_CODES`,
+      #   `false` otherwise.
+      #
+      # @example
+      #   # Assuming transaction_code is "101" and CREDIT_TRANSACTION_CODES includes "101"
+      #   credit? #=> true
+      #
+      #   # Assuming transaction_code is "200" and CREDIT_TRANSACTION_CODES does not include "200"
+      #   credit? #=> false
+      #
+      #   # Assuming transaction_code is nil
+      #   credit? #=> false
+      #
+      # @note
+      #   This method includes robust error handling. If a `NoMethodError`
+      #   occurs (e.g., if `transaction_code` is undefinable or does not respond
+      #   to `to_s` in an unexpected way) or a `NameError` occurs (e.g., if
+      #   `transaction_code` or `CREDIT_TRANSACTION_CODES` is not defined
+      #   in the current scope), the method gracefully rescues these exceptions
+      #   and returns `false`. This default behavior ensures that an inability
+      #   to determine the transaction type results in it being considered
+      #   "not a credit".
+      #
+      # @see #transaction_code (if `transaction_code` is an instance method or attribute)
+      # @see CREDIT_TRANSACTION_CODES (the constant defining credit codes)
       def credit?
         transaction_code &&
           CREDIT_TRANSACTION_CODES.include?(transaction_code.to_s)
+      rescue NoMethodError, NameError
+        false
       end
 
-      def self.unpack_str
-        @unpack_str ||= definition.values.collect do |d|
-          Nacha::Field.unpack_str(d)
-        end.join.freeze
+      def errors
+        (@errors + @fields.values.map { |field| field.errors }).flatten
       end
 
-      def self.matcher
-        # puts definition.keys.join(', ')
-        definition['matcher'] ||
-          Regexp.new('\A' + definition.values.collect do |d|
-                              if d[:contents] =~ /\AC(.+)\z/ || d['contents'] =~ /\AC(.+)\z/
-                                Regexp.last_match(1)
-                              else
-                                '.' * (d[:position] || d['position']).size
-                              end
-                            end.join + '\z')
-      end
 
-      def self.parse(ach_str)
-        rec = new
-        ach_str.unpack(unpack_str).zip(rec.fields.values) do |input_data, field|
-          field.data = input_data
-        end
-        rec
+      def add_error(err_string)
+        @errors << err_string
       end
 
       def respond_to?(method_name, include_private = false)

data/lib/nacha/record/filler.rb

@@ -8,6 +8,9 @@ module Nacha
   module Record
     class Filler < Nacha::Record::Base
       include FillerRecordType
+
+      nacha_field :record_type_code, inclusion: 'M', contents: ('C' + ('9' * 93)), position: 1..1
+      nacha_field :filler, inclusion: 'M', contents: 'Numeric', position: 2..94
     end
   end
 end

data/lib/nacha/record/filler_record_type.rb

@@ -8,7 +8,7 @@ module Nacha
       end
 
       module ClassMethods
-        def self.child_record_types
+        def child_record_types
           []
         end
       end

data/lib/nacha/record/validations/field_validations.rb

@@ -10,24 +10,34 @@ module Nacha
         end
         module ClassMethods
           def check_field_error(field, message = nil, condition = nil)
-            (block_given? ? yield : condition) || (field.add_error("'#{field.data}' is invalid") && false)
+            (block_given? ? yield : condition) || (field.add_error("'#{field.name}' '#{field}' is invalid") && false)
           end
 
           def valid_service_class_code field
-            check_field_error(field) { SERVICE_CLASS_CODES.include? field.to_s }
+            check_field_error(field, "'#{field.name}' '#{field}' should be one of #{SERVICE_CLASS_CODES.join(', ')}") {
+              SERVICE_CLASS_CODES.include? field.to_s
+            }
           end
 
           def valid_standard_entry_class_code field
-            check_field_error(field) { STANDARD_ENTRY_CLASS_CODES.include? field.data }
+            check_field_error(field, "'#{field.name}' '#{field}' should be one of #{STANDARD_ENTRY_CLASS_CODES.join(', ')}") {
+              STANDARD_ENTRY_CLASS_CODES.include? field.data
+            }
           end
 
           def valid_transaction_code field
-            check_field_error(field) { TRANSACTION_CODES.include? field.to_s }
+            check_field_error(field, "'#{field.name}' '#{field}' should be one of #{TRANSACTION_CODES.join(', ')}") {
+              TRANSACTION_CODES.include? field.to_s
+            }
           end
 
           def valid_receiving_dfi_identification field
             check_field_error(field) { field.valid? }
           end
+
+          def valid_filler field
+            check_field_error(field) { field.to_s == ('9' * 93) }
+          end
         end
       end
     end

data/lib/nacha/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nacha
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/nacha.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'nacha/version'
 require 'yaml'
 require 'nacha/aba_number'
 require 'nacha/ach_date'
 require 'nacha/field'
 require 'nacha/numeric'
+require 'nacha/version'
 
 Gem.find_files('nacha/record/*.rb').reject{|f| f =~ /\/spec\//}.each do |file|
   require File.expand_path(file)

data/nacha.gemspec

@@ -24,6 +24,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'bigdecimal'
 
   spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "factory_bot"
   spec.add_development_dependency "gitlab-styles"
   spec.add_development_dependency "guard"
@@ -33,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency 'rubocop-performance'
   spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
 end

data/templates/html_postamble.html

@@ -0,0 +1 @@
+</body></html>

data/templates/html_preamble.html

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<html lang='en'>
+<head>
+<meta charset='UTF-8'>
+<meta name='viewport' content='width=device-width, initial-scale=1.0'>
+<title>NACHA File Parser</title>
+
+<style>
+  body {
+    font-family: Arial, sans-serif;
+  }
+  body, h1, h2, h3, p {
+    margin: 0;
+    padding: 0;
+  }
+  body {
+    padding: 20px;
+  }
+  h1 {
+
+    font-size: 24px;
+    margin-bottom: 20px;
+  }
+
+  span.nacha-field:hover {
+    background-color: yellow;
+  }
+
+  .tooltip {
+    position: relative;
+    display: inline-block;
+    /* border-bottom: 1px dotted black;  *//* If you want dots under the hoverable text */
+  }
+
+  /* Tooltip text */
+  .tooltip > .tooltiptext {
+    visibility: hidden;
+    /* width: 120px; */
+    background-color: black;
+    color: #fff;
+    text-align: center;
+    padding: 5px 5px;
+    border-radius: 6px;
+
+    top: 100%;
+    left: 50%;
+
+    /* Position the tooltip text - see examples below! */
+    position: absolute;
+    z-index: 1;
+  }
+
+  .nacha-record {
+    font-family: monospace;
+  }
+
+  .nacha-field {
+    display: inline-block;
+    background-color: #f0f0f0;
+  }
+  .nacha-field.error {
+    background-color: pink;
+  }
+  }
+
+   .nacha-record > .tooltiptext {
+     top: -50%;
+     left: 100%;
+     background-color: gray;
+   }
+
+   .record-type {
+     padding-left: 5px;
+     font-weight: bold;
+     color: #333;
+   }
+
+
+   /* Show the tooltip text when you mouse over the tooltip container */
+   .tooltip:hover > .tooltiptext {
+     visibility: visible;
+   }
+
+
+</style>
+</head>
+<body>
+<h1>NACHA File Parser</h1>

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nacha
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - David H. Wilkins
 bindir: exe
 cert_chain: []
-date: 2025-06-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -37,6 +37,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: factory_bot
   requirement: !ruby/object:Gem::Requirement
@@ -163,10 +191,25 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby parser for ACH files.
 email:
 - dwilkins@conecuh.com
-executables: []
+executables:
+- nacha
 extensions: []
 extra_rdoc_files: []
 files:
@@ -185,12 +228,15 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/nacha
 - lib/nacha.rb
 - lib/nacha/aba_number.rb
 - lib/nacha/ach_date.rb
 - lib/nacha/field.rb
+- lib/nacha/has_errors.rb
 - lib/nacha/numeric.rb
 - lib/nacha/parser.rb
+- lib/nacha/parser_context.rb
 - lib/nacha/record/addenda_record_type.rb
 - lib/nacha/record/adv_batch_control.rb
 - lib/nacha/record/adv_entry_detail.rb
@@ -252,6 +298,8 @@ files:
 - lib/nacha/record/xck_entry_detail.rb
 - lib/nacha/version.rb
 - nacha.gemspec
+- templates/html_postamble.html
+- templates/html_preamble.html
 homepage: https://github.com/dwilkins/nacha
 licenses:
 - MIT
@@ -270,7 +318,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby parser for ACH files.
 test_files: []