synthra 0.1.0

data/lib/synthra/types/finance_banking/banking.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module FinanceBanking
+      # Money type
+      class Money < Base
+        # Generate a random money value
+        #
+        # Creates a hash with amount (2 decimal places) and currency code.
+        # Uses Faker::Currency.code if no currency specified.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param args [Hash] type arguments
+        # @option args [Range, Hash] :range amount range (default: 0..10000)
+        # @option args [String] :currency currency code (default: random from Faker)
+        # @return [Hash] { "amount" => Float, "currency" => String }
+        #
+        # @example
+        #   generate_random(rng, { range: 0..100, currency: "EUR" })
+        #   # => { "amount" => 45.67, "currency" => "EUR" }
+        #
+        def generate_random(rng, context, args)
+          range = args[:range] || (0..10_000)
+          min = range.is_a?(Hash) ? (range[:min] || 0) : range.min
+          max = range.is_a?(Hash) ? (range[:max] || 10_000) : range.max
+
+          # Use provided currency or generate one using Faker
+          currency = args[:currency] || generate_currency(context)
+
+          # Generate amount and round to 2 decimal places (cents)
+          amount = (rng.rand * (max.to_f - min.to_f) + min.to_f).round(2)
+
+          {
+            "amount" => amount,
+            "currency" => currency
+          }
+        end
+
+        def generate_edge(rng, context, args)
+          {
+            "amount" => 0.0,
+            "currency" => "USD"
+          }
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "not money", [], {}, 123])
+        end
+
+        private
+
+        def generate_currency(context)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.currency_code
+
+          else
+            Faker::Currency.code
+          end
+
+        rescue StandardError
+          "USD"
+        end
+
+      end
+
+      # Currency type
+      class Currency < Base
+        # Fallback currency codes if Faker is unavailable
+        #
+        # ISO 4217 currency codes used when Faker cannot generate codes.
+        #
+        # @return [Array<String>] list of 3-letter currency codes
+        #
+        FALLBACK_CODES = %w[
+          USD EUR GBP JPY CNY INR BRL CAD AUD CHF
+          SEK NOK DKK NZD SGD HKD KRW MXN ZAR RUB
+          TRY PLN CZK HUF RON BGN HRK ILS AED SAR
+          THB MYR IDR PHP VND EGP NGN KES MAD PKR
+        ].freeze
+
+        # Generate a random currency code
+        #
+        # Uses Faker::Currency.code for realistic ISO 4217 codes.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param args [Hash] type arguments (not used)
+        # @return [String] three-letter currency code
+        #
+        # @example
+        #   generate_random(rng, {})
+        #   # => "EUR"
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.currency_code
+
+          else
+            Faker::Currency.code
+          end
+
+        rescue StandardError
+          rng.sample(FALLBACK_CODES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["USD", "EUR", "GBP"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "XX", "123", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # CreditCard type
+      class CreditCard < Base
+        # Credit card type definitions
+        #
+        # Maps card type symbols to their specifications including
+        # valid prefixes and card number length.
+        #
+        # @return [Hash<Symbol, Hash>] card type to specification mapping
+        # @example
+        #   CARD_TYPES[:visa]       # => { prefix: [4], length: 16 }
+        #   CARD_TYPES[:mastercard] # => { prefix: [51, 52, 53, 54, 55], length: 16 }
+        #
+        CARD_TYPES = {
+          visa: { prefix: [4], length: 16 },
+          mastercard: { prefix: [51, 52, 53, 54, 55], length: 16 },
+          amex: { prefix: [34, 37], length: 15 },
+          discover: { prefix: [6011, 65], length: 16 },
+          diners: { prefix: [30, 36, 38], length: 14 },
+          jcb: { prefix: [35], length: 16 }
+        }.freeze
+
+        # Generate random credit card number
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol, String] :type card type (:visa, :mastercard, :amex, etc.)
+        # @return [String] generated credit card number
+        #
+        def generate_random(rng, context, args)
+          type = (args[:type] || rng.sample(CARD_TYPES.keys)).to_sym
+          card_spec = CARD_TYPES[type] || CARD_TYPES[:visa]
+
+          # :nocov:
+          # The non-Array arm is unreachable: every CARD_TYPES entry (and the
+          # :visa default) declares an Array prefix, so card_spec[:prefix] is
+          # always an Array here.
+          prefix = card_spec[:prefix].is_a?(Array) ? rng.sample(card_spec[:prefix]) : card_spec[:prefix]
+          # :nocov:
+          length = card_spec[:length]
+
+          # Generate base number with prefix
+          base = prefix.to_s
+          remaining = length - base.length - 1 # -1 for check digit
+
+          # Fill with random digits
+          remaining.times { base += rng.int(0, 9).to_s }
+
+          # Calculate and append Luhn check digit
+          check_digit = calculate_luhn_check_digit(base)
+          "#{base}#{check_digit}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["4111111111111111", "4000000000000002"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "1234", "invalid", [], {}])
+        end
+
+        private
+
+        def calculate_luhn_check_digit(number)
+          sum = 0
+          number.reverse.chars.each_with_index do |digit, index|
+            n = digit.to_i
+            n *= 2 if index.odd?
+            n -= 9 if n > 9
+            sum += n
+          end
+          (10 - (sum % 10)) % 10
+        end
+      end
+
+      # BankName type
+      class BankName < Base
+        # Generate random bank name
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated bank name
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.bank
+
+          else
+            Faker::Bank.name
+          end
+
+        rescue StandardError
+          rng.sample(["Chase Bank", "Bank of America", "Wells Fargo"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # AccountNumber type
+      class AccountNumber < Base
+        # Generate random account number
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer] :length account number length (default: 8..12)
+        # @option args [String] :format format string (e.g., "%010d" for zero-padding)
+        # @return [String] generated account number
+        #
+        def generate_random(rng, context, args)
+          length = args[:length] || rng.int(8, 12)
+          format_str = args[:format]
+
+          # Generate number
+          max_value = 10**length - 1
+          value = rng.int(0, max_value)
+
+          # Format if specified
+          if format_str
+            format(format_str, value)
+          else
+            value.to_s.rjust(length, "0")
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["00000000", "999999999999"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Iban type
+      class Iban < Base
+        # IBAN format specifications by country
+        #
+        # Maps country codes to their IBAN format specifications including
+        # country code and total length.
+        #
+        # @return [Hash<Symbol, Hash>] country code to format mapping
+        # @example
+        #   IBAN_FORMATS[:gb]  # => { code: "GB", length: 22 }
+        #   IBAN_FORMATS[:de]  # => { code: "DE", length: 22 }
+        #
+        IBAN_FORMATS = {
+          gb: { code: "GB", length: 22 },
+          de: { code: "DE", length: 22 },
+          fr: { code: "FR", length: 27 },
+          it: { code: "IT", length: 27 },
+          es: { code: "ES", length: 24 },
+          nl: { code: "NL", length: 18 },
+          be: { code: "BE", length: 16 },
+          us: { code: "US", length: 22 } # Not standard, but sometimes used
+        }.freeze
+
+        # Generate random IBAN
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol, String] :country country code (:gb, :de, :fr, etc.)
+        # @return [String] generated IBAN
+        #
+        def generate_random(rng, context, args)
+          country = (args[:country] || :gb).to_sym
+          format = IBAN_FORMATS[country] || IBAN_FORMATS[:gb]
+
+          country_code = format[:code]
+          length = format[:length]
+
+          # Generate check digits (2 digits)
+          check_digits = format("%02d", rng.int(0, 99))
+
+          # Generate BBAN (Basic Bank Account Number) - alphanumeric
+          bban_length = length - 4 # -4 for country code and check digits
+          chars = ("A".."Z").to_a + ("0".."9").to_a
+          bban = bban_length.times.map { rng.sample(chars) }.join
+
+          "#{country_code}#{check_digits}#{bban}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["GB00000000000000000000", "DE00000000000000000000"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "invalid", "123", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # BankRoutingNumber type
+      class BankRoutingNumber < Base
+        def generate_random(rng, context, args)
+          format("%09d", rng.int(100000000, 999999999))
+        end
+
+        def generate_edge(rng, context, args)
+          ["000000000", "999999999"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # BankSwiftBic type
+      class BankSwiftBic < Base
+        def generate_random(rng, context, args)
+          # Format: 4 letters (bank) + 2 letters (country) + 2 alphanumeric (location) + 3 alphanumeric (branch, optional)
+          bank = (0...4).map { rng.sample(('A'..'Z').to_a) }.join
+          country = rng.sample(["US", "GB", "FR", "DE", "JP", "CA", "AU"])
+          location = (0...2).map { rng.sample(('A'..'Z').to_a + ('0'..'9').to_a) }.join
+          branch = (0...3).map { rng.sample(('A'..'Z').to_a + ('0'..'9').to_a) }.join
+          "#{bank}#{country}#{location}#{branch}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["AAAAUS00", "ZZZZZZ99"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "invalid", "123", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # BankLei type
+      class BankLei < Base
+        def generate_random(rng, context, args)
+          # Format: 20 alphanumeric characters
+          chars = ('A'..'Z').to_a + ('0'..'9').to_a
+          20.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["00000000000000000000", "ZZZZZZZZZZZZZZZZZZZZ"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "invalid", "123", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # BankRiadCode type
+      class BankRiadCode < Base
+        def generate_random(rng, context, args)
+          # RIAD codes are typically 9 digits
+          format("%09d", rng.int(100000000, 999999999))
+        end
+
+        def generate_edge(rng, context, args)
+          ["000000000", "999999999"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # TransactionAmount type
+      class TransactionAmount < Base
+        # Generate random transaction amount
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Range] :range amount range (e.g., 1.00..1000.00)
+        # @option args [Float] :min minimum amount (default: 0.01)
+        # @option args [Float] :max maximum amount (default: 10000.00)
+        # @option args [Integer] :precision decimal precision (default: 2)
+        # @return [Float] generated transaction amount
+        #
+        def generate_random(rng, context, args)
+          if args[:range].is_a?(Range)
+            min = args[:range].min
+            max = args[:range].max
+          else
+            min = args[:min] || 0.01
+            max = args[:max] || 10_000.00
+          end
+
+          precision = args[:precision] || 2
+          value = rng.rand * (max - min) + min
+          value.round(precision)
+        end
+
+        def generate_edge(rng, context, args)
+          [0.01, 0.0, 999999.99].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", -1.0, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/finance_banking/credit_cards.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module FinanceBanking
+      # CreditCardType type
+      class CreditCardType < Base
+        CARD_TYPES = ["Visa", "Mastercard", "American Express", "Discover", "JCB", "Diners Club"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(CARD_TYPES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Visa", "Mastercard"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/finance_banking/identifiers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module FinanceBanking
+      # Ssn type
+      class Ssn < Base
+        def generate_random(rng, context, args)
+          # Format: XXX-XX-XXXX
+          part1 = format("%03d", rng.int(100, 999))
+          part2 = format("%02d", rng.int(10, 99))
+          part3 = format("%04d", rng.int(1000, 9999))
+          "#{part1}-#{part2}-#{part3}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["000-00-0000", "999-99-9999", "123-45-6789"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a ssn", [], {}, "123456789"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Ein type
+      class Ein < Base
+        def generate_random(rng, context, args)
+          # Format: XX-XXXXXXX
+          part1 = format("%02d", rng.int(10, 99))
+          part2 = format("%07d", rng.int(1000000, 9999999))
+          "#{part1}-#{part2}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["00-0000000", "99-9999999", "12-3456789"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not an ein", [], {}, "123456789"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # NhsNumber type
+      class NhsNumber < Base
+        def generate_random(rng, context, args)
+          # NHS numbers are 10 digits
+          format("%010d", rng.int(1000000000, 9999999999))
+        end
+
+        def generate_edge(rng, context, args)
+          ["0000000000", "9999999999", "1234567890"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a nhs", [], {}, "123456789"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # MedicareBeneficiaryId type
+      class MedicareBeneficiaryId < Base
+        def generate_random(rng, context, args)
+          # Format: 1-2-3-4-5-6-7-8-9-10-11 (11 characters, alphanumeric)
+          chars = ('A'..'Z').to_a + ('0'..'9').to_a
+          11.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["A" * 11, "0" * 11, "1A2B3C4D5E6"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "too short", [], {}, "too long string here"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # DunsNumber type
+      class DunsNumber < Base
+        def generate_random(rng, context, args)
+          # DUNS numbers are 9 digits, often formatted with dashes
+          format("%09d", rng.int(100000000, 999999999))
+        end
+
+        def generate_edge(rng, context, args)
+          ["000000000", "999999999", "123456789"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a duns", [], {}, "12345678"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end