fractional 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fef2bf465e3f0fb5a870268e07e3f5587d772bf
-  data.tar.gz: b1a895f28cc4138b09f7ef67570a18689a1771b3
+  metadata.gz: e102c37bdea15e535451f4ace3e8427b5cd80ba3
+  data.tar.gz: aca489da451ff4ded33297324f3691878696dd8a
 SHA512:
-  metadata.gz: 078854ddb0cb3b5aa76b2407fef374bef578e456ff9978da0a1794e37422fe12703a90ffa40a364040551f86354492273fc20aafa246672e999ef10cd9c32992
-  data.tar.gz: 34812c79b93d3f3b7ab1153e6cee209a17978906363d7ee3527f7e335fcee86c0c23eb3b7d3416f72e9eb14b5ef76833c27a144f64495444d72fc1cded18a135
+  metadata.gz: 4dae17fc2ee51bbe1ea07eb0596a759fa5ae34ebd6a9a2418ef9c600c8ff9432a8a5ff354b6f6669edb09f78286e9c8e2432101fbb4712722a66e37eaabf08e5
+  data.tar.gz: 8eb87fbff148bee9e9c6c39c860c598aa0fd9adc1741688597666c7c77d1b6550b39d87b650b756678131d112ff3e775590a302ef07999347627b74db7524e5c

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--debug
+--order rand

data/README.rdoc

@@ -1,13 +1,36 @@
 = Fractional
 
-Fractional is a library for parsing fractions.
+Fractional is a library for parsing, representing and operating on fractions.
 
-Convert fractional string to float:
- Fractional.to_f("1100 7/8") #=> 1100.875
+=== Conversions
 
-Convert float to fractional string:
- Fractional.to_s(1100.875)   #=> "1100 7/8"
- Fractional.to_s(1100.875, :to_nearest => "1/2") #=> "1101"
+Convert fractional strings to floats:
+ Fractional.new("1100 7/8").to_f #=> 1100.875
+
+Convert floats to fractional strings:
+ Fractional.new(1100.875).to_s   #=> "1100 7/8"
+ Fractional.new(1100.875, :to_nearest => "1/2").to_s #=> "1101"
+
+Also does a great job of guessing repeating decimal values:
+ Fractional.new(0.33333).to_s    #=> "1/3"
+ Fractional.new(3.142857142857).to_s    #=> "22/7"
+If you want to prevent this "guesswork" pass the :exact option
+ Fractional.new(0.33333, exact: true).to_s  #=> "33333/100000"
+
+It can render back out mixed numbers:
+ Fractional.new(1.45).to_s  #=> "29/20"
+ Fractional.new(1.45).to_s( mixed_number: true )  #=> "1 9/20"
+
+
+=== Math and Comparisons
+It will integrate nicely with Numerics:
+ a = Fractional.new("3/4")
+ puts a + 1.5   #=>  "9/4"
+
+And you can compare it to other Numerics:
+ puts Fractional.new("3/4") > -2.3    #=> true
+
+=== Rounding
 
 Round a value to the nearest fraction:
  Fractional.round_to_nearest_fraction("1100 1/7", "1/64")           #=> "1100 9/64"
@@ -28,6 +51,7 @@ Thanks to Jannis Harder for his hardcore float to rational method I nicked from
 
 = Contributors
 Joey Aghion https://github.com/joeyAghion
+
 muff1nman https://github.com/muff1nman
 
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+1.0.1

data/fractional.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "fractional"
-  spec.version       = "0.1.0"
+  spec.version       = "1.0.1"
   spec.authors       = ["Chris O'Sullivan"]
   spec.email         = ["thechrisoshow@gmail.com"]
   spec.description   = %q{Fractional is a Ruby library for parsing fractions.}
@@ -16,4 +16,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "debugger"
 end

data/lib/deprecated.rb

@@ -0,0 +1,33 @@
+module DeprecatedFractionalMethods
+
+  def to_f(value)
+    warn("Fractional.to_f will be removed in v1.1.")
+    string_to_fraction(value).to_f
+  end
+
+  def to_s(value, options={})
+    warn("Fractional.to_s will be removed in v1.1\nUse Fractional.new(value).to_s instead.")
+    new(float_to_fraction(value)).to_s(options)
+  end
+
+  def fraction?(value)
+    warn("Fractional.fraction? will be removed in v1.1\nUse Fractional.string_is_fraction? instead.")
+    string_is_fraction?(value)
+  end
+
+  def mixed_fraction?(value)
+    warn("Fractional.mixed_fraction? will be removed in v1.1\nUse Fractional.string_is_mixed_fraction? instead.")
+    string_is_mixed_fraction?(value)
+  end
+
+  def single_fraction?(value)
+    warn("Fractional.single_fraction? will be removed in v1.1\nUse Fractional.string_is_single_fraction? instead.")
+    string_is_single_fraction?(value)
+  end
+
+  private
+  def warn(message)
+    $stderr.puts "\n*** Fractional deprecation warning: #{message}\n\n"
+  end
+
+end

data/lib/fractional.rb

@@ -1,119 +1,220 @@
 require 'rational'
+require 'deprecated'
+
+class Fractional < Numeric
+  extend DeprecatedFractionalMethods
 
-class Fractional
   SINGLE_FRACTION = /^\s*(\-?\d+)\/(\-?\d+)\s*$/
   MIXED_FRACTION = /^\s*(\-?\d*)\s+(\d+)\/(\d+)\s*$/
 
-  def initialize(value)
-    @value = value
+  def initialize( value, options={} )
+    case value
+    when Rational
+      @value = value
+    when String
+      @value = Fractional.string_to_fraction( value, options )
+    when Fixnum
+      @value = Rational(value)
+    when Numeric
+      @value = Fractional.float_to_fraction( value.to_f, options )
+    else
+      raise TypeError, "Cannot instantiate Fractional from #{value.class}"
+    end
+
   end
 
-  def to_s
-    @value
+  def method_missing(name, *args, &blk)
+    return_value = @value.send(name, *args, &blk)
+    return_value.is_a?(Rational) ? Fractional.new(return_value) : return_value
+  end
+
+  def to_s( options={} )
+    if options[:mixed_fraction] or options[:mixed_number]
+      to_join = []
+      if whole_part != 0
+        to_join << whole_part.to_s
+      end
+      if fractional_part != 0
+        to_join << fractional_part.abs.to_s
+      end
+      to_join.join(" ")
+    else
+      @value.to_s
+    end
   end
 
   def to_f
-    Fractional.to_f(@value)
+    @value.to_f
   end
 
-  [:+, :-, :*, :/].each do |math_operator|
-    define_method(math_operator) do |another_fractional|
-      Fractional.new(Fractional.to_s(self.to_f.send(math_operator, another_fractional.to_f)))
-    end
+  def to_r
+    @value
   end
 
-  def self.to_f(value)
-    result = 0
+  def to_i
+    whole_part
+  end
 
-    if mixed_fraction?(value)
-      whole, numerator, denominator = value.scan(MIXED_FRACTION).flatten
+  def whole_part
+    @value.truncate
+  end
 
-      result = (numerator.to_f / denominator.to_f) + whole.to_f.abs
+  def fractional_part
+    @value - whole_part
+  end
 
-      result = whole.to_f > 0 ? result : -result
-    elsif single_fraction?(value)
-      numerator, denominator = value.split("/")
-      result =  numerator.to_f / denominator.to_f
+  def ==( other_num )
+    @value == other_num
+  end
+
+  def <=>(other)
+    case other
+    when Fractional, Rational
+      self.to_r <=> other.to_r
+    when Numeric
+      @value <=> other
+    when String
+      @value <=> Fractional.new(other).to_r
     else
-      result = value.to_f
+      nil
     end
-
-    result
   end
 
-  def self.to_s(value, args={})
-    whole_number = value.to_f.truncate.to_i
-
-    if whole_number == 0 # Single fraction
-      fractional_part_to_string(value, args[:to_nearest])
-    else # Mixed fraction
-      decimal_point_value = get_decimal_point_value(value.to_f)
-      return whole_number.to_s if decimal_point_value == 0
+  def coerce(other)
+    case other
+    when Numeric
+      return Fractional.new(other), self
+    when String
+      return Fractional.new(other), self
+    else
+      raise TypeError, "#{other.class} cannot be coerced into #{Numeric}"
+    end
+  end
 
-      fractional_part = fractional_part_to_string(decimal_point_value.abs, args[:to_nearest])
 
-      if (fractional_part == "1") || (fractional_part == "0")
-        (whole_number + fractional_part.to_i).to_s
+  [:+, :-, :*, :/, :**].each do |math_operator|
+    define_method(math_operator) do |another_fractional|
+      if another_fractional.is_a? Fractional or another_fractional.is_a? Rational
+        Fractional.new(@value.send(math_operator, another_fractional.to_r))
+      elsif another_fractional.is_a? Numeric
+        self.send(math_operator, Fractional.new(another_fractional))
       else
-        whole_number.to_s + " " + fractional_part
+        Fractional.new(self.to_r.send(math_operator, another_fractional))
       end
     end
   end
 
-  def self.round_to_nearest_fraction(value, to_nearest_fraction)
-    if value.is_a? String
-      to_nearest_float = to_f(to_nearest_fraction)
+  def self.float_to_fraction( value, options={} )
+    if value.to_f.nan?
+      return Rational(0,0) # Div by zero error
+    elsif value.to_f.infinite?
+      return Rational(value<0 ? -1 : 1,0) # Div by zero error
+    end
 
-      to_s((self.to_f(value) / to_nearest_float).round * to_nearest_float)
-    else
-      to_nearest_float = to_f(to_nearest_fraction)
+    if options[:to_nearest]
+      return self.round_to_nearest_fraction( value, options[:to_nearest] )
+    end
 
-      (value / to_nearest_float).round * to_nearest_float
+    # first try to convert a repeating decimal unless guesstimate is forbidden
+    unless options[:exact]
+      repeat = float_to_rational_repeat(value)
+      return repeat unless repeat.nil?
     end
 
+    # finally assume a simple decimal
+    # The to_s helps with float rounding issues
+    return Rational(value.to_s)
+
   end
 
-  private
+  def self.string_to_fraction( value, options={} )
+    if string_is_mixed_fraction?(value)
+      whole, numerator, denominator = value.scan(MIXED_FRACTION).flatten
+      return Rational( (whole.to_i.abs * denominator.to_i + numerator.to_i) *
+                      whole.to_i / whole.to_i.abs, denominator.to_i )
+    elsif string_is_single_fraction?(value)
+      numerator, denominator = value.split("/")
+      return Rational(numerator.to_i, denominator.to_i)
+    else
+      return float_to_fraction(value.to_f, options)
+    end
+  end
 
-  def self.fraction?(value)
+  def self.string_is_fraction?( value )
     value.is_a? String and (value.match(SINGLE_FRACTION) or value.match(MIXED_FRACTION))
   end
 
-  def self.single_fraction?(value)
-    fraction?(value) and value.match(SINGLE_FRACTION)
+  def self.string_is_mixed_fraction?( value )
+    string_is_fraction?(value) and value.match(MIXED_FRACTION)
   end
 
-  def self.mixed_fraction?(value)
-    fraction?(value) and value.match(MIXED_FRACTION)
+  def self.string_is_single_fraction?( value )
+    string_is_fraction?(value) and value.match(SINGLE_FRACTION)
+  end
+
+  def self.float_to_rational_repeat(base_value)
+    normalized_value = base_value.to_f
+    repeat = find_repeat( normalized_value )
+
+    if repeat.nil? or repeat.length < 1
+      # try again chomping off the last number (fixes float rounding issues)
+      normalized_value = normalized_value.to_s[0...-1].to_f
+      repeat = find_repeat(normalized_value.to_s)
+    end
+
+    if !repeat or repeat.length < 1
+      return nil
+    else
+      return fractional_from_parts(
+        find_before_decimal(normalized_value),
+        find_after_decimal(normalized_value),
+        repeat)
+    end
   end
 
-  def self.get_decimal_point_value(value)
-    value - value.truncate
+  def self.find_after_decimal( decimal )
+    s_decimal = decimal.to_s
+    regex = /(#{find_repeat(s_decimal)})+/
+    last = s_decimal.index( regex )
+    first = s_decimal.index( '.' ) + 1
+    s_decimal[first...last]
   end
 
-  def self.fractional_part_to_string(value, round)
-    if round
-      round_to_nearest_fraction(float_to_rational(value.to_f).to_s, round)
+  def self.find_before_decimal( decimal )
+    numeric = decimal.to_f.truncate.to_i
+    if numeric == 0
+      decimal.to_f < 0 ? "-0" : "0"
     else
-      float_to_rational(value.to_f).to_s
+      numeric.to_s
     end
   end
 
-  # Whoa this method is crazy
-  # I nicked it from Jannis Harder at http://markmail.org/message/nqgrsmaixwbrvsno
-  def self.float_to_rational(value)
-    if value.nan?
-      return Rational(0,0) # Div by zero error
-    elsif value.infinite?
-      return Rational(value<0 ? -1 : 1,0) # Div by zero error
+  def self.find_repeat( decimal )
+    return largest_repeat( decimal.to_s.reverse, 0 ).reverse
+  end
+
+  def self.largest_repeat( string, i )
+    if i * 2 > string.length
+      return ""
     end
-    s,e,f = [value].pack("G").unpack("B*").first.unpack("AA11A52")
-    s = (-1)**s.to_i
-    e = e.to_i(2)
-    if e.nonzero? and e<2047
-      Rational(s)* Rational(2)**(e-1023)*Rational("1#{f}".to_i(2),0x10000000000000)
-    elsif e.zero?
-      Rational(s)* Rational(2)**(-1024)*Rational("0#{f}".to_i(2),0x10000000000000)
+    repeat_string = string[0..i]
+    next_best = largest_repeat( string, i + 1)
+    if repeat_string == string[i+1..2*i + 1]
+      repeat_string.length > next_best.length ? repeat_string : next_best
+    else
+      next_best
     end
   end
+
+  def self.fractional_from_parts(before_decimal, after_decimal, repeat)
+    numerator = "#{before_decimal}#{after_decimal}#{repeat}".to_i - "#{before_decimal}#{after_decimal}".to_i
+    denominator = 10 ** (after_decimal.length + repeat.length) - 10 ** after_decimal.length
+    return Rational( numerator, denominator )
+  end
+
+  def self.round_to_nearest_fraction(value, to_nearest_fraction)
+    to_nearest_float = Fractional.new(to_nearest_fraction).to_f
+    Fractional.new((Fractional.new(value).to_f / to_nearest_float).round * to_nearest_float)
+  end
+
 end

data/spec/fractional_spec.rb

@@ -1,54 +1,486 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Fractional" do
+##################################
+# CLASS METHODS                  #
+##################################
+describe "Fractional::new" do
+  it "should accept Rationals" do
+    Fractional.new(Rational(3,4)).should_not be_nil
+  end
+
+  it "should accept strings" do
+    Fractional.new("3/4").should_not be_nil
+  end
+
+  it "should accept floats" do
+    Fractional.new(0.75).should_not be_nil
+  end
+
+  it "should pass options down (such as exact)" do
+    Fractional.new(0.333, exact: true).should_not == Rational(1,3)
+    Fractional.new("0.333", exact: true).should_not == Rational(1,3)
+  end
+
+end
+
+describe "Fractional::float_to_fractional" do
+  it "should parse simple decimals" do
+    Fractional.float_to_fraction(0.5).should == Fractional.new(Rational(1,2))
+    Fractional.float_to_fraction(1.5).should == Fractional.new(Rational(3,2))
+    Fractional.float_to_fraction(1100).should == Fractional.new(Rational(1100,1))
+    # This next example is especially important as Rational(1.2) is not a nice
+    # number.
+    Fractional.float_to_fraction(1.2).should == Fractional.new(Rational(6,5))
+  end
+
+  it "should parse more complex decimals" do
+    Fractional.float_to_fraction(1100.875).should == Fractional.new(Rational(8807,8))
+  end
+
+  it "should allow for negative values for mixed fractions" do
+    Fractional.float_to_fraction(-1100.875).should == Fractional.new(Rational(-8807,8))
+  end
+
+  it "should allow for negative values for single fractions" do
+    Fractional.float_to_fraction(-0.875).should == Fractional.new(Rational(-7,8))
+  end
+
+  it "should allow for negative mixed fractions that that are rounded" do
+    Fractional.float_to_fraction(-101.140625, :to_nearest => "1/64").should == Fractional.new("-101 9/64")
+  end
+
+  it "should allow for negative single fractions that that are rounded" do
+    Fractional.float_to_fraction(-0.140625, :to_nearest => "1/64").should == Fractional.new("-9/64")
+  end
+
+  it "should round if passed 'to nearest'" do
+    Fractional.float_to_fraction(1100.14285714286, :to_nearest => "1/64").should == Fractional.new("1100 9/64")
+  end
+
+  it "should round if passed 'to_nearest' that is a float" do
+    Fractional.float_to_fraction(1100.14285714286, :to_nearest => 0.015625).should == Fractional.new("1100 9/64")
+  end
+
+  it "should round if passed 'to_nearest' and is a simple fraction" do
+    Fractional.float_to_fraction(0.14285714286, :to_nearest => "1/64").should == Fractional.new("9/64")
+  end
+
+  it "should round if passed 'to_nearest' that rounds to nearest whole number" do
+    Fractional.float_to_fraction(1100.875, :to_nearest => "1/2").should == Fractional.new("1101")
+    Fractional.float_to_fraction(1100.2, :to_nearest => "1/2").should == Fractional.new("1100")
+  end
+
+end
+
+describe "Fractional::string_to_fractional" do
+  it "should parse a single fraction" do
+    Fractional.string_to_fraction('1/2').should == Fractional.new(Rational(1,2))
+  end
+
+  it "should parse a mixed fraction" do
+    Fractional.string_to_fraction('1 2/4').should == Fractional.new(Rational(3,2))
+    Fractional.string_to_fraction("1100 7/8").should == Fractional.new(Rational(8807,8))
+  end
+
+  it "should parse a simple decimal" do
+    Fractional.string_to_fraction('1.5').should == Fractional.new(Rational(3,2))
+  end
+
+  it "should allow for negative mixed fractions" do
+    Fractional.string_to_fraction('-10 1/2').should == Fractional.new(Rational(-21,2))
+  end
+
+  it "should allow for negative single fractions" do
+    Fractional.string_to_fraction("-1/64").should == Fractional.new(Rational(-1,64))
+  end
+
+  it "should allow for negative denominators in single fractions" do
+    Fractional.string_to_fraction("1/-64").should == Fractional.new(Rational(-1,64))
+    Fractional.string_to_fraction("-1/-64").should == Fractional.new(Rational(1,64))
+  end
+
+  it "should ignore repeated whitespace" do
+    Fractional.string_to_fraction("6   5/8").should == Fractional.string_to_fraction("6 5/8")
+  end
+
+  it "should try to get an accurate estimation of floating point values by default" do
+    Fractional.string_to_fraction("0.3333").should == Fractional.float_to_fraction(0.33333)
+  end
+
+  it "should not estimate if exact is specified" do
+    Fractional.string_to_fraction("0.3333", exact: true).should_not == Rational(1,3)
+  end
+
+end
+
+describe "Fractional::string_is_fraction?" do
+  it "should recognize a simple fraction" do
+    Fractional.string_is_fraction?("3/4").should be_true
+  end
+
+  it "should recognize a mixed fraction" do
+    Fractional.string_is_fraction?("1 11/12").should be_true
+  end
+
+  it "should recognize a negative fraction" do
+    Fractional.string_is_fraction?("-3/4").should be_true
+  end
+
+  it "should recognize a negative mixed fraction" do
+    Fractional.string_is_fraction?("-6 2/9").should be_true
+  end
+
+  it "should accept more than one space between the whole number and fractional part" do
+    Fractional.string_is_fraction?("1  2/3").should be_true
+    Fractional.string_is_fraction?("3               1/2").should be_true
+  end
+
+  it "should accept fractions with front and rear padding" do
+    Fractional.string_is_fraction?("     2/3").should be_true
+    Fractional.string_is_fraction?("2/3      ").should be_true
+    Fractional.string_is_fraction?("      2/3     ").should be_true
+    Fractional.string_is_fraction?("   1 2/3").should be_true
+    Fractional.string_is_fraction?("1 2/3      ").should be_true
+    Fractional.string_is_fraction?("    1 2/3   ").should be_true
+  end
+
+  it "should not recognize decimals" do
+    Fractional.string_is_fraction?("2.3").should be_false
+  end
+
+  it "should not recognize two consecutive fractions" do
+    Fractional.string_is_fraction?("2/3 9/5").should be_false
+  end
+
+  it "should not recognize a string with a slash" do
+    Fractional.string_is_fraction?("n/a").should be_false
+  end
+
+  it "should not recognize a fraction mixed with non-decimals" do
+    Fractional.string_is_fraction?("3a/4").should be_false
+    Fractional.string_is_fraction?("a2/3").should be_false
+    Fractional.string_is_fraction?("1 2/3a").should be_false
+  end
+
+  it "should not recognize fractions with improper spacing" do
+    Fractional.string_is_fraction?("2 /2").should be_false
+    Fractional.string_is_fraction?("1/ 3").should be_false
+    Fractional.string_is_fraction?("1  2/  3").should be_false
+    Fractional.string_is_fraction?("1 2    /3").should be_false
+  end
+
+end
+
+describe "Fractional::string_is_mixed_fraction?" do
+  it "should recognize a mixed fraction" do
+    Fractional.string_is_mixed_fraction?("1 11/12").should be_true
+  end
+
+  it "should recognize a negative mixed fraciton" do
+    Fractional.string_is_mixed_fraction?("-1 11/12").should be_true
+  end
+
+  it "should not recognize a single fraction" do
+    Fractional.string_is_mixed_fraction?("3/4").should be_false
+  end
+
+end
+
+describe "Fractional::string_is_single_fraction?" do
+  it "should recognize a single fraction" do
+    Fractional.string_is_single_fraction?("3/4").should be_true
+  end
+
+  it "should recognize a negative numerator with a single fraction" do
+    Fractional.string_is_single_fraction?("-3/4").should be_true
+  end
+
+  it "should not recognize a mixed fraction" do
+    Fractional.string_is_single_fraction?("1 11/12").should be_false
+  end
+
+  it "should allow for negative denominators in single fractions" do
+    Fractional.string_is_single_fraction?("1/-64").should be_true
+    Fractional.string_is_single_fraction?("-1/-64").should be_true
+  end
+
+end
+
+describe "Frational", "fractional_from_parts" do
+  it "should return rational values for various decimals" do
+    Fractional.fractional_from_parts("","","3").should eq(Rational(1,3))
+    Fractional.fractional_from_parts("","","7").should eq(Rational(7,9))
+    Fractional.fractional_from_parts("","","9").should eq(Rational(1,1))
+    Fractional.fractional_from_parts("5","8","144").should eq(Rational(3227,555))
+    Fractional.fractional_from_parts("","58","3").should eq(Rational(7,12))
+    Fractional.fractional_from_parts("","","012345679").should eq(Rational(1,81))
+    Fractional.fractional_from_parts("-0","","3333").should eq(Rational(-1,3))
+  end
+end
+
+describe "Fractional", "find_repeat" do
+  it "should return the repeating decimals in a string" do
+    Fractional.find_repeat("1.0333").should eq("3")
+    Fractional.find_repeat("0.333").should eq("3")
+    Fractional.find_repeat("3.142857142857").should eq("142857")
+  end
+
+  it "should return nil when there are not enough repeating decimals" do
+    Fractional.find_repeat("1.03").should eq("")
+  end
+end
+
+describe "Fractional", "find_after_decimal" do
+  it "should return the decimal characters after the decimal but before the repeating characters" do
+    Fractional.find_after_decimal("1.0333").should eq("0")
+    Fractional.find_after_decimal("0.3333").should eq("")
+    Fractional.find_after_decimal("0.58333").should eq("58")
+  end
+end
+
+
+describe "Fractional", "find_before_decimal" do
+  it "should return the decimal characters before the decimal" do
+    Fractional.find_before_decimal("1.0333").should eq("1")
+    Fractional.find_before_decimal(".3333").should eq("0")
+    Fractional.find_before_decimal("-1.4444").should eq("-1")
+    Fractional.find_before_decimal("-0.4444").should eq("-0")
+  end
+end
+
+describe "Fractional", "float_to_rational_repeat" do
+  it "should parse a repeating decimal into a fractional value" do
+    Fractional.float_to_rational_repeat("0.33").should eq(Rational(1,3))
+    Fractional.float_to_rational_repeat(".33").should eq(Rational(1,3))
+    Fractional.float_to_rational_repeat("0.8181").should eq(Rational(9,11))
+    Fractional.float_to_rational_repeat("3.142857142857").should eq(Rational(22,7))
+    Fractional.float_to_rational_repeat("-0.33333").should eq(Rational(-1,3))
+  end
+
+  it "should be able to deal with a rounding error at the end of a float value" do
+    Fractional.string_to_fraction("3.1666666666666665").should eq(Rational(19,6))
+  end
+
+  it "should not be able to parse a non repeating decimal" do
+    Fractional.float_to_rational_repeat("1.234").should be_nil
+    Fractional.float_to_rational_repeat("1.333312").should be_nil
+    Fractional.float_to_rational_repeat("as2342").should be_nil
+  end
+end
 
-  it "should create a fractional object from a string" do
-    one_half = Fractional.new("1/2")
+
+##################################
+# Arithematic                    #
+##################################
+
+describe "Fractional#+" do
+  it "should add with another Fractional" do
+    (Fractional.new(Rational(3,4)) + Fractional.new(Rational(1,2))).should == Fractional.new(1.25)
   end
 
-  it "should create a fractional object from a string" do
-    one_half = Fractional.new("1/2")
+  it "should add with other numerics" do
+    (Fractional.new(Rational(-4,5)) + 1).should == Fractional.new(Rational(1,5))
+    (Fractional.new("2/3") + 1.2).should == Fractional.new(1.86666666)
+    (Fractional.new(1.3) + BigDecimal.new(2)).should == Fractional.new("3.3")
   end
 
-  it "should create a fractional object from a string" do
-    one_half = Fractional.new("1/2")
+  it "should add with other numerics when other numerics are specified first" do
+    (1 + Fractional.new(Rational(-4,5)) ).should == Fractional.new(Rational(1,5))
+    (1.2 + Fractional.new("2/3")).should == Fractional.new(1.86666666)
+    (BigDecimal.new(2) + Fractional.new(1.3)).should == Fractional.new("3.3")
   end
-  
-  it "should convert fractional to string" do
-    one_half = Fractional.new("1/2")
-    one_half.to_s.should == "1/2"
+end
+
+describe "Fractional#-" do
+  (1 - Fractional.new(Rational(1,2))).should == Fractional.new(Rational(1,2))
+end
+
+describe "Fractional#*" do
+  (Fractional.new(Rational(1,2)) * Fractional.new(0.75)).should == Fractional.new(0.375)
+end
+
+describe "Fractional#/" do
+  (Fractional.new(Rational(4,3)) / Fractional.new(Rational(3,2))).should == Fractional.new(Rational(8,9))
+end
+
+describe "Fractional#**" do
+  (Fractional.new(8) ** Fractional.new(Rational(1,3))).should == Fractional.new(2)
+end
+
+##################################
+# comparison                     #
+##################################
+
+describe "Fractional#==" do
+  it "should be equal to same Fractions" do
+    (Fractional.new(Rational(3,1)) == Fractional.new(Rational(3,1))).should be_true
   end
-  
-  it "should convert fractional to float" do
-    one_half = Fractional.new("1/2")
-    one_half.to_f.should == 0.5
+
+  it "should not be equal to other Fractions" do
+    (Fractional.new(Rational(3,2)) == Fractional.new(Rational(3,1))).should be_false
   end
-  
-  it "should add two fractionals together" do
-    one_half = Fractional.new("1/2")
-    another_one_half = Fractional.new("1/2")
-    
-    (one_half + another_one_half).to_f.should == 1.0
+
+  it "should be equal regardless of type" do
+    (Fractional.new(Rational(3,4)) == Fractional.new(0.75)).should be_true
   end
+end
 
-  it "should minus a fractional from another fractional" do
-    one_and_a_half = Fractional.new("1 1/2")
-    one_quarter = Fractional.new("1/4")
-    
-    (one_and_a_half - one_quarter).to_f.should == 1.25
+describe "Frational#<=>" do
+  it "should return 0 if fractions are equal" do
+    (Fractional.new(Rational(5,4)) <=> Fractional.new(1.25)).should == 0
   end
 
-  it "should multiply 2 fractionals together" do
-    first_fraction = Fractional.new("1 7/8")
-    second_fraction = Fractional.new("11 15/64")
-    
-    (first_fraction * second_fraction).to_f.should == 21.064453125
+  it "should return -1 if the lhs is less" do
+    (Fractional.new(Rational(3,4)) <=> Fractional.new(Rational(8,9))).should == -1
   end
-  
-  it "should divide 2 fractionals together" do
-    first_fraction = Fractional.new("1 7/8")
-    second_fraction = Fractional.new("21 33/512")
-    
-    (second_fraction / first_fraction).to_s.should == "11 15/64"
+
+  it "should compare to other numerics" do
+    (Fractional.new(Rational(-1,2)) <=> -0.5).should == 0
+    (Fractional.new(Rational(-1,2)) <=> 1).should == -1
+    (Fractional.new(Rational(-1,2)) <=> BigDecimal.new(-2)).should == 1
+  end
+
+  it "should work the other way too" do
+    ( -0.5 <=> Fractional.new(Rational(-1,2))).should == 0
+    (1 <=> Fractional.new(Rational(-1,2))).should == 1
+    (BigDecimal.new(-2) <=> Fractional.new(Rational(-1,2))).should == -1
+  end
+
+  it "would be nice to compare to strings" do
+    (Fractional.new(Rational(1,2)) <=> "3/4").should == -1
+    ("3/4" <=> Fractional.new(Rational(1,2))).should == 1
+    ("-3/4" <=> Fractional.new(Rational(-1,2))).should == -1
+  end
+end
+
+describe "Frational", "comparsion" do
+  it "should use the numerics included comparsion module" do
+    (Fractional.new(Rational(-3,4)) < Fractional.new(Rational(1,2))).should be_true
+  end
+end
+
+##################################
+# conversion                     #
+##################################
+
+describe "Fractional#to_s" do
+  it "should return nice representations of single fractions" do
+    Fractional.new(0.75).to_s.should == "3/4"
+    Fractional.new(-0.3333).to_s.should == "-1/3"
+
+  end
+
+  it "should return nice representations of mixed fractions" do
+    Fractional.new(1.5).to_s.should == "3/2"
+    Fractional.new(-1.3333).to_s.should == "-4/3"
+    Fractional.new(0.0).to_s.should == "0/1"
+  end
+
+  it "should return mixed number representations if told so" do
+    Fractional.new(1.5).to_s(mixed_number: true).should == "1 1/2"
+    Fractional.new(Rational(-3,2)).to_s(mixed_number: true).should == "-1 1/2"
+    Fractional.new(1.00).to_s(mixed_number: true).should == "1"
+    Fractional.new(0.75).to_s(mixed_number: true).should == "3/4"
+  end
+end
+
+describe "Fractional#to_f" do
+  it "should return float representations of fractions" do
+    Fractional.new("3/4").to_f.should == 0.75
+    Fractional.new("-2/3").to_f.should be_within(0.0000001).of(-0.6666666)
+  end
+end
+
+describe "Fractional#to_r" do
+  it "should return a rational representation" do
+    Fractional.new("3/4").to_r.should == Rational(3,4)
+  end
+end
+
+describe "Fractional#to_i" do
+  it "should return a truncated value" do
+    Fractional.new("1 3/4").to_i.should == 1
+    Fractional.new("-2 1/3").to_i.should == -2
+  end
+end
+
+describe "Fractional", "round" do
+
+  it "should round 0.142857142857143 to nearest 1/64th as 0.140625" do
+    Fractional.round_to_nearest_fraction(0.142857142857143, "1/64").should == Fractional.new(0.140625)
+  end
+
+  it "should round '1/7' to nearest 1/64th as '9/64'" do
+    Fractional.round_to_nearest_fraction('1/7', "1/64").should == Fractional.new('9/64')
+  end
+
+  it "should round 0.125 to nearest 1/64th as 0.125" do
+    Fractional.round_to_nearest_fraction(0.125, "1/64").should == Fractional.new(0.125)
+  end
+
+  it "should round '1100 1/7' to nearest 1/64th as '1100 9/64'" do
+    Fractional.round_to_nearest_fraction('1100 1/7', "1/64").should == Fractional.new('70409/64')
+  end
+
+  it "should round 1100.142857142857143 to nearest 1/64th as 1100.140625" do
+    Fractional.round_to_nearest_fraction(1100.142857142857143, "1/64").should == Fractional.new(1100.140625)
+  end
+
+  it "should round if passed 'to_nearest' that rounds to nearest whole number" do
+    Fractional.round_to_nearest_fraction(1100.875, "1/2").should == Fractional.new(1101)
+    Fractional.round_to_nearest_fraction(1100.1, "1/2").should == Fractional.new(1100)
+  end
+
+  it "should round if passed a float" do
+    Fractional.round_to_nearest_fraction(1100.875, 0.5).should == Fractional.new(1101)
+  end
+end
+
+##################################
+# misc                           #
+##################################
+
+describe 'Fractional#whole_part' do
+  it "should return the whole part, if it exists, of a fraction" do
+    Fractional.new(Rational(3,2)).whole_part.should eq(1)
+    Fractional.new(Rational(-3,2)).whole_part.should eq(-1)
+    Fractional.new(Rational(1,2)).whole_part.should eq(0)
+  end
+end
+
+describe 'Fractional#fractional_part' do
+  it "should return the fractional part, if it exists, of a fraction" do
+    Fractional.new(Rational(3,2)).fractional_part.should eq(Fractional.new(Rational(1,2)))
+    Fractional.new(Rational(-3,2)).fractional_part.should eq(Fractional.new(Rational(-1,2)))
+    Fractional.new(Rational(1,2)).fractional_part.should eq(Fractional.new(Rational(1,2)))
+    Fractional.new(Rational(2,2)).fractional_part.should eq(Fractional.new(0))
+  end
+end
+
+
+##################################
+# deprecated methods             #
+##################################
+# remove in v1.1
+describe "deprecated methods" do
+  it "Fractional.to_f" do
+    Fractional.to_f(1.5).should == 1.5
+  end
+
+  it "Fractional.to_s" do
+    Fractional.to_s(0.5).should == '1/2'
+    Fractional.to_s(-0.140625, :to_nearest => "1/64").should == "-9/64"
+  end
+
+  it "Fraction.fraction?" do
+    Fractional.fraction?("3/4").should be_true
+  end
+
+  it "Fraction.mixed_fraction?" do
+    Fractional.mixed_fraction?("1 11/12").should be_true
+  end
+
+  it "Fraction.single_fraction?" do
+     Fractional.single_fraction?("-3/4").should be_true
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'fractional'
+require 'bigdecimal'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fractional
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Chris O'Sullivan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-11 00:00:00.000000000 Z
+date: 2013-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  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: Fractional is a Ruby library for parsing fractions.
 email:
 - thechrisoshow@gmail.com
@@ -60,14 +74,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
 - fractional.gemspec
+- lib/deprecated.rb
 - lib/fractional.rb
-- spec/fractional_class_methods_spec.rb
 - spec/fractional_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/thechrisoshow/fractional
@@ -96,6 +111,5 @@ specification_version: 4
 summary: 'You can use fractional to convert decimal numbers to string representations
   of fractions. e.g: Fractional.to_s(1.5) #=> "1 1/2"'
 test_files:
-- spec/fractional_class_methods_spec.rb
 - spec/fractional_spec.rb
 - spec/spec_helper.rb

data/spec/fractional_class_methods_spec.rb

@@ -1,219 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Fractional", "to_f" do
-
-  it "should parse '1/2' to 0.5" do
-    Fractional.to_f('1/2').should == 0.5
-  end
-
-  it "should parse '1 2/4' to 1.5" do
-    Fractional.to_f('1 2/4').should == 1.5
-  end
-
-  it "should parse '1.5' to 1.5" do
-    Fractional.to_f('1.5').should == 1.5
-  end
-
-  it "should parse 1.5 to 1.5" do
-    Fractional.to_f(1.5).should == 1.5
-  end
-
-  it "should parse '1100 7/8' to 1100.875" do
-    Fractional.to_f("1100 7/8").should == 1100.875
-  end
-
-  it "should allow for negative mixed fractions" do
-    Fractional.to_f('-10 1/2').should == -10.5
-  end
-
-  it "should allow for negative single fractions" do
-    Fractional.to_f("-1/64").should == -0.015625
-  end
-
-  it "should allow for negative denominators in single fractions" do
-    Fractional.to_f("1/-64").should == -0.015625
-    Fractional.to_f("-1/-64").should == 0.015625
-  end
-
-  it "should ignore repeated whitespace" do
-    Fractional.to_f("6 5/8").should == Fractional.to_f("6  5/8")
-  end
-end
-
-describe "Fractional", "to_s" do
-
-  it "should return 0.5 as '1/2'" do
-    Fractional.to_s(0.5).should == '1/2'
-  end
-
-  it "should return 1.5 as '1 1/2'" do
-    Fractional.to_s(1.5).should == '1 1/2'
-  end
-
-  it "should parse 1100.875 to '1100 7/8'" do
-    Fractional.to_s(1100.875).should == "1100 7/8"
-  end
-
-  it "should not have a fraction if it's just a whole number" do
-    Fractional.to_s(1100).should == "1100"
-  end
-
-  it "should round if passed 'to nearest'" do
-    Fractional.to_s(1100.14285714286, :to_nearest => "1/64").should == "1100 9/64"
-  end
-
-  it "should round if passed 'to_nearest' that is a float" do
-    Fractional.to_s(1100.14285714286, :to_nearest => 0.015625).should == "1100 9/64"
-  end
-
-  it "should round if passed 'to_nearest' and is a simple fraction" do
-    Fractional.to_s(0.14285714286, :to_nearest => "1/64").should == "9/64"
-  end
-
-  it "should round if passed 'to_nearest' that rounds to nearest whole number" do
-    Fractional.to_s(1100.875, :to_nearest => "1/2").should == "1101"
-    Fractional.to_s(1100.2, :to_nearest => "1/2").should == "1100"
-  end
-
-  it "should allow for negative values for mixed fractions" do
-    Fractional.to_s(-1100.875).should == "-1100 7/8"
-  end
-
-  it "should allow for negative values for single fractions" do
-    Fractional.to_s(-0.875).should == "-7/8"
-  end
-
-  it "should allow for negative mixed fractions that that are rounded" do
-    Fractional.to_s(-101.140625, :to_nearest => "1/64").should == "-101 9/64"
-  end
-
-  it "should allow for negative single fractions that that are rounded" do
-    Fractional.to_s(-0.140625, :to_nearest => "1/64").should == "-9/64"
-  end
-
-
-end
-
-describe "Fractional", "round" do
-
-  it "should round 0.142857142857143 to nearest 1/64th as 0.140625" do
-    Fractional.round_to_nearest_fraction(0.142857142857143, "1/64").should == 0.140625
-  end
-
-  it "should round '1/7' to nearest 1/64th as '9/64'" do
-    Fractional.round_to_nearest_fraction('1/7', "1/64").should == '9/64'
-  end
-
-  it "should round 0.125 to nearest 1/64th as 0.125" do
-    Fractional.round_to_nearest_fraction(0.125, "1/64").should == 0.125
-  end
-
-  it "should round '1100 1/7' to nearest 1/64th as '1100 9/64'" do
-    Fractional.round_to_nearest_fraction('1100 1/7', "1/64").should == '1100 9/64'
-  end
-
-  it "should round 1100.142857142857143 to nearest 1/64th as 1100.140625" do
-    Fractional.round_to_nearest_fraction(1100.142857142857143, "1/64").should == 1100.140625
-  end
-
-  it "should round if passed 'to_nearest' that rounds to nearest whole number" do
-    Fractional.round_to_nearest_fraction(1100.875, "1/2").should == 1101
-    Fractional.round_to_nearest_fraction(1100.1, "1/2").should == 1100
-  end
-
-  it "should round if passed a float" do
-    Fractional.round_to_nearest_fraction(1100.875, 0.5).should == 1101
-  end
-end
-
-describe "Fractional", "fraction?" do
-  it "should recognize a simple fraction" do
-    Fractional.fraction?("3/4").should be_true
-  end
-
-  it "should recognize a mixed fraction" do
-    Fractional.fraction?("1 11/12").should be_true
-  end
-
-  it "should recognize a negative fraction" do
-    Fractional.fraction?("-3/4").should be_true
-  end
-
-  it "should recognize a negative mixed fraction" do
-    Fractional.fraction?("-6 2/9").should be_true
-  end
-
-  it "should accept more than one space between the whole number and fractional part" do
-    Fractional.fraction?("1  2/3").should be_true
-    Fractional.fraction?("3               1/2").should be_true
-  end
-
-  it "should accept fractions with front and rear padding" do
-    Fractional.fraction?("     2/3").should be_true
-    Fractional.fraction?("2/3      ").should be_true
-    Fractional.fraction?("      2/3     ").should be_true
-    Fractional.fraction?("   1 2/3").should be_true
-    Fractional.fraction?("1 2/3      ").should be_true
-    Fractional.fraction?("    1 2/3   ").should be_true
-  end
-
-  it "should not recognize decimals" do
-    Fractional.fraction?("2.3").should be_false
-  end
-
-  it "should not recognize two consecutive fractions" do
-    Fractional.fraction?("2/3 9/5").should be_false
-  end
-
-  it "should not recognize a string with a slash" do
-    Fractional.fraction?("n/a").should be_false
-  end
-
-  it "should not recognize a fraction mixed with non-decimals" do
-    Fractional.fraction?("3a/4").should be_false
-    Fractional.fraction?("a2/3").should be_false
-    Fractional.fraction?("1 2/3a").should be_false
-  end
-
-  it "should not recognize fractions with improper spacing" do
-    Fractional.fraction?("2 /2").should be_false
-    Fractional.fraction?("1/ 3").should be_false
-    Fractional.fraction?("1  2/  3").should be_false
-    Fractional.fraction?("1 2    /3").should be_false
-  end
-
-end
-
-describe "Fractional", "single_fraction?" do
-  it "should recognize a single fraction" do
-    Fractional.single_fraction?("3/4").should be_true
-  end
-
-  it "should recognize a negative numerator with a single fraction" do
-    Fractional.single_fraction?("-3/4").should be_true
-  end
-
-  it "should not recognize a mixed fraction" do
-    Fractional.single_fraction?("1 11/12").should be_false
-  end
-
-  it "should allow for negative denominators in single fractions" do
-    Fractional.single_fraction?("1/-64").should be_true
-    Fractional.single_fraction?("-1/-64").should be_true
-  end
-
-end
-
-describe "Fractional", "mixed_fraction?" do
-  it "should recognize a mixed fraction" do
-    Fractional.mixed_fraction?("1 11/12").should be_true
-  end
-
-  it "should recognize a negative mixed fraciton" do
-    Fractional.mixed_fraction?("-1 11/12").should be_true
-  end
-
-  it "should not recognize a single fraction" do
-    Fractional.mixed_fraction?("3/4").should be_false
-  end
-end