spree_multi_currency 1.0.4 → 2.0.0

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 spec/dummy
+coverage

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--backtrace

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+script: bundle exec rake test_app ; bundle exec rspec
+

data/Gemfile

@@ -1,11 +1,29 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gem 'sqlite3'
 
 group :test do
-  gem 'rspec-rails', '= 2.6.1'
+  gem 'rspec-rails', '>= 2.6.1'
   gem 'factory_girl'
   gem 'faker'
+  gem 'therubyracer'
+  gem 'execjs'
+  gem 'rspec'
+  gem 'capybara'
+  gem 'capybara-webkit'
+  gem 'factory_girl'
+  gem 'ffaker'
+  gem 'simplecov'
+  gem 'database_cleaner','1.0.1'
+  gem 'i18n-spec'
+  gem 'launchy'
+  gem 'coveralls', require: false
+  gem 'sass'
+  gem 'coffee-script'
 end
 
-gemspec
+gem 'spree', github: 'spree/spree', branch: '2-0-stable'
+# provides basic authentication functionality for testing parts of your engine
+gem 'spree_auth_devise', github: 'spree/spree_auth_devise', branch: '2-0-stable'
+
+gemspec

data/README.markdown

@@ -1,3 +1,7 @@
+[![Coverage Status](https://coveralls.io/repos/pronix/spree-multi-currency/badge.png)](https://coveralls.io/r/pronix/spree-multi-currency)
+
+[![Build Status](https://travis-ci.org/pronix/spree-multi-currency.png)](https://travis-ci.org/pronix/spree-multi-currency)
+
 # Spree Multi-Currency
 
 Support different currency and recalculate price from one to another
@@ -180,6 +184,10 @@ Settings
 
 For tests
 _________________________
+  For start tests require exec:
+  `bundle exec rake test_app && bundle exec rake spec`
+
+
 
   extention require store in ./spree
   in Rakefile defined

data/Rakefile

@@ -1,9 +1,11 @@
+# Encoding: utf-8
+require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 require 'rake/packagetask'
 require 'rubygems/package_task'
 require 'rspec/core/rake_task'
-require 'spree/core/testing_support/common_rake'
+require 'spree/testing_support/common_rake'
 
 RSpec::Core::RakeTask.new
 
@@ -25,4 +27,4 @@ desc "Generates a dummy app for testing"
 task :test_app do
   ENV['LIB_NAME'] = 'spree_multi_currency'
   Rake::Task['common:test_app'].invoke
-end
+end

data/app/controllers/spree/admin/currencies_controller.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 module Spree
   class Admin::CurrenciesController < Admin::ResourceController
-    before_filter :set_currency, :only => [:edit, :update]
+    before_filter :set_currency, only: [:edit, :update]
 
     private
 

data/app/controllers/spree/admin/currency_converters_controller.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Spree
   class Admin::CurrencyConvertersController < Admin::ResourceController
   end

data/app/controllers/spree/base_controller_decorator.rb

@@ -1,11 +1,14 @@
+# encoding: utf-8
+
 Spree::BaseController.class_eval do
   before_filter :set_currency
 
   private
 
   def set_currency
-    if session[:currency_id].present? && (@currency = Spree::Currency.find_by_char_code(session[:currency_id]))
-      Spree::Currency.current!(@currency)
+    if session[:currency_id].present?
+        @currency = Spree::Currency.find_by_char_code(session[:currency_id])
+        Spree::Currency.current!(@currency) if @currency
     end
   end
 

data/app/controllers/spree/currency_controller.rb

@@ -1,9 +1,13 @@
+# encoding: utf-8
+
 module Spree
   class CurrencyController < Spree::BaseController
 
     def set
-      if @currency = Spree::Currency.find_by_char_code(params[:id].to_s.upcase)
-        session[:currency_id] = params[:id].to_s.upcase.to_sym
+      char_code = params[:id].to_s.upcase
+      @currency = Spree::Currency.find_by_char_code(char_code)
+      if @currency
+        session[:currency_id] = char_code.to_sym
         Spree::Currency.current!(@currency)
         flash.notice = t(:currency_changed)
       else
@@ -12,5 +16,6 @@ module Spree
 
       redirect_back_or_default(root_path)
     end
+
   end
 end

data/app/helpers/base_helper_decorator.rb

@@ -0,0 +1,8 @@
+Spree::BaseHelper.class_eval do
+
+  # redefine spree/core/app/helpers/spree/base_helper.rb
+  def display_price(product_or_variant)
+    product_or_variant.price_in(Spree::Currency.current).money.to_html
+  end
+end
+

data/app/helpers/number_helper_decorator.rb

@@ -1,3 +1,9 @@
+# encoding: utf-8
+
+# Encoding: utf-8
+#
+# redefined default method
+# http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html
 module ActionView
   module Helpers
     module NumberHelper
@@ -5,11 +11,17 @@ module ActionView
       def number_to_currency(number, options = {})
         return nil if number.nil?
         options.symbolize_keys!
-        options[:locale] = "currency_#{ Spree::Currency.current.try(:char_code) || I18n.default_locale }"
-        defaults  = I18n.translate('number.format', :locale => options[:locale], :default => {})
-        currency  = I18n.translate('number.currency.format', :locale => options[:locale], :default => {})
+        currency_char = Spree::Currency.current.try(:char_code) ||
+                        I18n.default_locale
+        options[:locale] = "currency_#{ currency_char }"
+        defaults  = I18n.translate('number.format',
+                                   locale: options[:locale],
+                                   default: {})
+        currency  = I18n.translate('number.currency.format',
+                                   locale: options[:locale],
+                                   default: {})
         defaults  = DEFAULT_CURRENCY_VALUES.merge(defaults).merge!(currency)
-        defaults[:negative_format] = "-" + options[:format] if options[:format]
+        defaults[:negative_format] = '-%n %u'
         options   = defaults.merge!(options)
 
         unit      = options.delete(:unit)
@@ -17,24 +29,14 @@ module ActionView
 
         if number.to_f < 0
           format = options.delete(:negative_format)
-          number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
+          number = number.abs
         end
 
-        begin
-          value = number_with_precision(number, options.merge(:raise => true))
-          format.gsub(/%n/, value).gsub(/%u/, unit).html_safe
-        rescue InvalidNumberError => e
-          if options[:raise]
-            raise
-          else
-            formatted_number = format.gsub(/%n/, e.number).gsub(/%u/, unit)
-            e.number.to_s.html_safe? ? formatted_number.html_safe : formatted_number
-          end
-        end
+        value = number_with_precision(number, options.merge(raise: true))
+        format.gsub(/%n/, value).gsub(/%u/, unit).html_safe
 
       end
 
-
     end
   end
 end

data/app/models/spree/adjustment_decorator.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 Spree::Adjustment.class_eval do
   extend Spree::MultiCurrency
   multi_currency :amount

data/app/models/spree/controller_helper_order.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+Spree::Core::ControllerHelpers::Order.class_eval do
+
+  # redefined spree/core/lib/spree/core/controller_helpers/order.rb
+  def current_currency
+    Spree::Currency.current.char_code
+  end
+
+end
+

data/app/models/spree/currency.rb

@@ -1,24 +1,25 @@
+# encoding: utf-8
+
 require 'money'
-class OriginMoney < Money
-end
 
 module Spree
   class Currency < ActiveRecord::Base
 
     has_many :currency_converters do
       def get_rate(date)
-        last(:conditions => ["date_req <= ?", date])
+        last(conditions: ["date_req <= ?", date])
       end
     end
 
-    default_scope :order => "spree_currencies.locale"
-    scope :locale, lambda{|str| where("locale like ?", "%#{str}%")}
+    default_scope order: 'spree_currencies.locale'
+    scope :locale, lambda { |str| where("locale like ?", "%#{str}%") }
     after_save :reset_basic_currency
 
     attr_accessible :basic, :locale, :char_code, :num_code, :name
 
+    # FIXME must be transaction
     def basic!
-      self.class.update_all(:basic => false) && update_attribute(:basic, true)
+      self.class.update_all(basic: false) && update_attribute(:basic, true)
     end
 
     def locale=(locales)
@@ -26,40 +27,89 @@ module Spree
     end
 
     def locale(need_split = true)
-      need_split ? read_attribute(:locale).to_s.split(',') : read_attribute(:locale).to_s
+      locale_var = read_attribute(:locale).to_s
+      if need_split
+        locale_var.split(',')
+      else
+        locale_var
+      end
     end
 
     # We can only have one main currency.
     # Therefore we reset all other currencies but the current if it's the main.
     def reset_basic_currency
-      self.class.where("id != ?", self.id).update_all(:basic => false) if self.basic?
+      if basic?
+        self.class.where("id != ?", id).update_all(basic: false)
+      end
     end
 
     class << self
 
+        # return array of all char_codes
+        def all_currencies
+            all.map(&:char_code)
+        end
+
       # Get the current locale
-      def current( current_locale = nil )
+      def current(current_locale = nil)
         @current ||= locale(current_locale || I18n.locale).first
+        if @current
+          return @current
+        else
+          mess = 'Require load and set default currency'
+          mess << '<br/>'
+          mess << 'Locale field is factor for determine current currency'
+          raise mess
+        end
       end
 
-      def current!(current_locale = nil )
-        @current = current_locale.is_a?(Spree::Currency) ? current_locale : locale(current_locale||I18n.locale).first
+      def current!(current_locale = nil)
+        if current_locale.is_a?(Spree::Currency)
+          @current = current_locale
+        else
+          @current = locale(current_locale || I18n.locale).first
+        end
       end
 
-      def load_rate(options= {})
+      def load_rate(options = {})
         current(options[:locale] || I18n.locale)
-        basic
-        if @rate = @current.currency_converters.get_rate(options[:date] || Time.now)
-          add_rate(@basic.char_code,   @current.char_code, @rate.nominal/@rate.value.to_f)
-          add_rate(@current.char_code, @basic.char_code,   @rate.value.to_f)
+        load_rate_from(@current.char_code)
+      end
+
+      # load rate for currency(char_code) to basic
+      def load_rate_from(from_char_code)
+        from_cur = Spree::Currency.find_by_char_code(from_char_code)
+        basic = Spree::Currency.basic
+        rate = from_cur.currency_converters.get_rate(Time.now)
+        if rate
+          add_rate(basic.char_code,
+                   from_cur.char_code,
+                   rate.nominal/rate.value.to_f)
+          add_rate(from_cur.char_code,
+                   basic.char_code,
+                   rate.value.to_f)
         end
       end
 
       # Exchanges money between two currencies.
       # E.g. with these args: 150, DKK, GBP returns 16.93
       def convert(value, from, to)
-        res = ( OriginMoney.new(value.to_f * 10000, from).exchange_to(to).to_f / 100).round(2)
-        #Rails.logger.info "#{value} #{from} == #{res} #{to}"
+        begin
+          from_money = ::Money.new(value.to_f * 10000, from)
+          res = from_money.exchange_to(to)
+          res = (res.to_f / 100).round(2)
+        rescue => e
+          load_rate_from(from)
+          begin
+            currency_config = Spree::Config.currency
+            res = from_money.exchange_to(currency_config)
+            load_rate_from(to)
+            res = ::Money.new(res, currency_config).exchange_to(to)
+            res = res.to_f
+          rescue => e
+            raise "Require load actual currency \t\n #{e}"
+          end
+        end
         res
       end
 
@@ -70,47 +120,41 @@ module Spree
         load_rate(options)
         convert(value, @basic.char_code, @current.char_code)
       rescue => ex
-        Rails.logger.error " [ Currency ] :#{ex.inspect} \n #{ex.backtrace.join('\n ')}"
+        error_logger(ex)
         value
       end
 
-      # Converts the currency value of the current locale to the basic currency.
+      # Converts the currency value of the current locale to the basic currency
       # In the parameters you can specify the locale you wish to convert FROM.
       # Usage: Currency.conversion_from_current(100, :locale => "da")
-      def conversion_from_current(value, options={})
+      def conversion_from_current(value, options = {})
         load_rate(options)
-
-        # Replace commas with dots as decimal mark for those languages that use this.
-
-        # 2,000.00 => 2000.00
-        value.gsub!(",","") if (value =~ /\,[0-9]+\./)
-
-        # 2.000,00 => 2000.00
-        value.gsub!(".","").gsub!(",",".") if (value =~ /\.[0-9]+\,/)
-
-        # 2000,00 => 2000.00
-        value.gsub!(",","") if (value =~ /\.[0-9]+\,/)
-
-        convert(value, @current.char_code, @basic.char_code)
+        convert(parse_price(value), @current.char_code, @basic.char_code)
       rescue => ex
-        Rails.logger.error " [ Currency ] :#{ex.inspect} \n #{e.backtrace.join('\n ')}"
+        error_logger(ex)
         value
       end
 
+      # write to error log
+      # ex - Exception from 'rescue => e'
+      def error_logger(ex)
+        mes = " [ Currency ] :#{ex.inspect} \n #{ex.backtrace.join('\n ')}"
+        Rails.logger.error mes
+      end
 
       # Retrieves the main currency.
       def basic
-        @basic ||= where(:basic => true).first
+        @basic ||= where(basic: true).first
       end
 
-      def get(num_code, options ={ })
+      def get(num_code, options = {})
         find_by_num_code(num_code) || create(options)
       end
 
       private
 
       def add_rate(from, to, rate)
-        OriginMoney.add_rate(from, to, rate.to_f )
+        ::Money.add_rate(from, to, rate.to_f)
       end
 
     end