money-rails 1.12.0 → 1.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 06fe320d8e4a586f4c77666ad7b84724dda8131d
-  data.tar.gz: 78fa897739471e33e09f80a25ae127284434041f
+SHA256:
+  metadata.gz: 618663a78af12610ff9901dd5ed3b3e5e5bf74d6d24b65141a52b2811179a0d8
+  data.tar.gz: 0724c64933122f73af34f1ad606c309e40c224a8b8636053ca437145527a8490
 SHA512:
-  metadata.gz: 770d0661ee7e420da951020b5b63ad584d3e6d211e129855d0994f95f8a4a45f31df1ca0f4724855f757d5ab8afc417ab354f2bf8c4e3e8f8c7c065e6deebb6f
-  data.tar.gz: 2d78aec95f0f07fbf2bfbf7d12d08ff8f7d938fb4337536de8377dba0305d7c53315d9053fb1eca66940fceec3a82a5a708edde784d1ce6cf5563e5cf3114dde
+  metadata.gz: d0b87a85f4fe133e3fc75d75722c42dbb445c05cc98ebe7d242d8b63a27d8b879d324d37a8ca9b1ee24fddc8c0381152cd04e449dc8f8c041ec1598371760551
+  data.tar.gz: c984f12a0162f918b6d5c67b009da28d37a96a63ee0db664a8778e03503d60064ad9e8227d2e1d4fd37f61098f235445f0b959b7612aa503a1b90416f70b69c0

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 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
+
 ## 1.12.0
 
 - Bump money version to ~> 6.12.0

data/README.md

@@ -22,7 +22,7 @@ welcome to contribute to the project.
 
 Add this line to your application's Gemfile:
 
-    gem 'money-rails', '~>1'
+    gem 'money-rails', '~>1.12'
 
 And then execute:
 
@@ -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
 

data/Rakefile

@@ -13,6 +13,7 @@ rescue Bundler::BundlerError => e
 end
 
 APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+GEMFILES_PATH = 'gemfiles/*.gemfile'.freeze
 
 load 'rails/tasks/engine.rake' if File.exist?(APP_RAKEFILE)
 
@@ -47,46 +48,27 @@ def run_with_gemfile(gemfile)
 end
 
 namespace :spec do
+  frameworks_versions = {}
 
-  desc "Run Tests against mongoid (version 5)"
-  task(:mongoid5) { run_with_gemfile 'gemfiles/mongoid5.gemfile' }
+  Dir[GEMFILES_PATH].each do |gemfile|
+    file_name = File.basename(gemfile, '.gemfile')
+    framework, version = file_name.split(/(\d+)/)
+    major, minor = version.split(//)
 
-  desc "Run Tests against mongoid (version 4)"
-  task(:mongoid4) { run_with_gemfile 'gemfiles/mongoid4.gemfile' }
+    frameworks_versions[framework] ||= []
+    frameworks_versions[framework] << file_name
 
-  desc "Run Tests against mongoid (version 3)"
-  task(:mongoid3) { run_with_gemfile 'gemfiles/mongoid3.gemfile' }
-
-  desc "Run Tests against mongoid (version 2)"
-  task(:mongoid2) { run_with_gemfile 'gemfiles/mongoid2.gemfile' }
-
-  desc "Run Tests against rails 5.1"
-  task(:rails51) { run_with_gemfile 'gemfiles/rails51.gemfile' }
-
-  desc "Run Tests against rails 5.0"
-  task(:rails50) { run_with_gemfile 'gemfiles/rails50.gemfile' }
-
-  desc "Run Tests against rails 4.2"
-  task(:rails42) { run_with_gemfile 'gemfiles/rails42.gemfile' }
-
-  desc "Run Tests against rails 4.1"
-  task(:rails41) { run_with_gemfile 'gemfiles/rails41.gemfile' }
-
-  desc "Run Tests against rails 4"
-  task(:rails4) { run_with_gemfile 'gemfiles/rails4.gemfile' }
-
-  desc "Run Tests against rails 3"
-  task(:rails3) { run_with_gemfile 'gemfiles/rails3.gemfile' }
-
-  desc "Run Tests against mongoid 2 & 3 & 4, 5"
-  task mongoid: [:mongoid2, :mongoid3, :mongoid4, :mongoid5]
-
-  desc "Run Tests against rails 3 & 4 & 4.1 & 4.2 & 5.0"
-  task rails: [:rails3, :rails4, :rails41, :rails42, :rails50, :rails51]
+    desc "Run Tests against #{framework} #{[major, minor].compact.join('.')}"
+    task(file_name) { run_with_gemfile gemfile }
+  end
 
-  desc "Run Tests against all ORMs"
-  task all: [:rails, :mongoid]
+  frameworks_versions.each do |framework, versions|
+    desc "Run Tests against all supported #{framework} versions"
+    task framework => versions
+  end
 
+  desc 'Run Tests against all ORMs'
+  task all: frameworks_versions.keys
 end
 
 desc "Update CONTRIBUTORS file"

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

@@ -11,8 +11,8 @@ module MoneyRails
 
         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/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