diff_matcher 2.2.0 → 2.2.1

data/Gemfile

@@ -2,10 +2,10 @@ source "http://rubygems.org"
 
 #gemspec
 
-gem "rake" , "~> 0.9"
-gem "rspec", "~> 2.6.0"
-
 group :development do
+  gem "rake" , "~> 0.9"
+  gem "rspec", "~> 2.6.0"
+
   platforms :mri_19 do
     gem "simplecov"
   end

data/README.md

@@ -147,7 +147,7 @@ Where, - 1 missing, + 1 additional, : 2 match_class
 
 When `actual` is an array with a *limited* size use an `AllMatcher` to match
 against *all* the elements in the array adhering to the limits of `:min`
-and or `:max`.
+and or `:max` or `:size` (where `:size` is a Fixnum or range of Fixnum).
 
 ``` ruby
 puts DiffMatcher::difference(DiffMatcher::AllMatcher.new(Fixnum, :min=>3), [1, 2])
@@ -159,6 +159,15 @@ puts DiffMatcher::difference(DiffMatcher::AllMatcher.new(Fixnum, :min=>3), [1, 2
 Where, - 1 missing, : 2 match_class
 ```
 
+``` ruby
+puts DiffMatcher::difference(DiffMatcher::AllMatcher.new(Fixnum, :size=>3..5), [1, 2])
+[
+  : 1,
+  : 2,
+  - Fixnum
+]
+Where, - 1 missing, : 2 match_class
+```
 
 When `actual` is an array of unknown size *and* `expected` can take
 multiple forms use a `Matcher` inside of an `AllMatcher` to match
@@ -246,6 +255,10 @@ Similar gems
   * <http://github.com/postmodern/tdiff> (Calculates the differences between two tree-like structures)
   * <http://github.com/Blargel/easy_diff> (Recursive diff, merge, and unmerge for hashes and arrays)
 
+### JSON matchers
+  * <http://github.com/collectiveidea/json_spec> (Easily handle JSON in RSpec and Cucumber)
+  * <http://github.com/lloyd/JSONSelect> (CSS-like selectors for JSON)
+
 
 Why another differ?
 ---
@@ -262,6 +275,8 @@ It has extra functionality in also being able to recursively merge hashes and ar
 DiffMatcher can match using not only regexes but classes and procs.
 And the difference string that it outputs can be formatted in several ways as needed.
 
+As for matching JSON, the matchers above work well, but don't allow for matching patterns.
+
 
 Use with rspec
 ---

data/lib/diff_matcher/difference.rb

@@ -50,9 +50,19 @@ module DiffMatcher
   class AllMatcher < Matcher
     def expected(e, actual)
       opts = expected_opts(e)
+      size = opts[:size]
+      case size
+      when Fixnum
+        min = size
+        max = size
+      when Range
+        min = size.first
+        max = size.last
+      else
+        min = opts[:min] || 0
+        max = opts[:max] || 1_000_000 # MAXINT?
+      end
       size = actual.size
-      min = opts[:min] || 0
-      max = opts[:max] || 1_000_000 # MAXINT?
       size = size > min ? (size < max ? size : max) : min
       [e]*size
     end
@@ -168,7 +178,7 @@ module DiffMatcher
         items_to_s(
           expected,
           (item_types_shown).inject([]) { |a, method|
-            a + send(method, left, right, expected.class).compact.map { |item| markup(method, item) }
+            a + send(method, left, right, expected).compact.map { |item| markup(method, item) }
           }
         )
       else
@@ -189,9 +199,10 @@ module DiffMatcher
       end if expected.is_a? actual.class
     end
 
-    def compare(right, expected_class, default=nil)
-      if [Hash, Array].include? expected_class
-        right && right.keys.tap { |keys| keys.sort if expected_class == Array }.map { |k|
+    def compare(right, expected, default=nil)
+      case expected
+      when Hash, Array
+        right && right.keys.tap { |keys| keys.sort if expected.is_a? Array }.map { |k|
           yield k
         }
       else
@@ -199,20 +210,20 @@ module DiffMatcher
       end
     end
 
-    def different(left, right, expected_class)
-      compare(right, expected_class, difference_to_s(right, left)) { |k|
-        "#{"#{k.inspect}=>" if expected_class == Hash}#{right[k]}" if right[k] and left.has_key?(k)
+    def different(left, right, expected)
+      compare(right, expected, difference_to_s(right, left)) { |k|
+        "#{"#{k.inspect}=>" if expected.is_a? Hash}#{right[k]}" if right[k] and left.has_key?(k)
       }
     end
 
-    def missing(left, right, expected_class)
-      compare(left, expected_class) { |k|
-        "#{"#{k.inspect}=>" if expected_class == Hash}#{left[k].inspect}" unless right.has_key?(k) || @optional_keys.include?(k)
+    def missing(left, right, expected)
+      compare(left, expected) { |k|
+        "#{"#{k.inspect}=>" if expected.is_a? Hash}#{left[k].inspect}" unless right.has_key?(k) || @optional_keys.include?(k)
       }
     end
 
-    def additional(left, right, expected_class)
-      missing(right, left, expected_class)
+    def additional(left, right, expected)
+      missing(right, left, expected)
     end
 
     def match?(expected, actual)

data/lib/diff_matcher/version.rb

@@ -1,3 +1,3 @@
 module DiffMatcher
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/spec/diff_matcher/difference_spec.rb

@@ -280,6 +280,22 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
       end
     end
 
+    context "of an Array derived class," do
+      class ArrayChild < Array; end
+      expected, same, different =
+        ArrayChild[ 1 ],
+        ArrayChild[ 1 ],
+        ArrayChild[ 2 ]
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF, {}
+        [
+          - 1+ 2
+        ]
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
     context "of Range," do
       expected, same, different =
         (1..3),
@@ -340,6 +356,22 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         end
       end
     end
+
+    context "of a Hash derived class," do
+      class HashChild < Hash; end
+      expected, same, different =
+        HashChild["a",1],
+        HashChild["a",1],
+        HashChild["a",2]
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        {
+          "a"=>- 1+ 2
+        }
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
   end
 
   describe "when expected is," do
@@ -476,6 +508,40 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           Where, + 1 additional, : 2 match_class
           EOF
       end
+
+      context "with a size restriction" do
+        expected, same, different =
+          DiffMatcher::AllMatcher.new(String, :size=>2),
+          %w(ay be),
+          %w(ay be ci)
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          <<-EOF
+          [
+            : "ay",
+            : "be",
+          + "ci"
+          ]
+          Where, + 1 additional, : 2 match_class
+          EOF
+      end
+
+      context "with a size restriction range" do
+        expected, same, different =
+          DiffMatcher::AllMatcher.new(String, :size=>0..2),
+          %w(ay be),
+          %w(ay be ci)
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          <<-EOF
+          [
+            : "ay",
+            : "be",
+          + "ci"
+          ]
+          Where, + 1 additional, : 2 match_class
+          EOF
+      end
     end
 
     context "a DiffMatcher::AllMatcher using an or-ed DiffMatcher::Matcher," do

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: diff_matcher
 version: !ruby/object:Gem::Version 
-  hash: 7
   prerelease: 
-  segments: 
-  - 2
-  - 2
-  - 0
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors: 
 - Playup
@@ -15,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-19 00:00:00 +11:00
-default_executable: 
+date: 2012-05-21 00:00:00 Z
 dependencies: []
 
 description: |
@@ -53,7 +47,6 @@ files:
 - lib/diff_matcher/version.rb
 - spec/diff_matcher/difference_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/playup/diff_matcher
 licenses: []
 
@@ -67,7 +60,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 2195120137284672671
       segments: 
       - 0
       version: "0"
@@ -76,14 +69,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Generates a diff by matching against expected values, classes, regexes and/or procs.