dynport_tools 0.2.11 → 0.2.12

data/VERSION

@@ -1 +1 @@
-0.2.11
+0.2.12

data/dynport_tools.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dynport_tools}
-  s.version = "0.2.11"
+  s.version = "0.2.12"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]

data/lib/dynport_tools/differ.rb

@@ -17,21 +17,31 @@ module DynportTools
         [a, b] if a != b
       end
     end
-  
-    def diff_to_message_lines(the_diff, prefix = nil)
+    
+    def each_diff(the_diff, prefix = nil, &block)
       if the_diff.is_a?(Array)
-        ["expected #{expected_value(the_diff.first)} to be #{expected_value(the_diff.at(1))}"]
+        yield(prefix, the_diff.first, the_diff.at(1))
       elsif the_diff.is_a?(Hash)
-        the_diff.map do |key, diff|
+        the_diff.each do |key, diff|
           if diff.is_a?(Array)
-            "expected #{merge_prefixes(prefix, key)} to #{use_return ? "return" : "be"} #{expected_value(diff.first)} but #{use_return ? "did" : "was"} #{expected_value(diff.at(1))}"
+            yield([prefix, key].flatten.compact, diff.first, diff.at(1))
           else
-            diff_to_message_lines(diff, merge_prefixes(prefix, key))
+            each_diff(diff, [prefix, key], &block)
           end
-        end.flatten
-      else
-        []
+        end
+      end
+    end
+  
+    def diff_to_message_lines(the_diff)
+      diffs = []
+      each_diff(the_diff) do |keys, old_value, new_value|
+        if keys.nil?
+          diffs << "expected #{expected_value(old_value)} to be #{expected_value(new_value)}"
+        else
+          diffs << "expected #{keys_to_s(keys)} to #{use_return ? "return" : "be"} #{expected_value(old_value)} but #{use_return ? "did" : "was"} #{expected_value(new_value)}"
+        end
       end
+      diffs
     end
     
     def diff_strings(a, b)
@@ -95,6 +105,10 @@ module DynportTools
     def both?(a, b, clazz)
       a.is_a?(clazz) && b.is_a?(clazz)
     end
+    
+    def keys_to_s(keys)
+      keys.compact.map { |k| k.is_a?(Hash) ? k.inspect : k }.join("/")
+    end
   
     def merge_prefixes(prefix, key)
       key_s = key.is_a?(Hash) ? key.inspect : key

data/spec/dynport_tools/differ_spec.rb

@@ -155,23 +155,24 @@ describe DynportTools::Differ do
       differ.diff_to_message_lines({ :a => [1, 2]}).should == ["expected a to return <1> but did <2>"]
     end
     
-    it "adds a prefix when diff is array" do
-      differ.diff_to_message_lines({ :a => [1, 2]}, "b").should == ["expected b[a] to be <1> but was <2>"]
-    end
-    
     it "returns the correctly nested diff" do
-      differ.diff_to_message_lines({ :a => { :b => [3, 4] } }).should == ["expected a[b] to be <3> but was <4>"]
+      differ.diff_to_message_lines({ :a => { :b => [3, 4] } }).should == ["expected a/b to be <3> but was <4>"]
     end
     
-    it "returns the correctly neep nested diff" do
-      differ.diff_to_message_lines({ :a => { :b => [3, 4] } }, "c").should == ["expected c[a][b] to be <3> but was <4>"]
+    it "returns the correctly nested even complexer diff" do
+      differ.diff_to_message_lines({ :a => { :b => { { :c => 1 } => [3, 4] } } }).should == ["expected a/b/{:c=>1} to be <3> but was <4>"]
     end
-    
-    it "returns multiple messages" do
-      differ.diff_to_message_lines({ :a => { :b => [3, 4], :c => [nil, 1] } }, "c").sort.should == [
-        "expected c[a][b] to be <3> but was <4>",
-        "expected c[a][c] to be <nil> but was <1>",
-      ].sort
+  end
+  
+  describe "#each_diff" do
+    it "calls dummy with correct attributes" do
+      d = double("to be called")
+      d.should_receive(:called).with([:a, :b], 3, 4)
+      d.should_receive(:called).with([:a, :c], nil, 1)
+      
+      differ.each_diff({ :a => { :b => [3, 4], :c => [nil, 1] } }) do |path, old, new|
+        d.called(path, old, new)
+      end
     end
   end
 end

data/spec/dynport_tools/have_attributes_spec.rb

@@ -42,7 +42,7 @@ describe "DynportTools::HaveAttributesMatcher" do
   it "returns the correct error message for complex hashes" do
     matcher = DynportTools::HaveAttributesMatcher::HaveAttributes.new(:a => { :b => [1] })
     matcher.matches?(:a => { :b => [2] }).should be_false
-    matcher.failure_message.should == "expected a[b][0] to be <1> but was <2>"
+    matcher.failure_message.should == "expected a/b/0 to be <1> but was <2>"
   end
   
   it "returns false when target hash as viewer values than expected" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dynport_tools
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 2
-  - 11
-  version: 0.2.11
+  - 12
+  version: 0.2.12
 platform: ruby
 authors: 
 - Tobias Schwab