minting-rails 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dddd6623b7e46d60d0e8e29da21afa581d28c6818ae4d37d5a5c1268da04425f
-  data.tar.gz: 4e6c1fa638f4f22c365d0cc5bc6540c9dccbdc770e8550f10c4ce94c4150088d
+  metadata.gz: bebeb146f003c49cd0f1c667648090a35f96d5d22edfec3c6616f5f45d812988
+  data.tar.gz: f6084d3f41dce76e7b437505566a1a606f54a92419cac641e017d33a9a2d0400
 SHA512:
-  metadata.gz: 0e0a4ff1d7dd9a0ccb543545b75740567d0c985e174bd6e1460e44f08a74bd9f0b68a016e42374bcfb83d859bdb253afb2941fcb1d0ac3d4a6507574802b8dc0
-  data.tar.gz: '09b31cae39bb1d85c3f34fe8c077406874fb8ebd429f37bb2347555fa8fef486685601ec45d06791ac8c7ebce1d8d2a87e7efcd8d46e2aad3c519226210799f5'
+  metadata.gz: 46539fbf075c057d2fb2727320975b13dd20f5efbe5a0ad2955d51f78f1720ecb4e9a3e7f52c9428f798dabf13a04a258403df6fe0735fff901a0c8e6e2ccf08
+  data.tar.gz: 66528813c392c867719ea9dcecf24fbc78a8bdd9fe9b234d6ca82c201b6d6da533ebd3058b0610223def05344e10843505a3c30fe13d65acd5593717b2d8fce2

data/README.md

@@ -166,6 +166,68 @@ offer.price_currency
 # => "EUR"
 ```
 
+### Integer storage
+
+By default, money attributes are stored as `decimal` columns. If you prefer to store amounts as integer subunits (cents, pence, etc.), use a `bigint` or `integer` column instead. Minting::Rails detects the column type automatically and adapts serialization accordingly.
+
+Migration:
+
+```ruby
+class CreateOrders < ActiveRecord::Migration[7.1]
+  def change
+    create_table :orders do |t|
+      t.bigint  :total_amount
+      t.string  :total_currency
+
+      t.timestamps
+    end
+  end
+end
+```
+
+Model:
+
+```ruby
+class Order < ApplicationRecord
+  money_attribute :total
+end
+```
+
+The amount is stored and retrieved in subunits:
+
+```ruby
+order = Order.new(total: 19.99.to_money(:USD))
+
+order.total
+# => #<Mint::Money ... USD 19.99>
+
+order.total_amount
+# => 1999
+
+order.total_currency
+# => "USD"
+```
+
+The same applies to single-column fixed-currency attributes:
+
+```ruby
+class Ticket < ApplicationRecord
+  money_attribute :price, currency: 'USD'
+end
+```
+
+Migration:
+
+```ruby
+t.bigint :price
+```
+
+No model change is needed. The column type drives the behavior.
+
+> **Note:** Integer storage avoids decimal rounding issues and is more efficient for large tables. 
+
+### Default Currency
+
 When you assign a plain number or string, Minting::Rails uses `Mint.default_currency`:
 
 ```ruby

data/lib/minting/money_attribute/configuration.rb

@@ -27,11 +27,10 @@ module Mint
   end
 
   def self.assert_valid_currency!(currency)
-    code = currency.is_a?(Mint::Currency) ? currency.code : currency.to_s
-    currency = Mint.currency(code)
+    currency = Mint.currency(currency)
     return currency if Mint.valid_currency?(currency)
 
-    raise ArgumentError, "Invalid currency '#{code}'. Please select a registered currency"
+    raise ArgumentError, "Invalid currency '#{currency}'. Please select a registered currency"
   end
 
   def self.default_currency
@@ -39,11 +38,7 @@ module Mint
   end
 
   def self.valid_currency?(currency)
-    return false if currency.nil?
-
-    code = currency.is_a?(Mint::Currency) ? currency.code : currency.to_s
-    currencies = config.enabled_currencies == :all ? Mint.currencies.keys : config.enabled_currencies
-
-    currencies.map(&:to_s).include?(code)
+    enabled = config.enabled_currencies
+    currency && (enabled == :all || enabled.include?(currency.code))
   end
 end

data/lib/minting/money_attribute/money_attribute.rb

@@ -9,7 +9,7 @@ module Mint
       # Money attribute
       def money_attribute(name, currency: Mint.default_currency, mapping: nil)
         currency = Mint.assert_valid_currency!(currency)
-        parser = proc { |amount, code = currency| MoneyAttribute.parse(amount, code) }
+        parser = Parser.new(currency)
         if attribute_names.include? name.to_s
           attribute(name, :mint_money, currency:)
           normalizes(name, with: parser)
@@ -18,12 +18,28 @@ module Mint
           options = {
             allow_nil: true, class_name: 'Mint::Money',
             constructor: parser, converter: parser,
-            mapping: { aggregated[:amount] => :to_i, aggregated[:currency] => :currency_code }
+            mapping: {
+              aggregated[:amount] => amount_extractor_for(aggregated[:amount]),
+              aggregated[:currency] => :currency_code
+            }
           }
           composed_of(name, options)
         end
       end
 
+      def amount_extractor_for(column_name)
+        col = columns.find { |c| c.name == column_name.to_s }
+
+        case col&.type
+        when :bigint, :integer
+          :fractional
+        when :decimal, :numeric
+          :to_d
+        else
+          :to_d # :decimal, :numeric, unknown
+        end
+      end
+
       def find_money_attributes(name, mapping:)
         composite = if mapping.present?
                       { amount: mapping.key(:amount).to_s, currency: mapping.key(:currency).to_s }
@@ -37,25 +53,5 @@ module Mint
         composite
       end
     end
-
-    def self.parse(amount, currency)
-      money = case amount
-              when NilClass
-                nil
-              when Mint::Money
-                amount
-              when Numeric
-                Mint.money(amount, currency)
-              else
-                if amount.respond_to? :to_money
-                  amount.to_money(currency)
-                else
-                  Mint.money(amount.to_s.split[0].to_r, currency)
-                end
-              end
-      # puts "parse(#{amount}, #{currency.inspect}) => #{money.inspect}"
-      Mint.assert_valid_currency!(currency)
-      money
-    end
   end
 end

data/lib/minting/money_attribute/money_type.rb

@@ -3,31 +3,43 @@
 module Mint
   # MintMoneyType
   class MintMoneyType < ActiveRecord::Type::Value
-    def initialize(currency:)
-      @currency = Mint.currency currency
+    def initialize(currency:, column_type: ActiveRecord::Type::Decimal.new)
+      @currency = currency
+      @column_type = column_type
       super()
     end
 
     def assert_valid_value(value)
       case value
-      when NilClass, Numeric, String
-        return
+      when NilClass, Numeric, String then return
       when Mint::Money
         return if value.currency == @currency
 
         message = "'#{value.inspect}' has different currency. Only #{@currency.code} allowed."
       else
-        message = "'#{value}' is not a valid type for the attribute."
+        message = "'#{value.inspect}' is not a valid type for the attribute."
       end
       raise ArgumentError, message
     end
 
     def deserialize(value)
-      value && Mint.money(value, @currency)
+      return nil unless value
+
+      if @column_type.is_a?(ActiveRecord::Type::Integer)
+        Mint.money(value * @currency.multiplier, @currency)
+      else
+        Mint.money(value, @currency)
+      end
     end
 
     def serialize(value)
-      value&.to_d
+      return nil unless value
+
+      if @column_type.is_a?(ActiveRecord::Type::Integer)
+        value.fractional
+      else
+        value.to_d
+      end
     end
 
     def self.type

data/lib/minting/money_attribute/parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mint
+  # MoneyAttribute
+  module MoneyAttribute
+    class Parser
+      def initialize(currency)
+        @default_currency = currency
+      end
+
+      def call(amount, currency = @default_currency)
+        currency = Mint.assert_valid_currency!(currency)
+        case amount
+        when NilClass    then nil
+        when Mint::Money then amount
+        when Numeric     then Mint::Money.create(amount, currency)
+        when String      then Mint::Money.create(amount.to_r, currency)
+        else
+          if amount.respond_to? :to_money
+            amount.to_money(currency)
+          else
+            Mint.parse(amount, currency)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minting/money_attribute/version.rb

@@ -2,6 +2,6 @@
 
 module Mint
   module MoneyAttribute
-    VERSION = '0.4.5'
+    VERSION = '0.5.0'
   end
 end

data/lib/minting/rails.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'minting'
-require 'minting/money_attribute/core_ext'
+require 'minting/core_ext'
 require 'minting/money_attribute/configuration'
 require 'minting/money_attribute/money_attribute'
 require 'minting/money_attribute/money_type'
+require 'minting/money_attribute/parser'
 require 'minting/money_attribute/version'
 require 'minting/railties'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minting-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Gilson Ferraz
@@ -49,10 +49,11 @@ files:
 - Rakefile
 - lib/generators/minting/initializer_generator.rb
 - lib/generators/templates/minting.rb
+- lib/minting/core_ext.rb
 - lib/minting/money_attribute/configuration.rb
-- lib/minting/money_attribute/core_ext.rb
 - lib/minting/money_attribute/money_attribute.rb
 - lib/minting/money_attribute/money_type.rb
+- lib/minting/money_attribute/parser.rb
 - lib/minting/money_attribute/version.rb
 - lib/minting/rails.rb
 - lib/minting/railties.rb