latinum 1.4.2 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3571f7728673389092f0ad54528e038ed15f7b9a5943b909ba355c3e9c96ad54
-  data.tar.gz: 4ab949df4e4666b2ed782a82efde0386186655ffe370ffbe028c8fc79d9f8dee
+  metadata.gz: 1d47aa25865b0ac4f8a71378e34f3ab3d2747cbcc53028aa39cf5db59ee7c283
+  data.tar.gz: 73244a39809482164e21800ac18a18831cd57c625e9a98d4036fc9a13e02ec71
 SHA512:
-  metadata.gz: de2de3d69cadf33628b97c74d57a524f0148805804b351b7164080d0fa43b900cc0e385de33f92ca899275b240e93beb2c0517a51d194bd0115f2cdebd48ad8b
-  data.tar.gz: ac41080a9e0f74116020e69850d57614f713934dd318f6664fec1b111a6cd3fd36103608e89f059bcbe80695fe1b10df55ea900b6aa1c3a35ab785890747f786
+  metadata.gz: af1494045eaecbf9ca00635bd7f9e02355554116d4227dc4fc8ef61326ab0be480b8891624352ad5f89639db482a0d7ed101e38ec47276523f93ab66d30059e1
+  data.tar.gz: f03166e50246ff382aa4423c3e1438d5fbfefb66f5da4c6cd043a40e7f64282e37eb1c27e424c0f290f9aa30f790746bf0d9813eec3b21818e5be65c3350f1e9

data/lib/latinum.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy

data/lib/latinum/bank.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -21,19 +23,31 @@
 require 'latinum/resource'
 
 module Latinum
+	# A basic exchange rate for a named resource.
 	class ExchangeRate
+		# @parameter input [String] The name of the input resource.
+		# @parameter output [String] The name of the output resource.
+		# @parameter factor [Numeric] The rate of exchange.
 		def initialize(input, output, factor)
 			@input = input
 			@output = output
 			@factor = factor.to_d
 		end
 		
+		# The name of the input resource.
+		# @attribute [String]
 		attr :input
+		
+		# The name of the output resource.
+		# @attribute [String]
 		attr :output
+		
+		# The rate of exchange.
+		# @attribute [String]
 		attr :factor
 	end
 	
-	# A bank defines exchange rates and formatting rules for resources. It is a centralised location for resource related state.
+	# A bank defines exchange rates and formatting rules for resources. It is a centralised location for resource formatting and metadata.
 	class Bank
 		# Imports all given currencies.
 		def initialize(*imports)
@@ -60,7 +74,7 @@ module Latinum
 				@currencies[name] = config
 				
 				# Create a formatter:
-				@formatters[name] = config[:formatter].new(config)
+				@formatters[name] = config[:formatter].new(**config)
 				
 				if config[:symbol]
 					symbols = (@symbols[config[:symbol]] ||= [])
@@ -71,16 +85,23 @@ module Latinum
 		end
 		
 		# Look up a currency by name.
-		def [] name
+		def [](name)
 			@currencies[name]
 		end
 		
 		attr :rates
+		
+		# A map of all recognised symbols ordered by priority.
+		# @attribute [Hash(String, Tuple(Integer, Name))]
 		attr :symbols
+		
+		# The supported currents and assocaited formatting details.
+		# @attribute [Hash(String, Hash)]
 		attr :currencies
 		
 		# Add an exchange rate to the bank.
-		def << rate
+		# @parameter rate [ExchangeRate] The exchange rate to add.
+		def <<(rate)
 			@rates << rate
 			
 			@exchange[rate.input] ||= {}
@@ -89,12 +110,13 @@ module Latinum
 		
 		# Exchange one resource for another using internally specified rates.
 		def exchange(resource, for_name)
-			rate = @exchange[resource.name][for_name] rescue nil
-			raise ArgumentError.new("Rate #{rate} unavailable") if rate == nil
+			unless rate = @exchange.dig(resource.name, for_name)
+				raise ArgumentError.new("Rate #{rate} unavailable")
+			end
 			
 			config = self[for_name]
 			
-			resource.exchange(rate.factor, for_name, config[:precision])
+			return resource.exchange(rate.factor, for_name, config[:precision])
 		end
 		
 		# Parse a string according to the loaded currencies.
@@ -102,35 +124,55 @@ module Latinum
 			parts = string.strip.split(/\s+/, 2)
 			
 			if parts.size == 2
-				Resource.new(parts[0].gsub(/[^\.0-9]/, ''), parts[1])
+				return parse_named_resource(parts[1], parts[0])
 			else
 				# Lookup the named symbol, e.g. '$', and get the highest priority name:
-				symbol = @symbols.fetch(string.gsub(/[\-\.,0-9]/, ''), []).last || default_name
+				symbol = @symbols.fetch(string.gsub(/[\-\.,0-9]/, ''), []).last
 				
 				if symbol
-					Resource.new(string.gsub(/[^\.0-9]/, ''), symbol.last.to_s)
+					name = symbol.last.to_s
+				elsif default_name
+					name = default_name
 				else
-					raise ArgumentError.new("Could not parse #{string}, could not determine currency!")
+					raise ArgumentError, "Could not parse #{string}, could not determine resource name!"
 				end
+				
+				return parse_named_resource(name, string)
 			end
 		end
 		
+		private def parse_named_resource(name, value)
+			if formatter = @formatters[name]
+				return Resource.new(formatter.parse(value), name)
+			else
+				raise ArgumentError, "No formatter found for #{name}!"
+			end
+		end
+		
+		# Rounds the specified resource to the maximum precision as specified by the formatter. Whe computing things like tax, you often get fractional amounts which are unpayable because they are smaller than the minimum discrete unit of the currency. This method helps to round a currency to a payable amount.
+		# @parameter resource [Resource] The resource to round.
+		# @returns [Resource] A copy of the resource with the amount rounded as per the formatter.
 		def round(resource)
-			formatter = @formatters[resource.name]
-			raise ArgumentError.new("No formatter found for #{resource.name}") unless formatter
+			unless formatter = @formatters[resource.name]
+				raise ArgumentError.new("No formatter found for #{resource.name}")
+			end
 			
-			Latinum::Resource.new(formatter.round(resource.amount), resource.name)
+			return Resource.new(formatter.round(resource.amount), resource.name)
 		end
 		
 		# Format a resource as a string according to the loaded currencies.
-		def format(resource, *args)
-			formatter = @formatters[resource.name]
-			raise ArgumentError.new("No formatter found for #{resource.name}") unless formatter
+		# @parameter resource [Resource] The resource to format.
+		def format(resource, *arguments, **options)
+			unless formatter = @formatters[resource.name]
+				raise ArgumentError.new("No formatter found for #{resource.name}")
+			end
 			
-			formatter.format(resource.amount, *args)
+			formatter.format(resource.amount, *arguments, **options)
 		end
 		
 		# Convert the resource to an integral representation based on the currency's precision.
+		# @parameter resource [Resource] The resource to convert.
+		# @returns [Integer] The integer representation.
 		def to_integral(resource)
 			formatter = @formatters[resource.name]
 			
@@ -138,10 +180,13 @@ module Latinum
 		end
 		
 		# Convert the resource from an integral representation based on the currency's precision.
-		def from_integral(amount, resource_name)
-			formatter = @formatters[resource_name]
+		# @parameter amount [Integer] The integral resource amount.
+		# @parameter name [String] The resource name.
+		# @returns [Resource] The converted resource.
+		def from_integral(amount, name)
+			formatter = @formatters[name]
 			
-			Resource.new(formatter.from_integral(amount), resource_name)
+			Resource.new(formatter.from_integral(amount), name)
 		end
 	end
 end

data/lib/latinum/collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -22,29 +24,34 @@ require 'bigdecimal'
 require 'set'
 
 module Latinum
-	# Aggregates a set of resources, typically used for summing values.
+	# Aggregates a set of resources, typically used for summing values to compute a total.
 	class Collection
 		include Enumerable
 		
 		# Initialize the collection with a given set of resource names.
 		def initialize(names = Set.new)
 			@names = names
-			@resources = Hash.new {|hash, key| @names << key; BigDecimal("0")}
+			@resources = Hash.new {|hash, key| @names << key; BigDecimal(0)}
 		end
 		
-		# All resource names which have been added to the collection, e.g. `['NZD', 'USD']`.
+		# All resource names which have been added to the collection.
+		# e.g. `['NZD', 'USD']`.
+		# @attribute [Set]
 		attr :names
 		
-		# A map of `name` => `total` for all added resources. Totals are stored as BigDecimal instances.
+		# Keeps track of all added resources.
+		# @attribute [Hash(String, BigDecimal)]
 		attr :resources
 		
 		# Add a resource into the totals.
-		def add resource
+		# @parameter resource [Resource] The resource to add.
+		def add(resource)
 			@resources[resource.name] += resource.amount
 		end
 		
 		# Add a resource, an array of resources, or another collection into this one.
-		def << object
+		# @parameter object [Resource | Array(Resource) | Collection] The resource(s) to add.
+		def <<(object)
 			case object
 			when Resource
 				add(object)
@@ -65,7 +72,8 @@ module Latinum
 			self << -other
 		end
 		
-		# Allow negation of all values within the collection:
+		# Allow negation of all values within the collection.
+		# @returns [Collection] A new collection with the inverted values.
 		def -@
 			collection = self.class.new
 			
@@ -76,16 +84,23 @@ module Latinum
 			return collection
 		end
 		
-		# Get a `Resource` for the given name:
+		# @returns [Resource | Nil] A resource for the specified name.
 		def [] key
-			Resource.new(@resources[key], key)
+			if amount = @resources[key]
+				Resource.new(@resources[key], key)
+			end
 		end
 		
-		# Set a `BigDecimal` value for the given name:
+		# Set the amount for the specified resource name.
+		# @parameter key [String] The resource name.
+		# @parameter value [BigDecimal] The resource amount.
 		def []= key, amount
 			@resources[key] = amount
 		end
 		
+		# Iterates over all the resources.
+		# @yields {|resource| ...} The resources if a block is given.
+		#		@parameter resource [Resource]
 		def each
 			return to_enum(:each) unless block_given?
 			
@@ -94,15 +109,20 @@ module Latinum
 			end
 		end
 		
+		# Whether the collection is empty.
+		# @returns [Boolean]
 		def empty?
 			@resources.empty?
 		end
 		
+		# Whether the collection contains the specified resource (may be zero).
+		# @returns [Boolean]
 		def include?(key)
 			@resources.include?(key)
 		end
 		
 		# Generate a new collection but ignore zero values.
+		# @returns [Collection] A new collection.
 		def compact
 			collection = self.class.new
 			
@@ -115,6 +135,9 @@ module Latinum
 			return collection
 		end
 		
+		# A human readable representation of the collection.
+		# e.g. `"5.0 NZD; 10.0 USD"`
+		# @returns [String]
 		def to_s
 			@resources.map{|name, amount| "#{amount.to_s('F')} #{name}"}.join("; ")
 		end

data/lib/latinum/currencies/global.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # encoding: UTF-8
 #
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
@@ -26,6 +28,8 @@ module Latinum
 	module Currencies
 		Global = {}
 		
+		# @name Global[:NZD]
+		# @attribute [Hash] The New Zealand Dollar configuration.
 		Global[:NZD] = {
 			:precision => 2,
 			:symbol => '$',
@@ -34,6 +38,8 @@ module Latinum
 			:formatter => Formatters::DecimalCurrencyFormatter,
 		}
 		
+		# @name Global[:GBP]
+		# @attribute [Hash] The Great British Pound configuration.
 		Global[:GBP] = {
 			:precision => 2,
 			:symbol => '£',
@@ -42,6 +48,8 @@ module Latinum
 			:formatter => Formatters::DecimalCurrencyFormatter,
 		}
 		
+		# @name Global[:AUD]
+		# @attribute [Hash] The Australian Dollar configuration.
 		Global[:AUD] = {
 			:precision => 2,
 			:symbol => '$',
@@ -50,6 +58,8 @@ module Latinum
 			:formatter => Formatters::DecimalCurrencyFormatter,
 		}
 		
+		# @name Global[:USD]
+		# @attribute [Hash] The United States Dollar configuration.
 		Global[:USD] = {
 			:precision => 2,
 			:symbol => '$',
@@ -58,16 +68,20 @@ module Latinum
 			:formatter => Formatters::DecimalCurrencyFormatter,
 		}
 		
+		# @name Global[:EUR]
+		# @attribute [Hash] The Euro configuration.
 		Global[:EUR] = {
 			:precision => 2,
 			:symbol => '€',
 			:name => 'EUR',
 			:description => 'Euro',
 			:formatter => Formatters::DecimalCurrencyFormatter,
-			#:delimeter => '.',
+			#:delimiter => '.',
 			#:separator => ','
 		}
 		
+		# @name Global[:JPY]
+		# @attribute [Hash] The Japanese Yen configuration.
 		Global[:JPY] = {
 			:precision => 0,
 			:symbol => '¥',
@@ -76,6 +90,20 @@ module Latinum
 			:formatter => Formatters::DecimalCurrencyFormatter
 		}
 		
+		# @name Global[:BRL]
+		# @attribute [Hash] The Brazilian Real configuration.
+		Global[:BRL] = {
+			:precision => 2,
+			:symbol => 'R$',
+			:name => 'BRL',
+			:description => 'Brazilian Real',
+			:formatter => Formatters::DecimalCurrencyFormatter,
+			:delimiter => '.',
+			:separator => ','
+		}
+		
+		# @name Global[:BTC]
+		# @attribute [Hash] The Bitcoin configuration.
 		Global[:BTC] = {
 			:precision => 8,
 			:symbol => 'B⃦',

data/{spec/latinum/comparison_spec.rb → lib/latinum/error.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -18,23 +20,11 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'latinum/resource'
-
-RSpec.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
-	
-	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
+module Latinum
+	# Represents an error when trying to perform arithmetic on differently named resources.
+	class DifferentResourceNameError < ArgumentError
+		def initialize
+			super "Cannot operate on different currencies!"
+		end
 	end
 end

data/lib/latinum/formatters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -20,77 +22,107 @@
 
 module Latinum
 	module Formatters
-		DEFAULT_OPTIONS = {
-			:format => :full
-		}
-		
+		# Formats a currency using a standard decimal notation.
 		class PlainFormatter
 			def initialize(name:)
 				@name = name
 			end
 			
+			# Parse a string into an amount.
+			# @returns [BigDecimal] The parsed amount.
+			def parse(string)
+				BigDecimal(string)
+			end
+			
+			# Formats the amount using a general notation.
+			# e.g. "5.0 NZD".
+			# @returns [String] The formatted string.
 			def format(amount)
 				"#{amount.to_s('F')} #{@name}"
 			end
 			
+			# Converts the amount directly to an integer, truncating any decimal part.
+			# @parameter amount [BigDecimal] The amount to convert to an integral.
+			# @returns [Integer] The converted whole number integer.
 			def to_integral(amount)
 				amount.to_i
 			end
 			
+			# Converts the amount to a decimal.
+			# @parameter amount [Integer] The amount to convert to a decimal.
+			# @returns [BigDecimal] The converted amount.
 			def from_integral(amount)
 				amount.to_d
 			end
 		end
-
+		
+		# Formats a currency using a standard decimal notation.
 		class DecimalCurrencyFormatter
-			def initialize(options = {})
+			def initialize(**options)
 				@symbol = options[:symbol] || '$'
 				@separator = options[:separator] || '.'
-				@delimeter = options[:delimter] || ','
+				@delimiter = options[:delimiter] || ','
 				@places = options[:precision] || 2
 				@zero = options[:zero] || '0'
-
+				
 				@name = options[:name]
 			end
-
+			
 			def round(amount)
 				return amount.round(@places)
 			end
-
-			def format(amount, options = DEFAULT_OPTIONS)
+			
+			# Parse a string into an amount using the configured separator and delimiter.
+			# @returns [BigDecimal] The parsed amount.
+			def parse(string)
+				BigDecimal(
+					string.gsub(/[^\-0-9#{@separator}]/, '').gsub(@separator, '.')
+				)
+			end
+			
+			# Formats the amount using the configured symbol, separator, delimiter, and places.
+			# e.g. "$5,000.00 NZD". Rounds the amount to the specified number of decimal places.
+			# @returns [String] The formatted string.
+			def format(amount, places: @places, **options)
 				# Round to the desired number of places. Truncation used to be the default.
-				amount = amount.round(@places)
+				amount = amount.round(places).to_d
+				
+				integral, fraction = amount.abs.to_s('F').split(/\./, 2)
 				
-				fix, frac = amount.abs.to_s('F').split(/\./, 2)
-
 				# The sign of the number
 				sign = '-' if amount < 0
-
+				
 				# Decimal places, e.g. the '.00' in '$10.00'
-				frac = frac[0...@places].ljust(@places, @zero)
-
+				fraction = fraction[0...places].ljust(places, @zero)
+				
 				# Grouping, e.g. the ',' in '$10,000.00'
-				remainder = fix.size % 3
-				groups = fix[remainder..-1].scan(/.{3}/).to_a
-				groups.unshift(fix[0...remainder]) if remainder > 0
-
+				remainder = integral.size % 3
+				groups = integral[remainder..-1].scan(/.{3}/).to_a
+				groups.unshift(integral[0...remainder]) if remainder > 0
+				
 				symbol = options.fetch(:symbol, @symbol)
-				value = "#{sign}#{symbol}#{groups.join(@delimeter)}"
-
+				value = "#{sign}#{symbol}#{groups.join(@delimiter)}"
+				
 				name = options.fetch(:name, @name)
 				suffix = name ? " #{name}" : ''
-
-				if @places > 0
-					"#{value}#{@separator}#{frac}#{suffix}"
+				
+				if places > 0
+					"#{value}#{@separator}#{fraction}#{suffix}"
 				else
 					"#{value}#{suffix}"
 				end
 			end
 			
+			# Converts the amount directly to an integer, truncating any decimal part, taking into account the number of specified decimal places.
+			# @parameter amount [BigDecimal] The amount to convert to an integral.
+			# @returns [Integer] The converted whole number integer.
 			def to_integral(amount)
 				(amount * 10**@places).to_i
 			end
 			
+			# Converts the amount to a decimal, taking into account the number of specified decimal places.
+			# @parameter amount [Integer] The amount to convert to a decimal.
+			# @returns [BigDecimal] The converted amount.
 			def from_integral(amount)
 				(amount.to_d / 10**@places)
 			end