i18n-complements 0.0.14 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b9fb647456ffc6a3b4761ab396bf66c312bf816
-  data.tar.gz: 7e4e5d33ccc8cdec4c79aaa0dcf860bca9487d45
+  metadata.gz: 16d692a49edce3b47b6a8ada497b8146cd1205ec
+  data.tar.gz: 8cf691d258e71da95029badf9114c5d9b9f5d969
 SHA512:
-  metadata.gz: 3e509773c1352f9749566bf6e59da58a96ddc901a91428a1769d390eeae202ab2385d2783da83505bbc12369261db508fb974092efcd2207580c8d3f86db252e
-  data.tar.gz: 52b6450de21b7d7612e498d6eb70fdb28985020cf4a3b44237a9ef74b85a7becebcb1c046c4865ace073f4d44a9a094659e25e0db14a655cc4bda9d949cec521
+  metadata.gz: 253e77f53716e54ca9bb917c2d7a2900fd3242c82768b13c0025dafdc9934aab9d448141d349d6419878287812dec382c425f4d3e4eead2067259c1ced36b282
+  data.tar.gz: 9d5867df77df878ae0bece031e7adff3872e3c10f05f3e570ea80b13ebb18b26dd2e9577883ce9204b39bb30cd0dc875e4f8ed380407fae211fec6124623d318

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 → i18n/complements}/localize_extension.rb

@@ -1,54 +1,53 @@
 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.new("Currency #{currency.to_s} does not exist.") unless I18nComplements::Numisma[currency.to_s]
-            return I18nComplements::Numisma[currency.to_s].localize(object, :locale => locale)
+            raise I18n::InvalidCurrency.new("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 => {})
+            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)
+              formatter = { format: '%n', separator: '.', delimiter: '', precision: 3 }.merge(formatter).merge(options)
               format = formatter[:format]
-              negative_format = formatter[:negative_format] || "-" + 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
+              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*$/) 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])
+              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(formatter[:delimiter])
+                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) or object.is_a?(FalseClass)
-          return I18n.translate("boolean.human.#{object.to_s}_class", locale: locale)
+        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          
+          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)
-
+      alias localize_without_complements localize
+      alias localize localize_with_complements
     end
   end
 end

data/lib/i18n/complements/numisma.rb

@@ -0,0 +1,97 @@
+# 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 = {}
+          for code, currency in @@currencies
+            x[code] = currency if currency.active
+          end
+          x
+        end
+
+        # Shorcut to get currency
+        def [](currency_code)
+          @@currencies[currency_code]
+        end
+
+        def currency_rate(from, to)
+          raise InvalidCurrency.new(":from currency is unknown (#{from.class}:#{from.inspect})") if Numisma[from].nil?
+          raise InvalidCurrency.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
+          rate
+        end
+
+        # Load currencies
+        def load_currencies
+          @@currencies = {}
+          for code, details in YAML.load_file(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
+
+  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/version.rb

@@ -0,0 +1,5 @@
+module I18n
+  module Complements
+    VERSION = '1.0.0'.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,30 +1,26 @@
 # encoding: utf-8
 require 'helper'
 
-class TestCurrencies < Test::Unit::TestCase
-
+class TestCurrencies < I18n::Complements::TestCase
   def test_conversion_rate
-
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate(:EUR, "JPY")
+    assert_raise I18n::InvalidCurrency do
+      I18n::Complements::Numisma.currency_rate(:EUR, 'JPY')
     end
-    
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate("EUR", :JPY)
+
+    assert_raise I18n::InvalidCurrency do
+      I18n::Complements::Numisma.currency_rate('EUR', :JPY)
     end
-    
-    assert_raise ArgumentError do
-      I18nComplements::Numisma.currency_rate(:EUR, :JPY)
+
+    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")
+    r1 = I18n::Complements::Numisma.currency_rate('EUR', 'JPY')
+    r2 = I18n::Complements::Numisma.currency_rate('JPY', 'EUR')
     assert 0.01 >= 1 - (r1 * r2).round(2), "EUR -> JPY: #{r1}, JPY -> EUR: #{r2}, #{r1 * r2}, #{(r1 * r2).round(2)}"
-    
-    rate = I18nComplements::Numisma.currency_rate("EUR", "JPY")
-    assert !rate.nil?, "Rate cannot be nil"
-    assert rate != 0, "Rate cannot be null"
-  end
-
 
+    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.14
+  version: 1.0.0
 platform: ruby
 authors:
 - Brice Texier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-21 00:00:00.000000000 Z
+date: 2016-05-03 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
@@ -63,12 +91,13 @@ 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/version.rb
 - test/helper.rb
 - test/locales/eng.yml
 - test/locales/fra.yml
@@ -99,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: I18n missing functionnalities

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.14"
-end