nacha 0.2.00 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e7e5a0b7067a5bc2fda825f05bc61f86992b4653056b5800892248b57561952
-  data.tar.gz: 547452686b682558a049c5c1b1d7985f9b55bec7219b9fc285a3c225c3ee5396
+  metadata.gz: c2ae01e0c5a90efda594187387efe2150ff1548affb15c65b50fcb1fbc73dc6f
+  data.tar.gz: db181b0d320ab60664c14af3cdcccfc69a6879085bf167c80496303ee9bf6d6a
 SHA512:
-  metadata.gz: f9d3b8d3e944540b87e2aa62061682c94786590bc1c1fdda8657a3bdf5e1ed57425a6a9e10cf9a0dcd71716ca01987d609cc8bb821460ff762e822c314734338
-  data.tar.gz: 21ed379b621b006d716e882d23f0e768269d39938e951bc2add70c3043670bb929117f19fa698ad69b1e6e9b2614b9582af25a3492eecaacbf8597601076b5bb
+  metadata.gz: 17564ad39c737c944c7d7b86ed3340fd7ac4aaf0422879051095788b3161b6e487bb892042af646eb760a9a4c84d5a06d13de737fd95f00cddf0daad0e093e46
+  data.tar.gz: 358f227a837f75d3f64717b44164e86d35f7c7d52ae95fef851e53e9b06422b71d7e62d975a2b3fa42167ce9e620b52c47c05e3c4fc816ba097b8d7343300710

data/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.2.0] - 2025-08-03
+## [0.2.1] - 2025-08-03
 
 - Better interface to parsed records (Nacha::AchFile)
 

data/README.md

@@ -34,6 +34,12 @@ Or install it yourself as:
 API may change at any time.   Pull requests welcomed
 
 
+```ruby
+ach_file = Nacha.parse('path/to/file.ach')
+
+puts ach_file.to_json
+puts ach_file.to_markdown
+```
 
 ```ruby
     ach_string = "101 124000054 1240000540907021214A094101ZIONS FIRST NATIONAL BAZIONS FIRST NATIONAL BA       1"

data/exe/nacha

@@ -23,65 +23,38 @@ module Nacha
            enum: %w[html json md markdown ach]
     option :md_flavor, default: "common_mark", enum: %w[common_mark github]
     def parse(file_path = nil)
-      if file_path.nil? || file_path.empty?
-        input_file = $stdin
-      elsif File.exist?(file_path)
-        input_file = File.open(file_path)
-      else
-        puts "Error: File not found at #{file_path}"
-        exit 1
-      end
+      ach_file = Nacha::AchFile.new(file_path || $stdin)
 
-      raw_records = input_file.read
-      ach_file = Nacha.parse(raw_records)
+      ach_file.parse
 
-      if ach_file && ach_file.is_a?(Array) && !ach_file.empty?
+      if ach_file.records.is_a?(Array) && !ach_file.records.empty?
         if options[:output_file]
           File.open(options[:output_file], "w") do |f|
-            write_output(ach_file, f, input_file)
+            write_output(ach_file, f)
           end
         else
-          write_output(ach_file, $stdout, input_file)
+          write_output(ach_file, $stdout)
         end
       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 write_output(ach_records, io, file)
-      formatter_options = {
-        file_name: File.basename(file.path),
-        file_size: file.respond_to?(:size) ? file.size : nil,
-        number_of_lines: ach_records.size,
-        created_at: file.respond_to?(:ctime) ? file.ctime : Time.now,
-        modified_at: file.respond_to?(:mtime) ? file.mtime : Time.now,
-        preamble: HTML_PREAMBLE_FILE,
-        postamble: HTML_POSTAMBLE_FILE
-      }
-
+    def write_output(ach_file, io)
       case options[:format]
       when 'ach'
-        output_ach(ach_records, io)
+        io.puts ach_file.to_ach
+      when 'html'
+        io.puts ach_file.to_html
       when 'md', 'markdown'
-        formatter_options[:flavor] = options[:md_flavor].to_sym
-        formatter = Nacha::Formatter::FormatterFactory.get(:markdown, ach_records, formatter_options)
-        io.puts formatter.format
+        io.puts ach_file.to_markdown
       else
-        formatter = Nacha::Formatter::FormatterFactory.get(options[:format].to_sym, ach_records,
-          formatter_options)
-        io.puts formatter.format
-      end
-    end
-
-    def output_ach(ach_records, io)
-      ach_records.each do |record|
-        io.puts record.to_ach
+        io.puts ach_file.to_json
       end
     end
   end

data/lib/nacha/ach_file.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'uri' # Required for URI.regexp
+require 'openssl'
+require 'httparty'
+require 'nacha/formatter'
+
+module Nacha
+  # Class for handling ACH files, which can be a URL, a file path, or a string of data.
+  # encapsulating the records and handling output
+  class AchFile
+    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")
+
+    attr_reader :raw_input, :input_type, :records, :checksum, :input_source,
+                :created_at, :modified_at
+
+    def initialize(input_string)
+      @input_type = classify_input(input_string)
+      @records = []
+      case @input_type
+      when 'url'
+        @input_source = input_string
+        @raw_input = read_url_contents_httparty(input_string)
+      when 'filepath'
+        raise ArgumentError, "File not found: #{input_string}" unless File.exist?(input_string)
+
+        @input_source = input_string
+        @raw_input = File.read(input_string)
+      when 'string of data'
+        @input_source = "string"
+        @raw_input = input_string
+      else
+        if input_string.respond_to?(:read)
+          # If input_string is an IO object (like $stdin), read it directly
+          @input_source = "stdin"
+          @raw_input = input_string.read
+        else
+          # Otherwise, treat it as a simple string
+          @input_source = "string"
+          @raw_input = input_string.to_s
+        end
+      end
+      @checksum = OpenSSL::Digest::SHA256.hexdigest(@raw_input) if @raw_input
+    end
+
+    def parse
+      @records = Nacha::Parser.new.parse_string(@raw_input)
+      self
+    end
+
+    def to_ach
+      records.map(&:to_ach).join("\n")
+    end
+
+    def to_json
+      formatter(:json).format
+    end
+
+    def to_html
+      formatter(:html).format
+    end
+
+    def to_markdown
+      formatter(:markdown).format
+    end
+
+    private
+
+    def formatter_options
+      {
+        file_name: File.basename(@input_source),
+        file_size: @raw_input.size,
+        number_of_lines: records.size,
+        checksum: @checksum,
+        preamble: HTML_PREAMBLE_FILE,
+        postamble: HTML_POSTAMBLE_FILE
+      }.merge(file_info)
+    end
+
+    def file_info
+      return {} unless @input_type == 'filepath' && File.exist?(@input_source)
+
+      File.open(@input_source,'r') do |file|
+        {
+          created_at: file.ctime,
+          modified_at: file.mtime,
+        }
+      end
+    end
+
+    def formatter(format)
+      Formatter::FormatterFactory.get(format, self, formatter_options)
+    end
+
+    # Reads the content of a URL using HTTParty.
+    #
+    # @param url [String] The URL to read.
+    # @return [String, nil] The content of the URL as a string, or nil if an error occurred.
+    def read_url_contents_httparty(url)
+      response = HTTParty.get(url, timeout: 60) # Set a timeout
+      if response.success?
+        response.body
+      else
+        puts "Error: HTTP request failed with status #{response.code} #{response.message} for #{url}"
+        nil
+      end
+    rescue StandardError, HTTParty::Error => err
+      # HTTParty wraps various network and HTTP errors
+      puts "Error: An unexpected error occurred while reading #{url} - #{err.message}"
+    end
+
+    # Classifies an input string as a filepath, URL, or string of data.
+    # The classification order is: URL -> Filepath -> String of Data (if >= 94 chars) -> Generic String.
+    #
+    # @param input_arg [String, Object] The input to classify. It will be converted to a string.
+    # @return [String] One of 'url', 'filepath', 'string of data', or 'string'.
+    def classify_input(input_arg)
+      return 'file' if input_arg.respond_to?(:read)
+      # Ensure the input is treated as a string for consistent pattern matching.
+      # This handles cases where the input might be a number, nil, etc., by converting them to string.
+      input = input_arg.to_s
+
+      # 1. Check for URL
+      # URI::DEFAULT_PARSER.make_regexp is the standard way to match URIs according to RFCs.
+      # It primarily looks for a scheme (e.g., http://, https://, ftp://, file://).
+      # Note: It will typically *not* classify "www.example.com" as a URL without a scheme.
+      return 'url' if URI::DEFAULT_PARSER.make_regexp.match?(input)
+
+      # 2. Check for Filepath
+      # This is the most complex part due to the variety of path formats (absolute, relative,
+      # Windows, Unix-like) and the ambiguity with general strings.
+      is_filepath = false
+
+      # A. Absolute Path Patterns:
+      #    - Unix-like absolute: `/path/to/file`
+      #    - Windows drive letter: `C:\path\to\file` or `C:/path/to/file`
+      #    - Windows UNC path: `\\server\share\path`
+      #    - Home directory (Unix-like): `~/path/to/file`
+      if input =~ %r{
+    ^                                        # Start of the string
+    (?:                                      # Non-capturing group for different absolute path roots
+      /                                      | # Unix-like root (e.g., /usr/local)
+      [A-Za-z]:[\\/]                         | # Windows drive letter (e.g., C:\, D:/)
+      \\\\(?:[a-zA-Z0-9_.-]+[\\/])+[a-zA-Z0-9_.-]* | # Windows UNC path (e.g., \\server\share\folder or \\server\share)
+      ~[\\/]                                   # Unix-like home directory (e.g., ~/documents)
+    )
+  }x # The 'x' modifier allows whitespace and comments in the regex for readability
+        is_filepath = true
+      # B. Relative Path Starting with Common Indicators:
+      #    - Current directory: `./file` or `.\file`
+      #    - Parent directory: `../file` or `..\file`
+      elsif input =~ %r{^\.{1,2}[\\/]}
+        is_filepath = true
+      # C. Path containing separators AND ending with a common file extension:
+      #    e.g., "folder/image.jpg", "document.pdf" (if it contains a slash or just "document.pdf")
+      #    This handles cases like "my_photo.png" or "data/report.xlsx".
+      elsif (input.include?('/') || input.include?('\\')) && input =~ /\.[a-zA-Z0-9]{2,5}$/
+        is_filepath = true
+      # D. Path with separators and multiple components or ending in a separator:
+      #    e.g., "folder/file", "dir1/dir2/file", "dir/subdir/", "/another_folder/"
+      #    This tries to identify directory structures.
+      elsif (input.include?('/') || input.include?('\\'))
+        # Split the path by either / or \ and remove any empty strings that result
+        # (e.g., "/a/b" splits to ["", "a", "b"]; rejecting empty ones yields ["a", "b"]).
+        segments = input.split(/[\/\\]/).reject(&:empty?)
+        if segments.length >= 2 || (segments.length >= 1 && (input.end_with?('/') || input.end_with?('\\')))
+          # Classify as filepath if:
+          # - It has two or more segments (e.g., "folder/file", "/folder/sub/file").
+          # - OR it has at least one segment AND ends with a path separator (e.g., "folder/", "/folder/").
+          is_filepath = true
+        end
+      # E. Simple filename with a common extension, not caught by other rules (e.g., "report.txt")
+      # This handles cases like "my_document.docx" which have no directory separators but are filenames.
+      elsif input =~ /^[a-zA-Z0-9_.-]+\.[a-zA-Z0-9]{2,5}$/
+        # Basic check for "name.ext" pattern, allowing common filename characters.
+        is_filepath = true
+      end
+
+      if is_filepath
+        return 'filepath'
+      end
+
+      # 3. Check for "string of data"
+      # This is the fallback for anything that isn't clearly a URL or a filepath,
+      # AND meets the minimum length requirement as per the problem description.
+      if input.length >= 94
+        return 'string of data'
+      end
+
+      # 4. Default: Just a regular string
+      # If it doesn't fit any of the above categories (URL, filepath, long data string),
+      # it's considered a generic string (e.g., "Hello World", "short_name", "a_simple_word").
+      return 'string'
+    end
+
+    # # --- Test Cases ---
+
+    # puts "--- URLs ---"
+    # puts "http://example.com                       => #{classify_input("http://example.com")}"
+    # puts "https://www.google.com/search?q=ruby+regex => #{classify_input("https://www.google.com/search?q=ruby+regex")}"
+    # puts "ftp://user:pass@ftp.example.com/file.txt => #{classify_input("ftp://user:pass@ftp.example.com/file.txt")}"
+    # puts "file:///C:/Users/user/Documents/report.pdf => #{classify_input("file:///C:/Users/user/Documents/report.pdf")}"
+    # puts "www.example.com                          => #{classify_input("www.example.com")} (Expected: string, as it lacks a scheme for URI.regexp)"
+
+    # puts "\n--- Filepaths ---"
+    # puts "/usr/local/bin/myscript.sh               => #{classify_input("/usr/local/bin/myscript.sh")}"
+    # puts "C:\\Program Files\\App\\config.ini        => #{classify_input("C:\\Program Files\\App\\config.ini")}"
+    # puts "/home/user/documents/report.pdf          => #{classify_input("/home/user/documents/report.pdf")}"
+    # puts "relative/path/to/file.txt                => #{classify_input("relative/path/to/file.txt")}"
+    # puts "./current_dir_file.log                   => #{classify_input("./current_dir_file.log")}"
+    # puts "../parent_dir/other_file.csv             => #{classify_input("../parent_dir/other_file.csv")}"
+    # puts "my_document.docx                         => #{classify_input("my_document.docx")}"
+    # puts "folder/another_folder/image.png          => #{classify_input("folder/another_folder/image.png")}"
+    # puts "just_a_folder_name/                      => #{classify_input("just_a_folder_name/")}"
+    # puts "root_dir/                                => #{classify_input("root_dir/")}"
+    # puts "C:/                                      => #{classify_input("C:/")}"
+    # puts "/                                        => #{classify_input("/")}"
+    # puts "\\\\server\\share\\file.txt              => #{classify_input("\\\\server\\share\\file.txt")}"
+    # puts "\\\\server\\share\\                     => #{classify_input("\\\\server\\share\\")}"
+
+    # puts "\n--- Strings of Data (>= 94 characters) ---"
+    # long_data_string = "This is a very long string that serves as an example of generic data. It must be at least 94 characters long to be classified as 'string of data' by our function. This particular string is precisely 160 characters long. Ruby is fun!"
+    # puts "#{long_data_string.slice(0, 50)}... (length #{long_data_string.length}) => #{classify_input(long_data_string)}"
+
+    # long_data_94_chars = "a" * 94 # A string of exactly 94 'a' characters
+    # puts "#{long_data_94_chars.slice(0, 50)}... (length #{long_data_94_chars.length}) => #{classify_input(long_data_94_chars)}"
+
+    # puts "\n--- Regular Strings (short, ambiguous) ---"
+    # puts "Hello World                              => #{classify_input("Hello World")}"
+    # puts "short_string                             => #{classify_input("short_string")}"
+    # puts "a_simple_word                            => #{classify_input("a_simple_word")}"
+    # puts "12345                                    => #{classify_input("12345")}"
+    # puts ""                                       => #{classify_input("")}" # Empty string
+    # puts "folder_name_only                         => #{classify_input("folder_name_only")}" # Not a path without separator or extension
+    # puts "not_a_path/but_looks_like_it_if_short_and_not_a_file_with_extension => #{classify_input("not_a_path/but_looks_like_it_if_short_and_not_a_file_with_extension")}" # This is still a filepath because of the / and multi-segments logic. This is correct behavior for a path-like string.
+  end
+end

data/lib/nacha/formatter/base.rb

@@ -5,13 +5,17 @@ require 'digest'
 module Nacha
   module Formatter
     class Base
-      attr_reader :records, :options
+      attr_reader :ach_file, :options
 
-      def initialize(records, options = {})
-        @records = records
+      def initialize(ach_file, options = {})
+        @ach_file = ach_file
         @options = options
       end
 
+      def records
+        @ach_file.records
+      end
+
       def format
         raise NotImplementedError, 'Subclasses must implement a format method'
       end

data/lib/nacha/formatter/json_formatter.rb

@@ -9,41 +9,11 @@ module Nacha
       def format
         output = {
           file: file_statistics,
-          records: records.map { |record| record_to_h(record) }
+          records: records.map(&:to_h)
         }
 
         JSON.pretty_generate(output)
       end
-
-      private
-
-      def record_to_h(record)
-        {
-          nacha_record_type: record.record_type,
-          metadata: {
-            klass: record.class.name,
-            errors: record.errors,
-            line_number: record.line_number,
-            original_input_line: record.original_input_line
-          }
-        }.merge(
-          record.fields.keys.to_h do |key|
-            [key, field_to_json_output(record.fields[key])]
-          end
-        )
-      end
-
-      def field_to_json_output(field)
-        if field.json_output
-          # rubocop:disable GitlabSecurity/PublicSend
-          field.json_output.reduce(field.raw) do |memo, operation|
-            memo&.public_send(*operation)
-          end
-          # rubocop:enable GitlabSecurity/PublicSend
-        else
-          field.to_s
-        end
-      end
     end
   end
 end

data/lib/nacha/parser.rb

@@ -2,6 +2,7 @@
 
 require 'nacha'
 require 'nacha/parser_context'
+require 'nacha/ach_file'
 
 # Nacha Parser - deal with figuring out what record type a line is
 class Nacha::Parser
@@ -18,9 +19,9 @@ class Nacha::Parser
   end
 
   def parse_file(file)
-    @context.parser_started_at = Time.now.utc
-    @context.file_name = file
-    parse_string(file.read)
+   @context.parser_started_at = Time.now.utc
+   @context.file_name = file
+   parse_string(file.read)
   end
 
   def detect_possible_record_types(line)
@@ -30,6 +31,8 @@ class Nacha::Parser
   end
 
   def parse_string(str)
+    return [] unless str.is_a?(String) && !str.empty?
+
     line_num = -1
     records = []
     @context.parser_started_at ||= Time.now.utc

data/lib/nacha/version.rb

@@ -2,7 +2,7 @@
 
 module Nacha
   module Version
-    STRING = '0.2.00'
+    STRING = '0.2.1'
   end
   VERSION = Version::STRING
 end

data/lib/nacha.rb

@@ -10,6 +10,7 @@
 # end
 
 require 'yaml'
+require 'nacha/ach_file'
 require 'nacha/version'
 require 'nacha/aba_number'
 require 'nacha/ach_date'
@@ -66,18 +67,14 @@ module Nacha
       types_hash
     end
 
-    # Parses a NACHA file or string into a structured object representation.
+    # Parses a NACHA file, string or url into a structured object representation.
     #
-    # @param object [String, File, IO] The input to parse, either a string containing
+    # @param object [String, File, IO, URL] The input to parse, either a string containing
     #   NACHA data or an IO object (e.g., a File) representing the NACHA file.
-    # @return [Nacha::Record::Base] The parsed NACHA file object.
+    # @return [Nacha::AchFile] The parsed NACHA file object.
     def parse(object)
-      parser = Nacha::Parser.new
-      if object.is_a?(String)
-        parser.parse_string(object)
-      else
-        parser.parse_file(object)
-      end
+      ach_file = AchFile.new(object)
+      ach_file.parse
     end
 
     # Converts a given string into a underscored, lowercase record name.

data/nacha.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.add_dependency 'bigdecimal'
+  spec.add_dependency 'httparty'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'byebug' if RUBY_ENGINE == 'ruby'
@@ -40,6 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'reek'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'webmock'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'rubocop-performance'
   spec.add_development_dependency 'rubocop-rspec'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nacha
 version: !ruby/object:Gem::Version
-  version: 0.2.00
+  version: 0.2.1
 platform: ruby
 authors:
 - David H. Wilkins
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -163,6 +177,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -278,6 +306,7 @@ files:
 - lib/nacha.rb
 - lib/nacha/aba_number.rb
 - lib/nacha/ach_date.rb
+- lib/nacha/ach_file.rb
 - lib/nacha/field.rb
 - lib/nacha/formatter.rb
 - lib/nacha/formatter/base.rb