nacha 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d8625f3af750aa7ba6e526909ad823f6020b761ab740616e82650f856585a13
-  data.tar.gz: 459d7359527c582eddf7d46770b2527896d465db86be48a1f6a994bc8d15471d
+  metadata.gz: 737ec495f2219167b7ef5ec5a959a6b205a4cf551eba2fdee6b5d3f0324b0735
+  data.tar.gz: 67f479ed3d4f1affb7d7a0f3fb92168bc2554a84b33cca2c3108d884a36e3989
 SHA512:
-  metadata.gz: fb31a6b021d3a7b7752f079651bfc5d2f78d5623883ab91201e76853273c3002c1d4a0423d971d5c75a2c38b03faee3e31d64d7cf82cb28f632c4c4174a6526b
-  data.tar.gz: 2aaf5af05547d0e0f10afb1f2a310e70b69e11c359979df5d238389c7800ab3f76ff163a5f35275162809f44b923603c2ed69658c96fe11e7f86eb8cbdf204cf
+  metadata.gz: 3fbae7e0193e68fa8fda30e32ff8272c4380556352fd6b64d3fdd6eb806e974ac147952a033603810f712f06b5437207a7a0d6a7d84ae4abe435c87314716329
+  data.tar.gz: 666b409414698a8502a69d02dca7cdc35f929cda66c66a6ef68430701d252f4640ed8aaaeeec1ba0064c5ff49a94befe189a69757fb5903142eede3a706dcfbe

data/.rubocop.yml

@@ -8,6 +8,7 @@ AllCops:
     - 'tmp/**/*'
     - 'bin/**/*'
   CacheRootDirectory: tmp
+  SuggestExtensions: false
 
 # This cop checks whether some constant value isn't a
 # mutable literal (e.g. array or hash).
@@ -25,8 +26,8 @@ Style/FrozenStringLiteralComment:
     - 'Rakefile'
     - 'spec/**/*'
 
-Metrics/LineLength:
-  Max: 92
+Layout/LineLength:
+  Max: 108
 
 Naming/FileName:
   ExpectMatchingDefinition: true

data/.ruby-version

@@ -1 +1 @@
-3.4.4
+3.2.8

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.12] - 2025-07-08
+
+- Fixed a bug with parsing files with misshapen lines.  Now it
+  _should_ handle lines that are shorter than 94 characters _and_ have
+  (CR|CRLF|LF) as the terminating character.
+
+
+
+## [0.1.11] - 2025-07-05
+
+### Output formatting options
+- use -f [html|json|ach] or --format [html|json|ach] to change
+
+- use -o filename or --output filename to specify a file to output
+
+- Aider and I fixed a bunch of rubocop offenses and refactored some code
+
 ## [0.1.10] - 2025-07-01
 
 - Added ability to get a list of possible record types and

data/exe/nacha

@@ -1,29 +1,42 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'byebug'
 require 'thor'
+require 'json'
 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
+      "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"
+    option :output_file, aliases: "-o"
+    option :format, aliases: "-f", default: "html",
+      desc: "Output format (html, json, or ach)", enum: %w[html json ach]
     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
+      ach_file = Nacha.parse(File.open(file_path))
 
       # 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)
+        if options[:output_file]
+          File.open(options[:output_file], "w") do |file|
+            write_output(ach_file, file)
+          end
+        else
+          write_output(ach_file, $stdout)
+        end
       else
         puts "Could not parse the file or the file was empty."
       end
@@ -35,13 +48,43 @@ module Nacha
 
     private
 
-    def output_html(file_path, ach_records)
-      puts html_preamble
-      puts "<h1>Successfully parsed #{file_path}</h1>\n"
+    def write_output(ach_records, io)
+      case options[:format]
+      when 'html'
+        output_html(ach_records, io)
+      when 'json'
+        output_json(ach_records, io)
+      when 'ach'
+        output_ach(ach_records, io)
+      end
+    end
+
+    def output_json(ach_records, io)
+      io.puts JSON.pretty_generate(ach_records.map(&:to_h))
+      # io.puts JSON.pretty_generate(json_output)
+    end
+
+    def record_to_h(record)
+      {
+        record.class.name.split('::').last => {
+          fields: record.fields.transform_values(&:to_s),
+          children: record.children.map { |child| record_to_h(child) }
+        }
+      }
+    end
+
+    def output_ach(ach_records, io)
       ach_records.each do |record|
-        display_child(0, record)
+        io.puts record.to_ach
       end
-      puts html_postamble
+    end
+
+    def output_html(ach_records, io)
+      io.puts html_preamble
+      ach_records.each do |record|
+        io.puts record.to_html
+      end
+      io.puts html_postamble
     end
 
     def html_preamble
@@ -51,18 +94,6 @@ module Nacha
     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
-      puts record.to_html
-      if record.respond_to?(:children) && record.children.any?
-        record.children.each do |child_record|
-          display_child(level + 1, child_record)
-        end
-      end
-    end
   end
 end
 

data/lib/nacha/aba_number.rb

@@ -3,10 +3,9 @@
 require "nacha/has_errors"
 
 class Nacha::AbaNumber
-  attr_reader :routing_number
-  attr_reader :aba_number
+  attr_reader :routing_number, :aba_number
 
-  include HasErrors
+  include Nacha::HasErrors
 
   def initialize(routing_number)
     @errors = []
@@ -33,19 +32,21 @@ class Nacha::AbaNumber
   end
 
   def check_digit
-    @routing_number.chars[8] if @routing_number.length == 9 && compute_check_digit == @routing_number.chars[8]
+    return unless @routing_number.length == 9 && compute_check_digit == @routing_number[8]
+
+    @routing_number[8]
   end
 
   def valid?
     @valid ||= if valid_routing_number_length?
-               if @routing_number.length == 9
-                 valid_check_digit?
-               else # 8 digits is valid
-                 true
+                 if @routing_number.length == 9
+                   valid_check_digit?
+                 else # 8 digits is valid
+                   true
+                 end
+               else
+                 false
                end
-             else
-               false
-             end
   end
 
   def valid_routing_number_length?
@@ -54,14 +55,16 @@ class Nacha::AbaNumber
     if [9, 10].include?(actual_length)
       true
     else
-      add_error("Routing number must be 8 or 9 digits long, but was #{actual_length} digits long.")
+      add_error("Routing number must be 8 or 9 digits long, but was " \
+        "#{actual_length} digits long.")
       false
     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 }\" ")
+    if compute_check_digit != @routing_number[8]
+      add_error("Incorrect Check Digit \"#{@routing_number[8]}\" should be " \
+        "\"#{compute_check_digit}\"")
       false
     else
       true

data/lib/nacha/ach_date.rb

@@ -12,22 +12,28 @@ class Nacha::AchDate < Date
       date_str = args[0]
       # Use Date.strptime to parse the string into a temporary Date object
       temp_date = Date.strptime(date_str, '%y%m%d')
-      year, month, day = temp_date.year, temp_date.month, temp_date.day
+      year = temp_date.year
+      month = temp_date.month
+      day = temp_date.day
     when Date
       original_date = args[0]
-      year, month, day = original_date.year, original_date.month, original_date.day
+      year = original_date.year
+      month = original_date.month
+      day = original_date.day
     when Integer # If it's a year integer, assume (year, month, day) or single Julian day
       # If 3 arguments (year, month, day) are provided like Date.new(2023, 10, 26)
-      if args.length == 3 && args.all? { |arg| arg.is_a?(Integer) }
-        year, month, day = args[0], args[1], args[2]
-      else
+      unless args.length == 3 && args.all?(Integer)
         # Fallback for other Date.new arguments like (jd) - let super handle directly
-        return super(*args) # IMPORTANT: Call super to create the instance
+        return super # IMPORTANT: Call super to create the instance
       end
+
+      year = args[0]
+      month = args[1]
+      day = args[2]
     else
       # If it's none of the above, pass arguments directly to Date.new.
       # This handles cases like Date.new(2459918) (Julian day) or other Date constructors.
-      return super(*args)
+      return super
     end
 
     # If year, month, day were successfully parsed, create a Nacha::AchDate instance
@@ -38,7 +44,8 @@ class Nacha::AchDate < Date
 
   rescue TypeError, ArgumentError => e
     # Catch errors that might arise from strptime or invalid date components
-    raise ArgumentError, "Invalid date format for Nacha::AchDate: #{args.inspect}. Original error: #{e.message}"
+    raise ArgumentError, "Invalid date format for Nacha::AchDate: #{args.inspect}. " \
+      "Original error: #{e.message}"
   end
 
   def to_s

data/lib/nacha/field.rb

@@ -7,15 +7,17 @@ require 'nacha/aba_number'
 require 'nacha/ach_date'
 
 class Nacha::Field
-  attr_accessor :inclusion, :position
-  attr_accessor :name, :errors
-  attr_reader :contents, :data, :input_data
-  attr_reader :data_type
-  attr_reader :validator
-  attr_reader :justification
-  attr_reader :fill_character
-  attr_reader :output_conversion
-  attr_reader :json_output
+  attr_accessor :inclusion, :position, :name, :errors
+  attr_reader :contents, :data, :input_data, :data_type, :validator,
+    :justification, :fill_character, :output_conversion, :json_output
+
+  def self.unpack_str(definition = {})
+    if definition[:contents].match?(/(Numeric|\$+\u00a2\u00a2)/)
+      'a'
+    else
+      'A'
+    end + definition[:position].size.to_s
+  end
 
   def initialize(opts = {})
     @data_type = String
@@ -29,9 +31,9 @@ class Nacha::Field
     @data_assigned = false
     opts.each do |k, v|
       setter = "#{k}="
-      if respond_to?(setter)
-        send(setter, v) unless v.nil?
-      end
+      # rubocop:disable GitlabSecurity/PublicSend
+      public_send(setter, v) if respond_to?(setter) && !v.nil?
+      # rubocop:enable GitlabSecurity/PublicSend
     end
   end
 
@@ -43,7 +45,7 @@ class Nacha::Field
     when /\$.*¢*/
       @data_type = Nacha::Numeric
       @justification = :rjust
-      cents = 10 ** (@contents.count('¢'))
+      cents = 10**@contents.count('¢')
       @json_output = [[:to_i], [:/, cents]]
       @output_conversion = [:to_i]
       @fill_character = '0'
@@ -104,36 +106,10 @@ class Nacha::Field
   def validate
     return if @validated
 
-    add_error("'inclusion' must be present for a field definition.") unless @inclusion
-    add_error("'position' must be present for a field definition.") unless @position
-    add_error("'contents' must be present for a field definition.") unless @contents
-
-    if @data_assigned &&
-       (mandatory? || required?) &&
-       ((@input_data.nil? || @input_data.to_s.empty?) && @contents !~ /\AC(  *)\z/)
-      add_error("'#{human_name}' is a required field and cannot be blank.")
-    end
-
-    # Type-specific validations
-    if @data_type == Nacha::Numeric && @input_data.to_s.strip.match(/\D/)
-      add_error("Invalid characters in numeric field '#{human_name}'. Got '#{@input_data}'.")
-    end
-
-    # If data object has its own validation, run it.
-    if @validator && @data.is_a?(@data_type)
-      # The call to the validator might populate errors on the data object.
-      is_valid = @data.send(@validator)
-
-      # Collect any errors from the data object.
-      if @data.respond_to?(:errors) && @data.errors && @data.errors.any?
-        @data.errors.each { |e| add_error(e) }
-      end
-
-      # If it's not valid and we haven't collected any specific errors, add a generic one.
-      if !is_valid && errors.empty?
-        add_error("'#{human_name}' is invalid. Got '#{@input_data}'.")
-      end
-    end
+    validate_definition_attributes
+    validate_data_presence
+    validate_numeric_format
+    run_custom_validator
 
     @validated = true
   end
@@ -147,26 +123,22 @@ class Nacha::Field
     errors << err_string
   end
 
-  def self.unpack_str(definition = {})
-    if definition[:contents] =~ /(Numeric|\$+\u00a2\u00a2)/
-      'a'
-    else
-      'A'
-    end + definition[:position].size.to_s
-  end
-
   def to_ach
     str = to_s
     fill_char = @fill_character
     fill_char = ' ' unless str
     str ||= ''
-    str.send(justification, position.count, fill_char)
+    # rubocop:disable GitlabSecurity/PublicSend
+    str.public_send(justification, position.count, fill_char)
+    # rubocop:enable GitlabSecurity/PublicSend
   end
 
   def to_json_output
     if @json_output
-      @json_output.reduce(@data) do |output, operation|
-        output = output.send(*operation) if output
+      @json_output.reduce(@data) do |memo, operation|
+        # rubocop:disable GitlabSecurity/PublicSend
+        memo&.public_send(*operation)
+        # rubocop:enable GitlabSecurity/PublicSend
       end
     else
       to_s
@@ -187,16 +159,55 @@ class Nacha::Field
     field_classes += ['error'] if errors.any?
 
     ach_string = to_ach.gsub(' ', '&nbsp;')
-    "<span data-field-name=\"#{@name}\" contentEditable=true class=\"#{field_classes.join(' ')}\" data-name=\"#{@name}\">#{ach_string}" +
-      tooltip_text.to_s +
-      "</span>"
+    "<span data-field-name=\"#{@name}\" contentEditable=true " \
+      "class=\"#{field_classes.join(' ')}\" data-name=\"#{@name}\">" \
+      "#{ach_string}#{tooltip_text}</span>"
   end
 
   def to_s
-    @data.send(*output_conversion).to_s
+    # rubocop:disable GitlabSecurity/PublicSend
+    @data.public_send(*output_conversion).to_s
+    # rubocop:enable GitlabSecurity/PublicSend
   end
 
   def raw
     @data
   end
+
+  private
+
+  def validate_definition_attributes
+    add_error("'inclusion' must be present for a field definition.") unless @inclusion
+    add_error("'position' must be present for a field definition.") unless @position
+    add_error("'contents' must be present for a field definition.") unless @contents
+  end
+
+  def validate_data_presence
+    return unless @data_assigned && (mandatory? || required?)
+    return unless @input_data.nil? || @input_data.to_s.empty?
+    return if @contents.match?(/\AC(  *)\z/)
+
+    add_error("'#{human_name}' is a required field and cannot be blank.")
+  end
+
+  def validate_numeric_format
+    return unless @data_type == Nacha::Numeric && @input_data.to_s.strip.match(/\D/)
+
+    add_error("Invalid characters in numeric field '#{human_name}'. " \
+      "Got '#{@input_data}'.")
+  end
+
+  def run_custom_validator
+    return unless @validator && @data.is_a?(@data_type)
+
+    # rubocop:disable GitlabSecurity/PublicSend
+    is_valid = @data.public_send(@validator)
+    # rubocop:enable GitlabSecurity/PublicSend
+
+    @data.errors.each { |e| add_error(e) } if @data.respond_to?(:errors) && @data.errors&.any?
+
+    return if is_valid || errors.any?
+
+    add_error("'#{human_name}' is invalid. Got '#{@input_data}'.")
+  end
 end

data/lib/nacha/has_errors.rb

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

data/lib/nacha/numeric.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 class Nacha::Numeric
-  def initialize val = nil
+  def initialize(val = nil)
     self.value = val
   end
 
@@ -17,14 +18,14 @@ class Nacha::Numeric
   def value=(val)
     if val.is_a?(String)
       @value = val.dup
-      if(val.strip.length > 0)
+      if !val.strip.empty?
         @op_value = BigDecimal(val.strip)
         @value = val.dup
       else
-        @op_value = BigDecimal(0)
+        @op_value = BigDecimal('0')
       end
     elsif val.nil?
-      @value = BigDecimal(0)
+      @value = BigDecimal('0')
       @op_value = @value
     else
       @value = BigDecimal(val)
@@ -36,8 +37,8 @@ class Nacha::Numeric
     @value ? @value.to_i.to_s : nil
   end
 
-  def respond_to_missing?(method_name, include_private = false)
-    @op_value.respond_to? method_name
+  def respond_to_missing?(method_name, _include_private = false)
+    @op_value.respond_to?(method_name)
   end
 
   # @op_value is the value for operations.   @value may still be a string
@@ -45,20 +46,22 @@ class Nacha::Numeric
   # should be checked to see if the operation is valid for it, not
   # necessarily the potentially string @value
   def method_missing(method_name, *args, &block)
-    if @op_value.respond_to? method_name
+    if @op_value.respond_to?(method_name)
       old_op_value = @op_value.dup
-      if /!\z/.match?(method_name.to_s)
-        # rubocop:disable GitlabSecurity/PublicSend
+      # rubocop:disable GitlabSecurity/PublicSend
+      if method_name.to_s.end_with?('!')
         @op_value.send(method_name, *args, &block)
         return_value = @op_value
       else
         return_value = @op_value.send(method_name, *args, &block)
-        # rubocop:enable GitlabSecurity/PublicSend
       end
+      # rubocop:enable GitlabSecurity/PublicSend
+
       if old_op_value != return_value
         @value = return_value
         @op_value = return_value
       end
+
       @value
     else
       super

data/lib/nacha/parser.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
+require 'byebug'
 require 'nacha'
 require 'nacha/parser_context'
 
 # Nacha Parser - deal with figuring out what record type a line is
 class Nacha::Parser
-  DEFAULT_RECORD_TYPES = ['Nacha::Record::AdvFileHeader',
-                          'Nacha::Record::FileHeader',
-                          'Nacha::Record::Filler'].freeze
+  DEFAULT_RECORD_TYPES = [
+    'Nacha::Record::FileHeader',
+    'Nacha::Record::AdvFileHeader',
+    'Nacha::Record::Filler'
+  ].freeze
 
   attr_reader :context
 
@@ -16,31 +19,25 @@ class Nacha::Parser
   end
 
   def parse_file(file)
-    @context.parser_started_at = Time.now
+    @context.parser_started_at = Time.now.utc
     @context.file_name = file
     parse_string(file.read)
   end
 
   def detect_possible_record_types(line)
-    Nacha.ach_record_types.map do |record_type|
-      record_type if record_type.matcher =~ line
-    end.compact
-  end
-
-  def parse_line(line)
-    record_types = detect_possible_record_types(line)
-
-    records = record_types.map do |record_type|
-
+    Nacha.ach_record_types.filter_map do |record_type|
+      record_type if record_type.matcher.match?(line)
     end
   end
 
   def parse_string(str)
     line_num = -1
     records = []
-    @context.parser_started_at ||= Time.now
-    str.scan(/(.{94}|(\A[^\n]+))/).each do |line|
-      line = line.first.strip
+    @context.parser_started_at ||= Time.now.utc
+    str.scan(/(.{0,94})[\r\n]*/).each do |line|
+      line = line.compact.first.strip
+      next if line.empty? || line.start_with?('#') # Skip empty lines and comments
+
       line_num += 1
       @context.line_number = line_num
       @context.line_length = line.length
@@ -54,9 +51,11 @@ class Nacha::Parser
     parent = previous
 
     record_types = valid_record_types(parent)
+
     while record_types
       record = parse_first_by_types(line, record_types)
       break if record || !parent
+
       record.validate if record
       parent = parent.parent
       record_types = valid_record_types(parent)
@@ -80,20 +79,16 @@ class Nacha::Parser
   end
 
   def parse_first_by_types(line, record_types)
-    record_types.detect do |rt|
+    record_types.lazy.filter_map do |rt|
       record_type = rt.is_a?(Class) ? rt : Object.const_get(rt)
-      record = nil
-      record = record_type.parse(line) if record_type.matcher =~ line
-      return record if record
-    end
+      record_type.parse(line) if record_type.matcher.match?(line)
+    end.first
   end
 
   def parse_all_by_types(line, record_types)
-    record_types.map do |rt|
+    record_types.filter_map do |rt|
       record_type = rt.is_a?(Class) ? rt : Object.const_get(rt)
-      record = nil
-      record = record_type.parse(line) if record_type.matcher =~ line
-      record
-    end.compact
+      record_type.parse(line) if record_type.matcher.match?(line)
+    end
   end
 end