amounts 0.0.8 → 0.1.0

data/test/amount/registry_test.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class AmountRegistryTest < Minitest::Test
+  def setup
+    AmountTestSupport.register_default_types!
+  end
+
+  def teardown
+    Amount.send(:replace_registry, Amount::Registry.new) if Amount.registry.locked?
+    Amount.registry.clear!
+  end
+
+  def test_registry_lock_marks_registry_locked
+    Amount.registry.lock!
+
+    assert Amount.registry.locked?
+  end
+
+  def test_registry_lock_prevents_register
+    Amount.registry.lock!
+
+    assert_raises(Amount::Registry::RegistryLocked) { Amount.register(:DOGE, decimals: 8) }
+  end
+
+  def test_registry_lock_prevents_register_default_rate
+    Amount.registry.lock!
+
+    assert_raises(Amount::Registry::RegistryLocked) { Amount.register_default_rate(:USD, :USDC, 1) }
+  end
+
+  def test_registry_lock_prevents_clear
+    Amount.registry.lock!
+
+    assert_raises(Amount::Registry::RegistryLocked) { Amount.registry.clear! }
+  end
+
+  def test_register_rejects_empty_symbol
+    assert_raises(ArgumentError) { Amount.register :"", decimals: 2 }
+  end
+
+  def test_register_rejects_empty_symbol_with_message
+    assert_match(/symbol must not be blank/, error_from(ArgumentError) { Amount.register :"", decimals: 2 }.message)
+  end
+
+  def test_register_rejects_nil_symbol
+    assert_raises(ArgumentError) { Amount.register nil, decimals: 2 }
+  end
+
+  def test_registry_can_be_read_from_multiple_threads
+    errors = Queue.new
+
+    threads = 10.times.map do
+      Thread.new do
+        100.times do
+          Amount.registry.lookup(:USDC)
+          Amount.registry.default_rate?(:USDC, :USD)
+        rescue StandardError => e
+          errors << e
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    assert errors.empty?, "expected no thread errors, got #{errors.size}"
+  end
+
+  def test_register_default_rate_accepts_rational
+    Amount.register_default_rate :USDC, :USD, Rational(1, 2)
+
+    assert_equal BigDecimal("0.5"), Amount.registry.default_rate(:USDC, :USD)
+  end
+
+  def test_register_default_rate_rational_converts_exactly
+    Amount.register_default_rate :USDC, :USD, Rational(1, 2)
+
+    assert_equal BigDecimal("0.5"), Amount.new("1", :USDC).to(:USD).decimal
+  end
+
+  def test_prefix_display_position_is_stored_as_its_template
+    assert_equal "%u%n", Amount.registry.lookup(:USD).display_format
+  end
+
+  def test_suffix_display_position_is_stored_as_its_template
+    assert_equal "%n %u", Amount.registry.lookup(:SOL).display_format
+  end
+
+  def test_display_position_defaults_to_suffix
+    Amount.register :PTS, decimals: 0
+
+    assert_equal :suffix, Amount.registry.lookup(:PTS).display_position
+  end
+
+  def test_default_display_position_is_stored_as_suffix_template
+    Amount.register :PTS, decimals: 0
+
+    assert_equal "%n %u", Amount.registry.lookup(:PTS).display_format
+  end
+
+  def test_display_format_leaves_display_position_unset
+    Amount.register :EUR, decimals: 2, display_format: "%u%n"
+
+    assert_nil Amount.registry.lookup(:EUR).display_position
+  end
+
+  def test_display_format_and_display_position_together_raise
+    assert_raises(ArgumentError) { register_eur_with_format_and_position }
+  end
+
+  def test_display_format_and_display_position_together_message
+    assert_match(/not both/, error_from(ArgumentError) { register_eur_with_format_and_position }.message)
+  end
+
+  def test_display_format_and_display_position_together_leave_type_unregistered
+    error_from(ArgumentError) { register_eur_with_format_and_position }
+
+    refute Amount.registry.registered?(:EUR)
+  end
+
+  {
+    "string_without_number" => "%u",
+    "symbol_with_only_number_marker" => :'%n'
+  }.each do |name, format|
+    define_method("test_display_format_#{name}_raises") do
+      assert_raises(ArgumentError) { Amount.register :EUR, decimals: 2, display_format: format }
+    end
+  end
+
+  def test_display_unit_format_and_position_together_raise
+    assert_raises(Amount::Registry::InvalidDisplayUnit) do
+      Amount.register :EUR, decimals: 2,
+                            display_units: { cents: { scale: 100, format: "%n %u", position: :prefix } }
+    end
+  end
+
+  def test_display_unit_format_without_number_raises
+    assert_raises(Amount::Registry::InvalidDisplayUnit) do
+      Amount.register :EUR, decimals: 2, display_units: { cents: { scale: 100, format: "%u" } }
+    end
+  end
+
+  private
+
+  def register_eur_with_format_and_position
+    Amount.register :EUR, decimals: 2, display_format: "%u%n", display_position: :prefix
+  end
+end

data/test/amount/ui_parser_test.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "i18n"
+require_relative "../test_helper"
+
+class AmountUiParserTest < Minitest::Test
+  NBSP = "\u00A0"
+  NARROW_NBSP = "\u202F"
+
+  CHAR_NAMES = {
+    "," => "comma", "." => "dot", "-" => "minus", "+" => "plus", " " => "space", NBSP => "nbsp",
+    NARROW_NBSP => "nnbsp", "\n" => "newline", "$" => "dollar", "€" => "euro"
+  }.freeze
+
+  # A method-name-safe spelling of an input, so "1,50,0" and "1.50.0" stay distinct.
+  def self.slug(input)
+    return "nil" if input.nil?
+    return "empty" if input.empty?
+
+    input.each_char.map { |c| c.match?(/[a-zA-Z0-9]/) ? c : "_#{CHAR_NAMES.fetch(c) { format('u%04x', c.ord) }}_" }
+         .join.squeeze("_").delete_prefix("_").delete_suffix("_")
+  end
+
+  def self.case_name(group, verb, input, symbol, opts)
+    "test_#{group}_#{verb}_#{slug(input)}_#{symbol.downcase}_#{opts.fetch(:locale, :plain)}"
+  end
+
+  # Defines a test that parses `input` and checks its atomic value. `before`
+  # names a private arrange method to run first.
+  def self.accepts(group, atomic, input, symbol = :USD, before: nil, **opts)
+    define_method(unique_name(case_name(group, :parses, input, symbol, opts))) do
+      send(before) if before
+
+      assert_equal atomic, parse(input, symbol, **opts).atomic
+    end
+  end
+
+  # Defines a test that `input` is rejected with Amount::InvalidInput.
+  def self.rejects(group, input, symbol = :USD, before: nil, **opts)
+    define_method(unique_name(case_name(group, :rejects, input, symbol, opts))) do
+      send(before) if before
+
+      assert_raises(Amount::InvalidInput, "#{input.inspect} should be rejected") { parse(input, symbol, **opts) }
+    end
+  end
+
+  # A later define_method with the same name would silently replace a case.
+  def self.unique_name(name)
+    raise ArgumentError, "duplicate test name #{name}" if method_defined?(name)
+
+    name
+  end
+
+  def setup
+    AmountTestSupport.register_default_types!
+    @previous_locale = I18n.locale
+    @previous_backend = I18n.backend
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.available_locales = %i[en de fr]
+    I18n.backend.store_translations(:en, number: { format: { delimiter: ",", separator: "." } })
+    I18n.backend.store_translations(:de, number: { format: { delimiter: ".", separator: "," } })
+    I18n.backend.store_translations(:fr, number: { format: { delimiter: " ", separator: "," } })
+    Amount.localize = false
+  end
+
+  def teardown
+    Amount.localize = false
+    I18n.backend = @previous_backend
+    I18n.locale = @previous_locale
+    Amount.registry.clear!
+  end
+
+  # Issue examples
+
+  def test_issue_example_de_equals_new
+    assert_equal Amount.new("1500.50", :USD), parse("1.500,50", locale: :de)
+  end
+
+  def test_issue_example_en_equals_new
+    assert_equal Amount.new("1500.50", :USD), parse("1,500.50", locale: :en)
+  end
+
+  def test_issue_example_plain_equals_new
+    assert_equal Amount.new("1500.50", :USD), parse("1500.50")
+  end
+
+  def test_issue_example_de_atomic
+    assert_equal 150_050, parse("1.500,50", locale: :de).atomic
+  end
+
+  # Without a locale there are no delimiters
+
+  accepts :plain, 150_000, "1500"
+  rejects :plain, "1,500.50"
+  rejects :plain, "1.500,50"
+
+  def test_localize_uses_i18n_locale
+    Amount.localize = true
+    I18n.locale = :de
+
+    assert_equal 150_050, parse("1.500,50").atomic
+  end
+
+  def test_explicit_locale_overrides_localize
+    Amount.localize = true
+    I18n.locale = :de
+
+    assert_equal 150_050, parse("1,500.50", locale: :en).atomic
+  end
+
+  # Whitespace, including NBSP
+
+  accepts :whitespace, 150_050, " #{NBSP}1.500,50#{NBSP}\n", locale: :de
+  accepts :whitespace, 150_050, "  1,500.50 ", locale: :en
+  accepts :whitespace, 150_050, "#{NBSP}1500.50#{NARROW_NBSP}"
+  accepts :whitespace, 150_050, "1 500,50", locale: :fr
+  accepts :whitespace, 150_050, "1#{NBSP}500,50", locale: :fr
+
+  # Signs
+
+  accepts :signs, -150_050, "-1.500,50", locale: :de
+  accepts :signs, -150_050, "-1,500.50", locale: :en
+  accepts :signs, 150_050, "+1,500.50", locale: :en
+  accepts :signs, -150_050, "$-1,500.50", locale: :en
+  accepts :signs, -150_050, "-$1,500.50", locale: :en
+  rejects :signs, "--1.50"
+  rejects :signs, "+-1.50"
+  rejects :signs, "1.50-"
+
+  # Delimiter groups
+
+  accepts :delimiter_groups, 123_456_789_00, "123,456,789.00", locale: :en
+  accepts :delimiter_groups, 123_456_789_00, "123.456.789,00", locale: :de
+  accepts :delimiter_groups, 150_000, "1500", locale: :en
+  accepts :delimiter_groups, 150_000, "1500", locale: :de
+  %w[1,50,0 1,5000 12,34,567 ,500 1,,500 1,500,5].each { |bad| rejects :delimiter_groups, bad, locale: :en }
+  %w[1.50.0 1.5000 12.34.567 .500 1..500].each { |bad| rejects :delimiter_groups, bad, locale: :de }
+
+  # Decimal places
+
+  accepts :decimal_places, 150_000, "1.500,00", locale: :de
+  accepts :decimal_places, 150_050, "1.500,50", locale: :de
+  accepts :decimal_places, 150_000, "1,500", :USD, locale: :en
+  rejects :decimal_places, "1,500.505", locale: :en
+  rejects :decimal_places, "1.500,505", locale: :de
+  rejects :decimal_places, "0.001"
+
+  # Separator used twice
+
+  rejects :separator_twice, "1.500.50", locale: :en
+  rejects :separator_twice, "1,500,50", locale: :de
+  rejects :separator_twice, "1.50.50"
+
+  # Malformed numbers
+
+  ["", "   ", NBSP, "abc", "$", "1.", ".5", "1e3", "1,500.", "- ", "1 2"].each do |bad|
+    rejects :malformed, bad, locale: :en
+  end
+  rejects :malformed, nil
+
+  # Labels at either end
+
+  accepts :labels, 150_050, "$1,500.50", locale: :en
+  accepts :labels, 150_050, "$ 1,500.50", locale: :en
+  accepts :labels, 150_050, "1.500,50 $", locale: :de
+  accepts :labels, 150_050, "1.500,50$", locale: :de
+  accepts :labels, 2_500_000_000, "2.5 SOL", :SOL
+  accepts :labels, 1_500, "1.500 logs", :LOGS, locale: :de
+  accepts :labels, 1_500, "logs 1,500", :LOGS, locale: :en
+
+  accepts :euro_label, 150_050, "1.500,50 €", :EUR, before: :register_euro, locale: :de
+  accepts :euro_label, 150_050, "€1,500.50", :EUR, before: :register_euro, locale: :en
+
+  # Another type's label
+
+  rejects :other_types_label, "1,500.50 SOL", :USD, locale: :en
+  rejects :other_types_label, "$1.500,50", :SOL, locale: :de
+  rejects :other_types_label, "1.500 logs", :USD, locale: :de
+  rejects :other_types_label, "$1,500.50 $", :USD, locale: :en
+
+  # Plural and translated labels
+
+  accepts :plural_label, 1, "1 search", :SEARCHES, before: :register_plural_searches
+  accepts :plural_label, 1500, "1,500 searches", :SEARCHES, before: :register_plural_searches, locale: :en
+  accepts :plural_label, 1500, "1.500 searches", :SEARCHES, before: :register_plural_searches, locale: :de
+  rejects :plural_label, "1 logs", :SEARCHES, before: :register_plural_searches
+
+  accepts :translated_label, 1500, "1.500 Suchen", :SEARCHES, before: :translate_searches, locale: :de
+  accepts :translated_label, 1, "1 Suche", :SEARCHES, before: :translate_searches, locale: :de
+  accepts :translated_label, 1, "1 s", :SEARCHES, before: :translate_searches, locale: :de
+  rejects :translated_label, "1 Suchen", :SEARCHES, before: :translate_searches, locale: :en
+
+  # Zero decimals
+
+  accepts :decimals_zero, 1_500_000, "1.500.000", :LOGS, locale: :de
+  accepts :decimals_zero, 1_500_000, "1,500,000", :LOGS, locale: :en
+  accepts :decimals_zero, -1500, "-1,500", :LOGS, locale: :en
+  accepts :decimals_zero, 0, "0", :LOGS
+  rejects :decimals_zero, "1,5", :LOGS, locale: :en
+  rejects :decimals_zero, "1.500,5", :LOGS, locale: :de
+  rejects :decimals_zero, "1.500,0", :LOGS, locale: :de
+  rejects :decimals_zero, "1500.5", :LOGS
+
+  # High precision
+
+  accepts :high_precision, 1_234_567_891, "1.234567891", :SOL
+  accepts :high_precision, 123_456_789_123_456_789_012_345_678, "123456789123456789.012345678", :SOL
+
+  # Without the i18n gem
+
+  def test_explicit_locale_without_i18n_raises
+    without_i18n { assert_raises(ArgumentError) { parse("1.50", locale: :de) } }
+  end
+
+  def test_plain_parsing_works_without_i18n
+    without_i18n { assert_equal 150, parse("1.50").atomic }
+  end
+
+  # Round trips of `ui` output
+
+  UI_USD_VALUES = %w[0 0.01 0.99 1 9.99 12.34 123.45 999.99 1000 1000.01 12345.67 123456.78 1234567.89
+                     -0.01 -1 -999.99 -1000 -1234567.89 99999999999.99].freeze
+  UI_LOGS_COUNTS = [0, 7, 999, 1000, 1_234_567, -1_500].freeze
+
+  %i[en de fr].each do |locale|
+    define_method("test_round_trips_usd_ui_#{locale}") do
+      amounts = UI_USD_VALUES.map { |value| Amount.of_usd(value) }
+
+      assert_equal amounts, amounts.map { |amount| parse(amount.ui(locale:), locale:) }
+    end
+
+    define_method("test_round_trips_usd_undecorated_ui_#{locale}") do
+      amounts = UI_USD_VALUES.map { |value| Amount.of_usd(value) }
+
+      assert_equal amounts, amounts.map { |amount| parse(amount.ui(locale:, decorated: false), locale:) }
+    end
+
+    define_method("test_round_trips_logs_ui_#{locale}") do
+      amounts = UI_LOGS_COUNTS.map { |n| Amount.of_logs(n) }
+
+      assert_equal amounts, amounts.map { |amount| parse(amount.ui(locale:), :LOGS, locale:) }
+    end
+  end
+
+  # (n**3) + n cents for n in 0, 7, 14, ..., 3997, in each locale and sign
+  RANGE_CENTS = (0..4000).step(7).map { |n| (n**3) + n }.freeze
+
+  %i[en de].each do |locale|
+    { "positive" => 1, "negative" => -1 }.each do |sign, factor|
+      define_method("test_round_trips_over_a_range_#{sign}_#{locale}") do
+        amounts = RANGE_CENTS.map { |cents| Amount.new(cents * factor, :USD) }
+
+        assert_equal amounts, amounts.map { |amount| parse(amount.ui(locale:), locale:) }
+      end
+    end
+  end
+
+  private
+
+  def parse(input, symbol = :USD, **opts)
+    Amount.parse_ui(input, symbol, **opts)
+  end
+
+  def register_euro
+    Amount.register :EUR, decimals: 2, display_symbol: "€"
+  end
+
+  def register_plural_searches
+    Amount.register :SEARCHES, decimals: 0, display_symbol: { one: "search", other: "searches" }
+  end
+
+  def translate_searches
+    Amount.register :SEARCHES, decimals: 0, display_symbol: "s"
+    I18n.backend.store_translations(:de, amounts: { units: { searches: { one: "Suche", other: "Suchen" } } })
+  end
+
+  # Runs the block as if the i18n gem were not loaded.
+  def without_i18n
+    i18n = Object.send(:remove_const, :I18n)
+    yield
+  ensure
+    Object.const_set(:I18n, i18n)
+  end
+end

data/test/amount_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class AmountTest < Minitest::Test
+  def setup
+    AmountTestSupport.register_default_types!
+  end
+
+  def teardown
+    Amount.registry.clear!
+  end
+
+  def test_inspect_uses_default_ui_representation_for_prefix_type
+    assert_equal "#<Amount USDC $1.50>", Amount.new("1.5", :USDC).inspect
+  end
+
+  def test_inspect_uses_default_ui_representation_for_suffix_type
+    assert_equal "#<Amount GOLD 1.0000 oz t>", Amount.new("1", :GOLD).inspect
+  end
+
+  def test_unregistered_type_raises
+    assert_raises(Amount::Registry::UnknownType) { Amount.new(1, :DOGE) }
+  end
+
+  def test_frozen_amount_renders_ui
+    assert_equal "$1.50", frozen_amount.ui
+  end
+
+  def test_frozen_amount_renders_formatted
+    assert_equal "1.500000", frozen_amount.formatted
+  end
+
+  def test_frozen_amount_renders_to_s
+    assert_equal "USDC|1.50", frozen_amount.to_s
+  end
+
+  def test_very_large_atomic_value_preserves_atomic
+    assert_equal 10**30, very_large_amount.atomic
+  end
+
+  def test_very_large_atomic_value_preserves_decimal
+    assert_equal "1000000000000000000000.0", very_large_amount.decimal.to_s("F")
+  end
+
+  private
+
+  def frozen_amount
+    Amount.new("1.5", :USDC).freeze
+  end
+
+  def very_large_amount
+    Amount.new(10**30, :SOL, from: :atomic)
+  end
+end

data/test/dummy/config/application.rb

@@ -4,6 +4,9 @@ require "rails"
 require "active_model/railtie"
 require "active_record/railtie"
 
+# What Bundler.require does in an app: the railtie then loads the adapter.
+require_relative "../../../lib/amounts"
+
 module Dummy
   class Application < Rails::Application
     config.root = File.expand_path("..", __dir__)

data/test/generators/amount/active_record/registry_generator_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "tmpdir"
+require "fileutils"
+require_relative "../../../../lib/amounts"
+require_relative "../../../../lib/generators/amount/active_record/registry_generator"
+require "rails/generators"
+
+class AmountActiveRecordRegistryGeneratorTest < Minitest::Test
+  PRESETS_DIR = File.expand_path("../../../../lib/generators/amount/active_record/templates/presets", __dir__)
+
+  def setup
+    @destination_root = Dir.mktmpdir("amounts-generator")
+  end
+
+  def teardown
+    FileUtils.remove_entry(@destination_root)
+  end
+
+  {
+    "rails_generate_command" => "rails generate amounts:registry fiat",
+    "registry_overview" => "# Registry overview:",
+    "fiat_section" => "# Major Fiat Currencies:",
+    "usd_description" => "# USD: United States dollar.",
+    "usd_fact" => "# Fact: Uses 2 decimal places for cents.",
+    "usd_preset_default" => "# Preset default: Uses \"$\" as the default display symbol in an English-oriented UI.",
+    "usd_registration" => "Amount.register :USD",
+    "jpy_registration" => "Amount.register :JPY"
+  }.each do |name, text|
+    define_method("test_fiat_initializer_includes_#{name}") do
+      assert_includes generated("fiat"), text
+    end
+  end
+
+  def test_fiat_initializer_excludes_btc_registration
+    refute_includes generated("fiat"), "Amount.register :BTC"
+  end
+
+  %w[USD USDC].each do |symbol|
+    define_method("test_all_initializer_registers_#{symbol}_once") do
+      assert_equal 1, generated("all").scan(/^\s*Amount\.register :#{symbol},/).size
+    end
+  end
+
+  %w[GOLD BTC].each do |symbol|
+    define_method("test_all_initializer_registers_#{symbol}") do
+      assert_includes generated("all"), "Amount.register :#{symbol}"
+    end
+  end
+
+  {
+    "btc_description" => "# BTC: Bitcoin.",
+    "ethereum_source" => "# Source: Ethereum denomination docs: https://ethereum.org/en/developers/docs/intro-to-ether/",
+    "usdt_registration" => "Amount.register :USDT"
+  }.each do |name, text|
+    define_method("test_crypto_initializer_includes_#{name}") do
+      assert_includes generated("crypto"), text
+    end
+  end
+
+  %w[MATIC POL].each do |symbol|
+    define_method("test_crypto_initializer_excludes_stale_#{symbol}_registration") do
+      refute_includes generated("crypto"), "Amount.register :#{symbol}"
+    end
+  end
+
+  %w[fiat metals crypto all].each do |preset|
+    define_method("test_static_#{preset}_preset_file_exists") do
+      assert File.exist?(preset_file(preset))
+    end
+  end
+
+  {
+    "fiat_section" => "# Major Fiat Currencies:",
+    "metals_section" => "# Precious And Industrial Metals:",
+    "crypto_section" => "# Large-Cap Crypto Assets:",
+    "usd_registration" => "Amount.register :USD",
+    "gold_registration" => "Amount.register :GOLD",
+    "btc_registration" => "Amount.register :BTC"
+  }.each do |name, text|
+    define_method("test_all_static_preset_file_includes_#{name}") do
+      assert_includes File.read(preset_file("all")), text
+    end
+  end
+
+  def test_rejects_unknown_preset
+    _stdout, stderr = capture_io do
+      invoke_generator("unknown")
+    end
+    assert_includes stderr, "unknown preset"
+  end
+
+  private
+
+  # The initializer generated for the preset, generated once per test.
+  def generated(preset)
+    @generated ||= {}
+    @generated[preset] ||= begin
+      invoke_generator(preset)
+      File.read(File.join(@destination_root, "config/initializers/amounts.rb"))
+    end
+  end
+
+  def invoke_generator(preset)
+    Amount::ActiveRecord::RegistryGenerator.start(
+      [preset],
+      destination_root: @destination_root,
+      shell: Thor::Shell::Basic.new
+    )
+  end
+
+  def preset_file(name)
+    File.join(PRESETS_DIR, "#{name}.fragment")
+  end
+end