monies 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 457a633b330a9b30ecebac6694ed2b29566e96ed3db33b3ba2a8feca86501c88
+  data.tar.gz: 9b3fe5366065d52108a6b3b6d74f0daba814174f47063ce12dfac75d10ecb132
+SHA512:
+  metadata.gz: ef772a5e785576896d10adc3638aa7062f9e148cf6678394c82e2d5f1555ea486822cc1bc018b3babc3c3976480d6fb8b7fff15bf4c315861b175c4f996ffbf2
+  data.tar.gz: a69ffff9d64b66179c71bdeb7d4443a594818523e7d54ba845d3ad7cebf9f580cdd86173be0a7cb68a5ed4078262946620f8908fbc2c58a86254e60a60ae248e

data/LICENSE.txt

@@ -0,0 +1,4 @@
+Copyright (c) 2024 TIMCRAFT
+
+This is an Open Source project licensed under the terms of the LGPLv3 license.
+Please see <http://www.gnu.org/licenses/lgpl-3.0.html> for license text.

data/README.md

@@ -0,0 +1,270 @@
+# monies
+
+Ruby gem for representing monetary values.
+
+Pure Ruby—compatible with MRI/CRuby, JRuby, TruffleRuby, and Natalie.
+
+
+## Installation
+
+Using Bundler:
+
+    $ bundle add monies
+
+Using RubyGems:
+
+    $ gem install monies
+
+
+## Usage
+
+Getting started:
+
+```ruby
+require 'monies'
+
+a = Monies(11, 'USD')
+b = Monies('22.22', 'USD') * 2
+c = Monies.parse('$33.44')
+
+puts Monies.format(a + b + c, symbol: true)
+```
+
+
+## Currencies
+
+Currencies are represented as strings. Using [ISO 4217 currency codes](https://en.wikipedia.org/wiki/ISO_4217)
+is recommended for maximum interoperability, however there are no restrictions
+on what strings you can use. For example:
+
+```ruby
+Monies(10, 'USD')
+Monies(10, 'BTC')
+Monies(10, 'GBX')
+Monies(10, 'X')
+Monies(10, 'LOL')
+Monies(10, 'Cubit')
+Monies(10, 'Latinum')
+Monies(10, 'sats')
+```
+
+If your application primarily uses a single currency you can set a default currency:
+
+```ruby
+Monies.currency = 'USD'
+
+Monies(10)
+```
+
+
+## Arithmetic
+
+Arithmetic is currency checked to prevent errors:
+
+```ruby
+Monies(1, 'USD') + Monies(1, 'RUB')  # raises Monies::CurrencyError
+```
+
+If you need to sum amounts in different currencies you should first convert
+them all to the same currency.
+
+Division is limited to 16 decimal places by default, which ought to be enough
+for everyone. If you need more accuracy you can use the #div method to specify
+the maximum number of decimal places you want:
+
+```ruby
+Monies(1, 'USD').div(9, 100)
+```
+
+
+## Currency conversion
+
+Use the #convert method to convert instances to another currency:
+
+```ruby
+value = Monies('1.23', 'BTC')
+
+price = Monies(100_000, 'USD')
+
+puts value.convert(price).round(2)
+```
+
+Fetching price data, caching that data, and rounding the result are all
+responsibilities of the caller.
+
+
+## Parsing strings
+
+Use the `Monies` method to convert strings that are expected to be valid and
+don't contain special formatting, such as those in source code and databases:
+
+```ruby
+Monies('12345.6')
+```
+
+Use the `Monies.parse` method to parse strings that could be invalid or could
+contain special formatting like thousand separators, currency codes, or symbols:
+
+```ruby
+Monies.parse('£1,999.99')
+Monies.parse('1.999,00 EUR')
+```
+
+An `ArgumentError` exception is raised for invalid input:
+
+```ruby
+Monies.parse('notmoney')  # raises ArgumentError
+```
+
+Currency symbols and currency codes are defined in `Monies.symbols` which can
+be updated to support additional currencies using #[]= or #update. For example:
+
+```ruby
+Monies.symbols["\u20BF"] = 'BTC'
+
+Monies.symbols.update({"\u20BF" => 'BTC'})
+
+Monies.parse('1,000 BTC')
+```
+
+
+## Formatting strings
+
+Use the `Monies.format` method to produce formatted strings:
+
+```ruby
+Monies.format(Monies('1234.56', 'USD'))  # "1,234.56"
+```
+
+Specify the `code` or `symbol` options to include the currency code or symbol:
+
+```ruby
+Monies.format(Monies('1234.56', 'USD'), code: true)  # "1,234.56 USD"
+
+Monies.format(Monies('1234.56', 'USD'), symbol: true)  # "$1,234.56"
+```
+
+Specify the name of the format to use different formatting rules:
+
+```ruby
+Monies.format(Monies('1234.56', 'USD'), :eu)  # "1.234,56"
+```
+
+The default format is `:en` and can be changed by updating `Monies.formats`,
+for example to change the default format to the built-in `:eu` format:
+
+```ruby
+Monies.formats[:default] = Monies.formats[:eu]
+```
+
+To create a custom format first create a `Monies::Format` subclass,
+and then add the format to `Monies.formats`. For example:
+
+```ruby
+class CustomFormat < Monies::Format::EN
+  # ...
+end
+
+Monies.formats[:custom] = CustomFormat.new
+```
+
+
+## BigDecimal integration
+
+Monies integrates with the [bigdecimal gem](https://rubygems.org/gems/bigdecimal)
+for multiplication and currency conversion. For example:
+
+```ruby
+require 'bigdecimal/util'
+
+Monies('1.23', 'USD') * BigDecimal('0.1')
+```
+
+Use the `Monies` method to convert from a `BigDecimal` value:
+
+```ruby
+Monies(BigDecimal(10), 'USD')
+```
+
+Use the #to_d method to convert to a `BigDecimal` value:
+
+```ruby
+monies.to_d
+```
+
+Specify a currency argument to use `BigDecimal` values for currency conversion:
+
+```ruby
+monies = Monies('1.11', 'BTC')
+monies.convert(BigDecimal(100_000), 'USD').round(2)
+```
+
+
+## Percentage integration
+
+Monies integrates with the [percentage gem](https://rubygems.org/gems/percentage)
+for percentage calculations. For example:
+
+```ruby
+require 'percentage'
+
+capital_gains = Monies(10_000, 'GBP')
+
+tax_rate = Percentage.new(20)
+
+tax_liability = capital_gains * tax_rate
+
+puts tax_liability
+```
+
+
+## Sequel integration
+
+Monies integrates with the [sequel gem](https://rubygems.org/gems/sequel)
+to support database serialization. For example:
+
+```ruby
+class Product < Sequel::Model
+  plugin Monies::Serialization::Sequel
+
+  serialize_monies :price
+end
+```
+
+This will serialize the value and the currency as a single string.
+
+You can also specify the currency at the model/application level using the
+currency keyword argument:
+
+```ruby
+serialize_monies :price, currency: Monies.currency
+```
+
+This will serialize just the value as a single string.
+
+You can also use two columns, one for the value and an additional string column
+to store the currency:
+
+```ruby
+serialize_monies :price, currency: :currency
+```
+
+## ActiveRecord integration
+
+Monies integrates with the [activerecord gem](https://rubygems.org/gems/activerecord)
+to support database serialization. For example:
+
+```ruby
+class Product < ApplicationRecord
+  include Monies::Serialization::ActiveRecord
+
+  serialize_monies :price
+end
+```
+
+Usage of `serialize_monies` is identical to the [sequel integration](#sequel-integration).
+
+
+## License
+
+Monies is released under the LGPL-3.0 license.

data/lib/monies/digits.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Monies::Digits
+  def self.dump(instance, scale: nil, zero: '0', separator: '.', thousands_separator: nil)
+    return zero if instance.zero?
+
+    string = instance.value.abs.to_s
+
+    integral_length = string.length - instance.scale
+
+    unless thousands_separator.nil?
+      index = integral_length
+      while index > 3
+        index -= 3
+        string.insert(index, thousands_separator)
+        integral_length += thousands_separator.length
+      end
+    end
+
+    unless instance.scale.zero? && scale.nil? || scale == 0
+      if integral_length > 0
+        string.insert(integral_length, separator)
+      else
+        string = string.rjust(instance.scale, '0') if integral_length < 0
+        string.insert(0, separator)
+        string.insert(0, '0')
+      end
+    end
+
+    unless scale.nil?
+      if scale > instance.scale
+        string = string.ljust(string.length + scale - instance.scale, '0')
+      elsif scale < instance.scale
+        string.slice!(scale - instance.scale .. -1)
+      end
+    end
+
+    string.insert(0, '-') if instance.negative?
+    string
+  end
+
+  def self.load(string, currency)
+    integral_digits, fractional_digits = string.split('.')
+
+    value = integral_digits.to_i
+
+    if fractional_digits.nil?
+      scale = 0
+    else
+      scale = fractional_digits.length
+
+      value *= Monies::BASE ** scale
+
+      if string.start_with?('-')
+        value -= fractional_digits.to_i
+      else
+        value += fractional_digits.to_i
+      end
+    end
+
+    Monies.new(value, scale, currency)
+  end
+end

data/lib/monies/format.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Monies::Format
+  def call(instance, symbol: false, code: false)
+    if symbol && code
+      raise ArgumentError, "can't format with both symbol and code keyword arguments"
+    end
+
+    digits = Monies::Digits.dump(instance, scale: scale, zero: zero, separator: separator, thousands_separator: thousands_separator)
+
+    if symbol
+      Monies.symbols.fetch_key(instance.currency) + digits
+    elsif code
+      "#{digits} #{instance.currency}"
+    else
+      digits
+    end
+  end
+end
+
+class Monies::Format::EN < Monies::Format
+  def scale
+    2
+  end
+
+  def zero
+    '0.00'
+  end
+
+  def separator
+    '.'
+  end
+
+  def thousands_separator
+    ','
+  end
+end
+
+class Monies::Format::EU < Monies::Format
+  def scale
+    2
+  end
+
+  def zero
+    '0,00'
+  end
+
+  def separator
+    ','
+  end
+
+  def thousands_separator
+    '.'
+  end
+end

data/lib/monies/parser.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+require 'strscan'
+
+class Monies::Parser < StringScanner
+  def parse
+    if comma_decimal_separator?
+      @decimal_separator = COMMA
+
+      @thousands_separator = POINT_THINSP
+    else
+      @decimal_separator = POINT
+
+      @thousands_separator = COMMA
+    end
+
+    parse_minus_sign
+    parse_currency_symbol
+    parse_integral_digits
+    parse_fractional_digits
+    parse_space
+    parse_currency_code
+
+    if @integral_digits.nil?
+      raise ArgumentError, "can't parse #{string.inspect}"
+    end
+
+    if @fractional_digits.nil?
+      value = @integral_digits.to_i
+
+      scale = 0
+    else
+      value = (@integral_digits + @fractional_digits).to_i
+
+      scale = @fractional_digits.length
+    end
+
+    currency = if @currency_code
+      @currency_code
+    elsif @currency_symbol
+      Monies.symbols.fetch(@currency_symbol)
+    elsif Monies.currency
+      Monies.currency
+    else
+      raise ArgumentError, "can't parse #{string.inspect} without currency"
+    end
+
+    if @minus_sign
+      -Monies.new(value, scale, currency)
+    else
+      Monies.new(value, scale, currency)
+    end
+  end
+
+  private
+
+  DIGITS = /\d+/
+
+  POINT = /\./
+
+  COMMA = /,/
+
+  COMMA_TWO_DIGITS = /,\d{2}\b/
+
+  POINT_THINSP = /[\.\u{2009}]/
+
+  MINUS = /-/
+
+  SPACE = /\s/
+
+  def comma_decimal_separator?
+    return true if string =~ COMMA_TWO_DIGITS
+
+    point_index = string =~ POINT
+
+    comma_index = string =~ COMMA
+
+    comma_index && point_index && comma_index > point_index
+  end
+
+  def parse_minus_sign
+    @minus_sign = scan(MINUS)
+  end
+
+  def parse_currency_symbol
+    @currency_symbol = scan(Monies.symbols.keys)
+  end
+
+  def parse_integral_digits
+    parse_minus_sign if @minus_sign.nil?
+
+    @integral_digits = scan(DIGITS)
+
+    while scan(@thousands_separator)
+      @integral_digits += scan(DIGITS)
+    end
+  end
+
+  def parse_fractional_digits
+    @fractional_digits = scan(@decimal_separator) && scan(DIGITS)
+  end
+
+  def parse_space
+    scan(SPACE)
+  end
+
+  def parse_currency_code
+    @currency_code = scan(Monies.symbols.values)
+  end
+end

data/lib/monies/serialization/active_record.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Monies::Serialization::ActiveRecord
+  module ClassMethods
+    def serialize_monies(column, currency: nil)
+      if currency.is_a?(Symbol) && !column_names.include?(currency.to_s)
+        raise RuntimeError, "missing currency column #{currency.inspect}"
+      end
+
+      column_type = columns.find { _1.name == column.to_s }.sql_type_metadata.type
+
+      serialize_monies_attribute(column, column_type, currency)
+    end
+
+    def serialize_monies_string(column)
+      serialize(column, coder: Monies)
+    end
+
+    def predicate_builder
+      @predicate_builder ||= super().tap { _1.register_handler(Monies, PredicateBuilderHandler.new(_1, self)) }
+    end
+  end
+
+  class PredicateBuilderHandler
+    def initialize(predicate_builder, model)
+      @predicate_builder, @model = predicate_builder, model
+    end
+
+    def call(attribute, value)
+      currency = @model.send(:"#{attribute.name}_currency")
+
+      if currency.nil?
+        @predicate_builder.build(attribute, Monies.dump(value))
+      elsif currency.is_a?(String)
+        unless value.nil? || value.currency == currency
+          raise Monies::CurrencyError, "can't serialize #{value.currency} to #{currency}"
+        end
+
+        @predicate_builder.build(attribute, @model.send(:"serialize_#{attribute.name}", value))
+      elsif currency.is_a?(Symbol)
+        Arel::Nodes::And.new([
+          @predicate_builder.build(attribute, @model.send(:"serialize_#{attribute.name}", value)),
+          @predicate_builder[currency, value.currency]
+        ])
+      end
+    end
+  end
+
+  def self.included(model)
+    model.extend Monies::Serialization::ClassMethods
+    model.extend ClassMethods
+  end
+end

data/lib/monies/serialization/sequel.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Monies::Serialization::Sequel
+  module ClassMethods
+    def serialize_monies(column, currency: nil)
+      if currency.is_a?(Symbol) && !columns.include?(currency)
+        raise RuntimeError, "missing currency column #{currency.inspect}"
+      end
+
+      column_type = db_schema.fetch(column).fetch(:type)
+
+      serialize_monies_attribute(column, column_type, currency)
+    end
+
+    def serialize_monies_string(column)
+      require 'sequel/plugins/serialization'
+
+      plugin(:serialization) unless respond_to?(:serialization_map)
+
+      serializer, deserializer = Monies.method(:dump), Monies.method(:load)
+
+      define_serialized_attribute_accessor(serializer, deserializer, column)
+    end
+  end
+
+  module BooleanExpressionPatch
+    def to_s_append(dataset, sql)
+      column, value = args[0], args[1]
+
+      return super(dataset, sql) unless value.is_a?(Monies)
+
+      column = column.value.to_sym if column.is_a?(::Sequel::SQL::Identifier)
+
+      currency = dataset.model.send(:"#{column}_currency")
+
+      sql << '('
+      dataset.literal_append(sql, column)
+      sql << ' ' << op.to_s << ' '
+
+      if currency.nil?
+        dataset.literal_append(sql, Monies.dump(value))
+      elsif currency.is_a?(String)
+        unless value.nil? || value.currency == currency
+          raise Monies::CurrencyError, "can't serialize #{value.currency} to #{currency}"
+        end
+
+        dataset.literal_append(sql, dataset.model.send(:"serialize_#{column}", value))
+      elsif currency.is_a?(Symbol)
+        dataset.literal_append(sql, dataset.model.send(:"serialize_#{column}", value))
+        sql << ' AND '
+        dataset.literal_append(sql, currency)
+        sql << ' = '
+        dataset.literal_append(sql, value.currency)
+      end
+
+      sql << ')'
+    end
+  end
+
+  ::Sequel::SQL::BooleanExpression.class_eval do
+    include BooleanExpressionPatch
+  end
+
+  def self.apply(model)
+    model.extend Monies::Serialization::ClassMethods
+  end
+end

data/lib/monies/serialization.rb

@@ -0,0 +1,58 @@
+module Monies::Serialization
+  autoload :ActiveRecord, 'monies/serialization/active_record'
+  autoload :Sequel, 'monies/serialization/sequel'
+
+  module ClassMethods
+    def serialize_monies_attribute(column, column_type, currency)
+      singleton_class.define_method(:"#{column}_currency") { currency }
+
+      if currency.nil?
+        unless column_type == :string
+          raise ArgumentError, "can't serialize monies to #{column_type} column without currency"
+        end
+
+        return serialize_monies_string(column)
+      elsif currency.is_a?(Symbol)
+        if column_type == :string
+          define_method(:"deserialize_#{column}") { |value| Monies::Digits.load(value, self[currency]) }
+        else
+          define_method(:"deserialize_#{column}") { |value| Monies(value, self[currency]) }
+        end
+
+        define_method(:"#{column}=") do |value|
+          result = super(value.nil? ? nil : self.class.send(:"serialize_#{column}", value))
+          send(:"#{currency}=", value&.currency)
+          result
+        end
+      elsif currency.is_a?(String)
+        if column_type == :string
+          define_method(:"deserialize_#{column}") { |value| Monies::Digits.load(value, currency) }
+        else
+          define_method(:"deserialize_#{column}") { |value| Monies(value, currency) }
+        end
+
+        define_method(:"#{column}=") do |value|
+          unless value.nil? || value.currency == currency
+            raise Monies::CurrencyError, "can't serialize #{value.currency} to #{currency}"
+          end
+
+          super(value.nil? ? nil : self.class.send(:"serialize_#{column}", value))
+        end
+      else
+        raise ArgumentError, "can't serialize monies with #{currency.class} currency"
+      end
+
+      if column_type == :string
+        singleton_class.define_method(:"serialize_#{column}") { |value| Monies::Digits.dump(value) }
+      else
+        singleton_class.define_method(:"serialize_#{column}") { |value| value.to_d }
+      end
+
+      define_method(column) do
+        value = super()
+
+        send(:"deserialize_#{column}", value) unless value.nil?
+      end
+    end
+  end
+end

data/lib/monies/symbols.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Monies::Symbols
+  def initialize
+    @hash, @inverse_hash = Hash.new, Hash.new
+  end
+
+  def keys
+    @keys ||= Regexp.new(@hash.keys.map { Regexp.escape(_1) }.join('|'))
+  end
+
+  def values
+    @values ||= Regexp.new(@hash.values.map { Regexp.escape(_1) }.join('|'))
+  end
+
+  def fetch(key)
+    @hash.fetch(key)
+  end
+  alias_method :[], :fetch
+
+  def fetch_key(value)
+    @inverse_hash.fetch(value)
+  end
+
+  def store(key, value)
+    @hash[key] = value
+
+    @inverse_hash[value] = key
+
+    @keys, @values = nil
+
+    value
+  end
+  alias_method :[]=, :store
+
+  def update(hash)
+    @hash.update(hash)
+
+    @inverse_hash = @hash.invert
+
+    @keys, @values = nil
+
+    self
+  end
+end

data/lib/monies.rb

@@ -0,0 +1,493 @@
+# frozen_string_literal: true
+
+class Monies
+  BASE = 10
+
+  CurrencyError = Class.new(ArgumentError)
+
+  autoload :Digits, 'monies/digits'
+  autoload :Format, 'monies/format'
+  autoload :Parser, 'monies/parser'
+  autoload :Serialization, 'monies/serialization'
+  autoload :Symbols, 'monies/symbols'
+
+  class << self
+    attr_accessor :currency
+    attr_accessor :formats
+    attr_accessor :symbols
+  end
+
+  self.currency = nil
+
+  self.formats = {
+    default: Monies::Format::EN.new,
+    en: Monies::Format::EN.new,
+    eu: Monies::Format::EU.new,
+  }
+
+  self.symbols = Symbols.new.update({
+    '$' => 'USD',
+    '€' => 'EUR',
+    '¥' => 'JPY',
+    '£' => 'GBP',
+    'A$' => 'AUD',
+    'C$' => 'CAD',
+    'CHF' => 'CHF',
+    '元' => 'CNY',
+    'HK$' => 'HKD',
+    'NZ$' => 'NZD',
+    'S$' => 'SGD',
+    '₹' => 'INR',
+    'MX$' => 'MXN',
+  })
+
+  def self.dump(value)
+    return value unless value.is_a?(self)
+
+    "#{Monies::Digits.dump(value)} #{value.currency}"
+  end
+
+  def self.format(value, name = :default, symbol: false, code: false)
+    unless formats.key?(name)
+      raise ArgumentError, "#{name.inspect} is not a valid format"
+    end
+
+    return if value.nil?
+
+    formats[name].call(value, symbol: symbol, code: code)
+  end
+
+  def self.load(string)
+    return if string.nil?
+
+    digits, currency = string.split
+
+    Monies::Digits.load(digits, currency)
+  end
+
+  def self.parse(string)
+    Parser.new(string).parse
+  end
+
+  def self._load(string)
+    value, scale, currency = string.split
+
+    new(value.to_i, scale.to_i, currency)
+  end
+
+  def initialize(value, scale, currency = self.class.currency)
+    unless value.is_a?(Integer)
+      raise ArgumentError, "#{value.inspect} is not a valid value argument"
+    end
+
+    unless scale.is_a?(Integer) && scale >= 0
+      raise ArgumentError, "#{scale.inspect} is not a valid scale argument"
+    end
+
+    unless currency.is_a?(String)
+      raise ArgumentError, "#{currency.inspect} is not a valid currency argument"
+    end
+
+    @value, @scale, @currency = value, scale, currency
+
+    freeze
+  end
+
+  def *(other)
+    if other.is_a?(Integer)
+      return reduce(@value * other, @scale)
+    end
+
+    if other.is_a?(Rational)
+      return self * other.numerator / other.denominator
+    end
+
+    if other.respond_to?(:to_d) && !other.is_a?(self.class)
+      other = other.to_d
+
+      sign, significant_digits, base, exponent = other.split
+
+      value = significant_digits.to_i * sign
+
+      length = significant_digits.length
+
+      if exponent.positive? && length < exponent
+        value *= base ** (exponent - length)
+      end
+
+      scale = other.scale
+
+      return reduce(@value * value, @scale + scale)
+    end
+
+    raise TypeError, "#{self.class} can't be multiplied by #{other.class}"
+  end
+
+  def +(other)
+    if other.respond_to?(:zero?) && other.zero?
+      return self
+    end
+
+    unless other.is_a?(self.class)
+      raise TypeError, "can't add #{other.class} to #{self.class}"
+    end
+
+    unless other.currency == @currency
+      raise CurrencyError, "can't add #{other.currency} to #{@currency}"
+    end
+
+    add(other)
+  end
+
+  def -(other)
+    if other.respond_to?(:zero?) && other.zero?
+      return self
+    end
+
+    unless other.is_a?(self.class)
+      raise TypeError, "can't subtract #{other.class} from #{self.class}"
+    end
+
+    unless other.currency == @currency
+      raise CurrencyError, "can't subtract #{other.currency} from #{@currency}"
+    end
+
+    add(-other)
+  end
+
+  def -@
+    self.class.new(-@value, @scale, @currency)
+  end
+
+  def /(other)
+    div(other)
+  end
+
+  def <=>(other)
+    if other.is_a?(self.class)
+      unless other.currency == @currency
+        raise CurrencyError, "can't compare #{other.currency} with #{@currency}"
+      end
+
+      value, other_value = @value, other.value
+
+      if other.scale > @scale
+        value *= BASE ** (other.scale - @scale)
+      elsif other.scale < @scale
+        other_value *= BASE ** (@scale - other.scale)
+      end
+
+      value <=> other_value
+    elsif other.respond_to?(:zero?) && other.zero?
+      @value <=> other
+    end
+  end
+
+  include Comparable
+
+  def _dump(_level)
+    "#{@value} #{@scale} #{@currency}"
+  end
+
+  def abs
+    return self unless negative?
+
+    self.class.new(@value.abs, @scale, @currency)
+  end
+
+  def ceil(digits = 0)
+    round(digits, :ceil)
+  end
+
+  def coerce(other)
+    unless other.respond_to?(:zero?) && other.zero?
+      raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+    end
+
+    return self, other
+  end
+
+  def convert(other, currency = nil)
+    if other.is_a?(self.class)
+      unless currency.nil?
+        raise ArgumentError, "#{self.class} can't be converted with #{other.class} and currency argument"
+      end
+
+      return self if @currency == other.currency
+
+      return other * to_r
+    end
+
+    if other.is_a?(Integer) || other.is_a?(Rational)
+      return Monies(to_r * other, currency || Monies.currency)
+    end
+
+    if defined?(BigDecimal) && other.is_a?(BigDecimal)
+      return Monies(to_d * other, currency || Monies.currency)
+    end
+
+    raise TypeError, "#{self.class} can't be converted with #{other.class}"
+  end
+
+  def currency
+    @currency
+  end
+
+  def div(other, digits = 16)
+    unless digits.is_a?(Integer) && digits >= 1
+      raise ArgumentError, 'digits must be greater than or equal to 1'
+    end
+
+    if other.respond_to?(:zero?) && other.zero?
+      raise ZeroDivisionError, 'divided by 0'
+    end
+
+    if other.is_a?(self.class)
+      unless other.currency == @currency
+        raise CurrencyError, "can't divide #{@currency} by #{other.currency}"
+      end
+
+      scale = @scale - other.scale
+
+      if scale.negative?
+        return divide(@value * BASE ** scale.abs, 0, other.value, digits)
+      else
+        return divide(@value, scale, other.value, digits)
+      end
+    end
+
+    if other.is_a?(Integer)
+      return divide(@value, @scale, other, digits)
+    end
+
+    if other.is_a?(Rational)
+      return self * other.denominator / other.numerator
+    end
+
+    if defined?(BigDecimal) && other.is_a?(BigDecimal)
+      return self / Monies(other, @currency)
+    end
+
+    raise TypeError, "#{self.class} can't be divided by #{other.class}"
+  end
+
+  def floor(digits = 0)
+    round(digits, :floor)
+  end
+
+  def inspect
+    "#<#{self.class.name}: #{Monies::Digits.dump(self)} #{@currency}>"
+  end
+
+  def negative?
+    @value.negative?
+  end
+
+  def nonzero?
+    !@value.zero?
+  end
+
+  def positive?
+    @value.positive?
+  end
+
+  def precision
+    return 0 if @value.zero?
+
+    @value.to_s.length
+  end
+
+  def round(digits = 0, mode = :default, half: nil)
+    if half == :up
+      mode = :half_up
+    elsif half == :down
+      mode = :half_down
+    elsif half == :even
+      mode = :half_even
+    elsif !half.nil?
+      raise ArgumentError, "invalid rounding mode: #{half.inspect}"
+    end
+
+    case mode
+    when :banker, :ceil, :ceiling, :default, :down, :floor, :half_down, :half_even, :half_up, :truncate, :up
+    else
+      raise ArgumentError, "invalid rounding mode: #{mode.inspect}"
+    end
+
+    if digits >= @scale
+      return self
+    end
+
+    n = @scale - digits
+
+    array = @value.abs.digits
+
+    digit = array[n - 1]
+
+    case mode
+    when :ceiling, :ceil
+      round_digits!(array, n) if @value.positive?
+    when :floor
+      round_digits!(array, n) if @value.negative?
+    when :half_down
+      round_digits!(array, n) if (digit > 5 || (digit == 5 && n > 1))
+    when :half_even, :banker
+      round_digits!(array, n) if (digit > 5 || (digit == 5 && n > 1)) || digit == 5 && n == 1 && array[n].odd?
+    when :half_up, :default
+      round_digits!(array, n) if digit >= 5
+    when :up
+      round_digits!(array, n)
+    end
+
+    n.times { |i| array[i] = nil }
+
+    value = array.reverse.join.to_i
+
+    value = -value if @value.negative?
+
+    if digits.zero?
+      self.class.new(value, 0, currency)
+    else
+      reduce(value, digits)
+    end
+  end
+
+  def scale
+    @scale
+  end
+
+  def to_d
+    BigDecimal(Monies::Digits.dump(self))
+  end
+
+  def to_i
+    @value / BASE ** @scale
+  end
+
+  def to_r
+    Rational(@value, BASE ** @scale)
+  end
+
+  alias to_s inspect
+
+  def truncate(digits = 0)
+    return self if digits >= @scale
+
+    reduce(@value / BASE ** (@scale - digits), digits)
+  end
+
+  def value
+    @value
+  end
+
+  def zero?
+    @value.zero?
+  end
+
+  private
+
+  def divide(value, scale, divisor, max_scale)
+    quotient, carry = 0, 0
+
+    value.digits.reverse_each do |digit|
+      dividend = carry + digit
+
+      quotient = (quotient * BASE) + (dividend / divisor)
+
+      carry = (dividend % divisor) * BASE
+    end
+
+    iterations = max_scale - scale
+
+    until iterations.zero? || carry.zero?
+      dividend = carry
+
+      quotient = (quotient * BASE) + (dividend / divisor)
+
+      carry = (dividend % divisor) * BASE
+
+      scale += 1
+
+      iterations -= 1
+    end
+
+    self.class.new(quotient, scale, @currency)
+  end
+
+  def add(other)
+    value, other_value = @value, other.value
+
+    if other.scale > @scale
+      value *= BASE ** (other.scale - @scale)
+
+      scale = other.scale
+    else
+      scale = @scale
+    end
+
+    if other.scale < @scale
+      other_value *= BASE ** (@scale - other.scale)
+    end
+
+    value += other_value
+
+    reduce(value, scale)
+  end
+
+  def reduce(value, scale)
+    while scale > 0 && value.nonzero? && (value % BASE).zero?
+      value = value / BASE
+
+      scale -= 1
+    end
+
+    self.class.new(value, scale, @currency)
+  end
+
+  def round_digits!(array, index)
+    if index == array.size
+      array << 1
+    else
+      digit = array[index]
+
+      if digit == 9
+        array[index] = 0
+
+        round_digits!(array, index + 1)
+      else
+        array[index] += 1
+      end
+    end
+  end
+end
+
+def Monies(object, currency = Monies.currency)
+  case object
+  when Monies
+    object
+  when Integer
+    Monies.new(object, 0, currency)
+  when Rational
+    Monies.new(object.numerator, 0, currency) / object.denominator
+  when String
+    Monies::Digits.load(object, currency)
+  else
+    if defined?(BigDecimal) && object.is_a?(BigDecimal)
+      sign, significant_digits, base, exponent = object.split
+
+      value = significant_digits.to_i * sign
+
+      length = significant_digits.length
+
+      if exponent.positive? && length < exponent
+        value *= base ** (exponent - length)
+      end
+
+      scale = object.scale
+
+      return Monies.new(value, scale, currency)
+    end
+
+    raise TypeError, "can't convert #{object.inspect} into #{Monies}"
+  end
+end

data/monies.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name = 'monies'
+  s.version = '1.0.0'
+  s.license = 'LGPL-3.0'
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Tim Craft']
+  s.email = ['email@timcraft.com']
+  s.homepage = 'https://github.com/readysteady/monies'
+  s.description = 'Ruby gem for representing monetary values'
+  s.summary = 'See description'
+  s.files = Dir.glob('lib/**/*.rb') + %w[LICENSE.txt README.md monies.gemspec]
+  s.required_ruby_version = '>= 3.1.0'
+  s.require_path = 'lib'
+  s.metadata = {
+    'homepage' => 'https://github.com/readysteady/monies',
+    'source_code_uri' => 'https://github.com/readysteady/monies',
+    'bug_tracker_uri' => 'https://github.com/readysteady/monies/issues',
+  }
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: monies
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tim Craft
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Ruby gem for representing monetary values
+email:
+- email@timcraft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/monies.rb
+- lib/monies/digits.rb
+- lib/monies/format.rb
+- lib/monies/parser.rb
+- lib/monies/serialization.rb
+- lib/monies/serialization/active_record.rb
+- lib/monies/serialization/sequel.rb
+- lib/monies/symbols.rb
+- monies.gemspec
+homepage: https://github.com/readysteady/monies
+licenses:
+- LGPL-3.0
+metadata:
+  homepage: https://github.com/readysteady/monies
+  source_code_uri: https://github.com/readysteady/monies
+  bug_tracker_uri: https://github.com/readysteady/monies/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: See description
+test_files: []