fxer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bee3714d8bd267547541f35c4c39439b3dd712133d7fa2486db961c0ce796a9a
+  data.tar.gz: be700568d0b2677254d7b58695e1de9587e10d6c8c72f14705f7503618be5e14
+SHA512:
+  metadata.gz: 4ce92080d2e7db647f7d3f684daafc69a94ea14fd3c179e679b70eb3fa9de70ac3ba79536645d4f098e1612155f44a1bbba61003e3cae96901caf23ffc87d9f9
+  data.tar.gz: 27f16af88934df6524be839438f6a0fbba1f73456472093079c8537b68307148f90d02e9c63e8fbb8b07a56adb719226ae03086b8342343b346114681cad9f45

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.DS_store
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.15.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in fxer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Sam Nissen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# Fxer
+
+Fxer is an exchange rate calculator, using the European Central Bank's
+rates covering the last 90 days.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fxer'
+```
+
+And then execute:
+
+```bash
+bundle
+```
+
+Or install it yourself as, replacing the version numbers:
+
+```bash
+gem build fxer.gemspec
+gem install fxer-1.2.3.gem
+```
+
+## Usage
+
+### Simplest exchange
+
+Fxer includes a quick and simple way of obtaining an exchange rate via a
+separate namespace:
+
+```ruby
+ExchangeRate.at(Date.today, 'EUR', 'AUD')
+# => 1.4732
+```
+
+### Configurable exchange
+
+For situations where you need more control, the Fxer namespace provides
+configuration:
+
+```ruby
+exchanger = Fxer::Exchange.new.configure do |config|
+  config.permissive = true
+  config.source = :ecb
+  config.store = "/my/path/"
+end
+
+exchanger.convert_at_date(Date.today, 'GBP', 'USD')
+# => 1.309507859949982
+```
+
+#### `config.permissive`
+
+Fxer by default uses the most recently available data at or before
+the date indicated. Setting permissive to false changes that, in effect a
+strict-mode, and an error will be raised if a date
+doesn't have corresponding data.
+
+#### `config.source`
+
+Fxer is designed to accommodate code for additional sources
+of exchange rate data. Source can only be `:ecb` as of now.
+
+#### `config.store`
+
+The configuration of store allows you to indicate where you have
+locally stored your exchange data file, so that Fxer does not need
+to download that data to determine the rate.
+
+### Executable exchange
+
+fxer also provides an executable for getting rates in Bash:
+
+```bash
+FXER_RATE_DATA_PATH="/my/path" fxer "2017-07-18" NOK HKD
+# => 0.9689571804652662
+```
+
+where the environment variable for local file hosting is optional.
+
+### Data retrieval (also executable)
+
+And fxer will download new ECB data for you, in either Ruby or Bash:
+
+```ruby
+ENV['FXER_RATE_DATA_DIRECTORY'] = "/my/path/"
+Fxer::Fetcher::Ecb.download
+```
+
+```bash
+FXER_RATE_DATA_DIRECTORY="/my/path/" fxer-fetcher ecb
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `bundle exec rspec spec` to run the tests.
+You can also run `bin/console` for an interactive prompt that
+will allow you to experiment.
+
+Until this is pushed to RubyGems and GitHub, there is no defined development
+process.
+
+## Contributing
+
+Bug reports and pull requests will be welcome once fxer is live
+at https://github.com/samnissen/fxer.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/release"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fxer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/ecb.yml

@@ -0,0 +1 @@
+:ecb_fx_rate_url: "http://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist-90d.xml"

data/config/fxer.yml

@@ -0,0 +1,5 @@
+:exchange:
+  :default_source_key: :ecb
+  :valid_source_keys:
+    - :ecb
+  :default_permission: true

data/exe/fxer

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'fxer'
+
+#
+# fxer is a simple command line tool to exchange data
+# using the default exchange rate data source and an
+# optional local store. See more documentation in Fxer::Exchange,
+# and in the README.
+#
+
+path = ENV['FXER_RATE_DATA_PATH']
+opts = { :store => path }
+
+exchanger = Fxer::Exchange.new(opts)
+puts exchanger.convert_at_date(ARGV[0], ARGV[1], ARGV[2])

data/exe/fxer-fetcher

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'fxer'
+
+#
+# fxer-fetcher is a commandline pre-fetcher for exchange rate data.
+# with only one data source, this is intentionally kept simple.
+# fxer-fetcher downloads the most recent available data from the ECB.
+#
+
+DEFAULT_FETCHER_DOWNLOAD_CLASS_NAME = "ecb"
+
+case "#{ARGV[0] || DEFAULT_FETCHER_DOWNLOAD_CLASS_NAME}".to_sym
+when :ecb
+  puts "\n\n\tFetching ECB data..."
+  Fxer::Fetcher::Ecb.download
+  puts "\tSuccess!\n\n"
+else
+  raise Fxer::ExchangeRate::INVALID_SOURCE_MESSAGE
+end

data/fxer.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fxer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fxer"
+  spec.version       = Fxer::VERSION
+  spec.authors       = ["Sam Nissen"]
+  spec.email         = ["scnissen@gmail.com"]
+
+  spec.summary       = "Convert currency based on external sources' rates"
+  spec.homepage      = "https://github.com/samnissen/fxer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 5.2.3"
+
+  spec.add_development_dependency "bundler", "~> 2.1.4"
+  spec.add_development_dependency "rake", "~> 13.0.1"
+  spec.add_development_dependency "rake-release", "~> 1.2"
+  spec.add_development_dependency "rspec", "~> 3.9"
+  spec.add_development_dependency "nokogiri", "~> 1.10"
+end

data/lib/exchange_rate.rb

@@ -0,0 +1,24 @@
+require "fxer"
+
+#
+# ExchangeRate is a convenience module with one method to pass through
+# data to Fxer::Exchange.
+#
+# Names like "ExchangeRate", "Exchange", etc. are the names of existing gems.
+# Also, while Fxer::Exchange has options and state, ExchangeRate is
+# simple and stateless. See that class for options and other details.
+#
+module ExchangeRate
+
+  #
+  # at requires three arguments, a date, and two strings representing
+  # currencies. More details about the requirements are detailed in
+  # Exchange.
+  #
+  # Example:
+  #   ExchangeRate.at(Date.today,'GBP','USD')
+  #
+  def self.at(date, base, counter)
+    Fxer::Exchange.new.convert_at_date(date, base, counter)
+  end
+end

data/lib/fxer.rb

@@ -0,0 +1,9 @@
+require "exchange_rate"
+require "fxer/exchange"
+require "fxer/fetcher"
+require "fxer/version"
+
+module Fxer
+  FXER_BASE_PATH = Pathname(__dir__).parent
+  FXER_CONFIGURATION_PATH = File.join(FXER_BASE_PATH, "config")
+end

data/lib/fxer/exchange.rb

@@ -0,0 +1,110 @@
+require "fxer/exchange/data"
+require "fxer/exchange/data_source"
+require "fxer/exchange/exchange_configuration"
+
+require "yaml"
+require "bigdecimal"
+
+module Fxer
+  class Exchange
+    attr_writer :configuration
+
+    #
+    # initialize takes a hash of optional values:
+    #   1. :source - a symbol representing the source of the exchange data
+    #   2. :store  - a string representing a directory where
+    #      exchange data is stored, so that new data is not
+    #      downloaded upon each exchange calculation.
+    #   3. :permissive - a boolean that, set to true, allows the exchange
+    #      rate to be pulled from the nearest possible date. Set to false,
+    #      an error will arise if no data exists for the date.
+    #
+    # Alternatively these same values can be provided through
+    # a configuraiton block, like so:
+    #   exchanger = Fxer::Exchange.new.configure do |config|
+    #     config.source = :ecb
+    #     config.store = "/path/to/data"
+    #   end
+    #
+    # Alternatively these same values can be provided directly
+    #   exchanger = Fxer::Exchange.new
+    #   exchanger.configuration.source = :ecb
+    #   exchanger.configuration.store = "/path/to/data"
+    #
+    # And these values can be reset to their defaults,
+    # defined in config/fxer.yml.
+    #
+    # Guidance on setting up much of the configuration comes from:
+    # http://brandonhilkert.com/blog/ruby-gem-configuration-patterns/
+    #
+    def initialize(opts = {})
+      configure { |config|
+        config.source = opts[:source] if opts[:source]
+        config.store  = opts[:store]  if opts[:store]
+        config.permissive  = opts[:permissive]  if opts[:permissive]
+      }
+    end
+
+    def configuration
+      @configuration ||= ExchangeConfiguration.new
+    end
+    def reset
+      @configuration = ExchangeConfiguration.new
+    end
+    def configure
+      yield(configuration)
+      self
+    end
+
+    #
+    # convert_at_date takes these arguments:
+    #   1. date - A Date object for the day's rates to access.
+    #      The closest available day will be accessed if the
+    #      chosen day is not available, or date is otherwise invalid
+    #   2. base - Representing a country's currency,
+    #      formatted per source requirements
+    #   3. counter - Same format as `base`
+    #
+    # and returns a float, the result of diving two floats
+    # representing the currency's relative value at the date specified.
+    #
+    # Example:
+    #   opts = {
+    #     :store => "/my/path/",
+    #     :source => :ecb,
+    #     :permissive => true
+    #   }
+    #   Fxer::Exchange.new(opts).convert_at_date(Date.today, "HKD", "NZD")
+    # => 1.12345
+    #
+    def convert_at_date(date, base, counter)
+      data_source = Fxer::Exchange::DataSource.new(options)
+      counter_rate, base_rate = data_source.exchange(date, base, counter, source)
+
+      Float(BigDecimal(counter_rate.rate.to_s) / BigDecimal(base_rate.rate.to_s))
+    end
+
+    private
+
+      #
+      # DataSource and its subclasses don't require the same level of
+      # convenient configuration -- so they get a Hash of options
+      # (instead of a ExchangeConfiguration object, for instance).
+      # options returns such a Hash.
+      #
+      def options
+        {
+          :store => @configuration.store,
+          :permissive => @configuration.permissive
+        }
+      end
+
+      #
+      # source is a convenience method for the configuration object's source,
+      # and it returns a Symbol.
+      #
+      def source
+        @configuration.source
+      end
+  end
+end

data/lib/fxer/exchange/data.rb

@@ -0,0 +1,84 @@
+require "fxer/exchange/data/date"
+
+module Fxer
+  class Exchange
+
+    DATE_ERROR_MESSAGE = "Unable to find your date:"
+
+    class Data
+      attr_accessor :dates, :transaction_date, :to, :from
+
+      #
+      # initalize instantiates dates as an array to contain its Date objects.
+      #
+      def initialize(opts = {})
+        @options = opts
+        @dates = []
+      end
+
+      #
+      # rates sifts the available data for the nearest date, then
+      # sifts through the currencies to find the base and counter rates.
+      #
+      # Note @transaction_date, @to, @from must be set before `rates`
+      # is called. Convenient methods exist for this purpose. For instance:
+      #   rate_set = Fxer::Exchange::DataSource::Ecb.new(options).rate_sets
+      #   rates = rate_set.at("2017-07-21").from("USD").to("GBP").rates
+      #
+      # rates returns an array of two Currency objects,
+      # [counter, base].
+      #
+      def rates
+        date = nearest_date
+
+        [
+          date.currencies.find{ |d| d.key == @to },
+          date.currencies.find{ |d| d.key == @from }
+        ]
+      end
+
+      #
+      # at, from and to are convenience methods to set the transaction date,
+      # base currency, and counter currency, respectively. They return self
+      # so that they can be chained. arguments are defined in Fxer::Exchange
+      #
+      def at(d)
+        @transaction_date = d
+        self
+      end
+      def from(f)
+        @from = f
+        self
+      end
+      def to(t)
+        @to = t
+        self
+      end
+
+      #
+      # transaction_date takes one argument, defined in Fxer::Exchange
+      # and normalizes it to a Date object
+      #
+      def transaction_date=(raw_date)
+        @transaction_date = Date.normalize_date(d)
+      end
+
+      private
+
+        #
+        # nearest_date chooses the date object matching the transaction date.
+        #
+        # If no date is matched, the next date can be chosen if the
+        # permissive flag evaluates to true. Otherwise it raises an error.
+        #
+        def nearest_date
+          d = @dates.find { |d| "#{d.date}" == "#{@transaction_date}" }
+          return d if d
+
+          raise "#{DATE_ERROR_MESSAGE} #{@transaction_date}" unless @options[:permissive]
+
+          dates.sort_by{ |d| d.date }.reverse.first
+        end
+    end
+  end
+end

data/lib/fxer/exchange/data/date.rb

@@ -0,0 +1,56 @@
+require "fxer/exchange/data/date/currency"
+
+module Fxer
+  class Exchange
+    class Data
+
+      #
+      # Fxer::Exchange::Data::Date must be namespaced or
+      # it will overwrite the existing Date class, resulting in warnings:
+      # "warning: toplevel constant Date referenced by X", and odd behavior.
+      # http://stem.ps/rails/2015/01/25/ruby-gotcha-toplevel-constant-referenced-by.html
+      #
+      class Fxer::Exchange::Data::Date
+        attr_accessor :currencies, :date
+
+        #
+        # In creating a date, create a shell to store this Date's currencies.
+        #
+        def initialize
+          @currencies = []
+        end
+
+        #
+        # Setting the date allows string or Date object. For more details,
+        # see the documentation for normalize_date.
+        #
+        def date=(raw_date)
+          @date = Date.normalize_date(raw_date)
+        end
+
+        #
+        # self.normalize_date takes one argument,
+        #   1. raw_date, either a string represnting a date, or a Date,
+        #      where the former will be converted into the latter
+        # and returns a Date object if it is a convertable string.
+        # Note this is used elsewhere, hence the Eigenclass method.
+        #
+        # In normalize_date, casing the class of a ruby object is not done
+        # by `.class`ing the object because of how the === operator works:
+        # https://stackoverflow.com/a/3801609/1651458
+        #
+        # Also, `::Date` is required because of the local Date
+        # class in this Gem: https://stackoverflow.com/a/29351635/1651458
+        #
+        def self.normalize_date(raw_date)
+          case raw_date
+          when String
+            ::Date.strptime(raw_date) # A namespace that specifies Ruby's core class.
+          else
+            raw_date
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fxer/exchange/data/date/currency.rb

@@ -0,0 +1,20 @@
+module Fxer
+  class Exchange
+    class Data
+      class Date
+        class Currency
+          attr_accessor :key, :rate
+
+          #
+          # rate= takes one argument,
+          #   1. raw_rate, a string representing a float
+          # and converts it into a float, and assigns it to its rate attribute
+          #
+          def rate=(raw_rate)
+            @rate = "#{raw_rate}".to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fxer/exchange/data_source.rb

@@ -0,0 +1,48 @@
+require "active_support/core_ext/hash"
+require "date"
+require "open-uri"
+require "pathname"
+
+require "fxer/exchange/data_source/ecb"
+
+module Fxer
+  class Exchange
+    class DataSource
+
+      #
+      # initialize accepts one optional argument,
+      #   1. a hash of options which will be passed to whichever data source
+      #      the user has indicated (i.e. Fxer::Exchange::DataSource::Ecb).
+      #
+      def initialize(opts = {})
+        @options = opts
+      end
+
+      #
+      # exchange takes 4 required arguments and returns the data required
+      # to determine an exchange value. Arguments are defined in Fxer::Exchange.
+      #
+      def exchange(date, base, counter, source)
+        fetch_rates(source).at(date).from(base).to(counter).rates
+      end
+
+      private
+
+        #
+        # fetch_rates takes one argument,
+        #   1. a symbol represnting a source's corresponding class name.
+        #      Source symbols are defined in Fxer::Exchange.
+        #
+        # fetch_rates converts the source of data indicated by the user,
+        # i.e. :ecb, (which has been sanitized during configuration), and
+        # converts that to a subclass of DataSource, providing options
+        # and returning a set of rates, represented by an
+        # Fxer::Exchange::Data object.
+        #
+        def fetch_rates(source)
+          klass_name = "#{source}".downcase.capitalize
+          Object.const_get("Fxer::Exchange::DataSource::#{klass_name}").new(@options).rate_set
+        end
+    end
+  end
+end

data/lib/fxer/exchange/data_source/ecb.rb

@@ -0,0 +1,114 @@
+module Fxer
+  class Exchange
+    class DataSource
+      class Ecb
+        attr_reader :rate_set
+
+        #
+        # initialize takes one optional hash.
+        # Arguments are defined in Fxer::Exchange.
+        #
+        # It assigns store to be used in the Ecb class. initialize also
+        # kicks off the request for data and normalization into our
+        # Data objects.
+        #
+        def initialize(opts = {})
+          @store = opts[:store]
+          @options = opts.except(:store)
+
+          fetch_rates
+          normalize_rates
+        end
+
+        private
+
+          #
+          # normalize_rates creates a Data object to store each Date, which
+          # itself stores n Currencies, all assigned to @rate_set
+          #
+          # In ECB data, the Euro is static, and so is omitted from the dataset.
+          # So, the Currency representing the Euro is manually added.
+          #
+          def normalize_rates
+            @rate_set = Fxer::Exchange::Data.new(@options)
+
+            @raw_data.each do |rate_sets|
+              date = Fxer::Exchange::Data::Date.new()
+              date.date = Date.strptime(rate_sets["time"], "%Y-%m-%d")
+
+              date.currencies = rate_sets["Cube"].map do |rate|
+                currency = Fxer::Exchange::Data::Date::Currency.new()
+                currency.key = rate["currency"]
+                currency.rate = rate["rate"]
+                currency
+              end
+              date.currencies << european_currency
+
+              @rate_set.dates << date
+            end
+          end
+
+          #
+          # european_currency creates the Euro currency object, and
+          # returns that static currency object.
+          #
+          # Since it is always the base of the ECB currency data,
+          # the Euro is always set to 1.
+          #
+          def european_currency
+            currency = Fxer::Exchange::Data::Date::Currency.new()
+            currency.key = "EUR"
+            currency.rate = 1
+            currency
+          end
+
+          #
+          # fetch_rates gathers the entire available data set. (For ECB,
+          # that's 90 days worth of exchange rate data.)
+          # First, fetch_rates tries to gather the data from file,
+          # then directly from the source URL when it cannot.
+          #
+          def fetch_rates
+            @raw_data   = local_data
+            @raw_data ||= from_url
+          end
+
+          #
+          # from_url opens the ECB XML feed, converts to hash, and
+          # returns a Hash representing the relevant portion.
+          #
+          def from_url
+            hashify(open(config[:ecb_fx_rate_url]))
+          end
+
+          #
+          # local_data accesses the provided data file, converts to hash and
+          # returns a Hash representing the relevant portion, but
+          # only if one is indeed provided.
+          #
+          def local_data
+            return false unless @store && File.exists?(@store)
+
+            return hashify(File.open(@store))
+          end
+
+          #
+          # hashify converts uses activesupport to convert XML to hash,
+          # then accesses and returns a Hash representing the relevant portion.
+          #
+          def hashify(raw)
+            Hash.from_xml(raw)["Envelope"]["Cube"]["Cube"]
+          end
+
+          #
+          # config accesses the yaml file containing the
+          # default Ecb configuration.
+          #
+          def config
+            @config_path = File.join(FXER_CONFIGURATION_PATH, "ecb.yml")
+            @config ||= YAML.load_file(@config_path)
+          end
+      end
+    end
+  end
+end

data/lib/fxer/exchange/exchange_configuration.rb

@@ -0,0 +1,70 @@
+module Fxer
+  class Exchange
+
+    INVALID_SOURCE_MESSAGE = "Please provide one of these valid source keys:"
+
+    class ExchangeConfiguration
+      attr_accessor :source, :store, :permissive
+
+      #
+      # This configuration object allows for hash, block or object setting
+      # of configuration options.
+      #
+      # initialize sets the default source and protects the app from attempting
+      # to use invalid source keys.
+      #
+      def initialize
+        set_defaults
+      end
+
+      #
+      # In order to ensure that a key passed at any arbitrary point is valid
+      # the setter is overwritten to validate the key.
+      #
+      def source=(key)
+        @source = validate_source_key(key)
+      end
+
+      private
+
+        #
+        # set_defaults does what is says on the tin, setting source and store
+        # to their default values.
+        #
+        # Note that a nil value for the store path will bypass the functions
+        # that access locally stored data.
+        #
+        def set_defaults
+          @source       = config[:default_source_key]
+          @store        = config[:default_store_path]
+          @permissive   = config[:default_permission]
+        end
+
+        #
+        # config accesses the yaml file containing the default configuration,
+        # and returns a Hash of its values.
+        #
+        def config
+          @config_path ||= File.join(FXER_CONFIGURATION_PATH, "fxer.yml")
+          @config ||= YAML.load_file(@config_path)[:exchange]
+        end
+
+
+        #
+        # validate_source_key takes an argument
+        #   1. key, a symbol representing
+        # and returns the key if it is within the array of valid keys
+        #
+        # This stops any request that specifies a key that that is not
+        # encoded in our application as a valid bank data source.
+        #
+        def validate_source_key(key)
+          unless config[:valid_source_keys].include?(key)
+            raise "#{INVALID_SOURCE_MESSAGE} #{config[:valid_source_keys]}."
+          end
+
+          key
+        end
+    end
+  end
+end

data/lib/fxer/fetcher.rb

@@ -0,0 +1,79 @@
+module Fxer
+  class Fetcher
+    class Ecb
+      class << self
+
+        #
+        # download fetches the most recent data from the ECB URL if
+        # today's data isn't already present in the user's chosen
+        # directory (otherwise it aborts).
+        #
+        # After downloading the ECB data, it checks if the data contains
+        # data not yet accounted for in the directory (otherwise it aborts).
+        #
+        # Then it saves that data to a new XML file in the user's
+        # chosen directory.
+        #
+        def download
+          set_data_parameters
+
+          return true if abort_if_current(Date.today.to_s)
+
+          fetch_data
+
+          return true if abort_if_current(@date)
+
+          save_data
+        end
+
+        private
+
+          #
+          # set_data_parameters fetches and assigns the ECB URL from config.
+          # And it assigns the user's chosen rate directory, falling back to
+          # the working directory.
+          #
+          def set_data_parameters
+            config_path = File.join(Fxer::FXER_CONFIGURATION_PATH, "ecb.yml")
+            @url = YAML.load_file(config_path)[:ecb_fx_rate_url]
+            @dir = ENV['FXER_RATE_DATA_DIRECTORY'] || Dir.pwd
+          end
+
+          #
+          # save_data to an XML file named after the @date
+          #
+          def save_data
+            @path = File.join(@dir, "#{@date.to_s}.xml")
+
+            puts "\tData found. Saving data for '#{@date.to_s}' to '#{@path}' ..."
+            open(@path, "wb") { |f| f.write(@data) }
+
+            puts "\tSuccess!\n\n"
+          end
+
+          #
+          # fetch_data from the URL, and fetch the file's
+          # most recent date from that data
+          #
+          def fetch_data
+            puts "\n\n\tGoing to fetch data from '#{@url}'"
+            @data = open(@url) { |io| io.read }
+            @date = Hash.from_xml(@data)["Envelope"]["Cube"]["Cube"].first["time"]
+          end
+
+          #
+          # abort_if_current takes one argument:
+          #   1. date - a string representing the date a file is named for,
+          # and returns a boolean of that file's existence.
+          #
+          def abort_if_current(date)
+            return false unless File.exist?(File.join(@dir, "#{date.to_s}.xml"))
+
+            puts "\n\n\tThe most recent data already exists in #{@dir}. Exiting ...\n\n"
+            true
+          end
+      end
+    end
+
+  end
+end

data/lib/fxer/version.rb

@@ -0,0 +1,3 @@
+module Fxer
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: fxer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Nissen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: rake-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: 
+email:
+- scnissen@gmail.com
+executables:
+- fxer
+- fxer-fetcher
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- config/ecb.yml
+- config/fxer.yml
+- exe/fxer
+- exe/fxer-fetcher
+- fxer.gemspec
+- lib/exchange_rate.rb
+- lib/fxer.rb
+- lib/fxer/exchange.rb
+- lib/fxer/exchange/data.rb
+- lib/fxer/exchange/data/date.rb
+- lib/fxer/exchange/data/date/currency.rb
+- lib/fxer/exchange/data_source.rb
+- lib/fxer/exchange/data_source/ecb.rb
+- lib/fxer/exchange/exchange_configuration.rb
+- lib/fxer/fetcher.rb
+- lib/fxer/version.rb
+homepage: https://github.com/samnissen/fxer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Convert currency based on external sources' rates
+test_files: []