lare_round 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34df43a119476abc7ae5444a36b0f0780037132e
-  data.tar.gz: 4080b4c67caaf8defc3f6cac1166cb79e899ed3a
+  metadata.gz: 22cc87361ca388e9fea449cc3fc775bba6c4869a
+  data.tar.gz: 5b837592bedcd9da1f528fdabf5a328896422860
 SHA512:
-  metadata.gz: ad2b381a02883609ffd9bed1a70c398a4e9a80c680c7e7e0def0b8ad752c8c2620bc602753dc38b84db4a0ee450091346d2b36843c8cdc84a9953a9b82c8121e
-  data.tar.gz: 99372d477e87a7ee1150fe1358752bf853215ca77101ac8dfe83d3be60129e396fdd4d4f04997cc919135615e7a2056f4533222aebc4d9cd601c9f781b37f5ad
+  metadata.gz: 92fc9fcefcdb98717afbd19cc8b2c2423f23dd53e2e195af746fe50183422c6518abe76a31260a1d1ef0d77fde661f27cd4d251841e3c6222e6e8da841a6ff15
+  data.tar.gz: cbd9d9df3a74c4f7a7a66d49f60923468e47066ffd615f421e055b732798c80b627c32f7ff12b03df05210cf5f04b9da51e41d32263f2d9c3d1daa1e9f6eae01

data/.travis.yml

@@ -1,9 +1,8 @@
-rvm:
-
-  - "1.9.3"
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-19mode
-branches:
-  only:
-    - master
+language: ruby
 
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - 2.1.2
+  - jruby-19mode

data/README.md

@@ -93,13 +93,13 @@ Item (unrounded)| Price (unrounded) | LareRound | Financial
  tax ( 8.23%) | 0.823 | 0.82 | 0.83
  **Total** | **10.823** | **10.82** | **10.83**
 
-  * release as gem
+  * refactoring ^^
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'lare_round', :git => "git://github.com/jethroo/lare_round.git"
+    gem 'lare_round', '~> 0.0.1'
 
 And then execute:
 

data/Rakefile

@@ -1,4 +1,4 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 
 require 'rake/testtask'
 
@@ -9,5 +9,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
-task :default => :test
+task default: :test

data/lare_round.gemspec

@@ -4,21 +4,34 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lare_round/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "lare_round"
+  spec.name          = 'lare_round'
   spec.version       = LareRound::VERSION
-  spec.authors       = ["Carsten Wirth\n\n"]
-  spec.email         = ["carsten.wirth@blacklane.com\n"]
-  spec.description   = %q{A collection of BigDecimal items e.g. invoice items can be rounded for displaying them in views. Rounding may apply a rounding error to the items such as the summed up rounded items will show deviation towards an invoice total with summed unrounded items. Which might cause confusion for customers and finance departments alike. Application of the largest remainder method can help to preserve the total sum for fractionated parts thus eliminating this confusion.
-  }
-  spec.summary       = %q{gem for rounding BigDecimal items by preserving its sum}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Carsten Wirth']
+  spec.email         = ['carsten.wirth@blacklane.com']
+
+  spec.description   = <<-DESCRIPTION
+    A collection of BigDecimal items e.g. invoice items can be rounded for
+    displaying them in views. Rounding may apply a rounding error to the
+    items such as the summed up rounded items will show deviation towards
+    an invoice total with summed unrounded items. Which might cause
+    confusion for customers and finance departments alike.
+
+    Application of the largest remainder method can help to preserve the
+    total sum for fractionated parts thus eliminating this confusion.
+  DESCRIPTION
+
+  spec.summary       = 'gem for rounding BigDecimal items by preserving its sum'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'simplecov'
 end

data/lib/lare_round.rb

@@ -1,54 +1,125 @@
 require 'bigdecimal'
 
 module LareRound
+  def self.round(values, precision)
+    # although it is the senders responsibility to ensure that correct messages
+    # are sent to this module it might not be quite obvious so i provide some
+    # help here with errors if input is invalid
+    array_of_values = values.is_a?(Hash) ? values.values : values
+    handle_value_errors(array_of_values)
+    handle_precision_errors(precision)
 
-  def self.round(values,precision)
-    raise LareRoundError.new("precision must not be nil")                   if precision.nil?
-    raise LareRoundError.new("precision must be a number")                  unless precision.is_a? Numeric
-    raise LareRoundError.new("precision must be greater or equal to 0")     if precision < 0
-    raise LareRoundError.new("values must not be nil")                      if values.nil?
-    raise LareRoundError.new("values must not be empty")                    if values.empty?
-    if values.kind_of?(Array)
-      round_array_of_values(values,precision)
-    elsif values.kind_of?(Hash)
-      rounded_values = round_array_of_values(values.values,precision)
-      values.keys.each_with_index do |key,index|
-        values[key] = rounded_values[index]
+    process(values, precision)
+  end
+
+  # StandardError for dealing with application level errors
+  class LareRoundError < StandardError; end
+
+  private
+
+  def self.process(values, precision)
+    if values.is_a? Hash
+      process_hash(values, precision)
+    else
+      round_array_of_values(values, precision)
+    end
+  end
+
+  def self.process_hash(values, precision)
+    rounded_values = round_array_of_values(values.values, precision)
+    values.tap do |hash|
+      hash.keys.each_with_index do |key, index|
+        hash[key] = rounded_values[index]
       end
-      return values
     end
   end
 
-  # StandardError for dealing with application level errors
-  class LareRoundError < StandardError
+  def self.handle_value_errors(values)
+    fail LareRoundError, 'values must not be nil' if values.nil?
+    fail LareRoundError, 'values must not be empty' if values.empty?
+    fail LareRoundError, 'values must be an array' unless values.is_a? Array
 
+    numbers_invalid = values.map { |i| i.is_a? Numeric }
+      .reject { |i| i == true }.size
+    if numbers_invalid > 0
+      error = <<-ERROR.strip.gsub(/\s+/, ' ')
+        values contains not numeric values (#{numbers_invalid})
+      ERROR
+      fail LareRoundError, error
+    end
+
+    if values.map { |i| i.is_a? BigDecimal }.reject { |i| i == true }.size > 0
+      warning = <<-WARNING.strip.gsub(/\s+/, ' ')
+        values contains non decimal values,
+        you might loose precision or even get wrong rounding results
+      WARNING
+      warn warning
+    end
   end
 
-  private
-  def self.round_array_of_values(array_of_values,precision)
-    raise LareRoundError.new("array_of_values must be an array")            unless array_of_values.is_a? Array
-    number_of_invalid_values = array_of_values.map{|i| i.is_a? Numeric}.reject{|i| i == true}.size
-    raise LareRoundError.new("values contains not numeric values (#{number_of_invalid_values})") if number_of_invalid_values > 0
-    warn "values contains non decimal values, you might loose precision or even get wrong rounding results" if array_of_values.map{|i| i.is_a? BigDecimal}.reject{|i| i == true}.size > 0
-
-    #prevention of can't omit precision for a Rational
-    decimal_shift = BigDecimal.new (10 ** precision.to_i)
-    rounded_total = array_of_values.reduce(:+).round(precision) * decimal_shift
-    array_of_values = array_of_values.map{|v| ((v.is_a? BigDecimal) ? v : BigDecimal.new(v.to_s))}
-    unrounded_values = array_of_values.map{|v| v * decimal_shift }
+  def self.handle_precision_errors(precision)
+    fail LareRoundError, 'precision must not be nil' if precision.nil?
 
-    # items needed to be rounded down if positiv:
-    # 0.7 + 0.7 + 0.7 = ( 2.1 ).round(0) = 2
-    # (0.7).round(0) + (0.7).round(0) + (0.7).round(0) = 1 + 1 + 1 = 3
-    # elsewise if negative
-    rounded_values = array_of_values.map{|v| v < 0 ? v.round(precision, BigDecimal::ROUND_UP) * decimal_shift : v.round(precision, BigDecimal::ROUND_DOWN) * decimal_shift }
+    unless precision.is_a? Numeric
+      fail LareRoundError, 'precision must be a number'
+    end
 
-    while not rounded_values.reduce(:+) >= rounded_total
-      fractions = unrounded_values.zip(rounded_values).map { |x, y| x - y }
-      rounded_values[fractions.index(fractions.max)] += 1
+    if precision < 0
+      fail LareRoundError, 'precision must be greater or equal to 0'
+    end
+  end
+
+  Struct.new(
+    'IntermediaryResults',
+    :decimal_shift,
+    :rounded_total,
+    :array_of_values,
+    :unrounded_values,
+    :precision,
+    :rounded_values
+  )
+
+  def self.round_array_of_values(array_of_values, precision)
+    mrc = Struct::IntermediaryResults.new
+    mrc.precision = precision
+    mrc.decimal_shift = BigDecimal.new(10**precision.to_i)
+    mrc.rounded_total = array_of_values.reduce(:+)
+      .round(precision) * mrc.decimal_shift
+    mrc.array_of_values = array_of_values.map do |v|
+      ((v.is_a? BigDecimal) ? v : BigDecimal.new(v.to_s))
+    end
+    mrc.unrounded_values = array_of_values.map { |v| v * mrc.decimal_shift }
+
+    largest_remainder_method(mrc)
+
+    mrc.rounded_values
+  end
+
+  def self.largest_remainder_method(mrc)
+    mrc.rounded_values = mrc.array_of_values.map do |v|
+      largest_remainder_round(v, mrc)
     end
 
-    return rounded_values.map{|v| v / decimal_shift }
+    until mrc.rounded_values.reduce(:+) >= mrc.rounded_total
+      fractions = mrc.unrounded_values.zip(mrc.rounded_values).map do |x, y|
+        x - y
+      end
+      mrc.rounded_values[fractions.index(fractions.max)] += 1
+    end
+
+    mrc.rounded_values.map! { |v| v / mrc.decimal_shift }
   end
 
+  def self.largest_remainder_round(v, mrc)
+    # items needed to be rounded down if positiv:
+    # 0.7 + 0.7 + 0.7 = ( 2.1 ).round(0) = 2
+    # (0.7).round(0) + (0.7).round(0) + (0.7).round(0) = 1 + 1 + 1 = 3
+    # elsewise if negative
+    rounding_strategy = if v < 0
+        BigDecimal::ROUND_UP
+      else
+        BigDecimal::ROUND_DOWN
+      end
+    v.round(mrc.precision, rounding_strategy) * mrc.decimal_shift
+  end
 end

data/lib/lare_round/version.rb

@@ -1,3 +1,3 @@
 module LareRound
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/test/lare_round_test.rb

@@ -2,115 +2,150 @@ require_relative 'test_helper'
 require 'bigdecimal'
 require 'securerandom'
 
-class LareRoundTest < MiniTest::Unit::TestCase
+class LareRoundTest < MiniTest::Spec
+  def test_has_static_method_round
+    assert_equal(true, LareRound.respond_to?(:round))
+  end
 
-  def test_lareRound_has_static_method_round
-    assert_equal(true,LareRound.respond_to?(:round))
+  def create_big_decimal(precision, digit)
+    BigDecimal.new('0.' + '3' * precision + "#{digit}")
   end
 
   (1..9).each do |digit|
     (1..23).each do |items|
       (0..10).each do |precision|
 
-        method_name = "test #{items} rounded items with last digit of #{digit} should sum up to rounded total of BigDecimal items with precision of #{precision} if passed as array".gsub(' ','_')
+        method_name = <<-TESTMETHOD.strip.gsub(/\s+/, '_')
+          test #{items} items with last digit of #{digit}
+          should sum up to rounded total of BigDecimal items
+          with precision of #{precision} if passed as array
+        TESTMETHOD
         define_method method_name do
-          decimal = BigDecimal.new("0."+"3"*precision+"#{digit}")
-          arr = Array.new(items){decimal}
+          arr =  Array.new(items) { create_big_decimal(precision, digit) }
           rounded_total = arr.reduce(:+).round(precision)
-          assert_equal(rounded_total,LareRound.round(arr,precision).reduce(:+).round(precision))
+          assert_equal(
+            rounded_total,
+            LareRound.round(arr, precision).reduce(:+).round(precision)
+          )
         end
 
-        method_name = "test #{items} rounded items with last digit of #{digit} should sum up to rounded total of BigDecimal items with precision of #{precision} if passed as hash".gsub(' ','_')
+        method_name = <<-TESTMETHOD.strip.gsub(/\s+/, '_')
+          test #{items} rounded items with last digit of #{digit}
+          should sum up to rounded total of BigDecimal items
+          with precision of #{precision} if passed as hash
+        TESTMETHOD
         define_method method_name do
-          decimal = BigDecimal.new("0."+"3"*precision+"#{digit}")
-          hash = Hash[(1..items).map.with_index{|x,i|[x,decimal]}]
+          hash = Hash[
+            (1..items).map do
+              |x| [x, create_big_decimal(precision, digit)]
+            end
+          ]
           rounded_total = hash.values.reduce(:+).round(precision)
-          assert_equal(rounded_total,LareRound.round(hash,precision).values.reduce(:+).round(precision))
+          assert_equal(
+            rounded_total,
+            LareRound.round(hash, precision).values.reduce(:+).round(precision)
+          )
         end
 
-        method_name = "test #{items} rounded items with last digit of #{digit} and precision of #{precision} if passed as hash should not change order".gsub(' ','_')
+        method_name = <<-TESTMETHOD.strip.gsub(/\s+/, '_')
+          test #{items} rounded items with last digit of #{digit}
+          and precision of #{precision}
+          if passed as hash should not change order
+        TESTMETHOD
         define_method method_name do
-          decimal = BigDecimal.new("0."+"3"*precision+"#{digit}")
-          hash = Hash[(1..items).map.with_index{|x,i|[x,decimal+BigDecimal.new(i)]}]
-          rounded_hash = LareRound.round(hash.clone,precision)
+          hash = Hash[
+            (1..items).map.with_index do |x, i|
+              [x, create_big_decimal(precision, digit) + BigDecimal.new(i)]
+            end
+          ]
+          rounded_hash = LareRound.round(hash.clone, precision)
           hash.keys.each do |key|
-            assert( (((hash[key] - rounded_hash[key])*10**precision).abs < 1) )
+            assert((((hash[key] - rounded_hash[key]) * 10**precision).abs < 1))
           end
         end
 
-        method_name = "test #{items} rounded negative items with last digit of #{digit} should sum up to rounded total of BigDecimal items with precision of #{precision} if passed as array".gsub(' ','_')
+        method_name = <<-TESTMETHOD.strip.gsub(/\s+/, '_')
+          test #{items} rounded negative items with last digit of #{digit}
+          should sum up to rounded total of BigDecimal items with precision
+          of #{precision} if passed as array
+        TESTMETHOD
         define_method method_name do
-          decimal = BigDecimal.new("-0."+"3"*precision+"#{digit}")
-          arr = Array.new(items){decimal}
+          arr = Array.new(items) do
+            BigDecimal.new(-1 * create_big_decimal(precision, digit))
+          end
           rounded_total = arr.reduce(:+).round(precision)
-          assert_equal(rounded_total,LareRound.round(arr,precision).reduce(:+).round(precision))
+          assert_equal(
+            rounded_total,
+            LareRound.round(arr, precision).reduce(:+).round(precision)
+          )
         end
 
-        method_name = "test #{items} rounded mixed (+/-) items with last digit of #{digit} should sum up to rounded total of BigDecimal items with precision of #{precision} if passed as array".gsub(' ','_')
+        method_name = <<-TESTMETHOD.strip.gsub(/\s+/, '_')
+          test #{items} rounded mixed (+/-) items with last digit of #{digit}
+          should sum up to rounded total of BigDecimal items with precision
+          of #{precision} if passed as array
+        TESTMETHOD
         define_method method_name do
-          decimal = BigDecimal.new( (SecureRandom.random_number(100) % 2 == 0) ? "" : "-" + "0."+"3"*precision+"#{digit}")
-          arr = Array.new(items){decimal}
+          arr = Array.new(items) { create_big_decimal(precision, digit) }
+          arr.map! { |i| SecureRandom.random_number(1).even? ? i : -1 * i }
           rounded_total = arr.reduce(:+).round(precision)
-          assert_equal(rounded_total,LareRound.round(arr,precision).reduce(:+).round(precision))
+          assert_equal(
+            rounded_total,
+            LareRound.round(arr, precision).reduce(:+).round(precision)
+          )
         end
-
       end
     end
   end
 
+  let(:default_array) { Array.new(3) { BigDecimal.new('0.1234') } }
+
   def test_should_raise_if_precision_is_nil
-    decimal = BigDecimal.new("0.1234")
-    arr = Array.new(3){decimal}
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round(arr,nil)
-    }
-    assert_equal("precision must not be nil", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round(default_array, nil)
+    end
+    assert_equal('precision must not be nil', exception.message)
   end
 
   def test_should_raise_if_precision_is_less_than_zero
-    decimal = BigDecimal.new("0.1234")
-    arr = Array.new(3){decimal}
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round(arr,-1)
-    }
-    assert_equal("precision must be greater or equal to 0", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round(default_array, -1)
+    end
+    assert_equal('precision must be greater or equal to 0', exception.message)
   end
 
   def test_should_raise_if_precision_is_not_a_number
-    decimal = BigDecimal.new("0.1234")
-    arr = Array.new(3){decimal}
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round(arr,"not_a_number")
-    }
-    assert_equal("precision must be a number", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round(default_array, 'not_a_number')
+    end
+    assert_equal('precision must be a number', exception.message)
   end
 
   def test_should_raise_if_values_is_nil
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round(nil,2)
-    }
-    assert_equal("values must not be nil", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round(nil, 2)
+    end
+    assert_equal('values must not be nil', exception.message)
   end
 
   def test_should_raise_if_values_is_empty
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round([],2)
-    }
-    assert_equal("values must not be empty", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round([], 2)
+    end
+    assert_equal('values must not be empty', exception.message)
   end
 
   def test_should_raise_if_values_contains_invalid_values
-    exception = assert_raises(LareRound::LareRoundError){
-      LareRound.round([3.2, 1, "not_a_number", Exception.new, nil],2)
-    }
-    assert_equal("values contains not numeric values (3)", exception.message)
+    exception = assert_raises(LareRound::LareRoundError) do
+      LareRound.round([3.2, 1, 'not_a_number', Exception.new, nil], 2)
+    end
+    assert_equal('values contains not numeric values (3)', exception.message)
   end
 
   def test_should_warn_if_numbers_not_big_decimals
-    out, err = capture_io do
-      LareRound.round([1.2132, 12.21212, 323.23],2)
+    _out, err = capture_io do
+      LareRound.round([1.2132, 12.21212, 323.23], 2)
     end
-    assert_match(/values contains non decimal values, you might loose precision or even get wrong rounding results/, err)
+    assert_match(/you might loose precision/, err)
   end
-
 end

data/test/test_helper.rb

@@ -1,8 +1,12 @@
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-lib_dir  = File.join(base_dir, "lib")
-test_dir = File.join(base_dir, "test")
+require 'simplecov'
+SimpleCov.start
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+lib_dir  = File.join(base_dir, 'lib')
 
 $LOAD_PATH.unshift(lib_dir)
 
-require 'test/unit'
+require 'minitest/spec'
+require 'minitest/autorun'
+
 require 'lare_round'

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lare_round
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
-- |+
-  Carsten Wirth
-
+- Carsten Wirth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-20 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -40,15 +38,59 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "A collection of BigDecimal items e.g. invoice items can be rounded for
-  displaying them in views. Rounding may apply a rounding error to the items such
-  as the summed up rounded items will show deviation towards an invoice total with
-  summed unrounded items. Which might cause confusion for customers and finance departments
-  alike. Application of the largest remainder method can help to preserve the total
-  sum for fractionated parts thus eliminating this confusion.\n  "
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: minitest
+  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: simplecov
+  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'
+description: |2
+      A collection of BigDecimal items e.g. invoice items can be rounded for
+      displaying them in views. Rounding may apply a rounding error to the
+      items such as the summed up rounded items will show deviation towards
+      an invoice total with summed unrounded items. Which might cause
+      confusion for customers and finance departments alike.
+
+      Application of the largest remainder method can help to preserve the
+      total sum for fractionated parts thus eliminating this confusion.
 email:
-- |
-  carsten.wirth@blacklane.com
+- carsten.wirth@blacklane.com
 executables: []
 extensions: []
 extra_rdoc_files: []