big_decimal_helper 2.0.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjM0YjdjYzcxYTM0YjdhYmM1NjIxNGRhYmQ5ODc0YjZlOTVhZjI5ZA==
+  data.tar.gz: !binary |-
+    ZTUyZmU2Y2FhMzNjOGYwZTZlYmNkZjBkYTk5ZjUxMTAzNmFlNGY2YQ==
+SHA512:
+  metadata.gz: !binary |-
+    YjliY2M0NjJhMjRmNmE5ODEyZGM3YTdlMzI5ZTFmNjk5ZjdmNjQzMjc1N2I0
+    MWJhYmE5YWRjOWEyMDBiMjVlYThiZWRkNTQ0NzRmMmQ2YWMzOTU5NzczYjcw
+    YzUzNTFiNDFhNTY5MDVmYjIwMjliOTFiNDY2NDEwYWFiMmQyM2Y=
+  data.tar.gz: !binary |-
+    OTkwOGU0NTc5NDQ0N2MwNDcyZDA0MmNiMTU3ZDExMDU4ZGU1NTAxMjYyMjVj
+    MTQwOGE0N2M5ZGZlMzlkNWI2MzhkYmQyOTZmZDZjMzUzMjhhZWVhYTNlY2Q2
+    NGFlNWFiMDk1MzRiNzRhYTFlMTRkZmU1YjczYjJiOGJiZGViOGU=

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1 @@
+--color --order random

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in big_decimal_helper.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 livingsocial
+
+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,52 @@
+big_decimal_helper
+==================
+
+Helpers for working with BigDecimals in Rails apps.
+
+* Defines a <code>#to_bd</code> conversion protocol on Float, Fixnum, String, and NilClass to ease finger typing.
+* Overrides <code>BigDecimal#inspect</code> to provide a more human-readable format:
+  <br />1234.56.to_bd # => #&lt;BigDecimal: 1,234.56&gt;</code>
+* Provides an <code>ActiveRecord::Base.has_big_decimal_field</code> macro to automatically convert various fields to BigDecimal.
+* Provides some convenience methods for finding the min and max of a list that might possibly include NaN values.  (This can cause some bugs that are extremely annoying to track down.)
+
+## A Note About Versions
+
+As of 2.0.4, this gem will be published to rubygems.org.  Earlier
+versions were published internally to LivingSocial.  You're
+welcome to build them locally, if you're into that sort of thing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'big_decimal_helper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install big_decimal_helper
+
+## Usage
+
+You'll be able to call <code>#to_bd</code> on any Fixnum, Float, String, or BigDecimal to ensure that you have a BigDecimal.  <code>nil.to_bd</code> is also defined, and works similarly to <code>nil.to_f</code> or <code>nil.to_i</code>.
+
+Also, if you have a field whose underlying type you can't change, but you want it to be automatically coerced to a BigDecimal, do this:
+
+    class Deal < ActiveRecord::Base
+      has_big_decimal_field :final_revenue
+    end
+
+This just calls <code>.composed_of</code> behind the scenes, but since I can never remember how to use that API, I wrapped it in a more intention-revealing macro.
+
+(*NOTE:*  This gem does not declare a dependency on ActiveRecord.  If this gem loads before ActiveRecord does, that macro won't automatically appear.  Should this happen to you, just add <code>BigDecimalHelper.add_active_record_macro!</code> to <code>config/initializers/big_decimal_helper.rb</code> in your Rails project.)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb' # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/big_decimal_helper.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/big_decimal_helper/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sam Livingston-Gray"]
+  gem.email         = ["sam.livingstongray@livingsocial.com"]
+  gem.description   = %q{Helpers for working with BigDecimals in Rails apps}
+  gem.summary       = %q{Defines a #to_bd conversion protocol to ease typing, and provides an ActiveRecord macro to facilitate presentation of float fields as BigDecimal.}
+  gem.homepage      = "https://github.com/livingsocial/big_decimal_helper"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "big_decimal_helper"
+  gem.require_paths = ["lib"]
+  gem.version       = BigDecimalHelper::VERSION
+
+  gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'rspec', '~> 2.14.1'
+end

data/lib/big_decimal_helper.rb

@@ -0,0 +1,15 @@
+require 'bigdecimal'
+
+module BigDecimalHelper
+end
+
+require 'pathname'
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), 'big_decimal_helper' ))
+lib_path = Pathname.new( lib_path )
+
+require lib_path.join( 'version' )
+require lib_path.join( 'conversion_protocol' )
+require lib_path.join( 'pretty_inspect' )
+require lib_path.join( 'has_big_decimal_field' )
+require lib_path.join( 'comparisons' )
+

data/lib/big_decimal_helper/comparisons.rb

@@ -0,0 +1,21 @@
+module BigDecimalHelper
+  module Comparisons
+    def max_of(list)
+      sanitize_list_for_comparison(list).max
+    end
+
+    def min_of(list)
+      sanitize_list_for_comparison(list).min
+    end
+
+    private
+
+    def sanitize_list_for_comparison(list)
+      list \
+        .map(&:to_bd) \
+        .reject(&:nan?)
+    end
+  end
+
+  extend Comparisons
+end

data/lib/big_decimal_helper/conversion_protocol.rb

@@ -0,0 +1,26 @@
+module BigDecimalHelper
+  # Defines a conversion protocol for BigDecimal that is
+  # (a) easier to type than { BigDecimal(something.to_s) }
+  # (b) idempotent (by virtue of being lazy^H^H returning self when called on BigDecimal)
+  # (c) restricted to a few known types
+  module ConversionProtocol
+    module Self
+      def to_bd
+        self
+      end
+    end
+
+    module ViaStringRepresentation
+      def to_bd
+        string_representation = to_s.gsub(/[^\-\d\.]/, '')
+        BigDecimal.new(string_representation)
+      end
+    end
+  end
+end
+
+BigDecimal.send :include, BigDecimalHelper::ConversionProtocol::Self
+Fixnum    .send :include, BigDecimalHelper::ConversionProtocol::ViaStringRepresentation
+Float     .send :include, BigDecimalHelper::ConversionProtocol::ViaStringRepresentation
+String    .send :include, BigDecimalHelper::ConversionProtocol::ViaStringRepresentation
+NilClass  .send :include, BigDecimalHelper::ConversionProtocol::ViaStringRepresentation

data/lib/big_decimal_helper/has_big_decimal_field.rb

@@ -0,0 +1,20 @@
+module BigDecimalHelper
+  # Provides an ActiveRecord macro to coerce fields to BigDecimal
+  module HasBigDecimalField
+    def has_big_decimal_field(attr_name)
+      composed_of attr_name,
+        :class_name  => 'BigDecimal',
+        :mapping     => [ [attr_name, :to_f] ],
+        :constructor => Proc.new {|x| x.to_bd },
+        :converter   => Proc.new {|x| x.to_bd }
+    end
+  end
+
+  def self.add_active_record_macro!
+    return unless defined?( ActiveRecord::Base )
+    return if ActiveRecord::Base.kind_of?( BigDecimalHelper::HasBigDecimalField )
+    ActiveRecord::Base.extend BigDecimalHelper::HasBigDecimalField
+  end
+end
+
+BigDecimalHelper.add_active_record_macro!

data/lib/big_decimal_helper/pretty_inspect.rb

@@ -0,0 +1,39 @@
+# Provide a notation that confirms that the proper class is being used,
+# but which a normal human can actually read.
+
+class BigDecimal
+  def inspect
+    BigDecimalHelper.pretty_inspect(self)
+  end
+end
+
+
+module BigDecimalHelper
+  def self.pretty_inspect(bd)
+    "#<BigDecimal: #{string_for_pretty_inspect(bd)}>"
+  end
+
+  private
+
+  def self.string_for_pretty_inspect(bd)
+    # Just use to_s for exceptional values
+    return bd.to_s if bd.nan? || bd.infinite?
+
+    # Lean on the Float class for basic formatting, but drop the trailing '.0'
+    s = bd.to_f.to_s.gsub(/\.0$/, '')
+
+    # Add commas to the integer part
+    int_part, dec_part = s.split('.')
+    int_part = int_part \
+      .to_s \
+      .reverse \
+      .scan(/(?:\.)?\d{1,3}-?/) \
+      .join(',') \
+      .reverse
+
+    # Put it all back together
+    dec_part = '.' + dec_part unless dec_part.nil?
+    [ int_part, dec_part ].join
+  end
+end
+

data/lib/big_decimal_helper/version.rb

@@ -0,0 +1,3 @@
+module BigDecimalHelper
+  VERSION = "2.0.4"
+end

data/spec/active_record_macro_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+unless defined?(ActiveRecord::Base)
+  module ActiveRecord
+    class Base
+    end
+  end
+end
+
+describe 'ActiveRecord mixin' do
+  before(:all) do
+    BigDecimalHelper.add_active_record_macro!
+  end
+
+  it 'gets mixed in to ActiveRecord::Base' do
+    expect(ActiveRecord::Base).to be_kind_of( BigDecimalHelper::HasBigDecimalField )
+  end
+
+  it 'adds a .has_big_decimal_field method that invokes .composed_of' do
+    expect(ActiveRecord::Base).to receive( :composed_of )
+    ActiveRecord::Base.class_eval do
+      has_big_decimal_field :foo
+    end
+  end
+end

data/spec/comparisons_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe "comparison helper(s, eventually)" do
+  it "checks sanity" do
+    expect( nan ).to     be_nan
+    expect( nan ).to_not be_infinite
+
+    expect( pos_inf ).to_not be_nan
+    expect( pos_inf ).to     be_infinite
+
+    expect( neg_inf ).to_not be_nan
+    expect( neg_inf ).to     be_infinite
+  end
+  
+  let(:nan)     {  0.to_bd / 0.to_bd }
+  let(:pos_inf) {  1.to_bd / 0.to_bd }
+  let(:neg_inf) { -1.to_bd / 0.to_bd }
+  let(:batman)  { -1.to_bd }
+
+  describe BigDecimalHelper::Comparisons do
+    describe ".max_of" do
+      def max_of(list)
+        BigDecimalHelper.max_of(list)
+      end
+
+      it "returns nil for an empty list" do
+        expect( max_of([]) ).to be_nil
+      end
+
+      it "returns nil for a list with nan in it" do
+        expect( max_of([nan]) ).to be_nil
+      end
+
+      it "returns 23 for a list containing just 23" do
+        expect( max_of([23]) ).to eq( 23 )
+      end
+
+      it "returns 42 for a list containing 23 and 42" do
+        expect( max_of([42, 23]) ).to eq( 42 )
+        expect( max_of([23, 42]) ).to eq( 42 )
+      end
+
+      it "returns numeric output as BigDecimal" do
+        expect( max_of([23]) ).to be_kind_of(BigDecimal)
+      end
+
+      it "returns 42 for a list with nan and 42 in it" do
+        expect( max_of([42, nan]) ).to eq( 42 )
+      end
+
+      it "returns +infinity for a list with a +infinity" do
+        expect( max_of([42, pos_inf]) ).to eq( pos_inf )
+      end
+
+      it "returns any other number for a list with a -infinity and any other number" do
+        expect( max_of([42, neg_inf]) ).to eq( 42 )
+      end
+    end
+
+    describe ".min_of" do
+      def min_of(list)
+        BigDecimalHelper.min_of(list)
+      end
+
+      it "returns nil for an empty list" do
+        expect( min_of([]) ).to be_nil
+      end
+
+      it "returns nil for a list with nan in it" do
+        expect( min_of([nan]) ).to be_nil
+      end
+
+      it "returns 23 for a list containing just 23" do
+        expect( min_of([23]) ).to eq( 23 )
+      end
+
+      it "returns 23 for a list containing 23 and 42" do
+        expect( min_of([42, 23]) ).to eq( 23 )
+        expect( min_of([23, 42]) ).to eq( 23 )
+      end
+
+      it "returns numeric output as BigDecimal" do
+        expect( min_of([23]) ).to be_kind_of(BigDecimal)
+      end
+
+      it "returns 42 for a list with nan and 42 in it" do
+        expect( min_of([42, nan]) ).to eq( 42 )
+      end
+
+      it "returns 42 for a list with a +infinity" do
+        expect( min_of([42, pos_inf]) ).to eq( 42 )
+      end
+
+      it "returns -infinity for a list with a -infinity and any other number" do
+        expect( min_of([42, neg_inf]) ).to eq( neg_inf )
+      end
+    end
+  end
+end

data/spec/conversion_protocol_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'Conversion protocol' do
+  describe "for numeric types" do
+    it "converts a BigDecimal to a BigDecimal" do
+      foo = BigDecimal('42')
+      expect( foo.to_bd ).to eq( foo )
+    end
+
+    it "converts an integer to a BigDecimal" do
+      expect( 42.to_bd ).to eq( BigDecimal('42') )
+    end
+
+    it "converts a float to a BigDecimal" do
+      expect( 1.23.to_bd ).to eq( BigDecimal('1.23') )
+    end
+  end
+
+  describe "for strings" do
+    it "converts a string to a BigDecimal" do
+      expect( '42'.to_bd ).to eq( BigDecimal('42') )
+    end
+
+    it "converts a string with commas to a BigDecimal" do
+      expect( '42,000'.to_bd ).to eq( BigDecimal('42000') )
+    end
+
+    it "converts a string with dollar signs to a BigDecimal" do
+      expect( '$42,000'.to_bd ).to eq( BigDecimal('42000') )
+    end
+
+    it "doesn't drop decimals either" do
+      expect( '$42,000.42'.to_bd ).to eq( BigDecimal('42000.42') )
+    end
+
+    it "groks negative numbers" do # oops
+      expect( '-42,000.42'.to_bd ).to eq( BigDecimal('-42000.42') )
+    end
+  end
+
+  describe "for other types" do
+    it "converts nil to zero, a la #to_i and #to_f" do
+      expect( nil.to_bd ).to eq( BigDecimal('0') )
+    end
+
+    it "won't even try to convert an Array to a BigDecimal" do
+      expect { %w[ 1 2 3 go ].to_bd }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/pretty_inspect_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'Pretty #inspect' do
+  it "handles NaN" do
+    expect( format(0       / 0.to_bd)  ).to eq( '#<BigDecimal: NaN>' )
+    expect( format(0.to_bd / 0      )  ).to eq( '#<BigDecimal: NaN>' )
+    expect( format(0.to_bd / 0.to_bd)  ).to eq( '#<BigDecimal: NaN>' )
+  end
+
+  it "handles Infinity" do
+    expect( format(1       / 0.to_bd)  ).to eq( '#<BigDecimal: Infinity>' )
+    expect( format(1.to_bd / 0      )  ).to eq( '#<BigDecimal: Infinity>' )
+    expect( format(1.to_bd / 0.to_bd)  ).to eq( '#<BigDecimal: Infinity>' )
+  end
+
+  it "handles -Infinity" do
+    expect( format(-1       / 0.to_bd)  ).to eq( '#<BigDecimal: -Infinity>' )
+    expect( format(-1.to_bd / 0      )  ).to eq( '#<BigDecimal: -Infinity>' )
+    expect( format(-1.to_bd / 0.to_bd)  ).to eq( '#<BigDecimal: -Infinity>' )
+  end
+
+  it "doesn't use pseudoscientific notation" do
+    expect( format(1.23)  ).to eq( '#<BigDecimal: 1.23>' )
+  end
+
+  it "groks negative numbers" do
+    expect( format(-1.23)  ).to eq( '#<BigDecimal: -1.23>' )
+  end
+
+  it "groks negative numbers, even small ones" do
+    expect( format(-0.5) ).to eq('#<BigDecimal: -0.5>' )
+  end
+
+  it "inserts commas left of the decimal point" do
+    expect( format(1234) ).to eq('#<BigDecimal: 1,234>' )
+  end
+
+  it "inserts commas left of the decimal point in negative numbers" do
+    expect( format(-1234) ).to eq('#<BigDecimal: -1,234>' )
+  end
+
+  it "does all of the above at once" do
+    expect( format(-1234.56) ).to eq('#<BigDecimal: -1,234.56>' )
+  end
+
+  def format(x)
+    x.to_bd.inspect
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'big_decimal_helper'
+
+RSpec.configure do |config|
+  # nothing to see here; move along
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: big_decimal_helper
+version: !ruby/object:Gem::Version
+  version: 2.0.4
+platform: ruby
+authors:
+- Sam Livingston-Gray
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: Helpers for working with BigDecimals in Rails apps
+email:
+- sam.livingstongray@livingsocial.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- big_decimal_helper.gemspec
+- lib/big_decimal_helper.rb
+- lib/big_decimal_helper/comparisons.rb
+- lib/big_decimal_helper/conversion_protocol.rb
+- lib/big_decimal_helper/has_big_decimal_field.rb
+- lib/big_decimal_helper/pretty_inspect.rb
+- lib/big_decimal_helper/version.rb
+- spec/active_record_macro_spec.rb
+- spec/comparisons_spec.rb
+- spec/conversion_protocol_spec.rb
+- spec/pretty_inspect_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/livingsocial/big_decimal_helper
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: ! 'Defines a #to_bd conversion protocol to ease typing, and provides an ActiveRecord
+  macro to facilitate presentation of float fields as BigDecimal.'
+test_files:
+- spec/active_record_macro_spec.rb
+- spec/comparisons_spec.rb
+- spec/conversion_protocol_spec.rb
+- spec/pretty_inspect_spec.rb
+- spec/spec_helper.rb