bond_calculator 0.0.2

data/lib/bond_calculator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'bond_calculator/version'
+require 'bond_calculator/bond'
+require 'bond_calculator/base_calculator'
+require 'bond_calculator/spread_to_benchmark'
+require 'bond_calculator/spread_to_curve'

data/lib/bond_calculator/base_calculator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+# Namespace for classes and modules that handle Bond calculation
+#  @since 0.0.1
+module BondCalculator
+  # Abstract base class for Bond Calculation. Provides some helper methods for
+  # convert the csv file to a bond map and a filter for the bonds collection
+  #
+  # @author Lucas Sant' Anna
+  # @since 0.0.1
+  class BaseCalculator
+    # convert a csv file to a Bond list 
+    # @author Lucas Sant' Anna
+    # @param  [file_path]  csv_path Any file with the the bond's csv header structure
+    # @return [Array<Bond>]
+    def csv_to_bonds(csv_path)
+      csv = File.open(csv_path, 'r')
+      bonds_csv = CSV.parse(csv, headers: true).map(&:to_h)
+      csv.close
+      bonds_csv.map { |line| Bond.new(line) }
+    end
+
+    # filter bond list by type
+    # @author Lucas Sant' Anna
+    # @param [String] type it is possible to search by any type eg:'corporate' or 'government'
+    # @param [Array<Bond>] bonds Bond list
+    # @return [Array<Bond>] bond list with the filterd type
+    def bonds_by_type(type, bonds)
+      return nil if type.nil? || bonds.nil?
+
+      bonds.select { |bond| bond.type == type }
+        .sort_by { |bond| bond.term_years }
+    end
+  end
+end

data/lib/bond_calculator/bond.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that handle Bond calculation
+#  @since 0.0.1
+module BondCalculator
+
+  # Bond is a PORO that represent the structure of benchmark and curve cvs's header
+  #
+  # @author Lucas Sant' Anna
+  # @since 0.0.1
+  class Bond
+    attr_reader :name, :type, :term_years, :yield_percent
+
+    # @param [Hash] args The options to create a Bond with
+    #
+    # @option args [String] :type Type of the Bond currencty we 
+    #   implement the calculation for corporate and government only.
+    # @option args [String] :bond Name of the company who is offering the Bond.
+    # @option args [String] :term Number of years to pay.
+    # @option args [String] :yield The interest rate.
+    #
+    # @return [<void>]
+    def initialize(args)
+      @type = format_type(args['type'])
+      @name = format_bond(args['bond'])
+      @term_years = format_term(args['term'])
+      @yield_percent = format_yield(args['yield'])
+    end
+
+    private
+
+    def format_type(type)
+      type
+    end
+
+    def format_bond(name)
+      name
+    end
+
+    def format_term(term)
+      term.split(' ').first.to_f unless term.nil?
+    end
+
+    def format_yield(yield_percent)
+      yield_percent&.delete('%').to_f
+    end
+  end
+end

data/lib/bond_calculator/spread_to_benchmark.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that handle Bond calculation
+#  @since 0.0.1
+module BondCalculator
+  # Class that handle the calculation of the spread to benchmark
+  # Calculate the yield spread (return) between a corporate bond
+  # and its government bond benchmark.
+  #
+  # A government bond is a good benchmark if it is as close as possible
+  # to the corporate bond in terms of years to maturity (term).
+  #
+  # @author Lucas Sant' Anna
+  # @since 0.0.1
+  class SpreadToBenchmark < BaseCalculator
+    attr_reader :bonds
+
+    # @param [File] bond_file_path Csv benchmark file path
+    #
+    # @return [<void>]
+    def initialize(bond_file_path)
+      @bonds = csv_to_bonds(bond_file_path)
+    end
+
+    # Execute the bussines rule to calculate the spread to Benchmark
+    # @return [Hash] :bond_name
+    # @return [Hash] :benchmark_name
+    # @return [Hash] :spread_to_benchmark
+    def calculate
+      response = []
+      corps = bonds_by_type('corporate', @bonds)
+      govs = bonds_by_type('government', @bonds)
+
+      corps.each do |corp|
+        benchmark = nil
+        govs.each do |gov|
+          if benchmark.nil?
+            benchmark = best_benchmark(corp, gov)
+            next
+          end
+          if benchmark[:term_spread] > term_spread(corp, gov)
+            benchmark.merge(best_benchmark(corp, gov))
+          end
+        end
+
+        response << { bond_name: corp.name,
+                      benchmark_name: benchmark[:candidate].name,
+                      spread_to_benchmark: spread_to_benchmark(benchmark, corp) }
+      end
+      print(response)
+
+      response
+    end
+
+    private
+
+    def best_benchmark(corporate, government)
+      { candidate: government,
+        term_spread: term_spread(corporate, government) }
+    end
+
+    def spread_to_benchmark(benchmark, corporate)
+      (benchmark[:candidate].yield_percent - corporate.yield_percent).round(2).abs
+    end
+
+    def print(response)
+      puts ' bond, benchmark, spread_to_benchmark '
+      response.each do |r|
+        puts " #{r[:bond_name]}, #{r[:benchmark_name]}, #{r[:spread_to_benchmark]} "
+      end
+    end
+
+    def term_spread(bond1, bond2)
+      (bond1.term_years - bond2.term_years).abs
+    end
+  end
+end

data/lib/bond_calculator/spread_to_curve.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Namespace for classes and modules that handle Bond calculationP
+#  @since 0.0.1
+module BondCalculator
+
+  # Class that handle the calculation of the spread to curve
+  #
+  # Since the corporate bond term is not exactly the same as
+  # its benchmark term, we use linear interpolation
+  # to calculate the spread to the curve.
+  class SpreadToCurve < BaseCalculator
+    attr_reader :bonds
+
+    # @param [File] bond_file_path Csv curve file path
+    #
+    # @return [<void>]
+    def initialize(bond_file_path)
+      @bonds = csv_to_bonds(bond_file_path)
+    end
+
+    # Execute the bussines rule to calculate the spread to curve
+    # @return [Hash] :bond_name
+    # @return [Hash] :spread_to_curve
+    def calculate
+      response = []
+      corps = bonds_by_type('corporate', @bonds)
+      govs = bonds_by_type('government', @bonds)
+
+      corps.each do |corp|
+        upper_bond = nil
+        lower_bond = nil
+
+        govs.each do |gov|
+          if corp.term_years <= gov.term_years
+            lower_bond = gov
+            break
+          else
+            upper_bond = gov
+          end
+        end
+
+        spread_to_curve = (corp.yield_percent - yield_on_curve(corp, lower_bond, upper_bond)).round(2)
+        response << { bond_name: corp.name, spread_to_curve: spread_to_curve }
+      end
+      print_response(response)
+
+      response
+    end
+
+    private
+
+    def print_response(response)
+      puts 'bond, spread to curve'
+      response.each do |r|
+        puts "#{r[:bond_name]}, #{r[:spread_to_curve]}"
+      end
+    end
+
+    def yield_on_curve(bond, lower_bond, upper_bond)
+      lower_bond.yield_percent + (bond.term_years - lower_bond.term_years) * ((upper_bond.yield_percent - lower_bond.yield_percent) / (upper_bond.term_years - lower_bond.term_years))
+    end
+  end
+end

data/lib/bond_calculator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BondCalculator
+  VERSION = '0.0.2'
+end

data/test/bond_calculator/base_calculator_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'BaseCalculator#csv_to_bonds' do
+  it 'return bonds when parse the bond csv' do
+    c1 = File.join(File.dirname(__FILE__), '../fixtures/c1.csv')
+    bonds = BondCalculator::BaseCalculator.new.csv_to_bonds(c1)
+    assert !bonds.nil?
+  end
+
+  it 'return error when file empty' do
+    assert_raises(Errno::ENOENT) { BondCalculator::BaseCalculator.new.csv_to_bonds('') }
+  end
+end
+
+describe 'BaseCalculator#bond_by_type' do
+  c1 = File.join(File.dirname(__FILE__), '../fixtures/c1.csv')
+  let(:bonds) { BondCalculator::BaseCalculator.new.csv_to_bonds(c1) }
+
+  it 'return all bonds for an expecific type' do
+    gov = BondCalculator::BaseCalculator.new.bonds_by_type('government', bonds)
+    assert !gov.nil?
+    assert !gov.empty?
+  end
+
+  it 'return empty when type is null' do
+    gov = BondCalculator::BaseCalculator.new.bonds_by_type(nil, bonds)
+    assert gov.nil?
+  end
+end

data/test/bond_calculator/bond_calculator_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'BondCalculator::VERSION' do
+  it 'has a version number' do
+    value(::BondCalculator::VERSION).wont_be_nil
+  end
+end

data/test/bond_calculator/bond_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'Bond#new' do
+  it 'create bond with all parameters passed' do
+    bond = BondCalculator::Bond.new(
+      'type' => 'corporate',
+      'bond' => 'c1',
+      'term' => '10.3 years',
+      'yield' => '5.3 %'
+    )
+
+    assert !bond.nil?
+    assert_equal bond.type, 'corporate'
+    assert_equal bond.name, 'c1'
+    assert_equal bond.term_years, 10.3
+    assert_equal bond.yield_percent, 5.3
+  end
+
+  it 'thow ArgumentError parameters not passed' do
+    assert_raises(ArgumentError) { BondCalculator::Bond.new }
+  end
+end

data/test/bond_calculator/spread_to_benchmark_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'SpreadToBanchmark#new' do
+  it 'populate bonds when file is correct' do
+    c1 = File.join(File.dirname(__FILE__), '../fixtures/c1.csv')
+    spread_to_benchmark = BondCalculator::SpreadToBenchmark.new(c1)
+
+    assert !spread_to_benchmark.bonds.nil?
+    assert spread_to_benchmark.bonds.size > 1
+  end
+  it 'error when file is wrong' do
+    assert_raises(Errno::ENOENT) { BondCalculator::SpreadToBenchmark.new('') }
+  end
+end
+
+describe 'SpreadToBanchmark#calculate' do
+  c1 = File.join(File.dirname(__FILE__), '../fixtures/c1.csv')
+  let(:spread_to_banchmark) { BondCalculator::SpreadToBenchmark.new(c1) }
+
+  it 'return list  with bond_name and spread to curve' do
+    response = spread_to_banchmark.calculate
+
+    assert !response.nil?
+    assert !response.empty?
+
+    first = response.first
+    assert_equal first[:bond_name], 'C1'
+    assert_equal first[:benchmark_name], 'G1'
+    assert_equal first[:spread_to_benchmark], 1.6
+  end
+end

data/test/bond_calculator/spread_to_curve_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'SpreadToCurve#new' do
+  it 'populate bonds when file is right' do
+    c2 = File.join(File.dirname(__FILE__), '../fixtures/c2.csv')
+    spread_to_curve = BondCalculator::SpreadToCurve.new(c2)
+
+    assert !spread_to_curve.bonds.nil?
+    assert !spread_to_curve.bonds.empty?
+  end
+  it 'error when file is wrong' do
+    assert_raises(Errno::ENOENT) { BondCalculator::SpreadToCurve.new('') }
+  end
+end
+
+describe 'SpreadToCurve#calculate' do
+  c2 = File.join(File.dirname(__FILE__), '../fixtures/c2.csv')
+  let(:spread_to_curve) { BondCalculator::SpreadToCurve.new(c2) }
+
+  it 'return list  with bond_name and spread to curve' do
+    response = spread_to_curve.calculate
+
+    response.each do |r|
+      assert !r[:bond_name].nil?
+      assert !r[:spread_to_curve].nil?
+    end
+
+    assert !response.nil?
+    assert !response.empty?
+
+    first = response.first
+    assert_equal first[:bond_name], 'C1'
+    assert_equal first[:spread_to_curve], 1.43
+  end
+end

data/test/fixtures/c1.csv

@@ -0,0 +1,4 @@
+bond,type,term,yield
+C1,corporate,10.3 years,5.30%
+G1,government,9.4 years,3.70%
+G2,government,12 years,4.80%

data/test/fixtures/c2.csv

@@ -0,0 +1,14 @@
+bond,type,term,yield
+C1,corporate,1.3 years,3.30%
+C2,corporate,2.0 years,3.80%
+C3,corporate,5.2 years,5.30%
+C4,corporate,9.0 years,6.20%
+C5,corporate,10.1 years,6.40%
+C6,corporate,16.0 years,9.30%
+C7,corporate,22.9 years,12.30%
+G1,government,0.9 years,1.70%
+G2,government,2.3 years,2.30%
+G3,government,7.8 years,3.30%
+G4,government,12 years,5.50%
+G5,government,15.1 years,7.50%
+G6,government,24.2 years,9.80%

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+require 'minitest/autorun'
+require 'bond_calculator'
+require 'pry'

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: bond_calculator
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Lucas Sant Anna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.13
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.50.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.50.0
+description: Calculate the best bond
+email:
+- l.minota@gmail.com
+executables:
+- console
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bond_calculator.gemspec
+- doc/BondCalculator.html
+- doc/BondCalculator/BaseCalculator.html
+- doc/BondCalculator/Bond.html
+- doc/BondCalculator/SpreadToBenchmark.html
+- doc/BondCalculator/SpreadToCurve.html
+- doc/_index.html
+- doc/class_list.html
+- doc/css/common.css
+- doc/css/full_list.css
+- doc/css/style.css
+- doc/file.README.html
+- doc/file_list.html
+- doc/frames.html
+- doc/index.html
+- doc/js/app.js
+- doc/js/full_list.js
+- doc/js/jquery.js
+- doc/method_list.html
+- doc/top-level-namespace.html
+- lib/bond_calculator.rb
+- lib/bond_calculator/base_calculator.rb
+- lib/bond_calculator/bond.rb
+- lib/bond_calculator/spread_to_benchmark.rb
+- lib/bond_calculator/spread_to_curve.rb
+- lib/bond_calculator/version.rb
+- test/bond_calculator/base_calculator_test.rb
+- test/bond_calculator/bond_calculator_test.rb
+- test/bond_calculator/bond_test.rb
+- test/bond_calculator/spread_to_benchmark_test.rb
+- test/bond_calculator/spread_to_curve_test.rb
+- test/fixtures/c1.csv
+- test/fixtures/c2.csv
+- test/test_helper.rb
+homepage: http://lucassantanna.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Ruby Best Bond Calculator
+test_files:
+- test/bond_calculator/base_calculator_test.rb
+- test/bond_calculator/bond_calculator_test.rb
+- test/bond_calculator/bond_test.rb
+- test/bond_calculator/spread_to_benchmark_test.rb
+- test/bond_calculator/spread_to_curve_test.rb
+- test/fixtures/c1.csv
+- test/fixtures/c2.csv
+- test/test_helper.rb