approximately 1.0.0 → 1.1.0

data/README.rdoc

@@ -4,7 +4,7 @@ Facilitates comparisons of Floats, primarily in mocking. Some mocking libraries
 delta assertions within the expectations of your method calls. For example:
 
    some_animated_point = mock()
-   mock.should_receive(:move_to).with(0.01456, -234.786)
+   some_animated_point.should_receive(:move_to).with(0.01456, -234.786)
    
 Then you feed this mock from the outside, using some iterative algorithm with arbitrary precision, and your
 assertion fails.
@@ -13,20 +13,30 @@ assertion fails.
 
 This comes because what you should have done is comparing within a delta/epsilon value instead of comparing verbatim.
 
-And this is what most mocking libraries will do.
+However, once the expected argument has been swallowed by the mocking library you don't really have any control
+on what is going to happen to it, and in most mocking libraries you cannot add detailed assertions on the 
+expectation arguments.
 
-Some mocking libraries allow you to stuff an "assert_in_delta" call into the block of the expectation setup, but not
-all of them - and the expectation block might not be called at all if the passed arguments do not match. So what
-we can do instead is create a special object that will be equal to another Float object when they both are in delta
-of one another. So instead you would do this (in your unit/spec framework du jour)
+So what we can do instead is create a special object that will be equal to another Float object when they both are in delta
+of one another. For example:
+
+  Approximately.approx(23.4, 0.1) == 23.44 # true
+
+In your unit testing/spec framework du jour your test would look like this:
   
   include Approximately
   
   some_animated_point = mock()
-  mock.should_receive(:move_to).with(approx(0.01456, 0.001), approx(-234.786, 0.001))
+  some_animated_point.should_receive(:move_to).with(approx(0.01456, 0.001), approx(-234.786, 0.001))
 
 These objects will compare properly with your reference inputs.
 
+You can also get this magic float object without including Approximately by calling
+
+  Approximately.approx(23.4, 0.1)
+
+This module is completely uninvasive and contains no hacks for minitest, RSpec or other testing/mocking frameworks.
+
 == Contributing to approximately
  
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.

data/approximately.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "approximately"
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Julik"]
-  s.date = "2012-05-07"
+  s.date = "2012-09-07"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/julik/approximately"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
+  s.rubygems_version = "1.8.24"
   s.summary = "Facilitates float comparisons in mocks"
 
   if s.respond_to? :specification_version then

data/lib/approximately.rb

@@ -1,32 +1,41 @@
+# Include this module into your spec/test case/whatever
 module Approximately
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
   DEFAULT_DELTA = 0.01
   
-  # This object can be used for float comparisons. When
-  # compared to another Float (or an object that responds to to_f)
-  # it will be equal to that object if the float value of the ApproximateFloat
-  # and the value being compared to are within a passed delta
-  class DeltaFloat
+  # This object can be used for float comparisons. When it is instantiaded
+  # with a float and a delta it will respond to <=>(another_float) and
+  # will return equality if the float it's being compared to is within the
+  # delta
+  class DeltaFloat < Struct.new(:float, :delta)
     include Comparable
-    attr_accessor :float, :delta
-    alias_method :to_f, :float
-    
-    def initialize(float_value, delta)
-      @float, @delta = float_value.to_f, delta
-    end
     
     def to_f
-      @float
+      float.to_f
     end
     
     def <=>(another)
-      d = (@float - another.to_f).abs
+      d = (to_f - another.to_f).abs
       return 0 if d < delta
       float <=> another.to_f
     end
+    
+    def inspect
+      "~%0.8f" % to_f
+    end
+    
+    def to_s
+      inspect
+    end
+    
   end
   
+  # Returns the passed Float into a DeltaFloat object. The optional
+  # second argument is the delta that will be considered sufficient for
+  # the comparison to evaluate to true
   def approx(float, delta = DEFAULT_DELTA)
     DeltaFloat.new(float, delta)
   end
+  
+  module_function :approx
 end

data/test/test_approximately.rb

@@ -1,25 +1,59 @@
 require 'helper'
 
-class TestApproximately < Test::Unit::TestCase
+class TestModule < Test::Unit::TestCase
+  should "provide a module method" do
+    obj = Approximately.approx(10)
+    assert_kind_of Approximately::DeltaFloat, obj
+  end
+end
+
+class TestDeltaFloat < Test::Unit::TestCase
   include Approximately
   
   should "return an approximate object" do
     obj = approx(10)
     assert_kind_of Approximately::DeltaFloat, obj
-    assert_kind_of Float, obj.float, "Should have stored a float in the attribute"
+    assert_kind_of Float, obj.to_f, "Should have stored a float in the attribute"
     assert_equal obj.float, obj.to_f
-    assert_in_delta 10.0, obj.float, 0.01
+    assert_in_delta 10.0, obj.to_f, 0.01
   end
   
-  should "compare to another float within delta" do
+  should "compare to another DeltaFloat within delta" do
     d = 0.1
-    assert_equal approx(1, d), approx(1, d), "Should be equal within delta"
-    assert_equal approx(1, d), approx(0.95, d), "Should be equal within delta"
-    assert_not_equal approx(1, d), approx(1.11, d), "Should not be equal outside delta"
+    assert_equal DeltaFloat.new(1, d), DeltaFloat.new(1, d), "Should be equal within delta"
+    assert_equal DeltaFloat.new(1, d), DeltaFloat.new(0.95, d), "Should be equal within delta"
+    assert_not_equal DeltaFloat.new(1.0, d), DeltaFloat.new(1.11, d), "Should not be equal outside delta"
+  end
+  
+  should "print well" do
+    d = 0.1
+    assert_equal "~1.00000000", DeltaFloat.new(1, d).to_s
+  end
+  
+  should "compare to another float as a left-hand expression" do
+    assert_equal DeltaFloat.new(1.0, 0.1), 1.05, "Should be equal within delta"
+  end
+  
+  should "compare to another float as a right-hand expression" do
+    assert_equal 1.05, approx(1.0, 0.1), "Should be equal within delta"
   end
   
   should "create the object with default delta" do
     a = approx(0.013)
+    assert_kind_of Approximately::DeltaFloat, a
+    assert_equal a.delta, Approximately::DEFAULT_DELTA
+  end
+
+  should "create the object with a module method" do
+    a = Approximately.approx(0.013)
+    assert_kind_of Approximately::DeltaFloat, a
     assert_equal a.delta, Approximately::DEFAULT_DELTA
   end
+  
+  should "create the object with custom delta" do
+    d = 0.001
+    a = approx(0.013, d)
+    assert_equal d, a.delta
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: approximately
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-07 00:00:00.000000000 Z
+date: 2012-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &9144310 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9144310
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &9143030 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *9143030
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &9141960 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +53,12 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *9141960
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
 description: 
 email: me@julik.nl
 executables: []
@@ -76,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -499016081
+      hash: -1659886568450334998
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -85,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Facilitates float comparisons in mocks