vlatko_dawanda 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83997f221c62c400d5001080e4e48c18e363ad3b
-  data.tar.gz: 892766a23ef320afc209b67ea20ca455c2f6fa00
+  metadata.gz: a4cb467fb704f4094f128b541ca44495c6341334
+  data.tar.gz: 3b3b527b160a2a526f36b7ab0a9d85041cd86742
 SHA512:
-  metadata.gz: 89a873e3f7f92ecbd8b89a2e9a8f02bc464b6434944c155b9aabdae284c83ec12fab024fb613c369fbaac73133c688c8c93b5e6c216c045e430777b5411e5b72
-  data.tar.gz: 66a0b0af4c780900e7d6b67a3e0b704bbbeeb0e5a9997226fadc168e730fad0e8a5f62427076a32a23877eed47bab35625da456e8426396a231c50db1dfa1f56
+  metadata.gz: 1b11457a61d48cc3bc772e4a0da2ba5eda39a4bfb14a88da7267a85d5f1054937e53ae47f238ea5c95c32ba4039588f3b8a1887ab7caf3ded402bdcf2a449ff8
+  data.tar.gz: 3a0e74e15ca39816c148050cc5eb8b094c39722e2d601c04671b765d7399934bb56141d971f45c238de1ba47c1dad36661144f7bc31bec7fe948bc056abac0ef

data/lib/vlatko_dawanda/bank.rb

@@ -0,0 +1,40 @@
+module VlatkoDawanda
+  class Bank
+
+    def conversion_rates(base_currency, currencies)
+      @currencies = parse_currencies(base_currency, currencies)
+    end
+
+    def currencies
+      @currencies ||= {}
+    end
+
+    def find_currency(search)
+      currency = case search
+      when ::String, ::Symbol
+        currencies[currency_id(search)]
+      when Currency
+        found = currencies[currency_id(search.iso_code)]
+        raise UnknownCurrency.new('currency not matching the rate') unless found == search
+        found
+      end
+
+      raise UnknownCurrency.new('currency not found') if currency.nil?
+      currency
+    end
+
+    private
+
+    def parse_currencies(base_currency, currencies)
+      currencies.merge({base_currency => 1}).inject({}) do |memo, (key,value)|
+        memo[currency_id(key)] = Currency.new({iso_code: key, rate: value})
+        memo
+      end
+    end
+
+    def currency_id(value)
+      value.downcase.to_sym
+    end
+
+  end
+end

data/lib/vlatko_dawanda/currency.rb

@@ -0,0 +1,24 @@
+module VlatkoDawanda
+  class Currency
+    include Comparable
+
+    attr_reader :iso_code, :rate
+
+    def initialize(options = {})
+      @iso_code = options[:iso_code]
+      @rate = validate_rate(options[:rate])
+    end
+
+    def <=>(other)
+      rate <=> other.rate
+    end
+
+    private
+
+    def validate_rate(value)
+      rate = value.to_d rescue 0.to_d
+      raise InvalidRate.new('please enter a positive float or integer as a rate') if rate <= 0
+      rate
+    end
+  end
+end

data/lib/vlatko_dawanda/money.rb

@@ -5,37 +5,20 @@ module VlatkoDawanda
     include Comparable
 
     class << self
-      def conversion_rates(base_currency, currencies)
-        @currencies = parse_currencies(base_currency, currencies)
-      end
-
-      def currencies
-        @currencies ||= {}
-      end
+      attr_writer :bank
 
-      private
-
-      # I'm doing this instead of simple merge with the input hash
-      # cause I prefer working with symbols as keys whenever possible
-      # and the garbage collector is not that polluted
-      def parse_currencies(base_currency, currencies)
-        currencies.merge({base_currency => 1}).inject({}) do |memo, (key,value)|
-          rate = validate_rate(value)
-          memo[key.downcase.to_sym] = {iso_code: key, rate: rate}
-          memo
-        end
+      def bank
+        @bank ||= Bank.new
       end
 
-      def validate_rate(value)
-        rate = value.to_d rescue 0.to_d
-        raise InvalidRate.new('please enter a positive float as a rate') if rate <= 0
-        rate
+      def conversion_rates(base_currency, currencies)
+        bank.conversion_rates(base_currency, currencies)
       end
     end
 
     def initialize(amount, iso_code)
       @amount = amount.to_d
-      @currency = find_currency(iso_code)
+      @currency = bank.find_currency(iso_code)
     end
 
     def amount
@@ -43,16 +26,21 @@ module VlatkoDawanda
     end
 
     def currency
-      @currency[:iso_code]
+      @currency.iso_code
     end
 
     def inspect
       "#{"%.2f" % amount} #{currency}"
     end
 
-    def convert_to(iso_code)
-      amount = (@amount / @currency[:rate]) * find_currency(iso_code)[:rate]
-      self.class.new(amount, iso_code)
+    def convert_to(currency)
+      to_currency = bank.find_currency(currency)
+      amount = if @currency == to_currency
+        @amount
+      else
+        (@amount / @currency.rate) * to_currency.rate
+      end
+      self.class.new(amount, to_currency.iso_code)
     end
 
     def <=>(other)
@@ -65,10 +53,8 @@ module VlatkoDawanda
 
     private
 
-    def find_currency(iso_code)
-      currency = self.class.currencies[iso_code.downcase.to_sym]
-      raise UnknownCurrency.new('currency not found') if currency.nil?
-      currency
+    def bank
+      self.class.bank
     end
 
     def to_f_or_i(v)
@@ -76,4 +62,4 @@ module VlatkoDawanda
     end
 
   end
-end
+end

data/lib/vlatko_dawanda/version.rb

@@ -1,3 +1,3 @@
 module VlatkoDawanda
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/vlatko_dawanda.rb

@@ -3,6 +3,8 @@ require "bigdecimal/util"
 require "vlatko_dawanda/version"
 require 'vlatko_dawanda/error_classes'
 require 'vlatko_dawanda/arithmetic'
+require 'vlatko_dawanda/currency'
+require 'vlatko_dawanda/bank'
 require 'vlatko_dawanda/money'
 
 begin

data/spec/vlatko_dawanda/bank_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe VlatkoDawanda::Bank do
+  it 'has currencies attribute that is a dictionary hash' do
+    expect(subject).to respond_to(:currencies)
+    expect(subject.currencies).to be_an_instance_of Hash
+  end
+
+  context 'conversion rates' do
+    before(:example) do
+      subject.conversion_rates('EUR', {'USD' => 1.11, 'Bitcoin' => 0.0047})
+    end
+
+    it 'parses all the currencies values into Currency objects' do
+      expect(subject.currencies.values).to all(be_an_instance_of(VlatkoDawanda::Currency))
+    end
+
+    it 'parses all the currencies keys to symbols of downcased iso codes' do
+      expect(subject.currencies.keys).to contain_exactly(:eur,:usd,:bitcoin)
+    end
+
+    it 'parses the base currency with rate 1' do
+      expect(subject.currencies[:eur].rate).to eq 1
+    end
+  end
+
+  context 'find currency' do
+    before(:example) do
+      subject.conversion_rates('EUR', {'USD' => 1.11, 'Bitcoin' => 0.0047})
+    end
+
+    let(:currency_by_iso_code){subject.find_currency('Bitcoin')}
+
+    context 'by iso code' do
+      it 'returns the approriate Currency object if the iso code is registered' do
+        expect(currency_by_iso_code).to be_an_instance_of(VlatkoDawanda::Currency)
+        expect(currency_by_iso_code.iso_code).to eq 'Bitcoin'
+        expect(currency_by_iso_code.rate).to eq 0.0047
+      end
+
+      it 'raises an error when currency is not found' do
+        expect{subject.find_currency('MKD')}.to raise_error VlatkoDawanda::UnknownCurrency
+      end
+    end
+
+    context 'by currency object' do
+      let(:currency_by_object){subject.find_currency(currency_by_iso_code)}
+
+      it 'returns the approriate Currency object if the iso code is registered' do
+        expect(currency_by_object).to be_an_instance_of(VlatkoDawanda::Currency)
+        expect(currency_by_object.iso_code).to eq 'Bitcoin'
+        expect(currency_by_object.rate).to eq 0.0047
+      end
+
+      it 'raises an error when currency is not found' do
+        invalid_currency = currency_by_object.instance_variable_set('@rate', currency_by_object.rate + 1)
+        expect{subject.find_currency(invalid_currency)}.to raise_error VlatkoDawanda::UnknownCurrency
+      end
+    end
+  end
+
+
+end

data/spec/vlatko_dawanda/currency_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe VlatkoDawanda::Currency do
+  let(:currency){described_class.new({iso_code: 'EUR', rate: rand(0.1..5.0)})}
+  let(:invalid_currency){described_class.new({iso_code: 'USD', rate: rand(-5.0..0)})}
+
+  context 'valid' do
+    specify 'to have rate' do
+      expect(currency).to respond_to(:rate)
+    end
+
+    specify 'to have iso_code' do
+      expect(currency).to respond_to(:iso_code)
+    end
+
+    specify 'when the rate is a positive float or integer' do
+      expect{currency}.to_not raise_error(VlatkoDawanda::InvalidRate)
+    end
+
+    specify 'rate is BigDecimal' do
+      expect(currency.rate).to be_an_instance_of(BigDecimal)
+    end
+  end
+
+  context 'invalid' do
+    specify 'when the rate is not a positive float or integer' do
+      expect{invalid_currency}.to raise_error(VlatkoDawanda::InvalidRate)
+    end
+  end
+
+  context 'comparable' do
+    let(:equal_currency){currency.dup}
+    it 'should be equal if the rate of the other is equal' do
+      expect(currency).to eq equal_currency
+    end
+
+    it 'should not equal if the rate of the other is different' do
+      diff_currency = described_class.new({iso_code: equal_currency.iso_code, rate: equal_currency.rate + 1 })
+
+      expect(currency).to_not eq diff_currency
+    end
+  end
+end

data/spec/vlatko_dawanda/money_spec.rb

@@ -1,88 +1,61 @@
 require 'spec_helper'
 
 describe VlatkoDawanda::Money do
-
-  context '#conversion_rates parsing' do
-    let(:hash_currency_input){{'USD' => 1.11, 'Bitcoin' => 0.0047}}
-    let(:currencies){described_class.conversion_rates('EUR', hash_currency_input)}
-
-    it 'includes the right currencies from input' do
-      expect(currencies.keys).to contain_exactly(:eur, :usd, :bitcoin)
-    end
-
-    it 'does not include a currency that is not in the input' do
-      expect(currencies.keys).to_not include(:mkd)
-    end
-
-    context 'raises an InvalidRate' do
-      specify 'rate is zero' do
-        invalid_hash = {'MKD' => 0}
-        expect{described_class.conversion_rates('EUR', invalid_hash)}.to raise_error VlatkoDawanda::InvalidRate
-      end
-
-      specify 'rate is negative number' do
-        invalid_hash = {'MKD' => -1}
-        expect{described_class.conversion_rates('EUR', invalid_hash)}.to raise_error VlatkoDawanda::InvalidRate
-      end
-    end
-
-    it 'parses the base currency with rate 1' do
-      expect(currencies[:eur][:rate]).to eq 1
-    end
-
-    it 'parses the currencies with bigdecimal classes' do
-      expect(currencies.map{|k,v| v[:rate]}).to all(be_an_instance_of(BigDecimal))
+  context 'bank' do
+    it 'is configurable for all money objects' do
+      expect(described_class).to respond_to(:bank=)
+      expect(described_class).to respond_to(:bank)
     end
 
-    it 'equals the same rates as the input hash' do
-      expect(currencies[:usd][:rate]).to eq hash_currency_input[currencies[:usd][:iso_code]]
-      expect(currencies[:bitcoin][:rate]).to eq hash_currency_input[currencies[:bitcoin][:iso_code]]
+    specify 'its default bank to be the Bank class' do
+      expect(described_class.bank).to be_an_instance_of(VlatkoDawanda::Bank)
     end
   end
 
-  context 'instantation of objects' do
+  context 'instantiate an object' do
     before(:context) do
       described_class.conversion_rates('EUR', {'USD' => 1.11, 'Bitcoin' => 0.0047})
     end
 
-    let(:existing_currency){described_class.new(50, 'EUR')}
-    let(:non_existing_currency){described_class.new(50, 'MKD')}
-    let(:float_currency){described_class.new(50.50, 'USD')}
-
-    it 'is valid when existing currency is in input' do
-      expect{ existing_currency }.to_not raise_error VlatkoDawanda::UnknownCurrency
-    end
+    context 'validation' do
+      specify 'when the currency is registered' do
+        euro = described_class.new(50, 'USD')
+        expect{euro}.to_not raise_error VlatkoDawanda::UnknownCurrency
+        expect(euro.instance_variable_get('@currency')).to be_an_instance_of(VlatkoDawanda::Currency)
+      end
 
-    it 'is raises UnknownCurrency error when non existing currency is in input' do
-      expect{ non_existing_currency }.to raise_error VlatkoDawanda::UnknownCurrency
+      it 'raises UnknownCurrency error when the currency is not registered' do
+        expect{described_class.new(50, 'MKD')}.to raise_error VlatkoDawanda::UnknownCurrency
+      end
     end
 
-    context 'depending of the amount input' do
+    context 'parsed outputs for attributes' do
+      let(:existing_currency){described_class.new(50, 'EUR')}
+      let(:float_currency){described_class.new(50.50, 'USD')}
 
-      it 'outputs the amount in integer when 50' do
+      it 'outputs the amount in integer when integer input' do
         expect(existing_currency.amount).to eq 50
         expect(existing_currency.amount).to be_an(Integer)
       end
 
-      it 'outputs the amount in float when 50.50' do
+      it 'outputs the amount in float when float input' do
         expect(float_currency.amount).to eq 50.50
         expect(float_currency.amount).to be_an(Float)
       end
 
-    end
-
-    it 'outputs iso code for currency' do
-      expect(existing_currency.currency).to eq 'EUR'
-    end
+      it 'outputs iso code for currency' do
+        expect(existing_currency.currency).to eq 'EUR'
+      end
 
-    it 'outputs the amount and currency iso code when inspected' do
-      expect(existing_currency.inspect).to eq "50.00 EUR"
+      it 'outputs the amount and currency iso code when inspected' do
+        expect(existing_currency.inspect).to eq "50.00 EUR"
+      end
     end
   end
 
   context 'conversion to different currency' do
     before(:context) do
-      @currencies = described_class.conversion_rates('EUR', {'USD' => 1.11, 'Bitcoin' => 0.0047})
+      described_class.conversion_rates('EUR', {'USD' => 1.11, 'Bitcoin' => 0.0047})
     end
 
     let(:euro){described_class.new(50,'EUR')}
@@ -137,5 +110,4 @@ describe VlatkoDawanda::Money do
       expect(twenty_usd).to be < fifty_eur
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vlatko_dawanda
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Vlatko Ristovski
@@ -85,11 +85,15 @@ files:
 - bin/setup
 - lib/vlatko_dawanda.rb
 - lib/vlatko_dawanda/arithmetic.rb
+- lib/vlatko_dawanda/bank.rb
+- lib/vlatko_dawanda/currency.rb
 - lib/vlatko_dawanda/error_classes.rb
 - lib/vlatko_dawanda/money.rb
 - lib/vlatko_dawanda/version.rb
 - spec/spec_helper.rb
 - spec/vlatko_dawanda/arithmetic_spec.rb
+- spec/vlatko_dawanda/bank_spec.rb
+- spec/vlatko_dawanda/currency_spec.rb
 - spec/vlatko_dawanda/money_spec.rb
 - spec/vlatko_dawanda_spec.rb
 - vlatko_dawanda.gemspec