i18n-complements 0.0.12 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e315e195eaf2ffc7641dafa65b29f64daf5270cf
-  data.tar.gz: ade2b242b65632eb4164c42ae859af019604f4d1
+SHA256:
+  metadata.gz: cdd3051546defefbdea07a93d272b73e439afed392c5d122cabae378e85ce74b
+  data.tar.gz: ce785fa0d3bd1807751dfb744eca066904823afe5280a40dea8bccda8ac19178
 SHA512:
-  metadata.gz: 03d540be38622615ed373e3f48aeb9288b58c16b12fbb5bb5aba1e9bd4e1270806b9ac04faeda0e7596b1a7ea61cf54165549970295ed5e19328e7c1ac3fe07a
-  data.tar.gz: 9fe8dc68f570ca829850deebdf3fd1f5bac7c5afbbb3c7bc0aaa8650412dbb1bb2b5ce8b95f631cfe41faffbc9a027077bb81c777835bdd89f747910feed8d7d
+  metadata.gz: fe42ba93dc9828cb432e713cba3dda7134a04dd4f0574dd5dd6849f71a3f8c62f906948172859a94cb3b43637b3c21b3682e5e96fe391bf2f986db3e39682dbd
+  data.tar.gz: 73eb8bc1073b0c877eec418e93457369a5449bd827834bb89091d66d73edb1ffe6d11bbad8915244eb942a5964504e500e7b5dbf58685c6130b29077b7ed1c04

data/README.rdoc

@@ -1,4 +1,4 @@
-= I18nComplements
+= I18n::Complements
 {<img src="https://badge.fury.io/rb/i18n-complements.png" alt="Gem Version" />}[http://badge.fury.io/rb/i18n-complements]
 {<img src="https://api.travis-ci.org/ekylibre/i18n-complements.png?branch=master"/>}[https://travis-ci.org/ekylibre/i18n-complements]
 {<img src="https://gemnasium.com/ekylibre/i18n-complements.png"/>}[https://gemnasium.com/ekylibre/i18n-complements]

data/lib/i18n-complements.rb

@@ -1,15 +1 @@
-require 'i18n'
-require 'i18n-complements/numisma'
-require 'i18n-complements/localize_extension'
-require 'i18n-complements/core_extension'
-require 'i18n-complements/version'
-
-module I18n
-
-  class InvalidCurrency < ArgumentError
-  end
-
-end
-
-module I18nComplements
-end
+require 'i18n/complements'

data/lib/i18n/complements.rb

@@ -0,0 +1,14 @@
+require 'i18n'
+
+module I18n
+  class InvalidCurrency < ArgumentError
+  end
+
+  module Complements
+  end
+end
+
+require 'i18n/complements/numisma'
+require 'i18n/complements/localize_extension'
+require 'i18n/complements/core_extension'
+require 'i18n/complements/version'

data/lib/{i18n-complements → i18n/complements}/core_extension.rb

@@ -4,12 +4,12 @@ class ::String
   def translate(options = {})
     I18n.translate(self, options)
   end
-  alias :t :translate
+  alias t translate
 
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 
   def to_currency
     I18n.currencies(self)
@@ -20,10 +20,10 @@ class ::Symbol
   def translate(options = {})
     I18n.translate(self, options)
   end
-  alias :t :translate
+  alias t translate
 
   def to_currency
-    I18n.currencies(self.to_s)
+    I18n.currencies(to_s)
   end
 end
 
@@ -31,40 +31,40 @@ class ::TrueClass
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end
 
 class ::FalseClass
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end
 
 class ::Numeric
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end
 
 class ::Date
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end
 
 class ::DateTime
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end
 
 class ::Time
   def localize(options = {})
     I18n.localize(self, options)
   end
-  alias :l :localize
+  alias l localize
 end

data/lib/i18n/complements/localize_extension.rb

@@ -0,0 +1,55 @@
+module I18n
+  module Backend
+    class Simple
+      def localize_with_complements(locale, object, format = nil, options = {})
+        if object.respond_to?(:strftime)
+          format ||= :default
+          return localize_without_complements(locale, object, format, options)
+        elsif object.respond_to?(:abs)
+          if currency = options[:currency]
+            raise I18n::InvalidCurrency, "Currency #{currency} does not exist." unless I18n::Complements::Numisma[currency.to_s]
+            return I18n::Complements::Numisma[currency.to_s].localize(object, locale: locale)
+          else
+            formatter = I18n.translate('number.format'.to_sym, locale: locale, default: {})
+            if formatter.is_a?(Proc)
+              return formatter[object]
+            elsif formatter.is_a?(Hash)
+              formatter = { format: '%n', separator: '.', delimiter: '', precision: 3 }.merge(formatter).merge(options)
+              format = formatter[:format]
+              negative_format = formatter[:negative_format] || '-' + format
+
+              if object.to_f < 0
+                format = negative_format
+                object = object.abs
+              end
+
+              formatter[:delimiter] = "\u{00A0}" if formatter[:delimiter] == ' '
+
+              value = object.to_s.split(/\./)
+              integrals = value[0].to_s
+              decimals = value[1].to_s
+              value = integrals.gsub(/^0+[1-9]+/, '').gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{formatter[:delimiter]}")
+              decimals = '0' if decimals.to_s.match(/^\s*$/) && object.is_a?(Float)
+              unless decimals.to_s =~ /^\s*$/
+                after = decimals.gsub(/0+$/, '').ljust(formatter[:precision], '0').scan(/.{1,3}/).join('')
+                unless after =~ /\A[[:space:]]*\z/
+                  value << formatter[:separator] + after
+                end
+              end
+              return format.gsub(/%n/, value).gsub(/%s/, "\u{00A0}")
+            end
+          end
+        elsif object.is_a?(TrueClass) || object.is_a?(FalseClass)
+          return I18n.translate("boolean.human.#{object}_class", locale: locale)
+        elsif object.is_a?(String)
+          return object
+        else
+          raise ArgumentError, "Object must be a Numeric, TrueClass, FalseClass, String, Date, DateTime or Time object. #{object.class.name}:#{object.inspect} given."
+        end
+      end
+
+      alias localize_without_complements localize
+      alias localize localize_with_complements
+    end
+  end
+end

data/lib/i18n/complements/numisma.rb

@@ -0,0 +1,124 @@
+# This module aimed to structure and controls currencies through the application
+# It represents the international monetary system with all its currencies like specified in ISO 4217
+# Numisma comes from latin: It designs here the "science of money"
+require 'net/http'
+require 'yaml'
+require 'i18n/complements/numisma/currency'
+
+module I18n
+  module Complements
+    module Numisma
+      class << self
+        def currencies
+          @@currencies
+        end
+
+        # Returns the path to currencies file
+        def currencies_file
+          # Rails.root.join("config", "currencies.yml")
+          File.join(File.dirname(__FILE__), 'numisma', 'currencies.yml')
+        end
+
+        # Returns a hash with active currencies only
+        def active_currencies
+          x = {}
+          @@currencies.each do |code, currency|
+            x[code] = currency if currency.active
+          end
+          x
+        end
+
+        # Shorcut to get currency
+        def [](currency_code)
+          @@currencies[currency_code]
+        end
+
+        def fixed_currency_rate(from, to)
+          rates = @@fixed_currency_rates[from]
+          return nil unless rates
+          rates[to]
+        end
+
+        def currency_rate(from, to)
+          if Numisma[from].nil?
+            raise InvalidCurrency, ":from currency is unknown (#{from.class}:#{from.inspect})"
+          end
+          if Numisma[to].nil?
+            raise InvalidCurrency, ":to currency is unknown (#{to.class}:#{to.inspect})"
+          end
+          rate = fixed_currency_rate(from, to)
+          return rate if rate
+          begin
+            uri = URI('http://www.webservicex.net/CurrencyConvertor.asmx/ConversionRate')
+            response = Net::HTTP.post_form(uri, 'FromCurrency' => from, 'ToCurrency' => to)
+            doc = ::LibXML::XML::Parser.string(response.body).parse
+            rate = doc.root.content.to_f
+          rescue
+            uri = URI("http://download.finance.yahoo.com/d/quotes.csv?s=#{from}#{to}=X&f=l1")
+            response = Net::HTTP.get(uri)
+            rate = response.strip.to_f
+          end
+          rate
+        end
+
+        # Load currencies
+        def load_currencies
+          @@currencies = {}
+          yaml = YAML.load_file(currencies_file)
+          yaml.each do |code, attributes|
+            currency = Currency.new(code, attributes.inject({}) { |h, p| h[p[0].to_sym] = p[1]; h })
+            @@currencies[currency.code] = currency
+          end
+        end
+
+        # Load fixed currency rates with reverse rates too.
+        def load_fixed_currency_rates
+          @@fixed_currency_rates = {}
+          yaml = YAML.load_file(File.join(File.dirname(__FILE__), 'numisma', 'fixed_currency_rates.yml'))
+          yaml.each do |from, rates|
+            @@fixed_currency_rates[from] ||= {}
+            rates.each do |to, rate|
+              @@fixed_currency_rates[from][to] = rate
+              @@fixed_currency_rates[to] ||= {}
+              @@fixed_currency_rates[to][from] = 1 / rate
+            end
+          end
+        end
+      end
+
+      # Finally load all currencies
+      load_currencies
+      load_fixed_currency_rates
+    end
+  end
+
+  class << self
+    def currencies(currency_code)
+      I18n::Complements::Numisma.currencies[currency_code.to_s]
+    end
+
+    def active_currencies
+      I18n::Complements::Numisma.active_currencies
+    end
+
+    def available_currencies
+      I18n::Complements::Numisma.currencies
+    end
+
+    def currency_label(currency_code)
+      if currency = I18n::Complements::Numisma.currencies[currency_code.to_s]
+        currency.label
+      else
+        return "Unknown currency: #{currency_code}"
+      end
+    end
+
+    def currency_rate(from, to)
+      I18n::Complements::Numisma.currency_rate(from, to)
+    end
+
+    def currencies_file
+      I18n::Complements::Numisma.currencies_file
+    end
+  end
+end

data/lib/i18n/complements/numisma/currency.rb

@@ -0,0 +1,81 @@
+module I18n
+  module Complements
+    module Numisma
+      class Currency
+        attr_reader :code, :active, :cash, :countries, :number, :precision, :unit
+
+        def initialize(code, options = {})
+          @code = code.strip # .upcase
+          @active = (options[:active] ? true : false)
+          @cash = options[:cash].to_a.collect(&:to_f).sort
+          @countries = options[:countries].to_a.collect(&:to_s).sort.collect(&:to_sym)
+          @number = options[:number].to_i
+          @precision = options[:precision].to_i
+          @unit = (options[:unit].nil? ? nil : options[:unit].to_s)
+        end
+
+        def name
+          ::I18n.translate("currencies.#{code}")
+        end
+
+        def label
+          ::I18n.translate('labels.currency_with_code', code: code, name: name, default: '%{name} (%{code})')
+        end
+
+        def round(value, _options = {})
+          precision = self.precision
+          if RUBY_VERSION =~ /^1\.8/
+            magnitude = 10**precision
+            return (value * magnitude).to_i.to_f * magnitude
+          else
+            return value.round(precision)
+          end
+        end
+
+        def ==(other_currency)
+          code == other_currency.code
+        end
+
+        def to_currency
+          self
+        end
+
+        # Produces a amount of the currency with the locale parameters
+        # TODO: Find a better way to specify number formats which are more complex that the default Rails use
+        def localize(amount, options = {})
+          return unless amount
+
+          # options.symbolize_keys!
+
+          defaults  = I18n.translate('number.format'.to_sym, locale: options[:locale], default: {})
+          defaultt  = I18n.translate('number.currency.format'.to_sym, locale: options[:locale], default: {})
+          defaultt[:negative_format] ||= ('-' + defaultt[:format]) if defaultt[:format]
+          formatcy = I18n.translate("number.currency.formats.#{code}".to_sym, locale: options[:locale], default: {})
+          formatcy[:negative_format] ||= '-' + formatcy[:format] if formatcy[:format]
+
+          formatter = {}
+          formatter[:separator] = formatcy[:separator] || defaultt[:separator] || defaults[:separator] || ','
+          formatter[:delimiter] = formatcy[:delimiter] || defaultt[:delimiter] || defaults[:delimiter] || ''
+          formatter[:precision] = formatcy[:precision] || precision || defaultt[:precision] || 3
+          format           = formatcy[:format] || defaultt[:format] || '%n-%u' # defaults[:format] ||
+          negative_format  = formatcy[:negative_format] || defaultt[:negative_format] || defaults[:negative_format] || '-' + format
+          unit             = formatcy[:unit] || self.unit || code
+
+          if amount.to_f < 0
+            format = negative_format # options.delete(:negative_format)
+            amount = amount.respond_to?('abs') ? amount.abs : amount.sub(/^-/, '')
+          end
+
+          value = amount.to_s
+          integers, decimals = value.split(/\./)
+          value = integers.gsub(/^0+[1-9]+/, '').gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{formatter[:delimiter]}")
+          unless decimals.to_s =~ /^\s*$/
+            value << formatter[:separator]
+            value << decimals.gsub(/0+$/, '').ljust(formatter[:precision], '0').scan(/.{1,3}/).join(formatter[:delimiter])
+          end
+          format.gsub(/%n/, value).gsub(/%u/, unit).gsub(/%s/, "\u{00A0}")
+        end
+      end
+    end
+  end
+end

data/lib/i18n/complements/numisma/fixed_currency_rates.yml

@@ -0,0 +1,20 @@
+EUR:
+  EEK: 15.6466
+  SKK: 30.126
+  GRD: 340.75
+  PTE: 200.482
+  NLG: 2.20371
+  BEF: 40.3399
+  FRF: 6.55957
+  LUF: 40.3399
+  LVL: 0.702804
+  ITL: 1936.27
+  MTL: 0.4293
+  LTL: 3.4528
+  CYP: 0.585274
+  IEP: 0.787564
+  DEM: 1.95583
+  FIM: 5.94573
+  ESP: 166.386
+  ATS: 13.7603
+  SIT: 239.64

data/lib/i18n/complements/version.rb

@@ -0,0 +1,5 @@
+module I18n
+  module Complements
+    VERSION = '1.1.1'.freeze
+  end
+end

data/test/helper.rb

@@ -2,13 +2,35 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'bundler/setup'
-require 'test/unit'
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'i18n-complements'
 
-for file in Dir[File.join(File.dirname(__FILE__), "locales", "*.yml")]
+Dir[File.join(File.dirname(__FILE__), 'locales', '*.yml')].each do |file|
   I18n.backend.load_translations(file)
 end
+
+module I18n
+  module Complements
+    class TestCase < Minitest::Test
+      def setup
+        I18n.locale = ENV['LOCALE'] || :eng
+      end
+
+      def assert_nothing_raised(*_args)
+        yield
+      end
+
+      def assert_raise(exception)
+        yield
+      rescue Exception => e
+        assert_equal exception, e.class
+      else
+        refute
+      end
+    end
+  end
+end

data/test/test_booleans.rb

@@ -1,8 +1,7 @@
 # encoding: utf-8
 require 'helper'
 
-class TestBooleans < Test::Unit::TestCase
-
+class TestBooleans < I18n::Complements::TestCase
   def test_localization
     assert_nothing_raised do
       I18n.localize(true)
@@ -20,15 +19,14 @@ class TestBooleans < Test::Unit::TestCase
 
     assert_nothing_raised do
       false.localize
-    end   
+    end
 
     assert_nothing_raised do
       true.l
     end
-    
+
     assert_nothing_raised do
       false.l
-    end   
+    end
   end
-
 end

data/test/test_currencies.rb

@@ -1,67 +1,65 @@
 # encoding: utf-8
 require 'helper'
 
-class TestCurrencies < Test::Unit::TestCase
-
+class TestCurrencies < I18n::Complements::TestCase
   def test_localization_with_currency
     assert_nothing_raised do
-      ::I18n.localize(14.5, :currency => :JPY)
+      ::I18n.localize(14.5, currency: :JPY)
     end
 
     assert_nothing_raised do
-      ::I18n.localize(14.5, :currency => "JPY")
+      ::I18n.localize(14.5, currency: 'JPY')
     end
-    
+
     assert_raise(I18n::InvalidCurrency) do
-      ::I18n.localize(14.5, :currency => "jPY")
+      ::I18n.localize(14.5, currency: 'jPY')
     end
   end
 
   def test_localization_with_currency_with_core_extensions
     assert_nothing_raised do
-      14.5.localize(:currency => :JPY)
+      14.5.localize(currency: :JPY)
     end
 
     assert_nothing_raised do
-      14.5.l(:currency => :JPY)
+      14.5.l(currency: :JPY)
     end
 
     assert_nothing_raised do
-      13546.localize(:currency => :JPY)
+      13_546.localize(currency: :JPY)
     end
-    
+
     assert_nothing_raised do
-      13546.l(:currency => :JPY)
+      13_546.l(currency: :JPY)
     end
-    
+
     assert_raise(I18n::InvalidCurrency) do
-      14.5.l(:currency => "jPY")
-    end    
+      14.5.l(currency: 'jPY')
+    end
 
     assert_raise(I18n::InvalidCurrency) do
-      14.5.l(:currency => "JPYXX")
-    end    
+      14.5.l(currency: 'JPYXX')
+    end
   end
-  
+
   def test_number_formatting_with_currency
-    number = 413500
-    assert_equal "¥413,500", ::I18n.localize(number, :locale => :eng, :currency => "JPY")
-    assert_equal "413\u{00A0}500\u{00A0}¥", ::I18n.localize(number, :locale => :fra, :currency => "JPY")
-    assert_equal "413,500円", ::I18n.localize(number, :locale => :jpn, :currency => "JPY")
-    assert_equal "€0.325,1", ::I18n.localize(0.3251, :locale => :eng, :currency => "EUR")
-    assert_equal "0,325\u{00A0}1\u{00A0}F", ::I18n.localize(0.3251, :locale => :fra, :currency => "FRF")
-    assert_equal "€123,852.325,1", ::I18n.localize(123852.3251, :locale => :eng, :currency => "EUR")
+    number = 413_500
+    assert_equal '¥413,500', ::I18n.localize(number, locale: :eng, currency: 'JPY')
+    assert_equal "413\u{00A0}500\u{00A0}¥", ::I18n.localize(number, locale: :fra, currency: 'JPY')
+    assert_equal '413,500円', ::I18n.localize(number, locale: :jpn, currency: 'JPY')
+    assert_equal '€0.325,1', ::I18n.localize(0.3251, locale: :eng, currency: 'EUR')
+    assert_equal "0,325\u{00A0}1\u{00A0}F", ::I18n.localize(0.3251, locale: :fra, currency: 'FRF')
+    assert_equal '€123,852.325,1', ::I18n.localize(123_852.3251, locale: :eng, currency: 'EUR')
   end
 
   def test_number_formatting_with_currency_with_core_extensions
-    for locale in [:eng, :fra, :jpn]
-      for money in [[413500, "JPY"], [1425.23, "USD"], [0.96, "EUR"]]
-        assert_equal(money[0].l(:locale => money[1]), ::I18n.localize(money[0], :locale => money[1]))
+    [:eng, :fra, :jpn].each do |locale|
+      [[413_500, 'JPY'], [1425.23, 'USD'], [0.96, 'EUR']].each do |money|
+        assert_equal(money[0].l(locale: locale, currency: money[1]), ::I18n.localize(money[0], locale: locale, currency: money[1]))
       end
     end
   end
 
-
   def test_listing_of_currencies
     assert_nothing_raised do
       ::I18n.active_currencies
@@ -71,32 +69,32 @@ class TestCurrencies < Test::Unit::TestCase
       ::I18n.available_currencies
     end
 
-    assert ::I18n.active_currencies.size <= ::I18n.available_currencies.size, "Available currencies cannot be less numerous than active currencies"
+    assert ::I18n.active_currencies.size <= ::I18n.available_currencies.size, 'Available currencies cannot be less numerous than active currencies'
   end
 
   def test_currency_properties
     assert !::I18n.currencies(:JPY).nil?
-    assert !::I18n.currencies("JPY").nil?
-    assert ::I18n.currencies("JPy").nil?
+    assert !::I18n.currencies('JPY').nil?
+    assert ::I18n.currencies('JPy').nil?
 
-    assert !::I18n.currencies("USD").nil?
-    assert !::I18n.currencies("EUR").nil?
+    assert !::I18n.currencies('USD').nil?
+    assert !::I18n.currencies('EUR').nil?
 
-    assert ::I18n.currencies("JPYXX").nil?
+    assert ::I18n.currencies('JPYXX').nil?
 
     assert_nothing_raised do
-      ::I18n.currency_label("JPY")
+      ::I18n.currency_label('JPY')
     end
-    assert !::I18n.currency_label("JPY").match(/Unknown/)
+    assert !::I18n.currency_label('JPY').match(/Unknown/)
   end
-  
+
   def test_currency_properties_with_core_extensions
     assert_nothing_raised do
       :JPY.to_currency.name
     end
-    
+
     assert_nothing_raised do
-      "USD".to_currency.name
+      'USD'.to_currency.name
     end
 
     assert_nothing_raised do
@@ -106,15 +104,12 @@ class TestCurrencies < Test::Unit::TestCase
     assert_nothing_raised do
       :JPY.to_currency.to_currency.to_currency.name
     end
-    
+
     assert_equal :JPY.to_currency, :JPY.to_currency.to_currency
 
     currency = :JPY.to_currency
-    
+
     assert_equal currency, currency.to_currency
     assert_equal currency.to_currency, currency.to_currency.to_currency
   end
-  
-  
-  
 end

data/test/test_currency_rates.rb

@@ -1,31 +1,32 @@
 # encoding: utf-8
 require 'helper'
 
-class TestCurrencies < Test::Unit::TestCase
-
+class TestCurrencies < I18n::Complements::TestCase
   def test_conversion_rate
+    rate = I18n::Complements::Numisma.currency_rate('EUR', 'FRF')
+    assert !rate.zero?, 'Rate should not be zero'
 
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate(:EUR, "JPY")
-    end
-    
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate("EUR", :JPY)
-    end
-    
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate(:EUR, :JPY)
+    assert rate == 6.55957
+
+    assert_raise I18n::InvalidCurrency do
+      I18n::Complements::Numisma.currency_rate(:EUR, 'JPY')
     end
 
-    r1 = I18nComplements::Numisma.currency_rate("EUR", "JPY")
-    r2 = I18nComplements::Numisma.currency_rate("JPY", "EUR")
-    assert 0.01 >= 1 - (r1 * r2).round(2)
-    
-    assert_nothing_raised do
-      I18nComplements::Numisma.currency_rate("EUR", "JPY")
+    assert_raise I18n::InvalidCurrency do
+      I18n::Complements::Numisma.currency_rate('EUR', :JPY)
     end
 
-  end
+    assert_raise I18n::InvalidCurrency do
+      I18n::Complements::Numisma.currency_rate(:EUR, :JPY)
+    end
 
+    r1 = I18n::Complements::Numisma.currency_rate('EUR', 'JPY')
+    r2 = I18n::Complements::Numisma.currency_rate('JPY', 'EUR')
+    rounded_one = (r1 * r2).round(2)
+    assert rounded_one >= 0.99, "EUR -> JPY: #{r1}, JPY -> EUR: #{r2}, #{r1 * r2}, #{rounded_one}"
 
+    rate = I18n::Complements::Numisma.currency_rate('EUR', 'JPY')
+    assert !rate.nil?, 'Rate cannot be nil'
+    assert rate != 0, 'Rate cannot be null'
+  end
 end

data/test/test_extensions.rb

@@ -1,29 +1,27 @@
 # encoding: utf-8
 require 'helper'
 
-class TestExtensions < Test::Unit::TestCase
-  
+class TestExtensions < I18n::Complements::TestCase
   def setup
     I18n.locale = :eng
   end
 
   def test_string_translation
-    assert_equal "My example is so short", I18n.translate("my_example")
-    assert_equal I18n.translate("my_example"), "my_example".translate
-    assert_equal I18n.translate("my_example"), "my_example".t
+    assert_equal 'My example is so short', I18n.translate('my_example')
+    assert_equal I18n.translate('my_example'), 'my_example'.translate
+    assert_equal I18n.translate('my_example'), 'my_example'.t
 
-    assert_equal "My example is short", I18n.translate("my.example")
-    assert_equal I18n.translate("my.example"), "my.example".translate
-    assert_equal I18n.translate("my.example"), "my.example".t
+    assert_equal 'My example is short', I18n.translate('my.example')
+    assert_equal I18n.translate('my.example'), 'my.example'.translate
+    assert_equal I18n.translate('my.example'), 'my.example'.t
   end
 
   def test_symbol_translation
-    assert_equal "My example is so short", I18n.translate(:my_example)
+    assert_equal 'My example is so short', I18n.translate(:my_example)
     assert_equal I18n.translate(:my_example), :my_example.translate
     assert_equal I18n.translate(:my_example), :my_example.t
   end
 
-
   def test_date_localization
     date = Date.civil(1999, 12, 31)
 
@@ -71,5 +69,4 @@ class TestExtensions < Test::Unit::TestCase
 
     assert_equal I18n.localize(time), time.l
   end
-
 end

data/test/test_numbers.rb

@@ -1,15 +1,14 @@
 # encoding: utf-8
 require 'helper'
 
-class TestNumbers < Test::Unit::TestCase
-
+class TestNumbers < I18n::Complements::TestCase
   def test_localization
     assert_nothing_raised do
       I18n.localize(14.5)
     end
 
     assert_nothing_raised do
-      I18n.localize(413500)
+      I18n.localize(413_500)
     end
   end
 
@@ -19,72 +18,75 @@ class TestNumbers < Test::Unit::TestCase
     end
 
     assert_nothing_raised do
-      413500.localize
-    end   
+      413_500.localize
+    end
 
     assert_nothing_raised do
       14.5.l
     end
 
     assert_nothing_raised do
-      413500.l
-    end   
+      413_500.l
+    end
   end
-  
+
   def test_number_formatting
     # Integer
     number = 3
-    assert_equal "3", I18n.localize(number, :locale => :eng)
-    assert_equal "3", I18n.localize(number, :locale => :fra)
+    assert_equal '3', I18n.localize(number, locale: :eng)
+    assert_equal '3', I18n.localize(number, locale: :fra)
 
     # Integer > 1000
-    number = 21145
-    assert_equal "21,145", I18n.localize(number, :locale => :eng)
-    assert_equal "21\u{00A0}145", I18n.localize(number, :locale => :fra)
+    number = 21_145
+    assert_equal '21,145', I18n.localize(number, locale: :eng)
+    assert_equal "21\u{00A0}145", I18n.localize(number, locale: :fra)
 
     # Float without integers with decimals
     number = 0.5
-    assert_equal "0.500", I18n.localize(number, :locale => :eng)
-    assert_equal "0,500", I18n.localize(number, :locale => :fra)
+    assert_equal '0.500', I18n.localize(number, locale: :eng)
+    assert_equal '0,500', I18n.localize(number, locale: :fra)
 
     # Float without decimals
     number = 3.0
-    assert_equal "3.000", I18n.localize(number, :locale => :eng)
-    assert_equal "3,000", I18n.localize(number, :locale => :fra)
+    assert_equal '3.000', I18n.localize(number, locale: :eng)
+    assert_equal '3,000', I18n.localize(number, locale: :fra)
+
+    # Float without decimals and no precision
+    number = 5.0
+    assert_equal '5', I18n.localize(number, locale: :eng, precision: 0)
+    assert_equal '5', I18n.localize(number, locale: :fra, precision: 0)
 
     # Float
     number = 14.53
-    assert_equal "14.530", I18n.localize(number, :locale => :eng)
-    assert_equal "14,530", I18n.localize(number, :locale => :fra)
+    assert_equal '14.530', I18n.localize(number, locale: :eng)
+    assert_equal '14,530', I18n.localize(number, locale: :fra)
 
     # Float > 1000
     number = 2114.5
-    assert_equal "2,114.500", I18n.localize(number, :locale => :eng)
-    assert_equal "2\u{00A0}114,500", I18n.localize(number, :locale => :fra)
+    assert_equal '2,114.500', I18n.localize(number, locale: :eng)
+    assert_equal "2\u{00A0}114,500", I18n.localize(number, locale: :fra)
 
     # Float without integers with decimals < 0.001
     number = 0.41421356
-    assert_equal "0.414,213,56", I18n.localize(number, :locale => :eng)
-    assert_equal "0,414\u{00A0}213\u{00A0}56", I18n.localize(number, :locale => :fra)
+    assert_equal '0.414,213,56', I18n.localize(number, locale: :eng)
+    assert_equal "0,414\u{00A0}213\u{00A0}56", I18n.localize(number, locale: :fra)
 
     # Float without integers with decimals < 0.001
     number = 3.1415926
-    assert_equal "3.141,592,6", I18n.localize(number, :locale => :eng)
-    assert_equal "3,141\u{00A0}592\u{00A0}6", I18n.localize(number, :locale => :fra)
+    assert_equal '3.141,592,6', I18n.localize(number, locale: :eng)
+    assert_equal "3,141\u{00A0}592\u{00A0}6", I18n.localize(number, locale: :fra)
 
     # Float without integers with decimals < 0.001
-    number = 62951413.1415926
-    assert_equal "62,951,413.141,592,6", I18n.localize(number, :locale => :eng)
-    assert_equal "62\u{00A0}951\u{00A0}413,141\u{00A0}592\u{00A0}6", I18n.localize(number, :locale => :fra)
+    number = 62_951_413.1415926
+    assert_equal '62,951,413.141,592,6', I18n.localize(number, locale: :eng)
+    assert_equal "62\u{00A0}951\u{00A0}413,141\u{00A0}592\u{00A0}6", I18n.localize(number, locale: :fra)
   end
 
   def test_number_formatting_with_core_extensions
     for locale in [:eng, :fra, :jpn]
-      for number in [3, 21145, 0.5, 3.0, 14.53, 2144.5, 0.41421356, 3.1415926, 62951413.1415926]
-        assert_equal(number.l(:locale => locale), I18n.localize(number, :locale => locale))
+      for number in [3, 21_145, 0.5, 3.0, 14.53, 2144.5, 0.41421356, 3.1415926, 62_951_413.1415926]
+        assert_equal(number.l(locale: locale), I18n.localize(number, locale: locale))
       end
     end
-
   end
-
 end

data/test/test_strings.rb

@@ -1,11 +1,10 @@
 # encoding: utf-8
 require 'helper'
 
-class TestStrings < Test::Unit::TestCase
-
+class TestStrings < I18n::Complements::TestCase
   def test_localization
     assert_nothing_raised do
-      I18n.localize("This is a test sentence")
+      I18n.localize('This is a test sentence')
     end
 
     assert_nothing_raised do
@@ -13,26 +12,25 @@ class TestStrings < Test::Unit::TestCase
     end
 
     assert_nothing_raised do
-      I18n.localize("")
+      I18n.localize('')
     end
   end
 
   def test_localization_with_core_extensions
     assert_nothing_raised do
-     "This is a test sentence".localize
+      'This is a test sentence'.localize
     end
 
     assert_nothing_raised do
       "C'est une phrase d'exemple axée sur les caractères spéciaux".localize
-    end   
+    end
 
     assert_nothing_raised do
-     "This is a test sentence".l
+      'This is a test sentence'.l
     end
 
     assert_nothing_raised do
       "C'est une phrase d'exemple axée sur les caractères spéciaux".l
-    end   
+    end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-complements
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 1.1.1
 platform: ruby
 authors:
 - Brice Texier
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-10-12 00:00:00.000000000 Z
+date: 2021-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -28,16 +28,44 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.6.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +80,7 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '10'
-description: 
+description:
 email: burisu@oneiros.fr
 executables: []
 extensions: []
@@ -63,12 +91,14 @@ files:
 - LICENSE
 - README.rdoc
 - lib/i18n-complements.rb
-- lib/i18n-complements/core_extension.rb
-- lib/i18n-complements/localize_extension.rb
-- lib/i18n-complements/numisma.rb
-- lib/i18n-complements/numisma/currencies.yml
-- lib/i18n-complements/numisma/currency.rb
-- lib/i18n-complements/version.rb
+- lib/i18n/complements.rb
+- lib/i18n/complements/core_extension.rb
+- lib/i18n/complements/localize_extension.rb
+- lib/i18n/complements/numisma.rb
+- lib/i18n/complements/numisma/currencies.yml
+- lib/i18n/complements/numisma/currency.rb
+- lib/i18n/complements/numisma/fixed_currency_rates.yml
+- lib/i18n/complements/version.rb
 - test/helper.rb
 - test/locales/eng.yml
 - test/locales/fra.yml
@@ -83,7 +113,7 @@ homepage: http://github.com/burisu/i18n-complements
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -98,9 +128,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: I18n missing functionnalities
 test_files:

data/lib/i18n-complements/localize_extension.rb

@@ -1,53 +0,0 @@
-module I18n
-  module Backend
-
-    class Simple
-
-      def localize_with_complements(locale, object, format = :default, options = {})
-        
-        if object.respond_to?(:strftime)
-          return localize_without_complements(locale, object, format, options)
-        elsif object.respond_to?(:abs)
-          if currency = options[:currency]
-            raise I18n::InvalidCurrency.new("Currency #{currency.to_s} does not exist.") unless I18nComplements::Numisma[currency.to_s]
-            return I18nComplements::Numisma[currency.to_s].localize(object, :locale => locale)
-          else
-            formatter = I18n.translate('number.format'.to_sym, :locale => locale, :default => {})
-            if formatter.is_a?(Proc)
-              return formatter[object]
-            elsif formatter.is_a?(Hash)
-              formatter = {:format => "%n", :separator => '.', :delimiter => '', :precision => 3}.merge(formatter).merge(options)
-              format = formatter[:format]
-              negative_format = formatter[:negative_format] || "-" + format
-
-              if object.to_f < 0
-                format = negative_format
-                object = object.abs
-              end
-              
-              value = object.to_s.split(/\./)
-              integrals, decimals = value[0].to_s, value[1].to_s
-              value = integrals.gsub(/^0+[1-9]+/, '').gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{formatter[:delimiter]}")
-              decimals = "0" if decimals.to_s.match(/^\s*$/) and object.is_a?(Float)
-              unless decimals.to_s.match(/^\s*$/)
-                value << formatter[:separator]
-                value << decimals.gsub(/0+$/, '').ljust(formatter[:precision], '0').scan(/.{1,3}/).join(formatter[:delimiter])
-              end
-              return format.gsub(/%n/, value).gsub(/%s/, "\u{00A0}")
-            end
-          end
-        elsif object.is_a?(TrueClass) or object.is_a?(FalseClass)
-          return I18n.translate("boolean.formats.#{format}.#{object.to_s}")
-        elsif object.is_a?(String)
-          return object          
-        else
-          raise ArgumentError, "Object must be a Numeric, TrueClass, FalseClass, String, Date, DateTime or Time object. #{object.class.name}:#{object.inspect} given."
-        end
-      end
-
-      alias_method(:localize_without_complements, :localize)
-      alias_method(:localize, :localize_with_complements)
-
-    end
-  end
-end

data/lib/i18n-complements/numisma.rb

@@ -1,107 +0,0 @@
-# This module aimed to structure and controls currencies through the application
-# It represents the international monetary system with all its currencies like specified in ISO 4217
-# Numisma comes from latin: It designs here the "science of money"
-require 'net/http'
-require 'yaml'
-require 'i18n-complements/numisma/currency'
-
-module I18nComplements
-  module Numisma
-
-    class << self
-
-      def currencies
-        @@currencies
-      end
-      
-
-      # Returns the path to currencies file
-      def currencies_file
-        # Rails.root.join("config", "currencies.yml")
-        File.join(File.dirname(__FILE__), "numisma", "currencies.yml")
-      end
-      
-      # Returns a hash with active currencies only
-      def active_currencies
-        x = {}
-        for code, currency in @@currencies
-          x[code] = currency if currency.active
-        end
-        return x
-      end
-      
-      # Shorcut to get currency
-      def [](currency_code)
-        @@currencies[currency_code]
-      end
-
-      def currency_rate(from, to)
-        raise ArgumentError.new(":from currency is unknown (#{from.class}:#{from.inspect})") if Numisma[from].nil?
-        raise ArgumentError.new(":to currency is unknown (#{to.class}:#{to.inspect})") if Numisma[to].nil?
-        rate = nil
-        begin
-          uri = URI("http://www.webservicex.net/CurrencyConvertor.asmx/ConversionRate")
-          response = Net::HTTP.post_form(uri, 'FromCurrency' => from, 'ToCurrency' => to)
-          doc = ::LibXML::XML::Parser.string(response.body).parse
-          rate = doc.root.content.to_f
-        rescue
-          uri = URI("http://download.finance.yahoo.com/d/quotes.csv?s=#{from}#{to}=X&f=l1")
-          response = Net::HTTP.get(uri)
-          rate = response.strip.to_f
-        end
-        return rate
-      end
-      
-      
-      # Load currencies
-      def load_currencies
-        @@currencies = {}
-        for code, details in YAML.load_file(self.currencies_file)
-
-          currency = Currency.new(code, details.inject({}){|h, p| h[p[0].to_sym] = p[1]; h})
-          @@currencies[currency.code] = currency
-        end
-      end
-    end
-
-    # Finally load all currencies
-    load_currencies
-  end
-end
-
-
-module ::I18n
-
-  class << self
-
-    def currencies(currency_code)
-      I18nComplements::Numisma.currencies[currency_code.to_s]
-    end
-
-    def active_currencies
-      I18nComplements::Numisma.active_currencies
-    end
-
-    def available_currencies
-      I18nComplements::Numisma.currencies
-    end
-
-    def currency_label(currency_code)
-      if currency = I18nComplements::Numisma.currencies[currency_code.to_s]
-        currency.label
-      else
-        return "Unknown currency: #{currency_code}"
-      end
-    end
-
-    def currency_rate(from, to)
-      I18nComplements::Numisma.currency_rate(from, to)
-    end
-
-    def currencies_file
-      I18nComplements::Numisma.currencies_file
-    end
-
-  end
-
-end

data/lib/i18n-complements/numisma/currency.rb

@@ -1,82 +0,0 @@
-module I18nComplements
-  module Numisma
-
-    class Currency
-      attr_reader :code, :active, :cash, :countries, :number, :precision, :unit
-      
-      def initialize(code, options = {})
-        @code = code.strip # .upcase
-        @active = (options[:active] ? true : false)
-        @cash = options[:cash].to_a.collect{|x| x.to_f}.sort
-        @countries = options[:countries].to_a.collect{|x| x.to_s}.sort.collect{|x| x.to_sym}
-        @number = options[:number].to_i
-        @precision = options[:precision].to_i
-        @unit = (options[:unit].nil? ? nil : options[:unit].to_s)
-      end
-
-      def name
-        ::I18n.translate("currencies.#{self.code}")
-      end
-
-      def label
-        ::I18n.translate("labels.currency_with_code", :code=>self.code, :name=>self.name, :default=>"%{name} (%{code})")
-      end
-
-      def round(value, options={})
-        precision = self.precision
-        if RUBY_VERSION.match(/^1\.8/)
-          magnitude = 10**precision 
-          return (value * magnitude).to_i.to_f*magnitude
-        else
-          return value.round(precision)
-        end
-      end
-
-      def ==(other_currency)
-        self.code == other_currency.code
-      end
-
-      def to_currency
-        self
-      end
-
-      # Produces a amount of the currency with the locale parameters
-      # TODO: Find a better way to specify number formats which are more complex that the default Rails use
-      def localize(amount, options={})
-        return unless amount
-
-        # options.symbolize_keys!
-        
-        defaults  = I18n.translate('number.format'.to_sym, :locale => options[:locale], :default => {})
-        defaultt  = I18n.translate('number.currency.format'.to_sym, :locale => options[:locale], :default => {})
-        defaultt[:negative_format] ||= ("-" + defaultt[:format]) if defaultt[:format]
-        formatcy  = I18n.translate("number.currency.formats.#{self.code}".to_sym, :locale => options[:locale], :default => {})
-        formatcy[:negative_format] ||= "-" + formatcy[:format] if formatcy[:format]
-
-        formatter = {}
-        formatter[:separator] = formatcy[:separator] || defaultt[:separator] || defaults[:separator] || ','
-        formatter[:delimiter] = formatcy[:delimiter] || defaultt[:delimiter] || defaults[:delimiter] || ''
-        formatter[:precision] = formatcy[:precision] || self.precision || defaultt[:precision] || 3
-        format           = formatcy[:format] || defaultt[:format] || "%n-%u" # defaults[:format] || 
-        negative_format  = formatcy[:negative_format] || defaultt[:negative_format] || defaults[:negative_format] || "-" + format
-        unit             = formatcy[:unit] || self.unit || self.code
-        
-        if amount.to_f < 0
-          format = negative_format # options.delete(:negative_format)
-          amount = amount.respond_to?("abs") ? amount.abs : amount.sub(/^-/, '')
-        end
-        
-        value = amount.to_s
-        integers, decimals = value.split(/\./)
-        value = integers.gsub(/^0+[1-9]+/, '').gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{formatter[:delimiter]}")
-        unless decimals.to_s.match(/^\s*$/)
-          value << formatter[:separator]
-          value << decimals.gsub(/0+$/, '').ljust(formatter[:precision], '0').scan(/.{1,3}/).join(formatter[:delimiter])
-        end
-        return format.gsub(/%n/, value).gsub(/%u/, unit).gsub(/%s/, "\u{00A0}")
-      end
-      
-    end
-
-  end
-end

data/lib/i18n-complements/version.rb

@@ -1,3 +0,0 @@
-module I18nComplements
-  VERSION = "0.0.12"
-end