mercury_banking 0.5.38 → 0.7.0

data/lib/mercury_banking/formatters/table_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MercuryBanking
   module Formatters
     # Formatter for table output
@@ -5,7 +7,7 @@ module MercuryBanking
       # Display accounts in a table format
       def display_accounts_table(accounts)
         return puts "No accounts found." if accounts.empty?
-        
+
         rows = accounts.map do |a|
           [
             a["name"],
@@ -16,23 +18,23 @@ module MercuryBanking
             a["status"].capitalize
           ]
         end
-        
+
         table = ::Terminal::Table.new(
           headings: ['Account Name', 'Account Number', 'Type', 'Current Balance', 'Available Balance', 'Status'],
           rows: rows
         )
-        
+
         puts table
       end
 
       # Display recipients in a table format
       def display_recipients_table(recipients)
         return puts "No recipients found." if recipients.empty?
-        
+
         rows = recipients.map do |r|
           account_info = r["electronicRoutingInfo"] || {}
           address_info = r["address"] || {}
-          
+
           [
             r["id"],
             r["name"],
@@ -42,61 +44,61 @@ module MercuryBanking
             r["status"].capitalize
           ]
         end
-        
+
         table = ::Terminal::Table.new(
           headings: ['ID', 'Name', 'Routing #', 'Account #', 'City', 'Status'],
           rows: rows
         )
-        
+
         puts table
       end
-      
+
       # Display transactions in a table format
       def display_transactions_table(transactions, show_account_name = false)
         return puts "No transactions found." if transactions.empty?
-        
-        headings = ['Date', 'Amount', 'Type']
+
+        headings = %w[Date Amount Type]
         headings.insert(0, 'Account') if show_account_name
-        headings.concat(['Description', 'Status'])
-        
+        headings.push("Description", "Status")
+
         rows = transactions.map do |t|
           date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : "Pending"
           amount = format("$%.2f", t["amount"].abs)
-          direction = t["amount"] < 0 ? "DEBIT" : "CREDIT"
+          direction = (t["amount"]).negative? ? "DEBIT" : "CREDIT"
           description = t["bankDescription"] || t["externalMemo"] || "N/A"
           description = description.length > 50 ? "#{description[0..47]}..." : description
           status = t["status"].capitalize
-          
+
           row = [date, amount, direction, description, status]
           row.insert(0, t["accountName"]) if show_account_name
           row
         end
-        
+
         table = ::Terminal::Table.new(
           headings: headings,
           rows: rows
         )
-        
+
         puts table
       end
-      
+
       # Display a single transaction's details
       def display_transaction_details(transaction)
         return puts "Transaction not found." unless transaction
-        
+
         # Format dates
         created_at = transaction["createdAt"] ? Time.parse(transaction["createdAt"]).strftime("%Y-%m-%d %H:%M:%S") : "N/A"
         posted_at = transaction["postedAt"] ? Time.parse(transaction["postedAt"]).strftime("%Y-%m-%d %H:%M:%S") : "Pending"
         estimated_delivery = transaction["estimatedDeliveryDate"] ? Time.parse(transaction["estimatedDeliveryDate"]).strftime("%Y-%m-%d") : "N/A"
-        
+
         # Format amount
         amount = transaction["amount"].to_f
         amount_str = format("$%.2f", amount.abs)
-        direction = amount < 0 ? "DEBIT" : "CREDIT"
-        
+        direction = amount.negative? ? "DEBIT" : "CREDIT"
+
         # Get counterparty info
-        counterparty = transaction["counterpartyId"] ? "ID: #{transaction["counterpartyId"]}" : "N/A"
-        
+        counterparty = transaction["counterpartyId"] ? "ID: #{transaction['counterpartyId']}" : "N/A"
+
         # Create a table for the transaction details
         details = [
           ["Transaction ID", transaction["id"]],
@@ -110,24 +112,24 @@ module MercuryBanking
           ["External Memo", transaction["externalMemo"] || "N/A"],
           ["Counterparty", counterparty]
         ]
-        
+
         table = ::Terminal::Table.new(
           title: "Transaction Details",
           rows: details
         )
-        
+
         puts table
       end
-      
+
       private
-      
+
       # Mask account number for security
       def mask_account_number(account_number)
         return "N/A" unless account_number
-        
+
         # Show only the last 4 digits
-        "••••#{account_number[-4..-1]}" if account_number.length >= 4
+        "••••#{account_number[-4..]}" if account_number.length >= 4
       end
     end
   end
-end 
+end

data/lib/mercury_banking/multi.rb

@@ -1,35 +1,40 @@
+# frozen_string_literal: true
+
 module MercuryBanking
+  # Multi-account management class
+  # Handles operations across multiple Mercury accounts
   class Multi
     def initialize(keys = [])
       @banks = {}
       @apis  = {}
       @keys = keys
-      
+
       @keys.each do |api_key|
         next if api_key.empty?
+
         mercury = MercuryBanking::API.new(api_key)
-        
+
         begin
           accounts = mercury.accounts
         rescue StandardError => e
           puts e
           next
         end
-        
+
         if accounts.nil?
           puts "*" * 80
           puts "* #{api_key} returned no accounts"
           puts "*" * 80
           next
         end
-        
+
         checking = find_all_checking_accounts(accounts)
 
         checking.each do |ac|
           identifier = ac['name']
           @banks[identifier] = ac
         end
-        
+
         @identifier = accounts.first["name"]
         count_checking_accounts(accounts)
         @apis[@identifier] = mercury
@@ -49,27 +54,29 @@ module MercuryBanking
       table = Terminal::Table.new rows: @banks.collect { |name, vals|
         [name, vals["availableBalance"], vals["status"]]
       }
-      print table.to_s + "\n"
+      print "#{table}\n"
     end
 
     def ensure_recipient(from:, to:, email:, address:, city:, region:, postal_code:, country:)
       raise "Target bank account not found: #{to}" unless @banks[to]
+
       mercury_source = @apis[from]
       target = mercury_source.find_recipient(name: @banks[to]["name"])
-     
+
       if target.nil?
-        target = add_target_account_to_recipient_list(mercury_source, to, email, address, city, region, postal_code, country)
+        target = add_target_account_to_recipient_list(mercury_source, to, email, address, city, region, postal_code,
+                                                      country)
       end
       target
     end
 
     def add_target_account_to_recipient_list(mercury_source, to, email, address, city, region, postal_code, country)
-      puts "Adding recipient: #{@banks[to]["name"]}"
+      puts "Adding recipient: #{@banks[to]['name']}"
       rec = MercuryBanking::Recipient.new(
-        name: @banks[to]["name"], 
-        address: address, 
-        email: email, 
-        account_number: @banks[to]["accountNumber"], 
+        name: @banks[to]["name"],
+        address: address,
+        email: email,
+        account_number: @banks[to]["accountNumber"],
         routing_number: @banks[to]["routingNumber"],
         city: city,
         region: region,
@@ -83,53 +90,52 @@ module MercuryBanking
     def ensure_account(account)
       found = @banks.keys.grep(/#{account}/i)
       raise "Account: #{account} not found." if found.empty?
-      raise "Account: #{account} matched multiple #{found.join(",")}." if found.size > 1
+      raise "Account: #{account} matched multiple #{found.join(',')}." if found.size > 1
+
       found.first
     end
 
-    def transfer(from:, to:, amount:, note:, wait: false, email:, address:, city:, region:, postal_code:, country:)
+    def transfer(from:, to:, amount:, note:, email:, address:, city:, region:, postal_code:, country:, wait: false)
       puts "#{from} -> #{to} (#{amount})"
       from_account = ensure_account(from)
       to_account = ensure_account(to)
-      
+
       # Create a recipient with "to" information in "from"'s account:
       recipient = ensure_recipient(
-        from: from_account, 
-        to: to_account, 
-        email: email, 
-        address: address, 
-        city: city, 
-        region: region, 
-        postal_code: postal_code, 
+        from: from_account,
+        to: to_account,
+        email: email,
+        address: address,
+        city: city,
+        region: region,
+        postal_code: postal_code,
         country: country
       )
-      
-      puts "From account #{@banks[from_account]["id"]} -> Recipient #{recipient["id"]} (account: #{@banks[to_account]["id"]})"
+
+      puts "From account #{@banks[from_account]['id']} -> Recipient #{recipient['id']} (account: #{@banks[to_account]['id']})"
       transfer = @apis[from_account].transfer(
-        recipient_id: recipient["id"], 
-        amount: amount, 
-        account_id: @banks[from_account]["id"], 
-        note: note, 
+        recipient_id: recipient["id"],
+        amount: amount,
+        account_id: @banks[from_account]["id"],
+        note: note,
         external: "Ex #{note}"
       )
-      
+
       if wait
         while transfer["status"] != "sent"
-          puts "Waiting on #{transfer["id"]} (#{transfer["status"]}) to complete."
+          puts "Waiting on #{transfer['id']} (#{transfer['status']}) to complete."
           sleep 10
           transfer = @apis[from_account].transaction(@banks[from_account]["id"], transfer["id"])
-          if transfer["status"] == "failed"
-            puts transfer
-          end
+          puts transfer if transfer["status"] == "failed"
         end
       end
-      
+
       write_log(from_account, to_account, amount, note, transfer)
       transfer
     end
 
     def write_log(from, to, amount, note, transfer)
-      File.write("log", "\"#{from}\", \"#{to}\", \"#{amount}\", \"#{note}\", \"#{transfer["status"]}\"\n")
+      File.write("log", "\"#{from}\", \"#{to}\", \"#{amount}\", \"#{note}\", \"#{transfer['status']}\"\n")
     end
   end
-end 
+end

data/lib/mercury_banking/recipient.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module MercuryBanking
+  # Recipient class for Mercury Banking API
   class Recipient
-    attr_accessor :name
+    attr_accessor :name, :address, :city, :region, :postal_code, :country, :email
 
     def initialize(name:, email:, account_number:, routing_number:, address:, city:, region:, postal_code:, country:)
       @name = name
@@ -12,18 +15,23 @@ module MercuryBanking
         postalCode: postal_code,
         country: country
       }
-      @emails = [ email ]
-      @paymentMethod = "electronic"
-      @electronicRoutingInfo = { 
-        accountNumber: account_number, 
-        routingNumber: routing_number, 
+      @emails = [email]
+      @payment_method = "electronic"
+      @electronic_routing_info = {
+        accountNumber: account_number,
+        routingNumber: routing_number,
         electronicAccountType: "businessChecking",
-        address: @address 
+        address: @address
       }
     end
 
     def json
-      { name: @name, address: @address, emails: @emails, paymentMethod: @paymentMethod, electronicRoutingInfo: @electronicRoutingInfo }
+      { name: @name, address: @address, emails: @emails, paymentMethod: @payment_method,
+        electronicRoutingInfo: @electronic_routing_info }
+    end
+
+    def to_json(*_args)
+      json.to_json
     end
   end
-end 
+end

data/lib/mercury_banking/reconciliation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'fileutils'
 
@@ -5,100 +7,97 @@ module MercuryBanking
   # Class to manage reconciliation status for transactions
   class Reconciliation
     RECONCILIATION_DIR = File.join(Dir.home, '.mercury-banking', 'reconciliation')
-    
+
     def initialize
       # Ensure reconciliation directory exists
       FileUtils.mkdir_p(RECONCILIATION_DIR)
     end
-    
+
     # Get the reconciliation file path for an account
     def reconciliation_file(account_id)
       File.join(RECONCILIATION_DIR, "#{account_id}.json")
     end
-    
+
     # Load reconciled transactions for an account
     def load_reconciled_transactions(account_id)
       file_path = reconciliation_file(account_id)
-      
-      if File.exist?(file_path)
-        begin
-          data = JSON.parse(File.read(file_path))
-          # Handle both old format (array of transaction IDs) and new format (hash with dates)
-          if data.is_a?(Array)
-            # Convert old format to new format
-            new_data = {}
-            data.each do |transaction_id|
-              new_data[transaction_id] = nil
-            end
-            return new_data
-          else
-            return data
-          end
-        rescue JSON::ParserError
-          # If the file is corrupted, return an empty hash
-          return {}
+
+      return {} unless File.exist?(file_path)
+
+      begin
+        data = JSON.parse(File.read(file_path))
+        # Handle both old format (array of transaction IDs) and new format (hash with dates)
+        return data unless data.is_a?(Array)
+
+        # Convert old format to new format
+        new_data = {}
+        data.each do |transaction_id|
+          new_data[transaction_id] = nil
         end
-      else
-        # If the file doesn't exist, return an empty hash
-        return {}
+        new_data
+      rescue JSON::ParserError
+        # If the file is corrupted, return an empty hash
+        {}
       end
+
+      # If the file doesn't exist, return an empty hash
     end
-    
+
     # Save reconciled transactions for an account
     def save_reconciled_transactions(account_id, transactions)
       file_path = reconciliation_file(account_id)
       File.write(file_path, JSON.pretty_generate(transactions))
     end
-    
+
     # Mark a transaction as reconciled
     def mark_reconciled(account_id, transaction_id)
       transactions = load_reconciled_transactions(account_id)
-      
+
       # Add the transaction ID if it's not already in the list
-      if transactions.key?(transaction_id)
-        return false # Already reconciled
-      else
-        transactions[transaction_id] = Time.now.strftime('%Y-%m-%d')
-        save_reconciled_transactions(account_id, transactions)
-        return true # Successfully reconciled
-      end
+      return false if transactions.key?(transaction_id)
+
+      # Already reconciled
+
+      transactions[transaction_id] = Time.now.strftime('%Y-%m-%d')
+      save_reconciled_transactions(account_id, transactions)
+      true # Successfully reconciled
     end
-    
+
     # Mark a transaction as unreconciled
     def mark_unreconciled(account_id, transaction_id)
       transactions = load_reconciled_transactions(account_id)
-      
+
       # Remove the transaction ID if it's in the list
-      if transactions.key?(transaction_id)
-        transactions.delete(transaction_id)
-        save_reconciled_transactions(account_id, transactions)
-        return true # Successfully unreconciled
-      else
-        return false # Not reconciled to begin with
-      end
+      return false unless transactions.key?(transaction_id)
+
+      transactions.delete(transaction_id)
+      save_reconciled_transactions(account_id, transactions)
+      true # Successfully unreconciled
+
+      # Not reconciled to begin with
     end
-    
+
     # Check if a transaction is reconciled
     def reconciled?(account_id, transaction_id)
       transactions = load_reconciled_transactions(account_id)
       transactions.key?(transaction_id)
     end
-    
+
     # Get all reconciled transaction IDs for an account
     def get_reconciled_transactions(account_id)
       load_reconciled_transactions(account_id).keys
     end
-    
+
     # Get the reconciliation date for a transaction
     def get_reconciliation_date(account_id, transaction_id)
       transactions = load_reconciled_transactions(account_id)
       transactions[transaction_id]
     end
-    
+
     # Get reconciliation status for all transactions
     def get_reconciliation_status(account_id, transactions)
       reconciled_data = load_reconciled_transactions(account_id)
-      
+
       transactions.map do |t|
         {
           transaction_id: t["id"],
@@ -110,23 +109,23 @@ module MercuryBanking
         }
       end
     end
-    
+
     # Get reconciliation summary
     def get_reconciliation_summary(account_id, transactions)
       reconciled_data = load_reconciled_transactions(account_id)
-      
+
       total_transactions = transactions.size
       reconciled_count = transactions.count { |t| reconciled_data.key?(t["id"]) }
       unreconciled_count = total_transactions - reconciled_count
-      
+
       reconciled_amount = transactions
-        .select { |t| reconciled_data.key?(t["id"]) }
-        .sum { |t| t["amount"].to_f }
-      
+                          .select { |t| reconciled_data.key?(t["id"]) }
+                          .sum { |t| t["amount"].to_f }
+
       unreconciled_amount = transactions
-        .reject { |t| reconciled_data.key?(t["id"]) }
-        .sum { |t| t["amount"].to_f }
-      
+                            .reject { |t| reconciled_data.key?(t["id"]) }
+                            .sum { |t| t["amount"].to_f }
+
       {
         total_transactions: total_transactions,
         reconciled_count: reconciled_count,
@@ -136,4 +135,4 @@ module MercuryBanking
       }
     end
   end
-end 
+end