latinum 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e0f3fcf6c01e2d091b709e6a02aa8453871276d
-  data.tar.gz: 65c8c8fed7bd38ee450212c631ea2fcccb9754e5
+  metadata.gz: d603254177726ef91a442d285c4ba917dd6cc003
+  data.tar.gz: bb81b377411b4ab43c8246c01c478740a0e4e8d4
 SHA512:
-  metadata.gz: 92dbfdfa7064f905e6ae559a972c7d6bd42a9a516d3b9aef9cf953e9431de51074c6a9afb523c729a7fb3f024bd10d1c3ebec57a1c6d63cd3a85feb558f1f543
-  data.tar.gz: 27fd684c753fa6ef97f0f12fdfa6d6ad3b42a5564ce15f089009a348b3061d6a5fc450b1629703b37ccbe3cca4d3f51333e53dcd23cf07dcacceea3ad94c21e3
+  metadata.gz: 0ae00f87d9c4a9b0a711b0736f2be1ec2e797fa4cdeb4ffc0dcedafe550b60e736e2d1ff665100f4a8665dea9bb34015458b7b55094aa8e2014033b1f3cc1705
+  data.tar.gz: 407e0b27c15a640b4893f70d413eb0eae70b5bcab2112c6e9af99590af9a2cda4de915740222bc332bc0653d73c1079b664a693f628fd4838643a9f9a11e0d15

data/README.md

@@ -65,10 +65,9 @@ But, you can't add resources of different names together:
 
 To add multiple currencies together, use a collection:
 
-	> currencies = Set.new
-	> collection = Latinum::Collection.new(currencies)
+	> collection = Latinum::Collection.new
 	> collection << [ten, twenty]
-	> currencies.collect {|currency| collection[currency]}
+	> collection.collect(&:to_s)
 	=> [10.0 NZD, 20.0 AUD]
 
 #### Calculating Totals

data/lib/latinum/collection.rb

@@ -57,6 +57,25 @@ module Latinum
 			return self
 		end
 		
+		# Add something to this collection.
+		alias + <<
+		
+		# Subtract something from this collection.
+		def - other
+			self << -other
+		end
+		
+		# Allow negation of all values within the collection:
+		def -@
+			collection = self.class.new
+			
+			@resources.each do |key, value|
+				collection.resources[key] = -value
+			end
+			
+			return collection
+		end
+		
 		# Get a `Resource` for the given name:
 		def [] key
 			Resource.new(@resources[key], key)

data/lib/latinum/formatters.rb

@@ -64,7 +64,7 @@ module Latinum
 				fix, frac = amount.abs.to_s('F').split(/\./, 2)
 
 				# The sign of the number
-				sign = amount.sign < 0 ? '-' : ''
+				sign = '-' if amount.negative?
 
 				# Decimal places, e.g. the '.00' in '$10.00'
 				frac = frac[0...@places].ljust(@places, @zero)

data/lib/latinum/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Latinum
-	VERSION = "1.2.0"
+	VERSION = "1.3.0"
 end

data/spec/latinum/bank_spec.rb

@@ -21,65 +21,63 @@
 require 'latinum'
 require 'latinum/currencies/global'
 
-module Latinum::BankSpec
-	describe Latinum::Bank do
-		before(:all) do
-			@bank = Latinum::Bank.new(Latinum::Currencies::Global)
-			
-			@bank << Latinum::ExchangeRate.new("NZD", "AUD", "0.5")
-		end
+RSpec.describe Latinum::Bank do
+	before(:all) do
+		@bank = Latinum::Bank.new(Latinum::Currencies::Global)
 		
-		it "should format the amounts correctly" do
-			resource = Latinum::Resource.new("10", "NZD")
-			
-			expect(@bank.format(resource)).to be == "$10.00 NZD"
-			expect(@bank.format(resource, name: nil)).to be == "$10.00"
-			
-			resource = Latinum::Resource.new("391", "AUD")
-			expect(@bank.format(resource)).to be == "$391.00 AUD"
-			
-			resource = Latinum::Resource.new("-100", "NZD")
-			expect(@bank.format(resource)).to be == "-$100.00 NZD"
-			
-			resource = Latinum::Resource.new("1.12345678", "BTC")
-			expect(@bank.format(resource)).to be == "B⃦1.12345678 BTC"
-		end
+		@bank << Latinum::ExchangeRate.new("NZD", "AUD", "0.5")
+	end
+	
+	it "should format the amounts correctly" do
+		resource = Latinum::Resource.new("10", "NZD")
+		
+		expect(@bank.format(resource)).to be == "$10.00 NZD"
+		expect(@bank.format(resource, name: nil)).to be == "$10.00"
+		
+		resource = Latinum::Resource.new("391", "AUD")
+		expect(@bank.format(resource)).to be == "$391.00 AUD"
 		
-		it "should round up using correct precision" do
-			resource = Latinum::Resource.new("19.9989", "NZD")
-			
-			expect(@bank.round(resource)).to be == Latinum::Resource.new(20, "NZD")
-		end
+		resource = Latinum::Resource.new("-100", "NZD")
+		expect(@bank.format(resource)).to be == "-$100.00 NZD"
+		
+		resource = Latinum::Resource.new("1.12345678", "BTC")
+		expect(@bank.format(resource)).to be == "B⃦1.12345678 BTC"
+	end
+	
+	it "should round up using correct precision" do
+		resource = Latinum::Resource.new("19.9989", "NZD")
 		
-		it "should round down using correct precision" do
-			resource = Latinum::Resource.new("19.991", "NZD")
-			
-			expect(@bank.round(resource)).to be == Latinum::Resource.new("19.99", "NZD")
-		end
+		expect(@bank.round(resource)).to be == Latinum::Resource.new(20, "NZD")
+	end
+	
+	it "should round down using correct precision" do
+		resource = Latinum::Resource.new("19.991", "NZD")
 		
-		it "should round values when formatting" do
-			resource = Latinum::Resource.new("19.9989", "NZD")
-			
-			expect(@bank.format(resource)).to be == "$20.00 NZD"
-		end
+		expect(@bank.round(resource)).to be == Latinum::Resource.new("19.99", "NZD")
+	end
+	
+	it "should round values when formatting" do
+		resource = Latinum::Resource.new("19.9989", "NZD")
 		
-		it "should exchange currencies from NZD to AUD" do
-			nzd = Latinum::Resource.new("10", "NZD")
-			
-			aud = @bank.exchange nzd, "AUD"
-			expect(aud).to be == Latinum::Resource.new("5", "AUD")
-		end
+		expect(@bank.format(resource)).to be == "$20.00 NZD"
+	end
+	
+	it "should exchange currencies from NZD to AUD" do
+		nzd = Latinum::Resource.new("10", "NZD")
 		
-		it "should parser strings into resources" do
-			expect(@bank.parse("$5")).to be == Latinum::Resource.new("5", "USD")
-			expect(@bank.parse("$5 NZD")).to be == Latinum::Resource.new("5", "NZD")
-			expect(@bank.parse("€5")).to be == Latinum::Resource.new("5", "EUR")
-			
-			expect(@bank.parse("5 NZD")).to be == Latinum::Resource.new("5", "NZD")
-		end
+		aud = @bank.exchange nzd, "AUD"
+		expect(aud).to be == Latinum::Resource.new("5", "AUD")
+	end
+	
+	it "should parser strings into resources" do
+		expect(@bank.parse("$5")).to be == Latinum::Resource.new("5", "USD")
+		expect(@bank.parse("$5 NZD")).to be == Latinum::Resource.new("5", "NZD")
+		expect(@bank.parse("€5")).to be == Latinum::Resource.new("5", "EUR")
 		
-		it "should fail to parse unknown resource" do
-			expect{@bank.parse("B5")}.to raise_error(ArgumentError)
-		end
+		expect(@bank.parse("5 NZD")).to be == Latinum::Resource.new("5", "NZD")
+	end
+	
+	it "should fail to parse unknown resource" do
+		expect{@bank.parse("B5")}.to raise_error(ArgumentError)
 	end
 end

data/spec/latinum/collection_spec.rb

@@ -23,76 +23,82 @@ require 'latinum/currencies/global'
 
 require 'set'
 
-module Latinum::CollectionSpec
-	describe Latinum::Collection do
-		it "can set an initial value" do
-			subject["NZD"] = BigDecimal.new("20")
-			
-			expect(subject["NZD"]).to be == Latinum::Resource.load("20 NZD")
-		end
+RSpec.describe Latinum::Collection do
+	it "can set an initial value" do
+		subject["NZD"] = BigDecimal.new("20")
 		
-		it "should sum up currencies correctly" do
-			resource = Latinum::Resource.new("10", "NZD")
-			
-			subject << resource
-			expect(subject["NZD"]).to be == resource
-			
-			subject << resource
-			expect(subject["NZD"]).to be == (resource * 2)
-		end
+		expect(subject["NZD"]).to be == Latinum::Resource.load("20 NZD")
+	end
+	
+	it "can be negated" do
+		subject["NZD"] = BigDecimal.new("20")
+		
+		negated = -subject
+		
+		expect(negated["NZD"]).to be == BigDecimal.new("-20")
+	end
+	
+	it "should sum up currencies correctly" do
+		resource = Latinum::Resource.new("10", "NZD")
+		
+		subject << resource
+		expect(subject["NZD"]).to be == resource
+		
+		subject << resource
+		expect(subject["NZD"]).to be == (resource * 2)
+	end
+	
+	it "should sum up multiple currencies correctly" do
+		resources = [
+			Latinum::Resource.new("10", "NZD"),
+			Latinum::Resource.new("10", "AUD"),
+			Latinum::Resource.new("10", "USD"),
+			Latinum::Resource.new("10", "NZD"),
+			Latinum::Resource.new("10", "AUD"),
+			Latinum::Resource.new("10", "USD"),
+		]
 		
-		it "should sum up multiple currencies correctly" do
-			resources = [
-				Latinum::Resource.new("10", "NZD"),
-				Latinum::Resource.new("10", "AUD"),
-				Latinum::Resource.new("10", "USD"),
-				Latinum::Resource.new("10", "NZD"),
-				Latinum::Resource.new("10", "AUD"),
-				Latinum::Resource.new("10", "USD"),
-			]
-			
-			subject = Latinum::Collection.new
-			subject << resources
-			
-			expect(subject["NZD"]).to be == (resources[0] * 2)
-			expect(subject.names).to be == Set.new(["NZD", "AUD", "USD"])
-		end
+		subject = Latinum::Collection.new
+		subject << resources
+		
+		expect(subject["NZD"]).to be == (resources[0] * 2)
+		expect(subject.names).to be == Set.new(["NZD", "AUD", "USD"])
+	end
+	
+	it "can add two collections together" do
+		other_resources = [
+			Latinum::Resource.new("10", "NZD"),
+			Latinum::Resource.new("10", "AUD"),
+			Latinum::Resource.new("10", "USD"),
+		]
+		
+		other_collection = Latinum::Collection.new
+		other_collection << other_resources
+		
+		resources = [
+			Latinum::Resource.new("10", "NZD"),
+			Latinum::Resource.new("10", "AUD"),
+			Latinum::Resource.new("10", "USD"),
+		]
+		
+		subject << resources
+		subject << other_collection
+		
+		expect(subject["NZD"]).to be == Latinum::Resource.load("20 NZD")
+		expect(subject["AUD"]).to be == Latinum::Resource.load("20 AUD")
+		expect(subject["USD"]).to be == Latinum::Resource.load("20 USD")
+	end
+	
+	it "can enumerate resources" do
+		resources = [
+			Latinum::Resource.new("10", "NZD"),
+			Latinum::Resource.new("10", "AUD"),
+			Latinum::Resource.new("10", "USD"),
+		]
 		
-		it "can add two collections together" do
-			other_resources = [
-				Latinum::Resource.new("10", "NZD"),
-				Latinum::Resource.new("10", "AUD"),
-				Latinum::Resource.new("10", "USD"),
-			]
-			
-			other_collection = Latinum::Collection.new
-			other_collection << other_resources
-			
-			resources = [
-				Latinum::Resource.new("10", "NZD"),
-				Latinum::Resource.new("10", "AUD"),
-				Latinum::Resource.new("10", "USD"),
-			]
-			
-			subject << resources
-			subject << other_collection
-			
-			expect(subject["NZD"]).to be == Latinum::Resource.load("20 NZD")
-			expect(subject["AUD"]).to be == Latinum::Resource.load("20 AUD")
-			expect(subject["USD"]).to be == Latinum::Resource.load("20 USD")
-		end
+		collection = Latinum::Collection.new
+		collection << resources
 		
-		it "can enumerate resources" do
-			resources = [
-				Latinum::Resource.new("10", "NZD"),
-				Latinum::Resource.new("10", "AUD"),
-				Latinum::Resource.new("10", "USD"),
-			]
-			
-			collection = Latinum::Collection.new
-			collection << resources
-			
-			expect(collection.each.to_a).to be == resources
-		end
+		expect(collection.each.to_a).to be == resources
 	end
 end

data/spec/latinum/comparison_spec.rb

@@ -20,23 +20,21 @@
 
 require 'latinum/resource'
 
-module Latinum::ComparisonSpec
-	describe Latinum::Resource do
-		it "should be comparable to numeric values" do
-			resource = Latinum::Resource.load("10 NZD")
-			
-			expect(resource).to be < 20
-			expect(resource).to be > 5
-			expect(resource).to be == 10
-		end
+RSpec.describe Latinum::Resource do
+	it "should be comparable to numeric values" do
+		resource = Latinum::Resource.load("10 NZD")
 		
-		it "should compare with nil" do
-			a = Latinum::Resource.load("10 NZD")
-			
-			expect{a <=> nil}.to_not raise_exception
-			expect{a == nil}.to_not raise_exception
-			expect(a <=> nil).to be == nil
-			expect(a == nil).to be == false
-		end
+		expect(resource).to be < 20
+		expect(resource).to be > 5
+		expect(resource).to be == 10
+	end
+	
+	it "should compare with nil" do
+		a = Latinum::Resource.load("10 NZD")
+		
+		expect{a <=> nil}.to_not raise_exception
+		expect{a == nil}.to_not raise_exception
+		expect(a <=> nil).to be == nil
+		expect(a == nil).to be == false
 	end
 end

data/spec/latinum/formatters_spec.rb

@@ -22,66 +22,72 @@ require 'latinum/bank'
 require 'latinum/currencies/global'
 require 'latinum/formatters'
 
-module Latinum::FormattersSpec
-	describe Latinum::Formatters::PlainFormatter.new(name: "NZD") do
-		let(:amount) {BigDecimal.new(10)}
-		
-		it "can convert to integral" do
-			expect(subject.to_integral(amount)).to be == 10
-		end
-		
-		it "can convert from integral" do
-			expect(subject.from_integral(10)).to be == amount
-		end
-		
-		it "can do basic formatting" do
-			expect(subject.format(amount)).to be == "10.0 NZD"
-		end
+RSpec.describe Latinum::Formatters::PlainFormatter.new(name: "NZD") do
+	let(:amount) {BigDecimal.new(10)}
+	
+	it "can convert to integral" do
+		expect(subject.to_integral(amount)).to be == 10
 	end
 	
-	describe Latinum::Formatters::DecimalCurrencyFormatter do
-		before(:all) do
-			@bank = Latinum::Bank.new
-			@bank.import(Latinum::Currencies::Global)
-		end
-		
-		let(:resource) {Latinum::Resource.load("10 NZD")}
-		
-		it "should format output" do
-			expect(@bank.format(resource)).to be == "$10.00 NZD"
-		end
-		
-		it "should format output without name" do
-			expect(@bank.format(resource, name: nil)).to be == "$10.00"
-		end
-		
-		it "should format output with alternative name" do
-			expect(@bank.format(resource, name: "Foo")).to be == "$10.00 Foo"
-		end
-		
-		it "should format output" do
-			expect(@bank.format(resource)).to be == "$10.00 NZD"
-		end
-		
-		it "should format output without symbol" do
-			expect(@bank.format(resource, symbol: nil)).to be == "10.00 NZD"
-		end
-		
-		it "should format output with alternative symbol" do
-			expect(@bank.format(resource, symbol: "!!")).to be == "!!10.00 NZD"
-		end
+	it "can convert from integral" do
+		expect(subject.from_integral(10)).to be == amount
 	end
 	
-	describe Latinum::Formatters::DecimalCurrencyFormatter do
-		before(:all) do
-			@bank = Latinum::Bank.new
-			@bank.import(Latinum::Currencies::Global)
-		end
-		
-		let(:resource) {Latinum::Resource.load("10 JPY")}
+	it "can do basic formatting" do
+		expect(subject.format(amount)).to be == "10.0 NZD"
+	end
+end
+
+RSpec.describe Latinum::Formatters::DecimalCurrencyFormatter do
+	before(:all) do
+		@bank = Latinum::Bank.new
+		@bank.import(Latinum::Currencies::Global)
+	end
+	
+	let(:resource) {Latinum::Resource.load("10 NZD")}
+	
+	it "should format output" do
+		expect(@bank.format(resource)).to be == "$10.00 NZD"
+	end
+	
+	it "should format output without name" do
+		expect(@bank.format(resource, name: nil)).to be == "$10.00"
+	end
+	
+	it "should format output with alternative name" do
+		expect(@bank.format(resource, name: "Foo")).to be == "$10.00 Foo"
+	end
+	
+	it "should format output" do
+		expect(@bank.format(resource)).to be == "$10.00 NZD"
+	end
+	
+	it "should format output without symbol" do
+		expect(@bank.format(resource, symbol: nil)).to be == "10.00 NZD"
+	end
+	
+	it "should format output with alternative symbol" do
+		expect(@bank.format(resource, symbol: "!!")).to be == "!!10.00 NZD"
+	end
+	
+	context "negative zero" do
+		let(:resource) {Latinum::Resource.new(BigDecimal.new("-0"), "NZD")}
 		
-		it "should format without separator or fractional part" do
-			expect(@bank.format(resource)).to be == "¥10 JPY"
+		it "should format as (positve) zero" do
+			expect(@bank.format(resource)).to be == "$0.00 NZD"
 		end
 	end
 end
+
+RSpec.describe Latinum::Formatters::DecimalCurrencyFormatter do
+	before(:all) do
+		@bank = Latinum::Bank.new
+		@bank.import(Latinum::Currencies::Global)
+	end
+	
+	let(:resource) {Latinum::Resource.load("10 JPY")}
+	
+	it "should format without separator or fractional part" do
+		expect(@bank.format(resource)).to be == "¥10 JPY"
+	end
+end

data/spec/latinum/integrals_spec.rb

@@ -21,27 +21,25 @@
 require 'latinum'
 require 'latinum/currencies/global'
 
-module Latinum::CollectionSpec
-	describe Latinum::Bank do
-		before(:all) do
-			@bank = Latinum::Bank.new
-			@bank.import(Latinum::Currencies::Global)
-		end
+RSpec.describe Latinum::Bank do
+	before(:all) do
+		@bank = Latinum::Bank.new
+		@bank.import(Latinum::Currencies::Global)
+	end
+	
+	it "should convert to NZD integral value" do
+		resource = Latinum::Resource.new("10", "NZD")
+		
+		expect(@bank.to_integral(resource)).to be == 1000
+		
+		expect(@bank.from_integral(1000, "NZD")).to be == resource
+	end
+	
+	it "should convert to BTC integral value" do
+		resource = Latinum::Resource.new("1.12345678", "BTC")
 		
-		it "should convert to NZD integral value" do
-			resource = Latinum::Resource.new("10", "NZD")
-			
-			expect(@bank.to_integral(resource)).to be == 1000
-			
-			expect(@bank.from_integral(1000, "NZD")).to be == resource
-		end
+		expect(@bank.to_integral(resource)).to be == 112345678
 		
-		it "should convert to BTC integral value" do
-			resource = Latinum::Resource.new("1.12345678", "BTC")
-			
-			expect(@bank.to_integral(resource)).to be == 112345678
-			
-			expect(@bank.from_integral(112345678, "BTC")).to be == resource
-		end
+		expect(@bank.from_integral(112345678, "BTC")).to be == resource
 	end
 end

data/spec/latinum/resource_spec.rb

@@ -20,113 +20,111 @@
 
 require 'latinum/resource'
 
-module Latinum::ResourceSpec
-	describe Latinum::Resource do
-		it "should load and dump resources" do
-			resource = Latinum::Resource.load("10 NZD")
-			string_representation = Latinum::Resource.dump(resource)
-			
-			loaded_resource = Latinum::Resource.load(string_representation)
-			
-			expect(loaded_resource).to be == loaded_resource
-		end
+RSpec.describe Latinum::Resource do
+	it "should load and dump resources" do
+		resource = Latinum::Resource.load("10 NZD")
+		string_representation = Latinum::Resource.dump(resource)
 		
-		it "should load and dump nil correctly" do
-			expect(Latinum::Resource.load(nil)).to be nil
-			expect(Latinum::Resource.dump(nil)).to be nil
-		end
+		loaded_resource = Latinum::Resource.load(string_representation)
 		
-		it "should handle empty strings correctly" do
-			expect(Latinum::Resource.load("")).to be nil
-		end
+		expect(loaded_resource).to be == loaded_resource
+	end
+	
+	it "should load and dump nil correctly" do
+		expect(Latinum::Resource.load(nil)).to be nil
+		expect(Latinum::Resource.dump(nil)).to be nil
+	end
+	
+	it "should handle empty strings correctly" do
+		expect(Latinum::Resource.load("")).to be nil
+	end
+	
+	it "should handle whitespace strings correctly" do
+		expect(Latinum::Resource.load(" ")).to be nil
+	end
+	
+	it "should load and dump resources correctly" do
+		resource = Latinum::Resource.new(10, 'NZD')
 		
-		it "should handle whitespace strings correctly" do
-			expect(Latinum::Resource.load(" ")).to be nil
-		end
+		expect(Latinum::Resource.load("10.0 NZD")).to be == resource
+		expect(Latinum::Resource.dump(resource)).to be == "10.0 NZD"
+	end
+	
+	it "should inspect nicely" do
+		resource = Latinum::Resource.load("10 NZD")
 		
-		it "should load and dump resources correctly" do
-			resource = Latinum::Resource.new(10, 'NZD')
-			
-			expect(Latinum::Resource.load("10.0 NZD")).to be == resource
-			expect(Latinum::Resource.dump(resource)).to be == "10.0 NZD"
-		end
+		expect(resource.inspect).to be == '#<Latinum::Resource "10.0 NZD">'
+	end
+	
+	it "should compute percentage difference" do
+		original_price = Latinum::Resource.load("10 NZD")
+		discount_price = Latinum::Resource.load("5 NZD")
 		
-		it "should inspect nicely" do
-			resource = Latinum::Resource.load("10 NZD")
-			
-			expect(resource.inspect).to be == '#<Latinum::Resource "10.0 NZD">'
-		end
+		discount = (original_price - discount_price) / original_price
 		
-		it "should compute percentage difference" do
-			original_price = Latinum::Resource.load("10 NZD")
-			discount_price = Latinum::Resource.load("5 NZD")
-			
-			discount = (original_price - discount_price) / original_price
-			
-			expect(discount).to be == 0.5
-		end
+		expect(discount).to be == 0.5
+	end
+	
+	it "should not divide" do
+		original_price = Latinum::Resource.load("10 NZD")
+		discount_price = Latinum::Resource.load("5 USD")
 		
-		it "should not divide" do
-			original_price = Latinum::Resource.load("10 NZD")
-			discount_price = Latinum::Resource.load("5 USD")
-			
-			expect{original_price / discount_price}.to raise_exception(Latinum::DifferentResourceNameError)
-		end
+		expect{original_price / discount_price}.to raise_exception(Latinum::DifferentResourceNameError)
+	end
+	
+	it "should compute quotient" do
+		original_price = Latinum::Resource.load("10 NZD")
 		
-		it "should compute quotient" do
-			original_price = Latinum::Resource.load("10 NZD")
-			
-			expect(original_price / 2.0).to be == Latinum::Resource.load("5 NZD")
-		end
+		expect(original_price / 2.0).to be == Latinum::Resource.load("5 NZD")
+	end
+	
+	it "should add two resources of the same symbol" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("5 NZD")
+		c = Latinum::Resource.load("15 NZD")
 		
-		it "should add two resources of the same symbol" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("5 NZD")
-			c = Latinum::Resource.load("15 NZD")
-			
-			expect(a+b).to be == c
-		end
+		expect(a+b).to be == c
+	end
+	
+	it "should fail two resources of different symbol" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("5 USD")
 		
-		it "should fail two resources of different symbol" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("5 USD")
-			
-			expect{a+b}.to raise_error(Latinum::DifferentResourceNameError)
-		end
+		expect{a+b}.to raise_error(Latinum::DifferentResourceNameError)
+	end
+	
+	it "should be able to negate a value" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("-10 NZD")
 		
-		it "should be able to negate a value" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("-10 NZD")
-			
-			expect(-a).to be == b
-		end
+		expect(-a).to be == b
+	end
+	
+	it "can be used as a hash key" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("0 NZD")
 		
-		it "can be used as a hash key" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("0 NZD")
-			
-			hash = {a => true}
-			
-			expect(hash).to be_include a
-			expect(hash).to_not be_include b
-		end
+		hash = {a => true}
 		
-		it "can be zero" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("0 NZD")
-			
-			expect(a).to_not be_zero
-			expect(b).to be_zero
-		end
+		expect(hash).to be_include a
+		expect(hash).to_not be_include b
+	end
+	
+	it "can be zero" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("0 NZD")
+		
+		expect(a).to_not be_zero
+		expect(b).to be_zero
+	end
+	
+	it "can be eql?" do
+		a = Latinum::Resource.load("10 NZD")
+		b = Latinum::Resource.load("0 NZD")
+		c = Latinum::Resource.load("0 NZD")
 		
-		it "can be eql?" do
-			a = Latinum::Resource.load("10 NZD")
-			b = Latinum::Resource.load("0 NZD")
-			c = Latinum::Resource.load("0 NZD")
-			
-			expect(a).to be_eql a
-			expect(a).to_not be_eql b
-			expect(b).to be_eql c
-		end
+		expect(a).to be_eql a
+		expect(a).to_not be_eql b
+		expect(b).to be_eql c
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: latinum
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-12 00:00:00.000000000 Z
+date: 2018-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Latinum is a simple gem for managing resource computations, including money