percentable 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a86a351aaeedff408bbab5f914b294f8a898f4a0
-  data.tar.gz: 99d9e1bb82f6ff9e5f9242518240d113f5c9f31f
+  metadata.gz: 0fbd045effde2a7949bd1f83593a92c8d320abf1
+  data.tar.gz: 0f629c3a9f5afb113e17a62265d47320cb78ae4d
 SHA512:
-  metadata.gz: 304b7c8663f0b5a6764d0e9b6739765d054c1a768a9247b20fa65d1e108e66405e9338f26f74213ac2eb39c03d42e4a7664f9d700cb60eca6175ee2833f9356d
-  data.tar.gz: b8323fc3c48aa7b7a1e448bea8694bbc23b3bea7a9c2fb206e4b52121b6aad1b2bba554a9c441dfc93291b10512f908ecad1649447e433d9eb28765d3c47ab8e
+  metadata.gz: 21674843db344a6ae56bab761521e302194d7350c891ccc0ee15d567f36ab1902e4590fb6c86878d12130550aaade1f602f9c0883ca35fe66160c7a610bd56eb
+  data.tar.gz: a9709db91180a7edb2498cbaee2a23d4999fdb0087d905ce9f236f2e1b6d6708f9765892ec8953f5b712d1013ea1add97a37be9afe9a9b48c4064542eb8de287

data/README.md

@@ -1,3 +1,8 @@
+[![Gem Version](https://badge.fury.io/rb/percentable.png)](http://badge.fury.io/rb/percentable)
+[![Build Status](https://travis-ci.org/ericroberts/percentable.png?branch=master)](https://travis-ci.org/ericroberts/percentable)
+[![Code Climate](https://codeclimate.com/github/ericroberts/percentable.png)](https://codeclimate.com/github/ericroberts/percentable)
+[![Coverage Status](https://coveralls.io/repos/ericroberts/percentable/badge.png?branch=master)](https://coveralls.io/r/ericroberts/percentable?branch=master)
+
 # Percentable
 
 Small gem to make working with percents easier.
@@ -37,7 +42,7 @@ That's the basics of the object itself. You probably want to know about how it w
 percent = Percent.new(10)
 percent + percent   #=> Percent.new(20)
 percent - percent   #=> Percent.new(0)
-percent * percent   #=> Percent.new(100)
+percent * percent   #=> Percent.new(1)
 percent / percent   #=> Percent.new(1)
 ```
 
@@ -51,6 +56,16 @@ percent * 10    #=> Percent.new(500)
 percent / 10    #=> Percent.new(5)
 ```
 
+And with the number on the other side...
+
+``` ruby
+percent = Percent.new(50)
+10 + percent    #=> 15
+10 - percent    #=> 5
+10 * percent    #=> 5
+10 / percent    #=> 20
+```
+
 Repeat steps above for Floats, BigDecimals, etc. It should all work.
 
 ### Can I turn other Numerics into Percents?
@@ -87,7 +102,7 @@ class OriginalClass
   end
 end
 
-class PercentizedClass
+class PercentizedClass < OriginalClass
   extend Percentable::Percentize
 
   percentize :returns_a_percent
@@ -97,13 +112,41 @@ percentize_object = PercentizedClass.new
 percentize_object.returns_a_percent     #=> Percent.new(10)
 ```
 
+You can do percentize multiple methods at a time:
+
+``` ruby
+class PercentizedClass < OriginalClass
+  extend Percentable::Percentize
+
+  percentize :method1, :method2
+end
+```
+
+You can define defaults for when the percentized method returns nil:
+
+``` ruby
+class PercentizedClass < OriginalClass
+  extend Percentable::Percentize
+
+  percentize :method1, :method2, default: 20
+end
+
+# assuming method1 on OriginalClass returns nil
+percentize_object = PercentizedClass.new
+percentize_object.method1     #=> Percent.new(20)
+```
+
 ### OK, but why would I want this?
 
 I don't know, all I can tell you is that I found it useful. Instead of writing methods to translate from 0.1 to 10% all over the place, I now have a class to represent everything to do with percents.
 
 ### Is that it?
 
-Hey, I only wrote this in a night. Happy to except contributions from others!
+Hey, I only wrote this in a night. Happy to accept contributions from others!
+
+### Your math is totally wrong and you are an idiot.
+
+That's not a question. I've had a fair bit of discussion with the fine folks at [Boltmade](http://www.boltmade.com) about how it should behave, and the examples you see above are what we settled on. If you would like to propose a change, the best way would be to edit the README to show examples for how you would like it to act. You can also submit a pull request that changes the code, but if you submit the README first we can have a discussion about whether or not it makes sense. I'm not totally sold on the current implementation and would be happy to discuss changes.
 
 ## Contributing
 

data/lib/percentable/percent.rb

@@ -21,9 +21,18 @@ module Percentable
     end
 
     def coerce other
+      method = caller[0].match("`(.+)'")[1].to_sym
+
       case other
       when Numeric
-        [to_f, other]
+        case method
+        when :+
+          [to_f * other, other]
+        when :-
+          [other, to_f * other]
+        else
+          [other, to_f]
+        end
       else
         fail TypeError, "#{self.class} can't be coerced into #{other.class}"
       end
@@ -41,39 +50,32 @@ module Percentable
       to_f <=> other.to_f
     end
 
-    def + other
-      case other
-      when Percent
-        self.class.new(other.value + value)
-      when Numeric
-        self.class.new(other + value)
-      end
-    end
-
     def * other
       case other
       when Percent
-        self.class.new(other.value * value)
+        self.class.new(to_f * other.value)
       when Numeric
-        self.class.new(other * value)
+        self.class.new(value * other)
       end
     end
 
-    def - other
-      case other
-      when Percent
-        self.class.new(value - other.value)
-      when Numeric
-        self.class.new(value - other)
+    [:+, :-, :/].each do |operator|
+      define_method operator do |other|
+        case other
+        when Percent
+          self.class.new(value.public_send(operator, other.value))
+        when Numeric
+          self.class.new(value.public_send(operator, other))
+        end
       end
     end
 
-    def / other
-      case other
-      when Percent
-        self.class.new(value / other.value)
+    def self.from_numeric(numeric)
+      case numeric
       when Numeric
-        self.class.new(value / other)
+        Percent.new(numeric*100)
+      else
+        fail TypeError, 'must inherit from Numeric'
       end
     end
   end

data/lib/percentable/percentize.rb

@@ -1,8 +1,12 @@
 module Percentable
   module Percentize
-    def percentize field
-      define_method(field) do |args=[]|
-        Percent.new(super(*args))
+    def percentize *args
+      options = args.pop if args.last.is_a? Hash
+
+      args.each do |method_name|
+        define_method(method_name) do |args=[]|
+          Percent.new(super(*args) || options[:default])
+        end
       end
     end
   end

data/lib/percentable/version.rb

@@ -1,3 +1,3 @@
 module Percentable
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/percentable.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "coveralls"
 end

data/spec/lib/percentable/numeric_spec.rb

@@ -1,4 +1,5 @@
-require 'percentable/numeric'
+require 'spec_helper'
+require 'percentable'
 require 'bigdecimal'
 
 describe Numeric do

data/spec/lib/percentable/percent_spec.rb

@@ -1,4 +1,6 @@
-require 'percentable/percent'
+require 'spec_helper'
+require 'bigdecimal'
+require 'percentable'
 
 describe Percentable::Percent do
   subject { Percentable::Percent.new(value) }
@@ -68,6 +70,48 @@ describe Percentable::Percent do
     end
   end
 
+  describe '#to_i' do
+    [0.1, 0.5, 1, 1.8, 2, 2.2].each do |value|
+      context "value of #{value}" do
+        let(:value) { value }
+
+        it "should return #{value.floor} for #{value}" do
+          expect(subject.to_i).to eq value.floor
+        end
+      end
+    end
+  end
+
+  describe '#coerce' do
+    context 'when other is non numeric' do
+      let(:other) { 'string' }
+
+      it 'should raise a TypeError' do
+        expect { subject.coerce(other) }.to raise_error TypeError
+      end
+    end
+
+    context 'math' do
+      let(:value) { 50 }
+
+      it 'should add the value of percent*number' do
+        expect(10 + subject).to eq 15
+      end
+
+      it 'should subtract the value of percent*number' do
+        expect(10 - subject).to eq 5
+      end
+
+      it 'should multiply by the float value of the percent' do
+        expect(10 * subject).to eq 5
+      end
+
+      it 'should divide by the float value of the percent' do
+        expect(10 / subject).to eq 20
+      end
+    end
+  end
+
   shared_examples 'it is equal' do |equal_method|
     it 'should consider itself equal to other percents with the same value' do
       percent1 = subject.class.new(50)
@@ -153,11 +197,11 @@ describe Percentable::Percent do
 
   describe '#*' do
     context 'multiplying percents' do
-      let(:percent1) { subject.class.new(9) }
-      let(:percent2) { subject.class.new(9) }
+      let(:percent1) { subject.class.new(10) }
+      let(:percent2) { subject.class.new(10) }
 
       it 'should return the result of multiplying the percents' do
-        expect(percent1 * percent2).to eq subject.class.new(81)
+        expect(percent1 * percent2).to eq subject.class.new(1)
       end
     end
 
@@ -232,4 +276,24 @@ describe Percentable::Percent do
       end
     end
   end
+
+  describe '.from_numeric' do
+    let(:n) { 0.5 }
+
+    it 'should multiply the input by 100 and return a percent for that value' do
+      expect(subject.class.from_numeric(n)).to eq Percent.new(50)
+    end
+
+    it 'should be considered equal to the numeric it was passed' do
+      expect(subject.class.from_numeric(n)).to eq n
+    end
+
+    context 'when passed a string' do
+      let(:n) { 'string' }
+
+      it 'should raise an argument error' do
+        expect { subject.class.from_numeric(n) }.to raise_error TypeError
+      end
+    end
+  end
 end

data/spec/lib/percentable/percentize_spec.rb

@@ -1,22 +1,78 @@
-require 'percentable/percent'
-require 'percentable/percentize'
+require 'spec_helper'
+require 'percentable'
 
 class TestClass
   def returns_a_percent
     10
   end
+
+  def first_percent_method
+    15
+  end
+
+  def second_percent_method
+    20
+  end
+
+  def default_percent_method
+  end
+
+  def default_filled_percent_method
+    100
+  end
+
+  def default_percent_method1
+  end
+
+  def default_percent_method2
+  end
+
+  def default_percent_method3
+    20.5
+  end
 end
 
 class Subject < TestClass
   extend Percentable::Percentize
 
   percentize :returns_a_percent
+  percentize :first_percent_method, :second_percent_method
+  percentize :default_percent_method, default: 10
+  percentize :default_filled_percent_method, default: 20
+  percentize :default_percent_method1, :default_percent_method2, :default_percent_method3, default: 20
 end
 
 describe Percentable::Percentize do
   subject { Subject.new }
+  let(:ancestor) { TestClass.new }
+
+  [:returns_a_percent, :first_percent_method, :second_percent_method].each do |method|
+    it 'should return a percent with value of TestClass' do
+      expect(subject.public_send(method)).to eq Percentable::Percent.new(ancestor.send(method))
+    end
+  end
+
+  context 'when passed a default value' do
+    it 'should return the default value when return value is nil' do
+      expect(subject.default_percent_method).to eq Percentable::Percent.new(10)
+    end
+
+    it 'should not return the default if the value is defined' do
+      expect(subject.default_filled_percent_method).to eq Percentable::Percent.new(100)
+    end
+
+    context 'with multiple methods' do
+      it 'should return the default value when return value is nil' do
+        expect(subject.default_percent_method1).to eq Percentable::Percent.new(20)
+      end
+
+      it 'should return the default value when return value is nil' do
+        expect(subject.default_percent_method2).to eq Percentable::Percent.new(20)
+      end
 
-  it 'should return a percent with value of TestClass' do
-    expect(subject.returns_a_percent).to eq Percentable::Percent.new(10)
+      it 'should not return the default when the value is set' do
+        expect(subject.default_percent_method3).to eq Percentable::Percent.new(20.5)
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: percentable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Roberts
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: Small gem to make working with percents easier. Includes methods to make
   selected rails attributes return percents.
 email:
@@ -76,6 +90,7 @@ files:
 - spec/lib/percentable/numeric_spec.rb
 - spec/lib/percentable/percent_spec.rb
 - spec/lib/percentable/percentize_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/ericroberts/percentable
 licenses:
 - MIT
@@ -104,3 +119,4 @@ test_files:
 - spec/lib/percentable/numeric_spec.rb
 - spec/lib/percentable/percent_spec.rb
 - spec/lib/percentable/percentize_spec.rb
+- spec/spec_helper.rb