money-rails 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 17a8dc1cf4b600e6893a143ea21e6a9bef017371
-  data.tar.gz: 21aa33f3cace05847f66f822b88b46059752ed99
+SHA256:
+  metadata.gz: 8226863e954671b603c22fac3eae1667b81ba88eb3425b8c9cd798e2cfa2f303
+  data.tar.gz: cc9c7c8fbc27bcc9343ad457f596b15594a576d0da93448d3bfbabe1caedcfbb
 SHA512:
-  metadata.gz: 3d8d1a12dccd30071f5e269b679b55a733fb2eaedf9ed694ed8dcd9c02ff95315293fe97387559e5d891240489f79c9acd57b79861a49c68cf6eeab387f5a032
-  data.tar.gz: 87e4fd7469311f179282531901437773316083fb695dc12003f5767d9d61c9a40cb06d553f7cdc17e4246dbbbb5b0d10973a64417bd602ee8060ddb7c42d9fa3
+  metadata.gz: 0ed641980d3b776a3b2ec80d9ff1e7247415248eeff0bdc3fbc7077ad7700171fdcbda6c4c13bf39c2cda063a9fdf2575b660f9625fb506e8d39a815b96ab02f
+  data.tar.gz: 301fbd73c779ac54d60e1be7137df6e0a89974b0372d1667fe9eb69c2a8e40c309768bcda6d885f1d6e7168512d2e62a61562ea2189dcd1bba14c53d58b1b891

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 1.14.0
+
+- Tweaks to support Ruby 3.0
+
+## 1.13.4
+
+- Fix validator race condition
+- Add Danish translation for errors
+- Change Money fields to Decimal in Rails Admin
+- Run hooks after active_record.initialize_database
+- Add optional currency argument to "#currency_symbol" helper
+- Rails 6.1 support
+
+## 1.13.3
+
+- Add Money#to_hash for JSON serialization
+- Update initializer template with #locale_backend config
+- Rollback support for remove_monetize / remove_money DB helpers
+- Rails 6 support
+
+## 1.13.2
+
+- Make validation compatible with Money.locale_backend
+
+## 1.13.1
+
+- Add a guard clause for "blank form" input (Mongoid)
+- Do not add extra errors in case attribute is not a number
+- Use Money.locale_backend instead of Money.use_i18n
+- Add money_only_cents helper method
+
 ## 1.13.0
 
 - Bump money version to ~> 6.13.0

data/LICENSE

@@ -1,22 +1,22 @@
-Copyright (c) 2012 Andreas Loupasakis
-
 MIT License
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Copyright (c) 2012 Andreas Loupasakis
+Copyright (c) 2021 Shane Emmons
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -116,7 +116,7 @@ end
 
 Notice. Default value of currency field, generated by migration's helper, is USD. To override these defaults, you need change default_currency in money initializer and run migrations.
 
-The ```add_money``` helper is reversible, so you an use it inside ```change```
+The ```add_money``` helper is reversible, so you can use it inside ```change```
 migrations.  If you're writing separate ```up``` and ```down``` methods, you
 can use the ```remove_money``` helper.
 
@@ -306,7 +306,7 @@ object using EUR as their currency, instead of the default USD.
 
 By passing the option ```:with_currency``` to the ```monetize``` macro call,
 with a currency code (symbol or string) or a callable object (object that responds to the method ```call```) that returns a currency code, as its value, you can define a currency in a more granular
-way. This will you attach the given currency only to the specified monetized model
+way. This will let you attach the given currency only to the specified monetized model
 attribute (allowing you to, for example, monetize different attributes of the same model with different currencies.).
 
 This allows you to override both the model level and the global
@@ -326,7 +326,7 @@ end
 ```
 
 In this case ```product.bonus``` will return a Money object with GBP as its
-currency, whereas ```product.discount.currency_as_string # => EUR ```
+currency, whereas ```product.discount.currency.to_s # => EUR ```
 
 As mentioned earlier you can use an object that responds to the method ```call``` and accepts the model instance as a parameter. That means you can use a ```Proc``` or ```lambda``` (we would recommend ```lambda``` over ```Proc``` because of their [different control flow characteristics](https://stackoverflow.com/questions/1740046/whats-the-difference-between-a-proc-and-a-lambda-in-ruby)) or even define a separate ```class``` with an instance or class method (maybe even a ```module```) to return the currency code:
 
@@ -502,6 +502,7 @@ _For examples below, `@money_object == <Money fractional:650 currency:USD>`_
 | `humanized_money_with_symbol @money_object`           | $6.50                                     |
 | `money_without_cents @money_object`                   | 6                                         |
 | `money_without_cents_and_with_symbol @money_object`   | $6                                        |
+| `money_only_cents @money_object`                      | 50                                        |
 
 #### `no_cents_if_whole`
 
@@ -552,7 +553,7 @@ For examples on using the test_helpers look at
 ## Supported ORMs/ODMs
 
 * ActiveRecord (>= 3.x)
-* Mongoid (2.x, 3.x)
+* Mongoid (>= 2.x)
 
 ## Supported Ruby interpreters
 
@@ -586,4 +587,4 @@ If you are testing against mongoid, make sure to have the mongod process running
 
 ## License
 
-MIT License. Copyright 2012-2014 RubyMoney.
+MIT License. Copyright 2021 RubyMoney.

data/Rakefile

@@ -55,6 +55,13 @@ namespace :spec do
     framework, version = file_name.split(/(\d+)/)
     major, minor = version.split(//)
 
+    # Ruby 3 exclusions
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0')
+      # Rails 5 does not support ruby-3.0.0 https://github.com/rails/rails/issues/40938#issuecomment-751569171
+      # Mongoid gem does not yet support ruby-3.0.0 https://github.com/mongodb/mongoid#compatibility
+      next if framework == 'mongoid' || (framework == 'rails' && version == "5")
+    end
+
     frameworks_versions[framework] ||= []
     frameworks_versions[framework] << file_name
 

data/config/locales/money.da.yml

@@ -0,0 +1,4 @@
+da:
+  errors:
+    messages:
+      invalid_currency: skal være en gyldig valuta  (f.eks. '100', '5%{decimal}24', eller '123%{thousands}456%{decimal}78'). Fik %{currency}

data/lib/generators/templates/money.rb

@@ -83,6 +83,29 @@ MoneyRails.configure do |config|
   #   sign_before_symbol: nil
   # }
 
+  # If you would like to use I18n localization (formatting depends on the
+  # locale):
+  # config.locale_backend = :i18n
+  #
+  # Example (using default localization from rails-i18n):
+  #
+  # I18n.locale = :en
+  # Money.new(10_000_00, 'USD').format # => $10,000.00
+  # I18n.locale = :es
+  # Money.new(10_000_00, 'USD').format # => $10.000,00
+  #
+  # For the legacy behaviour of "per currency" localization (formatting depends
+  # only on currency):
+  # config.locale_backend = :currency
+  #
+  # Example:
+  # Money.new(10_000_00, 'USD').format # => $10,000.00
+  # Money.new(10_000_00, 'EUR').format # => €10.000,00
+  #
+  # In case you don't need localization and would like to use default values
+  # (can be redefined using config.default_format):
+  # config.locale_backend = nil
+
   # Set default raise_error_on_money_parsing option
   # It will be raise error if assigned different currency
   # The default value is false

data/lib/money-rails/active_model/validator.rb

@@ -1,113 +1,108 @@
 module MoneyRails
   module ActiveModel
     class MoneyValidator < ::ActiveModel::Validations::NumericalityValidator
-      def validate_each(record, attr, _value)
-        reset_memoized_variables!
-        @record = record
-        @attr = attr
+      class Details < Struct.new(:raw_value, :thousands_separator, :decimal_mark)
+        def abs_raw_value
+          @abs_raw_value ||= raw_value.to_s.sub(/^\s*-/, "").strip
+        end
+
+        def decimal_pieces
+          @decimal_pieces ||= abs_raw_value.split(decimal_mark)
+        end
+      end
 
-        subunit_attr = @record.class.monetized_attributes[@attr.to_s]
+      def validate_each(record, attr, _value)
+        subunit_attr = record.class.monetized_attributes[attr.to_s]
+        currency = record.public_send("currency_for_#{attr}")
 
         # WARNING: Currently this is only defined in ActiveRecord extension!
-        before_type_cast = :"#{@attr}_money_before_type_cast"
-        @raw_value = @record.try(before_type_cast)
+        before_type_cast = :"#{attr}_money_before_type_cast"
+        raw_value = record.try(before_type_cast)
 
         # If raw value is nil and changed subunit is nil, then
         # nil is a assigned value, else we should treat the
         # subunit value as the one assigned.
-        if @raw_value.nil? && @record.public_send(subunit_attr)
-          subunit_value = @record.public_send(subunit_attr)
-          @raw_value = subunit_value.to_f / currency.subunit_to_unit
+        if raw_value.nil? && record.public_send(subunit_attr)
+          subunit_value = record.public_send(subunit_attr)
+          raw_value = subunit_value.to_f / currency.subunit_to_unit
         end
 
-        return if options[:allow_nil] && @raw_value.nil?
+        return if options[:allow_nil] && raw_value.nil?
 
-        # Set this before we modify @raw_value below.
-        stringy = @raw_value.present? && !@raw_value.is_a?(Numeric) && !@raw_value.is_a?(Money)
+        # Set this before we modify raw_value below.
+        stringy = raw_value.present? && !raw_value.is_a?(Numeric) && !raw_value.is_a?(Money)
 
         if stringy
+          # TODO: This is supporting legacy behaviour where a symbol can come from a i18n locale,
+          #       however practical implications of that are most likely non-existent
+          symbol = lookup(:symbol, currency) || currency.symbol
+
           # remove currency symbol
-          @raw_value = @raw_value.to_s.gsub(symbol, "")
+          raw_value = raw_value.to_s.gsub(symbol, "")
         end
 
-        normalize_raw_value!
-        super(@record, @attr, @raw_value)
-
-        if stringy && record_does_not_have_error?
-          add_error if
-            value_has_too_many_decimal_points ||
-            thousand_separator_after_decimal_mark ||
-            invalid_thousands_separation
-        end
-      end
+        # Cache abs_raw_value before normalizing because it's used in
+        # many places and relies on the original raw_value.
+        details = generate_details(raw_value, currency)
+        normalized_raw_value = normalize(details)
 
-      private
+        super(record, attr, normalized_raw_value)
 
-      def record_does_not_have_error?
-        return true unless @record.errors.has_key?(@attr)
-        !@record.errors.added?(@attr, :not_a_number)
-      end
+        return unless stringy
+        return if record_already_has_error?(record, attr, normalized_raw_value)
 
-      def reset_memoized_variables!
-        [:currency, :decimal_mark, :thousands_separator, :symbol,
-          :abs_raw_value, :decimal_pieces, :pieces_array].each do |var_name|
-          ivar_name = :"@_#{var_name}"
-          remove_instance_variable(ivar_name) if instance_variable_defined?(ivar_name)
-        end
+        add_error!(record, attr, details) if
+          value_has_too_many_decimal_points(details) ||
+          thousand_separator_after_decimal_mark(details) ||
+          invalid_thousands_separation(details)
       end
 
-      def currency
-        @_currency ||= @record.public_send("currency_for_#{@attr}")
-      end
+      private
 
-      def decimal_mark
-        character = currency.decimal_mark || '.'
-        @_decimal_mark ||= Money.use_i18n ? I18n.t('number.currency.format.separator', default: character) : character
-      end
+      DEFAULTS = {
+        decimal_mark: '.',
+        thousands_separator: ','
+      }.freeze
 
-      def thousands_separator
-        character = currency.thousands_separator || ','
-        @_thousands_separator ||= Money.use_i18n ? I18n.t('number.currency.format.delimiter', default: character) : character
-      end
+      def generate_details(raw_value, currency)
+        thousands_separator = lookup(:thousands_separator, currency)
+        decimal_mark = lookup(:decimal_mark, currency)
 
-      def symbol
-        @_symbol ||= Money.use_i18n ? I18n.t('number.currency.format.unit', default: currency.symbol) : currency.symbol
+        Details.new(raw_value, thousands_separator, decimal_mark)
       end
 
-      def abs_raw_value
-        @_abs_raw_value ||= @raw_value.to_s.sub(/^\s*-/, "").strip
+      def record_already_has_error?(record, attr, raw_value)
+        record.errors.added?(attr, :not_a_number, value: raw_value)
       end
 
-      def add_error
-        attr_name = @attr.to_s.tr('.', '_').humanize
-        attr_name = @record.class.human_attribute_name(@attr, default: attr_name)
+      def add_error!(record, attr, details)
+        attr_name = attr.to_s.tr('.', '_').humanize
+        attr_name = record.class.human_attribute_name(attr, default: attr_name)
 
-        @record.errors.add(@attr, :invalid_currency,
-                           { thousands: thousands_separator,
-                             decimal: decimal_mark,
-                             currency: abs_raw_value,
-                             attribute: attr_name })
+        record.errors.add(attr, :invalid_currency,
+          thousands: details.thousands_separator,
+          decimal: details.decimal_mark,
+          currency: details.abs_raw_value,
+          attribute: attr_name
+        )
       end
 
-      def decimal_pieces
-        @_decimal_pieces ||= abs_raw_value.split(decimal_mark)
+      def value_has_too_many_decimal_points(details)
+        ![1, 2].include?(details.decimal_pieces.length)
       end
 
-      def value_has_too_many_decimal_points
-        ![1, 2].include?(decimal_pieces.length)
+      def thousand_separator_after_decimal_mark(details)
+        details.thousands_separator.present? &&
+          details.decimal_pieces.length == 2 &&
+          details.decimal_pieces[1].include?(details.thousands_separator)
       end
 
-      def pieces_array
-        @_pieces_array ||= decimal_pieces[0].split(thousands_separator.presence)
-      end
+      def invalid_thousands_separation(details)
+        pieces_array = details.decimal_pieces[0].split(details.thousands_separator.presence)
 
-      def thousand_separator_after_decimal_mark
-        thousands_separator.present? && decimal_pieces.length == 2 && decimal_pieces[1].include?(thousands_separator)
-      end
-
-      def invalid_thousands_separation
         return false if pieces_array.length <= 1
         return true  if pieces_array[0].length > 3
+
         pieces_array[1..-1].any? do |thousands_group|
           thousands_group.length != 3
         end
@@ -115,16 +110,25 @@ module MoneyRails
 
       # Remove thousands separators, normalize decimal mark,
       # remove whitespaces and _ (E.g. 99 999 999 or 12_300_200.20)
-      def normalize_raw_value!
-        # Cache abs_raw_value before normalizing because it's used in
-        # many places and relies on the original @raw_value.
-        abs_raw_value
-
-        @raw_value = @raw_value.to_s
-          .gsub(thousands_separator, '')
-          .gsub(decimal_mark, '.')
+      def normalize(details)
+        details.raw_value
+          .to_s
+          .gsub(details.thousands_separator, '')
+          .gsub(details.decimal_mark, '.')
           .gsub(/[\s_]/, '')
       end
+
+      def lookup(key, currency)
+        if locale_backend
+          locale_backend.lookup(key, currency) || DEFAULTS[key]
+        else
+          DEFAULTS[key]
+        end
+      end
+
+      def locale_backend
+        Money.locale_backend
+      end
     end
   end
 end

data/lib/money-rails/active_record/migration_extensions/schema_statements_pg_rails4.rb

@@ -5,14 +5,15 @@ module MoneyRails
         def add_monetize(table_name, accessor, options={})
           [:amount, :currency].each do |attribute|
             column_present, *opts = OptionsExtractor.extract attribute, table_name, accessor, options
-            add_column(*opts) if column_present
+            constraints = opts.pop
+            add_column(*opts, **constraints) if column_present
           end
         end
 
         def remove_monetize(table_name, accessor, options={})
           [:amount, :currency].each do |attribute|
-            column_present, table_name, column_name, _, _ =  OptionsExtractor.extract attribute, table_name, accessor, options
-            remove_column table_name, column_name if column_present
+            column_present, table_name, column_name, type, _ =  OptionsExtractor.extract attribute, table_name, accessor, options
+            remove_column table_name, column_name, type if column_present
           end
         end
       end

data/lib/money-rails/active_record/migration_extensions/table_pg_rails4.rb

@@ -5,7 +5,8 @@ module MoneyRails
         def monetize(accessor, options={})
           [:amount, :currency].each do |attribute|
             column_present, _, *opts = OptionsExtractor.extract attribute, :no_table, accessor, options
-            column(*opts) if column_present
+            constraints = opts.pop
+            column(*opts, **constraints) if column_present
           end
         end
 

data/lib/money-rails/active_record/monetizable.rb

@@ -209,7 +209,7 @@ module MoneyRails
 
         if MoneyRails::Configuration.preserve_user_input
           value_before_type_cast = instance_variable_get "@#{name}_money_before_type_cast"
-          if errors[name.to_sym].present?
+          if errors.has_key?(name.to_sym)
             result.define_singleton_method(:to_s) { value_before_type_cast }
             result.define_singleton_method(:format) { |_| value_before_type_cast }
           end

data/lib/money-rails/configuration.rb

@@ -7,7 +7,6 @@ module MoneyRails
   # MoneyRails configuration module.
   # This is extended by MoneyRails to provide configuration settings.
   module Configuration
-
     # Start a MoneyRails configuration block in an initializer.
     #
     # example: Provide a default currency for the application
@@ -59,7 +58,7 @@ module MoneyRails
     #   MoneyRails.configure do |config|
     #     config.default_bank = EuCentralBank.new
     #   end
-    delegate :default_bank=, :default_bank, to: :Money
+    delegate :default_bank=, :default_bank, :locale_backend, :locale_backend=, to: :Money
 
     # Provide exchange rates
     delegate :add_rate, to: :Money