percent 0.0.1

data/spec/lib/percent/active_record/percentizable_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+if defined? ActiveRecord
+  describe Percent::ActiveRecord::Percentizable do
+    describe '#percentize' do
+      shared_examples_for 'Survey methods' do
+        it { is_expected.to respond_to(:percent_complete) }
+        it { is_expected.to respond_to(:percent_complete=) }
+        it { is_expected.to respond_to(:non_fraction_ending_percent) }
+        it { is_expected.to respond_to(:non_fraction_ending_percent=) }
+        it { is_expected.to respond_to(:percent) }
+        it { is_expected.to respond_to(:percent=) }
+        it { is_expected.to respond_to(:optional) }
+        it { is_expected.to respond_to(:optional=) }
+        it { is_expected.to respond_to(:sans_validation) }
+        it { is_expected.to respond_to(:sans_validation=) }
+        it { is_expected.to respond_to(:sans_frac_validate) }
+        it { is_expected.to respond_to(:sans_frac_validate=) }
+        it { is_expected.to respond_to(:in_a_weird_range) }
+        it { is_expected.to respond_to(:in_a_weird_range=) }
+        it { is_expected.to respond_to(:in_fraction_range) }
+        it { is_expected.to respond_to(:in_fraction_range=) }
+        it { is_expected.to respond_to(:first_percent) }
+        it { is_expected.to respond_to(:first_percent=) }
+        it { is_expected.to respond_to(:second_percent) }
+        it { is_expected.to respond_to(:second_percent=) }
+      end
+
+      let (:subject) do
+        Survey.create percent_complete_fraction: 0.1,
+                      non_fraction_ending: 0.2,
+                      as_option_percent_fraction: 0.3,
+                      optional_fraction: 0.4,
+                      sans_validation_fraction: 0.5,
+                      sans_frac_validate_fraction: 0.6,
+                      in_a_weird_range_fraction: 0.7,
+                      in_fraction_range_fraction: 0.8,
+                      first_percent_fraction: 0.9,
+                      second_percent_fraction: 1.0
+      end
+
+      describe 'methods' do
+        it_should_behave_like 'Survey methods'
+      end
+
+      context 'inherited class instance' do
+        let (:subject) { InheritedPercentizeSurvey.new }
+        it_should_behave_like 'Survey methods'
+      end
+
+      describe 'percentized attribute getter' do
+        it 'attaches a Percentage object to model field' do
+          expect(subject.percent_complete).to be_an_instance_of Percentage
+          expect(subject.non_fraction_ending_percent).to be_an_instance_of Percentage
+          expect(subject.percent).to be_an_instance_of Percentage
+          expect(subject.optional).to be_an_instance_of Percentage
+          expect(subject.sans_validation).to be_an_instance_of Percentage
+          expect(subject.sans_frac_validate).to be_an_instance_of Percentage
+          expect(subject.in_a_weird_range).to be_an_instance_of Percentage
+          expect(subject.in_fraction_range).to be_an_instance_of Percentage
+        end
+
+        it 'attaches a Percentage object to multiple model fields' do
+          expect(subject.first_percent).to be_an_instance_of Percentage
+          expect(subject.second_percent).to be_an_instance_of Percentage
+        end
+
+        it 'returns the expected percentage amount as a Percentage object' do
+          expect(subject.percent_complete).to eql Percentage.new(10)
+          expect(subject.non_fraction_ending_percent).to eql Percentage.new(20)
+          expect(subject.percent).to eql Percentage.new(30)
+          expect(subject.optional).to eql Percentage.new(40)
+          expect(subject.sans_validation).to eql Percentage.new(50)
+          expect(subject.sans_frac_validate).to eql Percentage.new(60)
+          expect(subject.in_a_weird_range).to eql Percentage.new(70)
+          expect(subject.in_fraction_range).to eql Percentage.new(80)
+          expect(subject.first_percent).to eql Percentage.new(90)
+          expect(subject.second_percent).to eql Percentage.new(100)
+        end
+      end
+
+      describe 'percentized attribute setter' do
+        context 'assign value to percentized attribute' do
+          it 'assigns the correct value from a Percentage object' do
+            subject.percent_complete = Percentage.new(0)
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new(0)
+          end
+
+          it 'assigns the correct value from an integer' do
+            subject.percent_complete = 10
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.1')
+          end
+
+          it 'assigns the correct value from a complex number' do
+            subject.percent_complete = Complex(20,0)
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.2')
+          end
+
+          it 'assigns the correct value from a decimal' do
+            subject.percent_complete = BigDecimal.new(30)
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.3')
+          end
+
+          it 'assigns the correct value from a float' do
+            subject.percent_complete = 40.0
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.4')
+          end
+
+          it 'assigns the correct value from a rational number' do
+            subject.percent_complete = Rational(100,2)
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.5')
+          end
+
+          it 'assigns the correct value from a string with value "60"' do
+            subject.percent_complete = '60'
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.6')
+          end
+
+          it 'assigns the correct value from a string with value "70.0"' do
+            subject.percent_complete = '70.0'
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.7')
+          end
+
+          it 'assigns the correct value from a string with value "0.8E2"' do
+            subject.percent_complete = '0.8E2'
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.8')
+          end
+
+          it 'assigns the correct value from a string with value "810/9"' do
+            subject.percent_complete = '810/9'
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.9')
+          end
+
+          it 'assigns the correct value from a string with value "100%"' do
+            subject.percent_complete = '100%'
+            expect(subject.save).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new(1)
+          end
+        end
+
+        context 'assign value to percentized attribute on create' do
+          it 'assigns the correct value from a Percentage object' do
+            subject = Survey.create percent_complete: 15.0,
+                                    non_fraction_ending_percent: 0,
+                                    percent: 0,
+                                    sans_frac_validate: 0
+            expect(subject.valid?).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.15')
+          end
+
+          it 'assigns the correct value from a number' do
+            subject = Survey.create percent_complete: 35.0,
+                                    non_fraction_ending_percent: 0,
+                                    percent: 0,
+                                    sans_frac_validate: 0
+            expect(subject.valid?).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.35')
+          end
+
+          it 'assigns the correct value from a string' do
+            subject = Survey.create percent_complete: '55',
+                                    non_fraction_ending_percent: 0,
+                                    percent: 0,
+                                    sans_frac_validate: 0
+            expect(subject.valid?).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.55')
+          end
+        end
+
+        context 'assign value to percentized attribute on update' do
+          it 'assigns the correct value from a Percentage object' do
+            expect(subject.update_attributes percent_complete: Percentage.new(25)).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.25')
+          end
+
+          it 'assigns the correct value from a number' do
+            expect(subject.update_attributes percent_complete: 45.0).to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.45')
+          end
+
+          it 'assigns the correct value from a string' do
+            expect(subject.update_attributes percent_complete: '65').to be_truthy
+            expect(subject.percent_complete_fraction).to eql BigDecimal.new('0.65')
+          end
+        end
+      end
+
+      describe 'numericality validation' do
+        context 'when no validation options are passed' do
+          it 'ensures that the percentage can not be nil' do
+            subject.percent_complete = nil
+            expect(subject).to_not be_valid
+          end
+
+          it 'ensures that the percentage is between 0 and 100' do
+            subject.percent_complete = true
+            expect(subject).to be_valid
+
+            subject.percent_complete = false
+            expect(subject).to be_valid
+
+            subject.percent_complete = -1
+            expect(subject).to_not be_valid
+
+            subject.percent_complete = 101
+            expect(subject).to_not be_valid
+
+            subject.percent_complete = 10
+            expect(subject).to be_valid
+          end
+        end
+
+        context 'when validation options are passed' do
+          it 'ensures that the percentage matches the given criteria' do
+            subject.in_a_weird_range = -10
+            expect(subject).to_not be_valid
+
+            subject.in_a_weird_range = 0
+            expect(subject).to be_valid
+
+            subject.in_a_weird_range = true
+            expect(subject).to be_valid
+
+            subject.in_a_weird_range = false
+            expect(subject).to be_valid
+
+            subject.in_a_weird_range = 200
+            expect(subject).to_not be_valid
+
+            subject.in_a_weird_range = 100
+            expect(subject).to be_valid
+          end
+        end
+
+        context 'when false is passed' do
+          it 'should not validate any values passed to the attribute' do
+            subject.sans_frac_validate_fraction = 'string'
+            expect(subject).to be_valid
+
+            subject.sans_frac_validate_fraction = false
+            expect(subject).to be_valid
+
+            subject.sans_frac_validate_fraction = true
+            expect(subject).to be_valid
+          end
+        end
+      end
+
+      describe 'fraction numericality validation' do
+        context 'when no validation options are passed' do
+          it 'ensures that the percentage fraction can not be nil' do
+            subject.percent_complete_fraction = nil
+            expect(subject).to_not be_valid
+          end
+
+          it 'ensures that the percentage fraction is between 0 and 1' do
+            subject.percent_complete_fraction = -0.01
+            expect(subject).to_not be_valid
+
+            subject.percent_complete_fraction = 1.01
+            expect(subject).to_not be_valid
+
+            subject.percent_complete_fraction = 0.1
+            expect(subject).to be_valid
+          end
+        end
+
+        context 'when validation options are passed' do
+          it 'ensures that the percentage matches the given criteria' do
+            subject.in_fraction_range_fraction = -0.1
+            expect(subject).to_not be_valid
+
+            subject.in_fraction_range_fraction = 0
+            expect(subject).to be_valid
+
+            subject.in_fraction_range_fraction = 2
+            expect(subject).to_not be_valid
+
+            subject.in_fraction_range_fraction = 1
+            expect(subject).to be_valid
+          end
+        end
+      end
+
+      describe 'allow nil validation' do
+        context 'when no validation is passed' do
+          it 'ensures that the percentage and percentage fraction can not be nil' do
+            subject.percent_complete_fraction = nil
+            expect(subject).to_not be_valid
+            subject.percent_complete = nil
+            expect(subject).to_not be_valid
+          end
+        end
+
+        context 'when false is passed' do
+          it 'ensures that the percentage and percentage fraction can not be nil' do
+            subject.percent_complete_fraction = nil
+            expect(subject).to_not be_valid
+            subject.percent_complete = nil
+            expect(subject).to_not be_valid
+          end
+        end
+
+        context 'when true is passed' do
+          it 'allows the percentage and percentage fraction to be nil' do
+            subject.optional_fraction = nil
+            expect(subject).to be_valid
+            subject.optional = nil
+            expect(subject).to be_valid
+          end
+        end
+      end
+
+      describe 'disable validation' do
+        context 'when disable validation is given a true value' do
+          it 'should allow any value' do
+            subject.sans_validation = nil
+            expect(subject).to be_valid
+
+            subject.sans_validation = 'string'
+            expect(subject).to be_valid
+
+            subject.sans_validation_fraction = nil
+            expect(subject).to be_valid
+
+            subject.sans_validation_fraction = 'string'
+            expect(subject).to be_valid
+
+            subject.sans_validation_fraction = false
+            expect(subject).to be_valid
+
+            subject.sans_validation_fraction = true
+            expect(subject).to be_valid
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/percentage_spec.rb

@@ -0,0 +1,719 @@
+require 'spec_helper'
+
+describe Percentage do
+  subject { Percentage.new value }
+  let (:value) { 0 }
+
+  describe 'methods' do
+    it { is_expected.to respond_to(:value) }
+    it { is_expected.to respond_to(:to_i) }
+    it { is_expected.to respond_to(:to_c) }
+    it { is_expected.to respond_to(:to_d) }
+    it { is_expected.to respond_to(:to_f) }
+    it { is_expected.to respond_to(:to_r) }
+    it { is_expected.to respond_to(:to_complex) }
+    it { is_expected.to respond_to(:to_decimal) }
+    it { is_expected.to respond_to(:to_float) }
+    it { is_expected.to respond_to(:to_rational) }
+    it { is_expected.to respond_to(:to_s) }
+    it { is_expected.to respond_to(:to_str) }
+    it { is_expected.to respond_to(:to_string) }
+    it { is_expected.to respond_to(:format) }
+    it { is_expected.to respond_to(:to_amount) }
+    it { is_expected.to respond_to(:inspect) }
+    it { is_expected.to respond_to(:==) }
+    it { is_expected.to respond_to(:eql?) }
+    it { is_expected.to respond_to(:<=>) }
+    it { is_expected.to respond_to(:+) }
+    it { is_expected.to respond_to(:-) }
+    it { is_expected.to respond_to(:/) }
+    it { is_expected.to respond_to(:*) }
+  end
+
+  describe 'class methods' do
+    subject { Percentage }
+
+    it { is_expected.to respond_to(:from_fraction) }
+    it { is_expected.to respond_to(:from_amount) }
+  end
+
+  context 'Initialization methods' do
+    shared_examples 'a percentage' do |amount|
+      let (:decimal_value) { amount.to_d / 100 }
+      let (:string_value)  { "#{amount.to_f}%" }
+
+      it 'should equal the given percentage' do
+        expect(subject.value).to eql decimal_value
+        expect(subject.format).to eql string_value
+      end
+    end
+
+    describe '#initialize' do
+      context 'with value of 50' do
+        let (:value) { 50 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with value of 0.5' do
+        let (:value) { 0.5 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 1/2' do
+        let (:value) { Rational 1, 2 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 0.5E0' do
+        let (:value) { BigDecimal.new '0.5' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 0.5+0i' do
+        let (:value) { Complex(0.5, 0) }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "50"' do
+        let (:value) { '50' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "50%"' do
+        let (:value) { '50%' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "50.0%"' do
+        let (:value) { '50.0%' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of ".5"' do
+        let (:value) { '.5' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "0.5"' do
+        let (:value) { '0.5' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "0.5E0"' do
+        let (:value) { '0.5E0' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "1/2"' do
+        let (:value) { '1/2' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a boolean value of true' do
+        let (:value) { true }
+        it_should_behave_like 'a percentage', 100
+      end
+
+      context 'with a boolean value of false' do
+        let (:value) { false }
+        it_should_behave_like 'a percentage', 0
+      end
+    end
+
+    describe '#self.from_fraction' do
+      let (:subject) { Percentage.from_fraction value }
+
+      context 'with a numeric value of 50.0' do
+        let (:value) { 50.0 }
+        it_should_behave_like 'a percentage', 5000
+      end
+
+      context 'with a numeric value of 50' do
+        let (:value) { 50 }
+        it_should_behave_like 'a percentage', 5000
+      end
+
+      context 'with a numeric value of 1' do
+        let (:value) { 1 }
+        it_should_behave_like 'a percentage', 100
+      end
+
+      context 'with a numeric value of 0' do
+        let (:value) { 0 }
+        it_should_behave_like 'a percentage', 0
+      end
+
+      context 'with a string value of "50.0"' do
+        let (:value) { '50.0' }
+        it_should_behave_like 'a percentage', 5000
+      end
+
+      context 'with a string value of "50"' do
+        let (:value) { '50' }
+        it_should_behave_like 'a percentage', 5000
+      end
+
+      context 'with a string value of "1"' do
+        let (:value) { '1' }
+        it_should_behave_like 'a percentage', 100
+      end
+
+      context 'with a string value of "0"' do
+        let (:value) { '0' }
+        it_should_behave_like 'a percentage', 0
+      end
+    end
+
+    describe '#self.from_amount' do
+      let (:subject) { Percentage.from_amount value }
+
+      context 'with a numeric value of 50' do
+        let (:value) { 50 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 50.0' do
+        let (:value) { 50.0 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 0.5E2' do
+        let (:value) { BigDecimal.new 50 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a numeric value of 100/2' do
+        let (:value) { Rational 100, 2 }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "50"' do
+        let (:value) { '50' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "50.0"' do
+        let (:value) { '50.0' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "0.5E2"' do
+        let (:value) { '0.5E2' }
+        it_should_behave_like 'a percentage', 50
+      end
+
+      context 'with a string value of "200/4"' do
+        let (:value) { '200/4' }
+        it_should_behave_like 'a percentage', 50
+      end
+    end
+  end
+
+  context 'Attributes' do
+    describe '#value' do
+      context 'when a value is passed to an initialization method' do
+        let (:value) { BigDecimal('1.5') }
+
+        it 'should return that value' do
+          expect(subject.value).to eql value
+          expect(Percentage.from_fraction(value).value).to eql value
+          expect(Percentage.from_amount(value * 100).value).to eql value
+        end
+      end
+
+      context 'when nothing is passed to an initialization method' do
+        it 'should return 0' do
+          expect(Percentage.new.value).to eql BigDecimal(0)
+          expect(Percentage.from_fraction.value).to eql BigDecimal(0)
+          expect(Percentage.from_amount.value).to eql BigDecimal(0)
+        end
+      end
+    end
+  end
+
+  context 'Conversions' do
+    let (:value) { 75 }
+
+    describe '#to_i' do
+      context 'with a numeric value of 75' do
+        it 'should return 75' do
+          expect(subject.to_i).to eql 75
+        end
+      end
+    end
+
+    describe '#to_c' do
+      context 'with a numeric value of 75' do
+        it 'should return 0.75E0+0i' do
+          expect(subject.to_c).to eql Complex(BigDecimal.new('0.75'), 0)
+        end
+      end
+    end
+
+    describe '#to_d' do
+      context 'with a numeric value of 75' do
+        it 'should return 0.75E0' do
+          expect(subject.to_d).to eql BigDecimal.new('0.75')
+        end
+      end
+    end
+
+    describe '#to_f' do
+      context 'with a numeric value of 75' do
+        it 'should return 0.75' do
+          expect(subject.to_f).to eql 0.75
+        end
+      end
+    end
+
+    describe '#to_r' do
+      context 'with a numeric value of 75' do
+        it 'should return 3/4' do
+          expect(subject.to_r).to eql Rational(3,4)
+        end
+      end
+    end
+
+    describe '#to_complex' do
+      context 'with a numeric value of 75' do
+        it 'should return 0.75E2+0i' do
+          expect(subject.to_complex).to eql Complex(BigDecimal.new(75), 0)
+        end
+      end
+    end
+
+    describe '#to_decimal' do
+      context 'with a numeric value of 75' do
+        it 'should return 0.75E2' do
+          expect(subject.to_decimal).to eql BigDecimal(75)
+        end
+      end
+    end
+
+    describe '#to_float' do
+      context 'with a numeric value of 75' do
+        it 'should return 75.0' do
+          expect(subject.to_float).to eql 75.0
+        end
+      end
+    end
+
+    describe '#to_rational' do
+      context 'with a numeric value of 75' do
+        it 'should return 75/1' do
+          expect(subject.to_rational).to eql Rational(75,1)
+        end
+      end
+    end
+
+    describe '#to_s' do
+      context 'with a numeric value of 75' do
+        it 'should return "75"' do
+          expect(subject.to_s).to eql '75'
+        end
+      end
+
+      context 'with a numeric value of 0.75' do
+        let (:value) { 0.75 }
+        it 'should return "75"' do
+          expect(subject.to_s).to eql '75'
+        end
+      end
+
+      context 'with a numeric value of 0.755' do
+        let (:value) { 0.755 }
+        it 'should return "75.5"' do
+          expect(subject.to_s).to eql '75.5'
+        end
+      end
+    end
+
+    describe '#to_str' do
+      context 'with a numeric value of 75' do
+        it 'should return "0.75"' do
+          expect(subject.to_str).to eql '0.75'
+        end
+      end
+    end
+
+    describe '#to_string' do
+      context 'with a numeric value of 75' do
+        it 'should return "75%"' do
+          expect(subject.to_string).to eql '75%'
+        end
+      end
+
+      context 'with a numeric value of 0.75' do
+        let (:value) { 0.75 }
+        it 'should return "75%"' do
+          expect(subject.to_string).to eql '75%'
+        end
+      end
+
+      context 'with a numeric value of 0.755' do
+        let (:value) { 0.755 }
+        it 'should return "75.5%"' do
+          expect(subject.to_string).to eql '75.5%'
+        end
+      end
+    end
+
+    describe "#format" do
+      context 'with a value of 0.6666' do
+        let (:value) { 0.6666 }
+
+        context 'when passed no options' do
+          it 'should return "66.66%"' do
+            expect(subject.format).to eql '66.66%'
+          end
+        end
+
+        context 'when passed percent_sign: true' do
+          it 'should return "66.66%"' do
+            expect(subject.format percent_sign: true).to eql '66.66%'
+          end
+        end
+
+        context 'when passed percent_sign: false' do
+          it 'should return "66.66"' do
+            expect(subject.format percent_sign: false).to eql '66.66'
+          end
+        end
+
+        context 'when passed as_decimal: true' do
+          it 'should return "0.6666"' do
+            expect(subject.format as_decimal: true).to eql '0.6666'
+          end
+        end
+
+        context 'when passed rounded: true' do
+          it 'should return "67%"' do
+            expect(subject.format rounded: true).to eql '67%'
+          end
+        end
+
+        context 'when passed no_decimal: true' do
+          it 'should return "66%"' do
+            expect(subject.format no_decimal: true).to eql '66%'
+          end
+        end
+
+        context 'when passed no_decimal_if_whole: true' do
+          it 'should return "66.66%"' do
+            expect(subject.format no_decimal_if_whole: true).to eql '66.66%'
+          end
+        end
+
+        context 'when passed space_before_sign: true' do
+          it 'should return "66.66 %"' do
+            expect(subject.format space_before_sign: true).to eql '66.66 %'
+          end
+        end
+
+        context 'when passed percent_sign: false, rounded: true, space_before_sign: true' do
+          it 'should return "67 "' do
+            f = subject.format percent_sign: false, rounded: true, space_before_sign: true
+            expect(f).to eql '67 '
+          end
+        end
+
+        context 'when passed no_decimal: true, space_before_sign: true' do
+          it 'should return "66 %"' do
+            f = subject.format no_decimal: true, space_before_sign: true
+            expect(f).to eql '66 %'
+          end
+        end
+
+        context 'when passed percent_sign: false, as_decimal: true, no_decimal: true' do
+          it 'should return "0.6666"' do
+            f = subject.format percent_sign: false, as_decimal: true, no_decimal: true
+            expect(f).to eql '0.6666'
+          end
+        end
+
+        context 'when passed no_decimal_if_whole: true, no_decimal: true, rounded: true' do
+          it 'should return "67%"' do
+            f = subject.format no_decimal_if_whole: true, no_decimal: true, rounded: true
+            expect(f).to eql '67%'
+          end
+        end
+
+        context 'when passed no_decimal_if_whole: true, no_decimal: true' do
+          it 'should return "66%"' do
+            f = subject.format no_decimal_if_whole: true, no_decimal: true
+            expect(f).to eql '66%'
+          end
+        end
+      end
+    end
+
+    describe '#to_amount' do
+      context 'with a numeric value of 75' do
+        it 'should return 75' do
+          expect(subject.to_amount).to eql 75
+        end
+      end
+
+      context 'with a numeric value of 0.75' do
+        let (:value) { 0.75 }
+        it 'should return 75' do
+          expect(subject.to_amount).to eql 75
+        end
+      end
+
+      context 'with a numeric value of 0.755' do
+        let (:value) { 0.755 }
+        it 'should return 75.5' do
+          expect(subject.to_amount).to eql 75.5
+        end
+      end
+    end
+  end
+
+  context 'Comparisons' do
+    let (:value) { 100 }
+    let (:duplicate) { Percentage.new value }
+    let (:other) { Percentage.new 99 }
+
+    shared_examples_for 'full ==' do
+      it 'should equal a number with the same value' do
+        expect(equivalent == subject).to eql true
+        expect(equivalent >= subject).to eql true
+        expect(equivalent <= subject).to eql true
+        expect(equivalent != subject).to eql false
+        expect(equivalent >  subject).to eql false
+        expect(equivalent <  subject).to eql false
+
+        expect(subject == equivalent).to eql true
+        expect(subject >= equivalent).to eql true
+        expect(subject <= equivalent).to eql true
+        expect(subject != equivalent).to eql false
+        expect(subject >  equivalent).to eql false
+        expect(subject <  equivalent).to eql false
+      end
+
+      it 'should not equal a number with a different value' do
+        expect(subject == different).to eql false
+        expect(subject != different).to eql true
+
+        expect(different == subject).to eql false
+        expect(different != subject).to eql true
+      end
+    end
+
+    shared_examples_for 'comparisons' do
+      it 'should know when something is greater than' do
+        expect(subject > smaller).to be true
+        expect(subject > larger ).to be false
+        expect(smaller > subject).to be false
+        expect(larger  > subject).to be true
+      end
+
+      it 'should know when something is less than' do
+        expect(subject < smaller).to be false
+        expect(subject < larger ).to be true
+        expect(smaller < subject).to be true
+        expect(larger  < subject).to be false
+      end
+
+      it 'should know when something is greater than or equal to' do
+        expect(subject >= smaller).to be true
+        expect(subject >= larger ).to be false
+        expect(smaller >= subject).to be false
+        expect(larger  >= subject).to be true
+      end
+
+      it 'should know when something is less than or equal to' do
+        expect(subject <= smaller).to be false
+        expect(subject <= larger ).to be true
+        expect(smaller <= subject).to be true
+        expect(larger  <= subject).to be false
+      end
+    end
+
+    describe '#==' do
+      context 'comparing with percentage' do
+        it 'should equal itself' do
+          expect(subject == subject).to eql true
+        end
+
+        it 'should equal a different percentage object with the same value' do
+          expect(subject == duplicate).to eql true
+        end
+
+        it 'should not equal a different percentage' do
+          expect(subject == other).to eql false
+        end
+      end
+
+      context 'comparing with integer' do
+        let (:equivalent) { 1 }
+        let (:different)  { 2 }
+        it_should_behave_like 'full =='
+      end
+
+      context 'comparing with complex' do
+        let (:equivalent) { Complex(1.0,0) }
+        let (:different)  { Complex(1.00101,0) }
+
+        it 'should equal a number with the same value' do
+          expect(equivalent == subject).to eql true
+          expect(equivalent != subject).to eql false
+
+          expect(subject == equivalent).to eql true
+          expect(subject != equivalent).to eql false
+        end
+
+        it 'should not equal a number with a different value' do
+          expect(subject == different).to eql false
+          expect(subject != different).to eql true
+
+          expect(different == subject).to eql false
+          expect(different != subject).to eql true
+        end
+      end
+
+      context 'comparing with decimal' do
+        let (:equivalent) { BigDecimal.new(1) }
+        let (:different)  { BigDecimal.new('.99') }
+        it_should_behave_like 'full =='
+      end
+
+      context 'comparing with float' do
+        let (:equivalent) { 1.0 }
+        let (:different)  { 1.1010 }
+        it_should_behave_like 'full =='
+      end
+
+      context 'comparing with rational' do
+        let (:equivalent) { Rational(1) }
+        let (:different)  { Rational(9,8) }
+        it_should_behave_like 'full =='
+      end
+    end
+
+    describe '#eql?' do
+      it 'should equal itself' do
+        expect(subject.eql? subject).to eql true
+      end
+
+      it 'should equal a different percentage object with the same value' do
+        expect(subject.eql? duplicate).to eql true
+      end
+
+      it 'should not equal a different percentage' do
+        expect(subject.eql? other).to eql false
+      end
+
+      it 'should not equal any other numbers with the same value' do
+        expect(subject.eql? 1).to eql false
+        expect(subject.eql? 1.0).to eql false
+        expect(subject.eql? Complex(1, 0)).to eql false
+        expect(subject.eql? Rational(1)).to eql false
+        expect(subject.eql? BigDecimal.new(1)).to eql false
+      end
+    end
+
+    describe 'comparable' do
+      it 'is comparable' do
+        expect(subject.is_a? Comparable).to be true
+      end
+
+      context 'compared to other percentages' do
+        let (:smaller) { other }
+        let (:larger)  { Percentage.new 101 }
+        it_should_behave_like 'comparisons'
+      end
+
+      context 'compared to decimals' do
+        let (:smaller) { BigDecimal.new '0.999999' }
+        let (:larger)  { BigDecimal.new '1.000001' }
+        it_should_behave_like 'comparisons'
+      end
+
+      context 'compared to floats' do
+        let (:smaller) { 0.999999 }
+        let (:larger)  { 1.000001 }
+        it_should_behave_like 'comparisons'
+      end
+
+      context 'compared to integers' do
+        let (:smaller) { 0 }
+        let (:larger)  { 2 }
+        it_should_behave_like 'comparisons'
+      end
+
+      context 'compared to rationals' do
+        let (:denominator) { 10 ** 10 }
+        let (:smaller) { Rational denominator - 1, denominator }
+        let (:larger)  { Rational denominator + 1, denominator }
+        it_should_behave_like 'comparisons'
+      end
+    end
+  end
+
+  context 'Mathematical operations' do
+    let (:value)  { 25 }
+    let (:number) { 10 }
+
+    describe '#+' do
+      context 'when adding two percentages' do
+        it 'should return the sum of the two percentages' do
+          expect(subject + subject).to eql Percentage.new(50)
+        end
+      end
+
+      context 'when adding a percent and a number' do
+        it 'should return sum of the two' do
+          expect(subject + number).to eq 10.25
+          expect(number + subject).to eq 10.25
+        end
+      end
+    end
+
+    describe '#-' do
+      context 'when subtracting two percentages' do
+        it 'should return the difference of the two percentages' do
+          expect(subject - subject).to eql Percentage.new(0)
+        end
+      end
+
+      context 'when subtracting a percent and a number' do
+        it 'should return the difference between the two' do
+          expect(subject - number).to eq -9.75
+          expect(number - subject).to eq 9.75
+        end
+      end
+    end
+
+    describe '#*' do
+      context 'when multiplying two percentagess' do
+        it 'should return the product of the two percentages' do
+          expect(subject * subject).to eql Percentage.from_amount(6.25)
+        end
+      end
+
+      context 'when multiplying a percent and a number' do
+        it 'should return the product of the two' do
+          expect(subject * number).to eq 2.5
+          expect(number * subject).to eq 2.5
+        end
+      end
+    end
+
+    describe '#/' do
+      context 'when dividing two percentages' do
+        it 'should return the quotient of the two percentages' do
+          expect(subject / subject).to eql Percentage.new(100)
+        end
+      end
+
+      context 'when subtracting a percent and a number' do
+        it 'should return the quotient' do
+          expect(subject / number).to eq 0.025
+          expect(number / subject).to eq 40.0
+        end
+      end
+    end
+  end
+end